hyperscan-4.4.1/0000755000175000017500000000000013055426554014277 5ustar sleuthkidsleuthkidhyperscan-4.4.1/include/0000755000175000017500000000000013055426554015722 5ustar sleuthkidsleuthkidhyperscan-4.4.1/include/boost-patched/0000755000175000017500000000000013055426554020456 5ustar sleuthkidsleuthkidhyperscan-4.4.1/include/boost-patched/graph/0000755000175000017500000000000013055426554021557 5ustar sleuthkidsleuthkidhyperscan-4.4.1/include/boost-patched/graph/dominator_tree.hpp0000644000175000017500000004317213055426554025312 0ustar sleuthkidsleuthkid//======================================================================= // Copyright (C) 2005-2009 Jongsoo Park // // Distributed under the Boost Software License, Version 1.0. // (See accompanying file LICENSE_1_0.txt or copy at // http://www.boost.org/LICENSE_1_0.txt) //======================================================================= #ifndef BOOST_GRAPH_DOMINATOR_HPP #define BOOST_GRAPH_DOMINATOR_HPP #include #include #include #include #include // Dominator tree computation // NOTE: This file contains modifications from the distributed Boost version to // correctly support supplying a vertex index map to the algorithm. To // differentiate it, it has been moved into the boost_ue2 namespace. namespace boost_ue2 { using namespace boost; namespace detail { /** * An extended time_stamper which also records vertices for each dfs number */ template class time_stamper_with_vertex_vector : public base_visitor< time_stamper_with_vertex_vector > { public : typedef Tag event_filter; time_stamper_with_vertex_vector(TimeMap timeMap, VertexVector& v, TimeT& t) : timeStamper_(timeMap, t), v_(v) { } template void operator()(const typename property_traits::key_type& v, const Graph& g) { timeStamper_(v, g); v_[timeStamper_.m_time] = v; } private : time_stamper timeStamper_; VertexVector& v_; }; /** * A convenient way to create a time_stamper_with_vertex_vector */ template time_stamper_with_vertex_vector stamp_times_with_vertex_vector(TimeMap timeMap, VertexVector& v, TimeT& t, Tag) { return time_stamper_with_vertex_vector(timeMap, v, t); } template class dominator_visitor { typedef typename graph_traits::vertex_descriptor Vertex; typedef typename graph_traits::vertices_size_type VerticesSizeType; public : /** * @param g [in] the target graph of the dominator tree * @param entry [in] the entry node of g * @param indexMap [in] the vertex index map for g * @param domTreePredMap [out] the immediate dominator map * (parent map in dominator tree) */ dominator_visitor(const Graph& g, const Vertex& entry, const IndexMap& indexMap, DomTreePredMap domTreePredMap) : semi_(num_vertices(g)), ancestor_(num_vertices(g), graph_traits::null_vertex()), samedom_(ancestor_), best_(semi_), semiMap_(make_iterator_property_map(semi_.begin(), indexMap)), ancestorMap_(make_iterator_property_map(ancestor_.begin(), indexMap)), bestMap_(make_iterator_property_map(best_.begin(), indexMap)), buckets_(num_vertices(g)), bucketMap_(make_iterator_property_map(buckets_.begin(), indexMap)), entry_(entry), domTreePredMap_(domTreePredMap), numOfVertices_(num_vertices(g)), samedomMap(make_iterator_property_map(samedom_.begin(), indexMap)) { } void operator()(const Vertex& n, const TimeMap& dfnumMap, const PredMap& parentMap, const Graph& g) { if (n == entry_) return; const Vertex p(get(parentMap, n)); Vertex s(p); // 1. Calculate the semidominator of n, // based on the semidominator thm. // * Semidominator thm. : To find the semidominator of a node n, // consider all predecessors v of n in the CFG (Control Flow Graph). // - If v is a proper ancestor of n in the spanning tree // (so dfnum(v) < dfnum(n)), then v is a candidate for semi(n) // - If v is a non-ancestor of n (so dfnum(v) > dfnum(n)) // then for each u that is an ancestor of v (or u = v), // Let semi(u) be a candidate for semi(n) // of all these candidates, the one with lowest dfnum is // the semidominator of n. // For each predecessor of n typename graph_traits::in_edge_iterator inItr, inEnd; for (boost::tie(inItr, inEnd) = in_edges(n, g); inItr != inEnd; ++inItr) { const Vertex v = source(*inItr, g); // To deal with unreachable nodes if (get(dfnumMap, v) < 0 || get(dfnumMap, v) >= numOfVertices_) continue; Vertex s2; if (get(dfnumMap, v) <= get(dfnumMap, n)) s2 = v; else s2 = get(semiMap_, ancestor_with_lowest_semi_(v, dfnumMap)); if (get(dfnumMap, s2) < get(dfnumMap, s)) s = s2; } put(semiMap_, n, s); // 2. Calculation of n's dominator is deferred until // the path from s to n has been linked into the forest get(bucketMap_, s).push_back(n); get(ancestorMap_, n) = p; get(bestMap_, n) = n; // 3. Now that the path from p to v has been linked into // the spanning forest, these lines calculate the dominator of v, // based on the dominator thm., or else defer the calculation // until y's dominator is known // * Dominator thm. : On the spanning-tree path below semi(n) and // above or including n, let y be the node // with the smallest-numbered semidominator. Then, // // idom(n) = semi(n) if semi(y)=semi(n) or // idom(y) if semi(y) != semi(n) typename std::deque::iterator buckItr; for (buckItr = get(bucketMap_, p).begin(); buckItr != get(bucketMap_, p).end(); ++buckItr) { const Vertex v(*buckItr); const Vertex y(ancestor_with_lowest_semi_(v, dfnumMap)); if (get(semiMap_, y) == get(semiMap_, v)) put(domTreePredMap_, v, p); else put(samedomMap, v, y); } get(bucketMap_, p).clear(); } protected : /** * Evaluate function in Tarjan's path compression */ const Vertex ancestor_with_lowest_semi_(const Vertex& v, const TimeMap& dfnumMap) { const Vertex a(get(ancestorMap_, v)); if (get(ancestorMap_, a) != graph_traits::null_vertex()) { const Vertex b(ancestor_with_lowest_semi_(a, dfnumMap)); put(ancestorMap_, v, get(ancestorMap_, a)); if (get(dfnumMap, get(semiMap_, b)) < get(dfnumMap, get(semiMap_, get(bestMap_, v)))) put(bestMap_, v, b); } return get(bestMap_, v); } std::vector semi_, ancestor_, samedom_, best_; PredMap semiMap_, ancestorMap_, bestMap_; std::vector< std::deque > buckets_; iterator_property_map >::iterator, IndexMap> bucketMap_; const Vertex& entry_; DomTreePredMap domTreePredMap_; const VerticesSizeType numOfVertices_; public : PredMap samedomMap; }; } // namespace detail /** * @brief Build dominator tree using Lengauer-Tarjan algorithm. * It takes O((V+E)log(V+E)) time. * * @pre dfnumMap, parentMap and verticesByDFNum have dfs results corresponding * indexMap. * If dfs has already run before, * this function would be good for saving computations. * @pre Unreachable nodes must be masked as * graph_traits::null_vertex in parentMap. * @pre Unreachable nodes must be masked as * (std::numeric_limits::max)() in dfnumMap. * * @param domTreePredMap [out] : immediate dominator map (parent map * in dom. tree) * * @note reference Appel. p. 452~453. algorithm 19.9, 19.10. * * @todo : Optimization in Finding Dominators in Practice, Loukas Georgiadis */ template void lengauer_tarjan_dominator_tree_without_dfs (const Graph& g, const typename graph_traits::vertex_descriptor& entry, const IndexMap& indexMap, TimeMap dfnumMap, PredMap parentMap, VertexVector& verticesByDFNum, DomTreePredMap domTreePredMap) { // Typedefs and concept check typedef typename graph_traits::vertex_descriptor Vertex; typedef typename graph_traits::vertices_size_type VerticesSizeType; BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept )); const VerticesSizeType numOfVertices = num_vertices(g); if (numOfVertices == 0) return; // 1. Visit each vertex in reverse post order and calculate sdom. detail::dominator_visitor visitor(g, entry, indexMap, domTreePredMap); VerticesSizeType i; for (i = 0; i < numOfVertices; ++i) { const Vertex u(verticesByDFNum[numOfVertices - 1 - i]); if (u != graph_traits::null_vertex()) visitor(u, dfnumMap, parentMap, g); } // 2. Now all the deferred dominator calculations, // based on the second clause of the dominator thm., are performed for (i = 0; i < numOfVertices; ++i) { const Vertex n(verticesByDFNum[i]); if (n == entry || n == graph_traits::null_vertex()) continue; Vertex u = get(visitor.samedomMap, n); if (u != graph_traits::null_vertex()) { put(domTreePredMap, n, get(domTreePredMap, u)); } } } /** * Unlike lengauer_tarjan_dominator_tree_without_dfs, * dfs is run in this function and * the result is written to dfnumMap, parentMap, vertices. * * If the result of dfs required after this algorithm, * this function can eliminate the need of rerunning dfs. */ template void lengauer_tarjan_dominator_tree (const Graph& g, const typename graph_traits::vertex_descriptor& entry, const IndexMap& indexMap, TimeMap dfnumMap, PredMap parentMap, VertexVector& verticesByDFNum, DomTreePredMap domTreePredMap) { // Typedefs and concept check typedef typename graph_traits::vertices_size_type VerticesSizeType; BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept )); // 1. Depth first visit const VerticesSizeType numOfVertices = num_vertices(g); if (numOfVertices == 0) return; VerticesSizeType time = (std::numeric_limits::max)(); std::vector colors(numOfVertices, color_traits::white()); depth_first_visit (g, entry, make_dfs_visitor (make_pair(record_predecessors(parentMap, on_tree_edge()), detail::stamp_times_with_vertex_vector (dfnumMap, verticesByDFNum, time, on_discover_vertex()))), make_iterator_property_map(colors.begin(), indexMap)); // 2. Run main algorithm. lengauer_tarjan_dominator_tree_without_dfs(g, entry, indexMap, dfnumMap, parentMap, verticesByDFNum, domTreePredMap); } /** * Use vertex_index as IndexMap and make dfnumMap, parentMap, verticesByDFNum * internally. * If we don't need the result of dfs (dfnumMap, parentMap, verticesByDFNum), * this function would be more convenient one. */ template void lengauer_tarjan_dominator_tree (const Graph& g, const typename graph_traits::vertex_descriptor& entry, DomTreePredMap domTreePredMap) { // typedefs typedef typename graph_traits::vertex_descriptor Vertex; typedef typename graph_traits::vertices_size_type VerticesSizeType; typedef typename property_map::const_type IndexMap; typedef iterator_property_map::iterator, IndexMap> TimeMap; typedef iterator_property_map::iterator, IndexMap> PredMap; // Make property maps const VerticesSizeType numOfVertices = num_vertices(g); if (numOfVertices == 0) return; const IndexMap indexMap = get(vertex_index, g); std::vector dfnum(numOfVertices, 0); TimeMap dfnumMap(make_iterator_property_map(dfnum.begin(), indexMap)); std::vector parent(numOfVertices, graph_traits::null_vertex()); PredMap parentMap(make_iterator_property_map(parent.begin(), indexMap)); std::vector verticesByDFNum(parent); // Run main algorithm lengauer_tarjan_dominator_tree(g, entry, indexMap, dfnumMap, parentMap, verticesByDFNum, domTreePredMap); } /** * Muchnick. p. 182, 184 * * using iterative bit vector analysis */ template void iterative_bit_vector_dominator_tree (const Graph& g, const typename graph_traits::vertex_descriptor& entry, const IndexMap& indexMap, DomTreePredMap domTreePredMap) { typedef typename graph_traits::vertex_descriptor Vertex; typedef typename graph_traits::vertex_iterator vertexItr; typedef typename graph_traits::vertices_size_type VerticesSizeType; typedef iterator_property_map >::iterator, IndexMap> vertexSetMap; BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept )); // 1. Finding dominator // 1.1. Initialize const VerticesSizeType numOfVertices = num_vertices(g); if (numOfVertices == 0) return; vertexItr vi, viend; boost::tie(vi, viend) = vertices(g); const std::set N(vi, viend); bool change = true; std::vector< std::set > dom(numOfVertices, N); vertexSetMap domMap(make_iterator_property_map(dom.begin(), indexMap)); get(domMap, entry).clear(); get(domMap, entry).insert(entry); while (change) { change = false; for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi) { if (*vi == entry) continue; std::set T(N); typename graph_traits::in_edge_iterator inItr, inEnd; for (boost::tie(inItr, inEnd) = in_edges(*vi, g); inItr != inEnd; ++inItr) { const Vertex p = source(*inItr, g); std::set tempSet; std::set_intersection(T.begin(), T.end(), get(domMap, p).begin(), get(domMap, p).end(), std::inserter(tempSet, tempSet.begin())); T.swap(tempSet); } T.insert(*vi); if (T != get(domMap, *vi)) { change = true; get(domMap, *vi).swap(T); } } // end of for (boost::tie(vi, viend) = vertices(g) } // end of while(change) // 2. Build dominator tree for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi) get(domMap, *vi).erase(*vi); Graph domTree(numOfVertices); for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi) { if (*vi == entry) continue; // We have to iterate through copied dominator set const std::set tempSet(get(domMap, *vi)); typename std::set::const_iterator s; for (s = tempSet.begin(); s != tempSet.end(); ++s) { typename std::set::iterator t; for (t = get(domMap, *vi).begin(); t != get(domMap, *vi).end(); ) { typename std::set::iterator old_t = t; ++t; // Done early because t may become invalid if (*old_t == *s) continue; if (get(domMap, *s).find(*old_t) != get(domMap, *s).end()) get(domMap, *vi).erase(old_t); } } } for (boost::tie(vi, viend) = vertices(g); vi != viend; ++vi) { if (*vi != entry && get(domMap, *vi).size() == 1) { Vertex temp = *get(domMap, *vi).begin(); put(domTreePredMap, *vi, temp); } } } template void iterative_bit_vector_dominator_tree (const Graph& g, const typename graph_traits::vertex_descriptor& entry, DomTreePredMap domTreePredMap) { typename property_map::const_type indexMap = get(vertex_index, g); iterative_bit_vector_dominator_tree(g, entry, indexMap, domTreePredMap); } } // namespace boost #endif // BOOST_GRAPH_DOMINATOR_HPP hyperscan-4.4.1/include/boost-patched/graph/reverse_graph.hpp0000644000175000017500000000120513055426554025122 0ustar sleuthkidsleuthkid#ifndef REVERSE_GRAPH_PATCHED_H_ #define REVERSE_GRAPH_PATCHED_H_ #include #include #if defined(BOOST_REVGRAPH_PATCH) // Boost 1.62.0 does not implement degree() in reverse_graph which is required // by BidirectionalGraph, so add it. namespace boost { template inline typename graph_traits::degree_size_type degree(const typename graph_traits::vertex_descriptor u, const reverse_graph& g) { return degree(u, g.m_g); } } // namespace boost #endif // Boost 1.62.0 #endif hyperscan-4.4.1/.gitignore0000644000175000017500000000271713055426554016276 0ustar sleuthkidsleuthkid## ## There are some more .gitignore files in subdirs, but this is the main place ## to add new entries. These are mostly for the common case when ue2 is built ## in place ## # Autogenerated stuff that we don't want to know about .deps autom4te.cache autojunk .dirstamp # Temp and swap files *~ .*.swp .sw? # compiler output and binaries *.a *.o *.lo *.la *.so *.pyc .libs bin # Merge files created by git. *.orig # sigs dir is handled externally signatures # ignore pcre symlink if it exists pcre # but not pcre subdirs! !pcre/ # ignore boost symlink if it exists include/boost # ignore sqlite3 symlink if it exists sqlite3 # Generated files src/config.h src/config.h.in src/hs_version.h src/parser/Parser.cpp # Generated PCRE files pcre/pcre_chartables.c pcre/pcregrep pcre/pcretest # Autoconf/automake/libtool noise Makefile Makefile.in aclocal.m4 config.cache config.log config.status configure libhs.pc libtool m4/libtool.m4 m4/ltoptions.m4 m4/ltsugar.m4 m4/ltversion.m4 m4/lt~obsolete.m4 src/stamp-h1 # Docs !doc/dev-reference/Makefile # not generated doc/dev-reference/doxygen_sqlite3.db doc/dev-reference/doxygen_xml/ doc/dev-reference/_build/ # Autotools noise in pcre pcre/INSTALL pcre/Makefile pcre/Makefile.in pcre/aclocal.m4 pcre/ar-lib pcre/compile pcre/config.* pcre/configure pcre/depcomp pcre/install-sh pcre/*.pc pcre/libtool pcre/ltmain.sh pcre/missing pcre/pcre-config pcre/pcre.h pcre/pcre_stringpiece.h pcre/pcrecpparg.h pcre/stamp-h1 pcre/test-driver hyperscan-4.4.1/LICENSE0000644000175000017500000001357513055426554015317 0ustar sleuthkidsleuthkidHyperscan is licensed under the BSD License. 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. -------------------------------------------------------------------------------- This product also contains code from third parties, under the following licenses: Intel's Slicing-by-8 CRC32 implementation ----------------------------------------- Copyright (c) 2004-2006, Intel Corporation All rights reserved. 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. 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 HOLDER 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. Boost C++ Headers Library ------------------------- Boost Software License - Version 1.0 - August 17th, 2003 Permission is hereby granted, free of charge, to any person or organization obtaining a copy of the software and accompanying documentation covered by this license (the "Software") to use, reproduce, display, distribute, execute, and transmit the Software, and to prepare derivative works of the Software, and to permit third-parties to whom the Software is furnished to do so, all subject to the following: The copyright notices in the Software and this entire statement, including the above license grant, this restriction and the following disclaimer, must be included in all copies of the Software, in whole or in part, and all derivative works of the Software, unless such copies or derivative works are solely in the form of machine-executable object code generated by a source language processor. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. The Google C++ Testing Framework (Google Test) ---------------------------------------------- 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 Google Inc. 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. hyperscan-4.4.1/CHANGELOG.md0000644000175000017500000001747013055426554016121 0ustar sleuthkidsleuthkid# Hyperscan Change Log This is a list of notable changes to Hyperscan, in reverse chronological order. ## [4.4.1] 2017-02-28 - Bugfixes to fix issues where stale data was being referenced in scratch memory. In particular this may have resulted in hs_close_stream() referencing data from other previously scanned streams. This may result in incorrect matches being been reported. ## [4.4.0] 2017-01-20 - Introduce the "fat runtime" build. This will build several variants of the Hyperscan scanning engine specialised for different processor feature sets, and use the appropriate one for the host at runtime. This uses the "ifunc" indirect function attribute provided by GCC and is currently available on Linux only, where it is the default for release builds. - New API function: add the `hs_valid_platform()` function. This function tests whether the host provides the SSSE3 instruction set required by Hyperscan. - Introduce a new standard benchmarking tool, "hsbench". This provides an easy way to measure Hyperscan's performance for a particular set of patterns and corpus of data to be scanned. - Introduce a 64-bit GPR LimEx NFA model, which uses 64-bit GPRs on 64-bit hosts and SSE registers on 32-bit hosts. - Introduce a new DFA model ("McSheng") which is a hybrid of the existing McClellan and Sheng models. This improves scanning performance for some cases. - Introduce lookaround specialisations to improve scanning performance. - Improve the handling of long literals by moving confirmation to the Rose interpreter and simplifying the hash table used to track them in streaming mode. - Improve compile time optimisation for removing redundant paths from expression graphs. - Build: improve support for building with MSVC toolchain. - Reduce the size of small write DFAs used for small scans in block mode. - Introduce a custom graph type (`ue2_graph`) used in place of the Boost Graph Library's `adjacency_list` type. Improves compile time performance and type safety. - Improve scanning performance of the McClellan DFA. - Bugfix for a very unusual SOM case where the incorrect start offset was reported for a match. - Bugfix for issue #37, removing execute permissions from some source files. - Bugfix for issue #41, handle Windows line endings in pattern files. ## [4.3.2] 2016-11-15 - Bugfix for issue #39. This small change is a workaround for an issue in Boost 1.62. The fix has been submitted to Boost for inclusion in a future release. ## [4.3.1] 2016-08-29 - Bugfix for issue #30. In recent versions of Clang, a write to a variable was being elided, resulting in corrupted stream state after calling `hs_reset_stream()`. ## [4.3.0] 2016-08-24 - Introduce a new analysis pass ("Violet") used for decomposition of patterns into literals and smaller engines. - Introduce a new container engine ("Tamarama") for infix and suffix engines that can be proven to run exclusively of one another. This reduces stream state for pattern sets with many such engines. - Introduce a new shuffle-based DFA engine ("Sheng"). This improves scanning performance for pattern sets where small engines are generated. - Improve the analysis used to extract extra mask information from short literals. - Reduced compile time spent in equivalence class analysis. - Build: frame pointers are now only omitted for 32-bit release builds. - Build: Workaround for C++ issues reported on FreeBSD/libc++ platforms. (github issue #27) - Simplify the LimEx NFA with a unified "variable shift" model, which reduces the number of different NFA code paths to one per model size. - Allow some anchored prefixes that may squash the literal to which they are attached to run eagerly. This improves scanning performance for some patterns. - Simplify and improve EOD ("end of data") matching, using the interpreter for all operations. - Elide unnecessary instructions in the Rose interpreter at compile time. - Reduce the number of inlined instantiations of the Rose interpreter in order to reduce instruction cache pressure. - Small improvements to literal matcher acceleration. - Parser: ignore `\E` metacharacters that are not preceded by `\Q`. This conforms to PCRE's behaviour, rather than returning a compile error. - Check for misaligned memory when allocating an error structure in Hyperscan's compile path and return an appropriate error if detected. ## [4.2.0] 2016-05-31 - Introduce an interpreter for many complex actions to replace the use of internal reports within the core of Hyperscan (the "Rose" engine). This improves scanning performance and reduces database size for many pattern sets. - Many enhancements to the acceleration framework used by NFA and DFA engines, including more flexible multibyte implementations and more AVX2 support. This improves scanning performance for many pattern sets. - Improved prefiltering support for complex patterns containing very large bounded repeats (`R{M,N}` with large `N`). - Improve scanning performance of pattern sets with a very large number of EOD-anchored patterns. - Improve scanning performance of large pattern sets that use the `HS_FLAG_SINGLEMATCH` flag. - Improve scanning performance of pattern sets that contain a single literal by improving the "Noodle" literal matcher. - Small reductions in total stream state for many pattern sets. - Improve runtime detection of AVX2 support. - Disable -Werror for release builds, in order to behave better for packagers and users with different compiler combinations than those that we test. - Improve support for building on Windows with MSVC 2015 (github issue #14). Support for Hyperscan on Windows is still experimental. - Small updates to fix warnings identified by Coverity. - Remove Python codegen for the "FDR" and "Teddy" literal matchers. These are now implemented directly in C code. - Remove the specialist "Sidecar" engine in favour of using our more general repeat engines. - New API function: add the `hs_expression_ext_info()` function. This is a variant of `hs_expression_info()` that can accept patterns with extended parameters. - New API error value: add the `HS_SCRATCH_IN_USE` error, which is returned when Hyperscan detects that a scratch region is already in use on entry to an API function. ## [4.1.0] 2015-12-18 - Update version of PCRE used by testing tools as a syntax and semantic reference to PCRE 8.38. - Small updates to fix warnings identified by Coverity. - Clean up and unify exception handling behaviour across GPR and SIMD NFA models. - Fix bug in handling of bounded repeat triggers with large gaps between them for sparse repeat model. - Correctly reject POSIX collating elements (`[.ch.]`, `[=ch=]`) in the parser. These are not supported by Hyperscan. - Add support for quoted sequences (`\Q...\E`) inside character classes. - Simplify FDR literal matcher runtime by removing some static specialization. - Fix handling of the POSIX `[:graph:]`, `[:print:]` and `[:punct:]` character classes to match the behaviour of PCRE 8.38 in both standard operation and with the UCP flag set. (Note: some bugs were fixed in this area in PCRE 8.38.) Previously Hyperscan's behaviour was the same as versions of PCRE before 8.34. - Improve performance when compiling pattern sets that include a large number of similar bounded repeat constructs. (github issue #9) ## [4.0.1] 2015-10-30 - Minor cleanups to test code. - CMake and other build system improvements. - API update: allow `hs_reset_stream()` and `hs_reset_and_copy_stream()` to be supplied with a NULL scratch pointer if no matches are required. This is in line with the behaviour of `hs_close_stream()`. - Disallow bounded repeats with a very large minimum repeat but no maximum, i.e. { N, } for very large N. - Reduce compile memory usage in literal set explansion for some large cases. ## [4.0.0] 2015-10-20 - Original release of Hyperscan as open-source software. hyperscan-4.4.1/src/0000755000175000017500000000000013055426554015066 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/hs_compile.h0000644000175000017500000010635513055426554017373 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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_COMPILE_H_ #define HS_COMPILE_H_ /** * @file * @brief The Hyperscan compiler API definition. * * Hyperscan is a high speed regular expression engine. * * This header contains functions for compiling regular expressions into * Hyperscan databases that can be used by the Hyperscan runtime. */ #include "hs_common.h" #ifdef __cplusplus extern "C" { #endif /** * A type containing error details that is returned by the compile calls (@ref * hs_compile(), @ref hs_compile_multi() and @ref hs_compile_ext_multi()) on * failure. The caller may inspect the values returned in this type to * determine the cause of failure. * * Common errors generated during the compile process include: * * - *Invalid parameter* * * An invalid argument was specified in the compile call. * * - *Unrecognised flag* * * An unrecognised value was passed in the flags argument. * * - *Pattern matches empty buffer* * * By default, Hyperscan only supports patterns that will *always* * consume at least one byte of input. Patterns that do not have this * property (such as `/(abc)?/`) will produce this error unless * the @ref HS_FLAG_ALLOWEMPTY flag is supplied. Note that such * patterns will produce a match for *every* byte when scanned. * * - *Embedded anchors not supported* * * Hyperscan only supports the use of anchor meta-characters (such as * `^` and `$`) in patterns where they could *only* match * at the start or end of a buffer. A pattern containing an embedded * anchor, such as `/abc^def/`, can never match, as there is no * way for `abc` to precede the start of the data stream. * * - *Bounded repeat is too large* * * The pattern contains a repeated construct with very large finite * bounds. * * - *Unsupported component type* * * An unsupported PCRE construct was used in the pattern. * * - *Unable to generate bytecode* * * This error indicates that Hyperscan was unable to compile a pattern * that is syntactically valid. The most common cause is a pattern that is * very long and complex or contains a large repeated subpattern. * * - *Unable to allocate memory* * * The library was unable to allocate temporary storage used during * compilation time. * * - *Allocator returned misaligned memory* * * 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. * * - *Internal error* * * An unexpected error occurred: if this error is reported, please contact * the Hyperscan team with a description of the situation. */ typedef struct hs_compile_error { /** * A human-readable error message describing the error. */ char *message; /** * The zero-based number of the expression that caused the error (if this * can be determined). If the error is not specific to an expression, then * this value will be less than zero. */ int expression; } hs_compile_error_t; /** * A type containing information on the target platform which may optionally be * provided to the compile calls (@ref hs_compile(), @ref hs_compile_multi(), * @ref hs_compile_ext_multi()). * * A hs_platform_info structure may be populated for the current platform by * using the @ref hs_populate_platform() call. */ typedef struct hs_platform_info { /** * Information about the target platform which may be used to guide the * optimisation process of the compile. * * Use of this field does not limit the processors that the resulting * database can run on, but may impact the performance of the resulting * database. */ unsigned int tune; /** * Relevant CPU features available on the target platform * * This value may be produced by combining HS_CPU_FEATURE_* flags (such as * @ref HS_CPU_FEATURES_AVX2). Multiple CPU features may be or'ed together * to produce the value. */ unsigned long long cpu_features; /** * Reserved for future use. */ unsigned long long reserved1; /** * Reserved for future use. */ unsigned long long reserved2; } hs_platform_info_t; /** * A type containing information related to an expression that is returned by * @ref hs_expression_info() or @ref hs_expression_ext_info. */ typedef struct hs_expr_info { /** * The minimum length in bytes of a match for the pattern. */ unsigned int min_width; /** * The maximum length in bytes of a match for the pattern. If the pattern * has an unbounded maximum width, this will be set to the maximum value of * an unsigned int (UINT_MAX). */ unsigned int max_width; /** * Whether this expression can produce matches that are not returned in * order, such as those produced by assertions. Zero if false, non-zero if * true. */ char unordered_matches; /** * Whether this expression can produce matches at end of data (EOD). In * streaming mode, EOD matches are raised during @ref hs_close_stream(), * since it is only when @ref hs_close_stream() is called that the EOD * location is known. Zero if false, non-zero if true. * * Note: trailing `\b` word boundary assertions may also result in EOD * matches as end-of-data can act as a word boundary. */ char matches_at_eod; /** * Whether this expression can *only* produce matches at end of data (EOD). * In streaming mode, all matches for this expression are raised during * @ref hs_close_stream(). Zero if false, non-zero if true. */ char matches_only_at_eod; } hs_expr_info_t; /** * A structure containing additional parameters related to an expression, * passed in at build time to @ref hs_compile_ext_multi() or @ref * hs_expression_ext_info. * * These parameters allow the set of matches produced by a pattern to be * constrained at compile time, rather than relying on the application to * process unwanted matches at runtime. */ typedef struct hs_expr_ext { /** * Flags governing which parts of this structure are to be used by the * compiler. See @ref HS_EXT_FLAG. */ unsigned long long flags; /** * The minimum end offset in the data stream at which this expression * should match successfully. To use this parameter, set the * @ref HS_EXT_FLAG_MIN_OFFSET flag in the hs_expr_ext::flags field. */ unsigned long long min_offset; /** * The maximum end offset in the data stream at which this expression * should match successfully. To use this parameter, set the * @ref HS_EXT_FLAG_MAX_OFFSET flag in the hs_expr_ext::flags field. */ unsigned long long max_offset; /** * The minimum match length (from start to end) required to successfully * match this expression. To use this parameter, set the * @ref HS_EXT_FLAG_MIN_LENGTH flag in the hs_expr_ext::flags field. */ unsigned long long min_length; } hs_expr_ext_t; /** * @defgroup HS_EXT_FLAG hs_expr_ext_t flags * * These flags are used in @ref hs_expr_ext_t::flags to indicate which fields * are used. * * @{ */ /** Flag indicating that the hs_expr_ext::min_offset field is used. */ #define HS_EXT_FLAG_MIN_OFFSET 1ULL /** Flag indicating that the hs_expr_ext::max_offset field is used. */ #define HS_EXT_FLAG_MAX_OFFSET 2ULL /** Flag indicating that the hs_expr_ext::min_length field is used. */ #define HS_EXT_FLAG_MIN_LENGTH 4ULL /** @} */ /** * The basic regular expression compiler. * * This is the function call with which an expression is compiled into a * Hyperscan database which can be passed to the runtime functions (such as * @ref hs_scan(), @ref hs_open_stream(), etc.) * * @param expression * The NULL-terminated expression to parse. Note that this string must * represent ONLY the pattern to be matched, with no delimiters or flags; * any global flags should be specified with the @a flags argument. For * example, the expression `/abc?def/i` should be compiled by providing * `abc?def` as the @a expression, and @ref HS_FLAG_CASELESS as the @a * flags. * * @param flags * Flags which modify the behaviour of the expression. Multiple flags may * be used by ORing them together. Valid values are: * - HS_FLAG_CASELESS - Matching will be performed case-insensitively. * - HS_FLAG_DOTALL - Matching a `.` will not exclude newlines. * - HS_FLAG_MULTILINE - `^` and `$` anchors match any newlines in data. * - HS_FLAG_SINGLEMATCH - Only one match will be generated for the * expression per stream. * - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an * empty string, such as `.*`. * - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. * - HS_FLAG_UCP - Use Unicode properties for character classes. * - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. * - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset * when a match is found. * * @param mode * Compiler mode flags that affect the database as a whole. One of @ref * HS_MODE_STREAM or @ref HS_MODE_BLOCK or @ref HS_MODE_VECTORED must be * supplied, to select between the generation of a streaming, block or * vectored database. In addition, other flags (beginning with HS_MODE_) * may be supplied to enable specific features. See @ref HS_MODE_FLAG for * more details. * * @param platform * If not NULL, the platform structure is used to determine the target * platform for the database. If NULL, a database suitable for running * on the current host platform is produced. * * @param db * On success, a pointer to the generated database will be returned in * this parameter, or NULL on failure. The caller is responsible for * deallocating the buffer using the @ref hs_free_database() function. * * @param error * If the compile fails, a pointer to a @ref hs_compile_error_t will be * returned, providing details of the error condition. The caller is * responsible for deallocating the buffer using the @ref * hs_free_compile_error() function. * * @return * @ref HS_SUCCESS is returned on successful compilation; @ref * HS_COMPILER_ERROR on failure, with details provided in the error * parameter. */ hs_error_t hs_compile(const char *expression, unsigned int flags, unsigned int mode, const hs_platform_info_t *platform, hs_database_t **db, hs_compile_error_t **error); /** * The multiple regular expression compiler. * * This is the function call with which a set of expressions is compiled into a * database which can be passed to the runtime functions (such as @ref * hs_scan(), @ref hs_open_stream(), etc.) Each expression can be labelled with * a unique integer which is passed into the match callback to identify the * pattern that has matched. * * @param expressions * Array of NULL-terminated expressions to compile. Note that (as for @ref * hs_compile()) these strings must contain only the pattern to be * matched, with no delimiters or flags. For example, the expression * `/abc?def/i` should be compiled by providing `abc?def` as the first * string in the @a expressions array, and @ref HS_FLAG_CASELESS as the * first value in the @a flags array. * * @param flags * Array of flags which modify the behaviour of each expression. Multiple * flags may be used by ORing them together. Specifying the NULL pointer * in place of an array will set the flags value for all patterns to zero. * Valid values are: * - HS_FLAG_CASELESS - Matching will be performed case-insensitively. * - HS_FLAG_DOTALL - Matching a `.` will not exclude newlines. * - HS_FLAG_MULTILINE - `^` and `$` anchors match any newlines in data. * - HS_FLAG_SINGLEMATCH - Only one match will be generated by patterns * with this match id per stream. * - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an * empty string, such as `.*`. * - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. * - HS_FLAG_UCP - Use Unicode properties for character classes. * - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. * - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset * when a match is found. * * @param ids * An array of integers specifying the ID number to be associated with the * corresponding pattern in the expressions array. Specifying the NULL * pointer in place of an array will set the ID value for all patterns to * zero. * * @param elements * The number of elements in the input arrays. * * @param mode * Compiler mode flags that affect the database as a whole. One of @ref * HS_MODE_STREAM or @ref HS_MODE_BLOCK or @ref HS_MODE_VECTORED must be * supplied, to select between the generation of a streaming, block or * vectored database. In addition, other flags (beginning with HS_MODE_) * may be supplied to enable specific features. See @ref HS_MODE_FLAG for * more details. * * @param platform * If not NULL, the platform structure is used to determine the target * platform for the database. If NULL, a database suitable for running * on the current host platform is produced. * * @param db * On success, a pointer to the generated database will be returned in * this parameter, or NULL on failure. The caller is responsible for * deallocating the buffer using the @ref hs_free_database() function. * * @param error * If the compile fails, a pointer to a @ref hs_compile_error_t will be * returned, providing details of the error condition. The caller is * responsible for deallocating the buffer using the @ref * hs_free_compile_error() function. * * @return * @ref HS_SUCCESS is returned on successful compilation; @ref * HS_COMPILER_ERROR on failure, with details provided in the @a error * parameter. * */ hs_error_t hs_compile_multi(const char *const *expressions, const unsigned int *flags, const unsigned int *ids, unsigned int elements, unsigned int mode, const hs_platform_info_t *platform, hs_database_t **db, hs_compile_error_t **error); /** * The multiple regular expression compiler with extended parameter support. * * This function call compiles a group of expressions into a database in the * same way as @ref hs_compile_multi(), but allows additional parameters to be * specified via an @ref hs_expr_ext_t structure per expression. * * @param expressions * Array of NULL-terminated expressions to compile. Note that (as for @ref * hs_compile()) these strings must contain only the pattern to be * matched, with no delimiters or flags. For example, the expression * `/abc?def/i` should be compiled by providing `abc?def` as the first * string in the @a expressions array, and @ref HS_FLAG_CASELESS as the * first value in the @a flags array. * * @param flags * Array of flags which modify the behaviour of each expression. Multiple * flags may be used by ORing them together. Specifying the NULL pointer * in place of an array will set the flags value for all patterns to zero. * Valid values are: * - HS_FLAG_CASELESS - Matching will be performed case-insensitively. * - HS_FLAG_DOTALL - Matching a `.` will not exclude newlines. * - HS_FLAG_MULTILINE - `^` and `$` anchors match any newlines in data. * - HS_FLAG_SINGLEMATCH - Only one match will be generated by patterns * with this match id per stream. * - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an * empty string, such as `.*`. * - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. * - HS_FLAG_UCP - Use Unicode properties for character classes. * - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. * - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset * when a match is found. * * @param ids * An array of integers specifying the ID number to be associated with the * corresponding pattern in the expressions array. Specifying the NULL * pointer in place of an array will set the ID value for all patterns to * zero. * * @param ext * An array of pointers to filled @ref hs_expr_ext_t structures that * define extended behaviour for each pattern. NULL may be specified if no * extended behaviour is needed for an individual pattern, or in place of * the whole array if it is not needed for any expressions. Memory used by * these structures must be both allocated and freed by the caller. * * @param elements * The number of elements in the input arrays. * * @param mode * Compiler mode flags that affect the database as a whole. One of @ref * HS_MODE_STREAM, @ref HS_MODE_BLOCK or @ref HS_MODE_VECTORED must be * supplied, to select between the generation of a streaming, block or * vectored database. In addition, other flags (beginning with HS_MODE_) * may be supplied to enable specific features. See @ref HS_MODE_FLAG for * more details. * * @param platform * If not NULL, the platform structure is used to determine the target * platform for the database. If NULL, a database suitable for running * on the current host platform is produced. * * @param db * On success, a pointer to the generated database will be returned in * this parameter, or NULL on failure. The caller is responsible for * deallocating the buffer using the @ref hs_free_database() function. * * @param error * If the compile fails, a pointer to a @ref hs_compile_error_t will be * returned, providing details of the error condition. The caller is * responsible for deallocating the buffer using the @ref * hs_free_compile_error() function. * * @return * @ref HS_SUCCESS is returned on successful compilation; @ref * HS_COMPILER_ERROR on failure, with details provided in the @a error * parameter. * */ hs_error_t hs_compile_ext_multi(const char *const *expressions, const unsigned int *flags, const unsigned int *ids, const hs_expr_ext_t *const *ext, unsigned int elements, unsigned int mode, const hs_platform_info_t *platform, hs_database_t **db, hs_compile_error_t **error); /** * Free an error structure generated by @ref hs_compile(), @ref * hs_compile_multi() or @ref hs_compile_ext_multi(). * * @param error * The @ref hs_compile_error_t to be freed. NULL may also be safely * provided. * * @return * @ref HS_SUCCESS on success, other values on failure. */ hs_error_t hs_free_compile_error(hs_compile_error_t *error); /** * Utility function providing information about a regular expression. The * information provided in @ref hs_expr_info_t includes the minimum and maximum * width of a pattern match. * * @param expression * The NULL-terminated expression to parse. Note that this string must * represent ONLY the pattern to be matched, with no delimiters or flags; * any global flags should be specified with the @a flags argument. For * example, the expression `/abc?def/i` should be compiled by providing * `abc?def` as the @a expression, and @ref HS_FLAG_CASELESS as the @a * flags. * * @param flags * Flags which modify the behaviour of the expression. Multiple flags may * be used by ORing them together. Valid values are: * - HS_FLAG_CASELESS - Matching will be performed case-insensitively. * - HS_FLAG_DOTALL - Matching a `.` will not exclude newlines. * - HS_FLAG_MULTILINE - `^` and `$` anchors match any newlines in data. * - HS_FLAG_SINGLEMATCH - Only one match will be generated by the * expression per stream. * - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an * empty string, such as `.*`. * - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. * - HS_FLAG_UCP - Use Unicode properties for character classes. * - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. * - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset * when a match is found. * * @param info * On success, a pointer to the pattern information will be returned in * this parameter, or NULL on failure. This structure is allocated using * the allocator supplied in @ref hs_set_allocator() (or malloc() if no * allocator was set) and should be freed by the caller. * * @param error * If the call fails, a pointer to a @ref hs_compile_error_t will be * returned, providing details of the error condition. The caller is * responsible for deallocating the buffer using the @ref * hs_free_compile_error() function. * * @return * @ref HS_SUCCESS is returned on successful compilation; @ref * HS_COMPILER_ERROR on failure, with details provided in the error * parameter. */ hs_error_t hs_expression_info(const char *expression, unsigned int flags, hs_expr_info_t **info, hs_compile_error_t **error); /** * Utility function providing information about a regular expression, with * extended parameter support. The information provided in @ref hs_expr_info_t * includes the minimum and maximum width of a pattern match. * * @param expression * The NULL-terminated expression to parse. Note that this string must * represent ONLY the pattern to be matched, with no delimiters or flags; * any global flags should be specified with the @a flags argument. For * example, the expression `/abc?def/i` should be compiled by providing * `abc?def` as the @a expression, and @ref HS_FLAG_CASELESS as the @a * flags. * * @param flags * Flags which modify the behaviour of the expression. Multiple flags may * be used by ORing them together. Valid values are: * - HS_FLAG_CASELESS - Matching will be performed case-insensitively. * - HS_FLAG_DOTALL - Matching a `.` will not exclude newlines. * - HS_FLAG_MULTILINE - `^` and `$` anchors match any newlines in data. * - HS_FLAG_SINGLEMATCH - Only one match will be generated by the * expression per stream. * - HS_FLAG_ALLOWEMPTY - Allow expressions which can match against an * empty string, such as `.*`. * - HS_FLAG_UTF8 - Treat this pattern as a sequence of UTF-8 characters. * - HS_FLAG_UCP - Use Unicode properties for character classes. * - HS_FLAG_PREFILTER - Compile pattern in prefiltering mode. * - HS_FLAG_SOM_LEFTMOST - Report the leftmost start of match offset * when a match is found. * * @param ext * A pointer to a filled @ref hs_expr_ext_t structure that defines * extended behaviour for this pattern. NULL may be specified if no * extended parameters are needed. * * @param info * On success, a pointer to the pattern information will be returned in * this parameter, or NULL on failure. This structure is allocated using * the allocator supplied in @ref hs_set_allocator() (or malloc() if no * allocator was set) and should be freed by the caller. * * @param error * If the call fails, a pointer to a @ref hs_compile_error_t will be * returned, providing details of the error condition. The caller is * responsible for deallocating the buffer using the @ref * hs_free_compile_error() function. * * @return * @ref HS_SUCCESS is returned on successful compilation; @ref * HS_COMPILER_ERROR on failure, with details provided in the error * parameter. */ hs_error_t hs_expression_ext_info(const char *expression, unsigned int flags, const hs_expr_ext_t *ext, hs_expr_info_t **info, hs_compile_error_t **error); /** * Populates the platform information based on the current host. * * @param platform * On success, the pointed to structure is populated based on the current * host. * * @return * @ref HS_SUCCESS on success, other values on failure. */ hs_error_t hs_populate_platform(hs_platform_info_t *platform); /** * @defgroup HS_PATTERN_FLAG Pattern flags * * @{ */ /** * Compile flag: Set case-insensitive matching. * * This flag sets the expression to be matched case-insensitively by default. * The expression may still use PCRE tokens (notably `(?i)` and * `(?-i)`) to switch case-insensitive matching on and off. */ #define HS_FLAG_CASELESS 1 /** * Compile flag: Matching a `.` will not exclude newlines. * * This flag sets any instances of the `.` token to match newline characters as * well as all other characters. The PCRE specification states that the `.` * token does not match newline characters by default, so without this flag the * `.` token will not cross line boundaries. */ #define HS_FLAG_DOTALL 2 /** * Compile flag: Set multi-line anchoring. * * This flag instructs the expression to make the `^` and `$` tokens match * newline characters as well as the start and end of the stream. If this flag * is not specified, the `^` token will only ever match at the start of a * stream, and the `$` token will only ever match at the end of a stream within * the guidelines of the PCRE specification. */ #define HS_FLAG_MULTILINE 4 /** * Compile flag: Set single-match only mode. * * This flag sets the expression's match ID to match at most once. In streaming * mode, this means that the expression will return only a single match over * the lifetime of the stream, rather than reporting every match as per * standard Hyperscan semantics. In block mode or vectored mode, only the first * match for each invocation of @ref hs_scan() or @ref hs_scan_vector() will be * returned. * * If multiple expressions in the database share the same match ID, then they * either must all specify @ref HS_FLAG_SINGLEMATCH or none of them specify * @ref HS_FLAG_SINGLEMATCH. If a group of expressions sharing a match ID * specify the flag, then at most one match with the match ID will be generated * per stream. * * Note: The use of this flag in combination with @ref HS_FLAG_SOM_LEFTMOST * is not currently supported. */ #define HS_FLAG_SINGLEMATCH 8 /** * Compile flag: Allow expressions that can match against empty buffers. * * This flag instructs the compiler to allow expressions that can match against * empty buffers, such as `.?`, `.*`, `(a|)`. Since Hyperscan can return every * possible match for an expression, such expressions generally execute very * slowly; the default behaviour is to return an error when an attempt to * compile one is made. Using this flag will force the compiler to allow such * an expression. */ #define HS_FLAG_ALLOWEMPTY 16 /** * Compile flag: Enable UTF-8 mode for this expression. * * This flag instructs Hyperscan to treat the pattern as a sequence of UTF-8 * characters. The results of scanning invalid UTF-8 sequences with a Hyperscan * library that has been compiled with one or more patterns using this flag are * undefined. */ #define HS_FLAG_UTF8 32 /** * Compile flag: Enable Unicode property support for this expression. * * This flag instructs Hyperscan to use Unicode properties, rather than the * default ASCII interpretations, for character mnemonics like `\w` and `\s` as * well as the POSIX character classes. It is only meaningful in conjunction * with @ref HS_FLAG_UTF8. */ #define HS_FLAG_UCP 64 /** * Compile flag: Enable prefiltering mode for this expression. * * This flag instructs Hyperscan to compile an "approximate" version of this * pattern for use in a prefiltering application, even if Hyperscan does not * support the pattern in normal operation. * * The set of matches returned when this flag is used is guaranteed to be a * superset of the matches specified by the non-prefiltering expression. * * If the pattern contains pattern constructs not supported by Hyperscan (such * as zero-width assertions, back-references or conditional references) these * constructs will be replaced internally with broader constructs that may * match more often. * * Furthermore, in prefiltering mode Hyperscan may simplify a pattern that * would otherwise return a "Pattern too large" error at compile time, or for * performance reasons (subject to the matching guarantee above). * * It is generally expected that the application will subsequently confirm * prefilter matches with another regular expression matcher that can provide * exact matches for the pattern. * * Note: The use of this flag in combination with @ref HS_FLAG_SOM_LEFTMOST * is not currently supported. */ #define HS_FLAG_PREFILTER 128 /** * Compile flag: Enable leftmost start of match reporting. * * This flag instructs Hyperscan to report the leftmost possible start of match * offset when a match is reported for this expression. (By default, no start * of match is returned.) * * Enabling this behaviour may reduce performance and increase stream state * requirements in streaming mode. */ #define HS_FLAG_SOM_LEFTMOST 256 /** @} */ /** * @defgroup HS_CPU_FEATURES_FLAG CPU feature support flags * * @{ */ /** * CPU features flag - Intel(R) Advanced Vector Extensions 2 (Intel(R) AVX2) * * Setting this flag indicates that the target platform supports AVX2 * instructions. */ #define HS_CPU_FEATURES_AVX2 (1ULL << 2) /** @} */ /** * @defgroup HS_TUNE_FLAG Tuning flags * * @{ */ /** * Tuning Parameter - Generic * * This indicates that the compiled database should not be tuned for any * particular target platform. */ #define HS_TUNE_FAMILY_GENERIC 0 /** * Tuning Parameter - Intel(R) microarchitecture code name Sandy Bridge * * This indicates that the compiled database should be tuned for the * Sandy Bridge microarchitecture. */ #define HS_TUNE_FAMILY_SNB 1 /** * Tuning Parameter - Intel(R) microarchitecture code name Ivy Bridge * * This indicates that the compiled database should be tuned for the * Ivy Bridge microarchitecture. */ #define HS_TUNE_FAMILY_IVB 2 /** * Tuning Parameter - Intel(R) microarchitecture code name Haswell * * This indicates that the compiled database should be tuned for the * Haswell microarchitecture. */ #define HS_TUNE_FAMILY_HSW 3 /** * Tuning Parameter - Intel(R) microarchitecture code name Silvermont * * This indicates that the compiled database should be tuned for the * Silvermont microarchitecture. */ #define HS_TUNE_FAMILY_SLM 4 /** * Tuning Parameter - Intel(R) microarchitecture code name Broadwell * * This indicates that the compiled database should be tuned for the * Broadwell microarchitecture. */ #define HS_TUNE_FAMILY_BDW 5 /** @} */ /** * @defgroup HS_MODE_FLAG Compile mode flags * * The mode flags are used as values for the mode parameter of the various * compile calls (@ref hs_compile(), @ref hs_compile_multi() and @ref * hs_compile_ext_multi()). * * A mode value can be built by ORing these flag values together; the only * required flag is one of @ref HS_MODE_BLOCK, @ref HS_MODE_STREAM or @ref * HS_MODE_VECTORED. Other flags may be added to enable support for additional * features. * * @{ */ /** * Compiler mode flag: Block scan (non-streaming) database. */ #define HS_MODE_BLOCK 1 /** * Compiler mode flag: Alias for @ref HS_MODE_BLOCK. */ #define HS_MODE_NOSTREAM 1 /** * Compiler mode flag: Streaming database. */ #define HS_MODE_STREAM 2 /** * Compiler mode flag: Vectored scanning database. */ #define HS_MODE_VECTORED 4 /** * Compiler mode flag: use full precision to track start of match offsets in * stream state. * * This mode will use the most stream state per pattern, but will always return * an accurate start of match offset regardless of how far back in the past it * was found. * * One of the SOM_HORIZON modes must be selected to use the @ref * HS_FLAG_SOM_LEFTMOST expression flag. */ #define HS_MODE_SOM_HORIZON_LARGE (1U << 24) /** * Compiler mode flag: use medium precision to track start of match offsets in * stream state. * * This mode will use less stream state than @ref HS_MODE_SOM_HORIZON_LARGE and * will limit start of match accuracy to offsets within 2^32 bytes of the * end of match offset reported. * * One of the SOM_HORIZON modes must be selected to use the @ref * HS_FLAG_SOM_LEFTMOST expression flag. */ #define HS_MODE_SOM_HORIZON_MEDIUM (1U << 25) /** * Compiler mode flag: use limited precision to track start of match offsets in * stream state. * * This mode will use less stream state than @ref HS_MODE_SOM_HORIZON_LARGE and * will limit start of match accuracy to offsets within 2^16 bytes of the * end of match offset reported. * * One of the SOM_HORIZON modes must be selected to use the @ref * HS_FLAG_SOM_LEFTMOST expression flag. */ #define HS_MODE_SOM_HORIZON_SMALL (1U << 26) /** @} */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* HS_COMPILE_H_ */ hyperscan-4.4.1/src/hs_version.h.in0000644000175000017500000000356513055426554020034 0ustar sleuthkidsleuthkid/* * 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 HS_VERSION_H_C6428FAF8E3713 #define HS_VERSION_H_C6428FAF8E3713 /** * A version string to identify this release of Hyperscan. */ #define HS_VERSION_STRING "@HS_VERSION@ @BUILD_DATE@" #define HS_VERSION_32BIT ((@HS_MAJOR_VERSION@ << 24) | (@HS_MINOR_VERSION@ << 16) | (@HS_PATCH_VERSION@ << 8) | 0) #endif /* HS_VERSION_H_C6428FAF8E3713 */ hyperscan-4.4.1/src/runtime.c0000644000175000017500000010062513055426554016721 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Runtime functions. */ #include #include #include "allocator.h" #include "hs_compile.h" /* for HS_MODE_* flags */ #include "hs_runtime.h" #include "hs_internal.h" #include "hwlm/hwlm.h" #include "nfa/mcclellan.h" #include "nfa/nfa_api.h" #include "nfa/nfa_api_util.h" #include "nfa/nfa_internal.h" #include "nfa/nfa_rev_api.h" #include "nfa/sheng.h" #include "smallwrite/smallwrite_internal.h" #include "rose/rose.h" #include "rose/runtime.h" #include "database.h" #include "report.h" #include "scratch.h" #include "som/som_runtime.h" #include "som/som_stream.h" #include "state.h" #include "ue2common.h" #include "util/exhaust.h" #include "util/multibit.h" static really_inline void prefetch_data(const char *data, unsigned length) { __builtin_prefetch(data); __builtin_prefetch(data + length/2); __builtin_prefetch(data + length - 24); } /** dummy event handler for use when user does not provide one */ static int null_onEvent(UNUSED unsigned id, UNUSED unsigned long long from, UNUSED unsigned long long to, UNUSED unsigned flags, UNUSED void *ctxt) { return 0; } static really_inline u32 getHistoryAmount(const struct RoseEngine *t, u64a offset) { return MIN(t->historyRequired, offset); } static really_inline u8 *getHistory(char *state, const struct RoseEngine *t, u64a offset) { return (u8 *)state + t->stateOffsets.history + t->historyRequired - MIN(t->historyRequired, offset); } /** \brief Sanity checks for scratch space. * * Although more at home in scratch.c, it is located here to be closer to its * callers. */ static really_inline char validScratch(const struct RoseEngine *t, const struct hs_scratch *s) { if (!ISALIGNED_CL(s)) { DEBUG_PRINTF("bad alignment %p\n", s); return 0; } if (s->magic != SCRATCH_MAGIC) { DEBUG_PRINTF("bad magic 0x%x\n", s->magic); return 0; } if (t->mode == HS_MODE_BLOCK && t->stateOffsets.end > s->bStateSize) { DEBUG_PRINTF("bad state size\n"); return 0; } if (t->queueCount > s->queueCount) { DEBUG_PRINTF("bad queue count\n"); return 0; } /* TODO: add quick rose sanity checks */ return 1; } static really_inline void populateCoreInfo(struct hs_scratch *s, const struct RoseEngine *rose, char *state, match_event_handler onEvent, void *userCtx, const char *data, size_t length, const u8 *history, size_t hlen, u64a offset, u8 status, UNUSED unsigned int flags) { assert(rose); s->core_info.userContext = userCtx; s->core_info.userCallback = onEvent ? onEvent : null_onEvent; s->core_info.rose = rose; s->core_info.state = state; /* required for chained queues + evec */ s->core_info.exhaustionVector = state + rose->stateOffsets.exhausted; s->core_info.status = status; s->core_info.buf = (const u8 *)data; s->core_info.len = length; s->core_info.hbuf = history; s->core_info.hlen = hlen; s->core_info.buf_offset = offset; /* and some stuff not actually in core info */ s->som_set_now_offset = ~0ULL; s->deduper.current_report_offset = ~0ULL; s->deduper.som_log_dirty = 1; /* som logs have not been cleared */ // Rose program execution (used for some report paths) depends on these // values being initialised. s->tctxt.lastMatchOffset = 0; s->tctxt.minMatchOffset = offset; s->tctxt.minNonMpvMatchOffset = offset; } #define STATUS_VALID_BITS \ (STATUS_TERMINATED | STATUS_EXHAUSTED | STATUS_DELAY_DIRTY) /** \brief Retrieve status bitmask from stream state. */ static really_inline u8 getStreamStatus(const char *state) { u8 status = *(const u8 *)state; assert((status & ~STATUS_VALID_BITS) == 0); return status; } /** \brief Store status bitmask to stream state. */ static really_inline void setStreamStatus(char *state, u8 status) { assert((status & ~STATUS_VALID_BITS) == 0); *(u8 *)state = status; } /** \brief Initialise SOM state. Used in both block and streaming mode. */ static really_inline void initSomState(const struct RoseEngine *rose, char *state) { assert(rose && state); const u32 somCount = rose->somLocationCount; mmbit_clear((u8 *)state + rose->stateOffsets.somValid, somCount); mmbit_clear((u8 *)state + rose->stateOffsets.somWritable, somCount); } static really_inline void rawBlockExec(const struct RoseEngine *rose, struct hs_scratch *scratch) { assert(rose); assert(scratch); initSomState(rose, scratch->core_info.state); DEBUG_PRINTF("blockmode scan len=%zu\n", scratch->core_info.len); roseBlockExec(rose, scratch); } static really_inline void pureLiteralInitScratch(struct hs_scratch *scratch, u64a offset) { // Some init has already been done. assert(offset == scratch->core_info.buf_offset); scratch->tctxt.lit_offset_adjust = offset + 1; scratch->tctxt.lastEndOffset = offset; scratch->tctxt.delayLastEndOffset = offset; scratch->tctxt.filledDelayedSlots = 0; scratch->al_log_sum = 0; } static really_inline void pureLiteralBlockExec(const struct RoseEngine *rose, struct hs_scratch *scratch) { assert(rose); assert(scratch); const struct HWLM *ftable = getFLiteralMatcher(rose); initSomState(rose, scratch->core_info.state); const u8 *buffer = scratch->core_info.buf; size_t length = scratch->core_info.len; DEBUG_PRINTF("rose engine %d\n", rose->runtimeImpl); pureLiteralInitScratch(scratch, 0); scratch->tctxt.groups = rose->initialGroups; hwlmExec(ftable, buffer, length, 0, roseCallback, scratch, rose->initialGroups); } static really_inline void initOutfixQueue(struct mq *q, u32 qi, const struct RoseEngine *t, struct hs_scratch *scratch) { const struct NfaInfo *info = getNfaInfoByQueue(t, qi); q->nfa = getNfaByInfo(t, info); q->end = 0; q->cur = 0; q->state = scratch->fullState + info->fullStateOffset; q->streamState = (char *)scratch->core_info.state + info->stateOffset; q->offset = scratch->core_info.buf_offset; q->buffer = scratch->core_info.buf; q->length = scratch->core_info.len; q->history = scratch->core_info.hbuf; q->hlength = scratch->core_info.hlen; q->cb = roseReportAdaptor; q->context = scratch; q->report_current = 0; DEBUG_PRINTF("qi=%u, offset=%llu, fullState=%u, streamState=%u, " "state=%u\n", qi, q->offset, info->fullStateOffset, info->stateOffset, *(u32 *)q->state); } static never_inline void soleOutfixBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch) { assert(t); assert(scratch); initSomState(t, scratch->core_info.state); assert(t->outfixEndQueue == 1); assert(!t->amatcherOffset); assert(!t->ematcherOffset); assert(!t->fmatcherOffset); const struct NFA *nfa = getNfaByQueue(t, 0); size_t len = nfaRevAccelCheck(nfa, scratch->core_info.buf, scratch->core_info.len); if (!len) { return; } struct mq *q = scratch->queues; initOutfixQueue(q, 0, t, scratch); q->length = len; /* adjust for rev_accel */ nfaQueueInitState(nfa, q); pushQueueAt(q, 0, MQE_START, 0); pushQueueAt(q, 1, MQE_TOP, 0); pushQueueAt(q, 2, MQE_END, scratch->core_info.len); char rv = nfaQueueExec(q->nfa, q, scratch->core_info.len); if (rv && nfaAcceptsEod(nfa) && len == scratch->core_info.len) { nfaCheckFinalState(nfa, q->state, q->streamState, q->length, q->cb, scratch); } } static rose_inline void runSmallWriteEngine(const struct SmallWriteEngine *smwr, struct hs_scratch *scratch) { assert(smwr); assert(scratch); const u8 *buffer = scratch->core_info.buf; size_t length = scratch->core_info.len; DEBUG_PRINTF("USING SMALL WRITE\n"); if (length <= smwr->start_offset) { DEBUG_PRINTF("too short\n"); return; } const struct NFA *nfa = getSmwrNfa(smwr); size_t local_alen = length - smwr->start_offset; const u8 *local_buffer = buffer + smwr->start_offset; assert(isDfaType(nfa->type)); if (nfa->type == MCCLELLAN_NFA_8) { nfaExecMcClellan8_B(nfa, smwr->start_offset, local_buffer, local_alen, roseReportAdaptor, scratch); } else if (nfa->type == MCCLELLAN_NFA_16) { nfaExecMcClellan16_B(nfa, smwr->start_offset, local_buffer, local_alen, roseReportAdaptor, scratch); } else { nfaExecSheng_B(nfa, smwr->start_offset, local_buffer, local_alen, roseReportAdaptor, scratch); } } HS_PUBLIC_API hs_error_t hs_scan(const hs_database_t *db, const char *data, unsigned length, unsigned flags, hs_scratch_t *scratch, match_event_handler onEvent, void *userCtx) { if (unlikely(!scratch || !data)) { return HS_INVALID; } hs_error_t err = validDatabase(db); if (unlikely(err != HS_SUCCESS)) { return err; } const struct RoseEngine *rose = hs_get_bytecode(db); if (unlikely(!ISALIGNED_16(rose))) { return HS_INVALID; } if (unlikely(rose->mode != HS_MODE_BLOCK)) { return HS_DB_MODE_ERROR; } if (unlikely(!validScratch(rose, scratch))) { return HS_INVALID; } if (unlikely(markScratchInUse(scratch))) { return HS_SCRATCH_IN_USE; } if (rose->minWidth > length) { DEBUG_PRINTF("minwidth=%u > length=%u\n", rose->minWidth, length); unmarkScratchInUse(scratch); return HS_SUCCESS; } prefetch_data(data, length); /* populate core info in scratch */ populateCoreInfo(scratch, rose, scratch->bstate, onEvent, userCtx, data, length, NULL, 0, 0, 0, flags); clearEvec(rose, scratch->core_info.exhaustionVector); if (!length) { if (rose->boundary.reportZeroEodOffset) { roseRunBoundaryProgram(rose, rose->boundary.reportZeroEodOffset, 0, scratch); } goto set_retval; } if (rose->boundary.reportZeroOffset) { int rv = roseRunBoundaryProgram(rose, rose->boundary.reportZeroOffset, 0, scratch); if (rv == MO_HALT_MATCHING) { goto set_retval; } } if (rose->minWidthExcludingBoundaries > length) { DEBUG_PRINTF("minWidthExcludingBoundaries=%u > length=%u\n", rose->minWidthExcludingBoundaries, length); goto done_scan; } // Similarly, we may have a maximum width (for engines constructed entirely // of bi-anchored patterns). if (rose->maxBiAnchoredWidth != ROSE_BOUND_INF && length > rose->maxBiAnchoredWidth) { DEBUG_PRINTF("block len=%u longer than maxBAWidth=%u\n", length, rose->maxBiAnchoredWidth); goto done_scan; } // Is this a small write case? if (rose->smallWriteOffset) { const struct SmallWriteEngine *smwr = getSmallWrite(rose); assert(smwr); // Apply the small write engine if and only if the block (buffer) is // small enough. Otherwise, we allow rose &co to deal with it. if (length < smwr->largestBuffer) { DEBUG_PRINTF("Attempting small write of block %u bytes long.\n", length); runSmallWriteEngine(smwr, scratch); goto done_scan; } } switch (rose->runtimeImpl) { default: assert(0); case ROSE_RUNTIME_FULL_ROSE: rawBlockExec(rose, scratch); break; case ROSE_RUNTIME_PURE_LITERAL: pureLiteralBlockExec(rose, scratch); break; case ROSE_RUNTIME_SINGLE_OUTFIX: soleOutfixBlockExec(rose, scratch); break; } done_scan: if (told_to_stop_matching(scratch)) { unmarkScratchInUse(scratch); return HS_SCAN_TERMINATED; } if (rose->hasSom) { int halt = flushStoredSomMatches(scratch, ~0ULL); if (halt) { unmarkScratchInUse(scratch); return HS_SCAN_TERMINATED; } } if (rose->boundary.reportEodOffset) { roseRunBoundaryProgram(rose, rose->boundary.reportEodOffset, length, scratch); } set_retval: DEBUG_PRINTF("done. told_to_stop_matching=%d\n", told_to_stop_matching(scratch)); hs_error_t rv = told_to_stop_matching(scratch) ? HS_SCAN_TERMINATED : HS_SUCCESS; unmarkScratchInUse(scratch); return rv; } static really_inline void maintainHistoryBuffer(const struct RoseEngine *rose, char *state, const char *buffer, size_t length) { if (!rose->historyRequired) { return; } // Hopefully few of our users are scanning no data. if (unlikely(length == 0)) { DEBUG_PRINTF("zero-byte scan\n"); return; } char *his_state = state + rose->stateOffsets.history; if (length < rose->historyRequired) { size_t shortfall = rose->historyRequired - length; memmove(his_state, his_state + rose->historyRequired - shortfall, shortfall); } size_t amount = MIN(rose->historyRequired, length); memcpy(his_state + rose->historyRequired - amount, buffer + length - amount, amount); #ifdef DEBUG_HISTORY printf("History [%u] : ", rose->historyRequired); for (size_t i = 0; i < rose->historyRequired; i++) { printf(" %02hhx", his_state[i]); } printf("\n"); #endif } static really_inline void init_stream(struct hs_stream *s, const struct RoseEngine *rose, char init_history) { char *state = getMultiState(s); if (init_history) { // Make absolutely sure that the 16 bytes leading up to the end of the // history buffer are initialised, as we rely on this (regardless of the // actual values used) in FDR. char *hist_end = state + rose->stateOffsets.history + rose->historyRequired; assert(hist_end - 16 >= (const char *)s); memset(hist_end - 16, 0x5a, 16); } s->rose = rose; s->offset = 0; setStreamStatus(state, 0); roseInitState(rose, state); clearEvec(rose, state + rose->stateOffsets.exhausted); // SOM state multibit structures. initSomState(rose, state); } HS_PUBLIC_API hs_error_t hs_open_stream(const hs_database_t *db, UNUSED unsigned flags, hs_stream_t **stream) { if (unlikely(!stream)) { return HS_INVALID; } *stream = NULL; hs_error_t err = validDatabase(db); if (unlikely(err != HS_SUCCESS)) { return err; } const struct RoseEngine *rose = hs_get_bytecode(db); if (unlikely(!ISALIGNED_16(rose))) { return HS_INVALID; } if (unlikely(rose->mode != HS_MODE_STREAM)) { return HS_DB_MODE_ERROR; } size_t stateSize = rose->stateOffsets.end; struct hs_stream *s = hs_stream_alloc(sizeof(struct hs_stream) + stateSize); if (unlikely(!s)) { return HS_NOMEM; } init_stream(s, rose, 1); *stream = s; return HS_SUCCESS; } static really_inline void rawEodExec(hs_stream_t *id, hs_scratch_t *scratch) { const struct RoseEngine *rose = id->rose; if (can_stop_matching(scratch)) { DEBUG_PRINTF("stream already broken\n"); return; } if (isAllExhausted(rose, scratch->core_info.exhaustionVector)) { DEBUG_PRINTF("stream exhausted\n"); return; } roseStreamEodExec(rose, id->offset, scratch); } static never_inline void soleOutfixEodExec(hs_stream_t *id, hs_scratch_t *scratch) { const struct RoseEngine *t = id->rose; if (can_stop_matching(scratch)) { DEBUG_PRINTF("stream already broken\n"); return; } if (isAllExhausted(t, scratch->core_info.exhaustionVector)) { DEBUG_PRINTF("stream exhausted\n"); return; } assert(t->outfixEndQueue == 1); assert(!t->amatcherOffset); assert(!t->ematcherOffset); assert(!t->fmatcherOffset); const struct NFA *nfa = getNfaByQueue(t, 0); struct mq *q = scratch->queues; initOutfixQueue(q, 0, t, scratch); if (!scratch->core_info.buf_offset) { DEBUG_PRINTF("buf_offset is zero\n"); return; /* no vacuous engines */ } nfaExpandState(nfa, q->state, q->streamState, q->offset, queue_prev_byte(q, 0)); assert(nfaAcceptsEod(nfa)); nfaCheckFinalState(nfa, q->state, q->streamState, q->offset, q->cb, scratch); } static really_inline void report_eod_matches(hs_stream_t *id, hs_scratch_t *scratch, match_event_handler onEvent, void *context) { DEBUG_PRINTF("--- report eod matches at offset %llu\n", id->offset); assert(onEvent); const struct RoseEngine *rose = id->rose; char *state = getMultiState(id); u8 status = getStreamStatus(state); if (status & (STATUS_TERMINATED | STATUS_EXHAUSTED)) { DEBUG_PRINTF("stream is broken, just freeing storage\n"); return; } populateCoreInfo(scratch, rose, state, onEvent, context, NULL, 0, getHistory(state, rose, id->offset), getHistoryAmount(rose, id->offset), id->offset, status, 0); if (rose->somLocationCount) { loadSomFromStream(scratch, id->offset); } if (!id->offset) { if (rose->boundary.reportZeroEodOffset) { int rv = roseRunBoundaryProgram( rose, rose->boundary.reportZeroEodOffset, 0, scratch); if (rv == MO_HALT_MATCHING) { return; } } } else { if (rose->boundary.reportEodOffset) { int rv = roseRunBoundaryProgram( rose, rose->boundary.reportEodOffset, id->offset, scratch); if (rv == MO_HALT_MATCHING) { return; } } if (rose->requiresEodCheck) { switch (rose->runtimeImpl) { default: case ROSE_RUNTIME_PURE_LITERAL: assert(0); case ROSE_RUNTIME_FULL_ROSE: rawEodExec(id, scratch); break; case ROSE_RUNTIME_SINGLE_OUTFIX: soleOutfixEodExec(id, scratch); break; } } } if (rose->hasSom && !told_to_stop_matching(scratch)) { int halt = flushStoredSomMatches(scratch, ~0ULL); if (halt) { DEBUG_PRINTF("told to stop matching\n"); scratch->core_info.status |= STATUS_TERMINATED; } } } HS_PUBLIC_API hs_error_t hs_copy_stream(hs_stream_t **to_id, const hs_stream_t *from_id) { if (!to_id) { return HS_INVALID; } *to_id = NULL; if (!from_id || !from_id->rose) { return HS_INVALID; } const struct RoseEngine *rose = from_id->rose; size_t stateSize = sizeof(struct hs_stream) + rose->stateOffsets.end; struct hs_stream *s = hs_stream_alloc(stateSize); if (!s) { return HS_NOMEM; } memcpy(s, from_id, stateSize); *to_id = s; return HS_SUCCESS; } HS_PUBLIC_API hs_error_t 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) { if (!from_id || !from_id->rose) { return HS_INVALID; } if (!to_id || to_id->rose != from_id->rose) { return HS_INVALID; } if (to_id == from_id) { return HS_INVALID; } if (onEvent) { if (!scratch || !validScratch(to_id->rose, scratch)) { return HS_INVALID; } if (unlikely(markScratchInUse(scratch))) { return HS_SCRATCH_IN_USE; } report_eod_matches(to_id, scratch, onEvent, context); unmarkScratchInUse(scratch); } size_t stateSize = sizeof(struct hs_stream) + from_id->rose->stateOffsets.end; memcpy(to_id, from_id, stateSize); return HS_SUCCESS; } static really_inline void rawStreamExec(struct hs_stream *stream_state, struct hs_scratch *scratch) { assert(stream_state); assert(scratch); assert(!can_stop_matching(scratch)); DEBUG_PRINTF("::: streaming rose ::: offset = %llu len = %zu\n", stream_state->offset, scratch->core_info.len); const struct RoseEngine *rose = stream_state->rose; assert(rose); roseStreamExec(rose, scratch); if (!told_to_stop_matching(scratch) && isAllExhausted(rose, scratch->core_info.exhaustionVector)) { DEBUG_PRINTF("stream exhausted\n"); scratch->core_info.status |= STATUS_EXHAUSTED; } } static really_inline void pureLiteralStreamExec(struct hs_stream *stream_state, struct hs_scratch *scratch) { assert(stream_state); assert(scratch); assert(!can_stop_matching(scratch)); const struct RoseEngine *rose = stream_state->rose; const struct HWLM *ftable = getFLiteralMatcher(rose); size_t len2 = scratch->core_info.len; DEBUG_PRINTF("::: streaming rose ::: offset = %llu len = %zu\n", stream_state->offset, scratch->core_info.len); pureLiteralInitScratch(scratch, stream_state->offset); scratch->tctxt.groups = loadGroups(rose, scratch->core_info.state); // Pure literal cases don't have floatingMinDistance set, so we always // start the match region at zero. const size_t start = 0; hwlmExecStreaming(ftable, scratch, len2, start, roseCallback, scratch, rose->initialGroups); if (!told_to_stop_matching(scratch) && isAllExhausted(rose, scratch->core_info.exhaustionVector)) { DEBUG_PRINTF("stream exhausted\n"); scratch->core_info.status |= STATUS_EXHAUSTED; } } static never_inline void soleOutfixStreamExec(struct hs_stream *stream_state, struct hs_scratch *scratch) { assert(stream_state); assert(scratch); assert(!can_stop_matching(scratch)); const struct RoseEngine *t = stream_state->rose; assert(t->outfixEndQueue == 1); assert(!t->amatcherOffset); assert(!t->ematcherOffset); assert(!t->fmatcherOffset); const struct NFA *nfa = getNfaByQueue(t, 0); struct mq *q = scratch->queues; initOutfixQueue(q, 0, t, scratch); if (!scratch->core_info.buf_offset) { nfaQueueInitState(nfa, q); pushQueueAt(q, 0, MQE_START, 0); pushQueueAt(q, 1, MQE_TOP, 0); pushQueueAt(q, 2, MQE_END, scratch->core_info.len); } else { nfaExpandState(nfa, q->state, q->streamState, q->offset, queue_prev_byte(q, 0)); pushQueueAt(q, 0, MQE_START, 0); pushQueueAt(q, 1, MQE_END, scratch->core_info.len); } if (nfaQueueExec(q->nfa, q, scratch->core_info.len)) { nfaQueueCompressState(nfa, q, scratch->core_info.len); } else if (!told_to_stop_matching(scratch)) { scratch->core_info.status |= STATUS_EXHAUSTED; } } static inline hs_error_t hs_scan_stream_internal(hs_stream_t *id, const char *data, unsigned length, UNUSED unsigned flags, hs_scratch_t *scratch, match_event_handler onEvent, void *context) { assert(id); assert(scratch); if (unlikely(!data)) { return HS_INVALID; } const struct RoseEngine *rose = id->rose; char *state = getMultiState(id); u8 status = getStreamStatus(state); if (status & (STATUS_TERMINATED | STATUS_EXHAUSTED)) { DEBUG_PRINTF("stream is broken, halting scan\n"); if (status & STATUS_TERMINATED) { return HS_SCAN_TERMINATED; } else { return HS_SUCCESS; } } // We avoid doing any work if the user has given us zero bytes of data to // scan. Arguably we should define some semantics for how we treat vacuous // cases here. if (unlikely(length == 0)) { DEBUG_PRINTF("zero length block\n"); return HS_SUCCESS; } u32 historyAmount = getHistoryAmount(rose, id->offset); populateCoreInfo(scratch, rose, state, onEvent, context, data, length, getHistory(state, rose, id->offset), historyAmount, id->offset, status, flags); assert(scratch->core_info.hlen <= id->offset && scratch->core_info.hlen <= rose->historyRequired); prefetch_data(data, length); if (rose->somLocationCount) { loadSomFromStream(scratch, id->offset); } if (!id->offset && rose->boundary.reportZeroOffset) { DEBUG_PRINTF("zero reports\n"); int rv = roseRunBoundaryProgram(rose, rose->boundary.reportZeroOffset, 0, scratch); if (rv == MO_HALT_MATCHING) { DEBUG_PRINTF("halting scan\n"); setStreamStatus(state, scratch->core_info.status); if (told_to_stop_matching(scratch)) { return HS_SCAN_TERMINATED; } else { assert(scratch->core_info.status & STATUS_EXHAUSTED); return HS_SUCCESS; } } } switch (rose->runtimeImpl) { default: assert(0); case ROSE_RUNTIME_FULL_ROSE: rawStreamExec(id, scratch); break; case ROSE_RUNTIME_PURE_LITERAL: pureLiteralStreamExec(id, scratch); break; case ROSE_RUNTIME_SINGLE_OUTFIX: soleOutfixStreamExec(id, scratch); } if (rose->hasSom && !told_to_stop_matching(scratch)) { int halt = flushStoredSomMatches(scratch, ~0ULL); if (halt) { scratch->core_info.status |= STATUS_TERMINATED; } } setStreamStatus(state, scratch->core_info.status); if (likely(!can_stop_matching(scratch))) { maintainHistoryBuffer(rose, state, data, length); id->offset += length; /* maintain offset */ if (rose->somLocationCount) { storeSomToStream(scratch, id->offset); } } else if (told_to_stop_matching(scratch)) { return HS_SCAN_TERMINATED; } return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_scan_stream(hs_stream_t *id, const char *data, unsigned length, unsigned flags, hs_scratch_t *scratch, match_event_handler onEvent, void *context) { if (unlikely(!id || !scratch || !data || !validScratch(id->rose, scratch))) { return HS_INVALID; } if (unlikely(markScratchInUse(scratch))) { return HS_SCRATCH_IN_USE; } hs_error_t rv = hs_scan_stream_internal(id, data, length, flags, scratch, onEvent, context); unmarkScratchInUse(scratch); return rv; } HS_PUBLIC_API hs_error_t hs_close_stream(hs_stream_t *id, hs_scratch_t *scratch, match_event_handler onEvent, void *context) { if (!id) { return HS_INVALID; } if (onEvent) { if (!scratch || !validScratch(id->rose, scratch)) { return HS_INVALID; } if (unlikely(markScratchInUse(scratch))) { return HS_SCRATCH_IN_USE; } report_eod_matches(id, scratch, onEvent, context); unmarkScratchInUse(scratch); } hs_stream_free(id); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_reset_stream(hs_stream_t *id, UNUSED unsigned int flags, hs_scratch_t *scratch, match_event_handler onEvent, void *context) { if (!id) { return HS_INVALID; } if (onEvent) { if (!scratch || !validScratch(id->rose, scratch)) { return HS_INVALID; } if (unlikely(markScratchInUse(scratch))) { return HS_SCRATCH_IN_USE; } report_eod_matches(id, scratch, onEvent, context); unmarkScratchInUse(scratch); } // history already initialised init_stream(id, id->rose, 0); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_stream_size(const hs_database_t *db, size_t *stream_size) { if (!stream_size) { return HS_INVALID; } hs_error_t ret = validDatabase(db); if (ret != HS_SUCCESS) { return ret; } const struct RoseEngine *rose = hs_get_bytecode(db); if (!ISALIGNED_16(rose)) { return HS_INVALID; } if (rose->mode != HS_MODE_STREAM) { return HS_DB_MODE_ERROR; } u32 base_stream_size = rose->stateOffsets.end; // stream state plus the hs_stream struct itself *stream_size = base_stream_size + sizeof(struct hs_stream); return HS_SUCCESS; } #if defined(DEBUG) || defined(DUMP_SUPPORT) #include "util/compare.h" // A debugging crutch: print a hex-escaped version of the match for our // perusal. static UNUSED void dumpData(const char *data, size_t len) { DEBUG_PRINTF("BUFFER:"); for (size_t i = 0; i < len; i++) { u8 c = data[i]; if (ourisprint(c) && c != '\'') { printf("%c", c); } else { printf("\\x%02x", c); } } printf("\n"); } #endif HS_PUBLIC_API hs_error_t hs_scan_vector(const hs_database_t *db, const char * const * data, const unsigned int *length, unsigned int count, UNUSED unsigned int flags, hs_scratch_t *scratch, match_event_handler onEvent, void *context) { if (unlikely(!scratch || !data || !length)) { return HS_INVALID; } hs_error_t err = validDatabase(db); if (unlikely(err != HS_SUCCESS)) { return err; } const struct RoseEngine *rose = hs_get_bytecode(db); if (unlikely(!ISALIGNED_16(rose))) { return HS_INVALID; } if (unlikely(rose->mode != HS_MODE_VECTORED)) { return HS_DB_MODE_ERROR; } if (unlikely(!validScratch(rose, scratch))) { return HS_INVALID; } if (unlikely(markScratchInUse(scratch))) { return HS_SCRATCH_IN_USE; } hs_stream_t *id = (hs_stream_t *)(scratch->bstate); init_stream(id, rose, 1); /* open stream */ for (u32 i = 0; i < count; i++) { DEBUG_PRINTF("block %u/%u offset=%llu len=%u\n", i, count, id->offset, length[i]); #ifdef DEBUG dumpData(data[i], length[i]); #endif hs_error_t ret = hs_scan_stream_internal(id, data[i], length[i], 0, scratch, onEvent, context); if (ret != HS_SUCCESS) { unmarkScratchInUse(scratch); return ret; } } /* close stream */ if (onEvent) { report_eod_matches(id, scratch, onEvent, context); if (told_to_stop_matching(scratch)) { unmarkScratchInUse(scratch); return HS_SCAN_TERMINATED; } } unmarkScratchInUse(scratch); return HS_SUCCESS; } hyperscan-4.4.1/src/report.h0000644000175000017500000002163613055426554016562 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Runtime functions to do with reports, inlined into callers. */ #ifndef REPORT_H #define REPORT_H #include "hs_internal.h" #include "hs_runtime.h" #include "scratch.h" #include "ue2common.h" #include "nfa/callback.h" #include "nfa/nfa_internal.h" #include "rose/runtime.h" #include "som/som_runtime.h" #include "util/exhaust.h" #include "util/fatbit.h" enum DedupeResult { DEDUPE_CONTINUE, //!< Continue with match, not a dupe. DEDUPE_SKIP, //!< Don't report this match, dupe or delayed due to SOM. DEDUPE_HALT //!< User instructed us to stop matching. }; static really_inline enum DedupeResult dedupeCatchup(const struct RoseEngine *rose, struct hs_scratch *scratch, u64a offset, u64a from_offset, u64a to_offset, u32 dkey, s32 offset_adjust, char is_external_report, char quash_som, const char do_som) { DEBUG_PRINTF("offset=%llu, match=[%llu,%llu], dkey=%u, do_som=%d\n", offset, from_offset, to_offset, dkey, do_som); // We should not have been called if there's no dedupe work to do. assert(do_som || dkey != MO_INVALID_IDX); struct match_deduper *deduper = &scratch->deduper; if (offset != deduper->current_report_offset) { assert(deduper->current_report_offset == ~0ULL || deduper->current_report_offset < offset); if (offset == deduper->current_report_offset + 1) { fatbit_clear(deduper->log[offset % 2]); } else { fatbit_clear(deduper->log[0]); fatbit_clear(deduper->log[1]); } if (do_som && flushStoredSomMatches(scratch, offset)) { return DEDUPE_HALT; } deduper->current_report_offset = offset; } if (dkey != MO_INVALID_IDX) { const u32 dkeyCount = rose->dkeyCount; if (is_external_report || quash_som) { DEBUG_PRINTF("checking dkey %u at offset %llu\n", dkey, to_offset); assert(offset_adjust == 0 || offset_adjust == -1); if (fatbit_set(deduper->log[to_offset % 2], dkeyCount, dkey)) { /* we have already raised this report at this offset, squash * dupe match. */ DEBUG_PRINTF("dedupe\n"); return DEDUPE_SKIP; } } else if (do_som) { /* SOM external event */ DEBUG_PRINTF("checking dkey %u at offset %llu\n", dkey, to_offset); assert(offset_adjust == 0 || offset_adjust == -1); u64a *starts = deduper->som_start_log[to_offset % 2]; if (fatbit_set(deduper->som_log[to_offset % 2], dkeyCount, dkey)) { starts[dkey] = MIN(starts[dkey], from_offset); } else { starts[dkey] = from_offset; } DEBUG_PRINTF("starts[%u]=%llu\n", dkey, starts[dkey]); if (offset_adjust) { deduper->som_log_dirty |= 1; } else { deduper->som_log_dirty |= 2; } return DEDUPE_SKIP; } } return DEDUPE_CONTINUE; } /** \brief Test whether the given key (\a ekey) is set in the exhaustion vector * \a evec. */ static really_inline int isExhausted(const struct RoseEngine *rose, const char *evec, u32 ekey) { DEBUG_PRINTF("checking exhaustion %p %u\n", evec, ekey); assert(ekey != INVALID_EKEY); assert(ekey < rose->ekeyCount); return mmbit_isset((const u8 *)evec, rose->ekeyCount, ekey); } /** \brief Returns 1 if all exhaustion keys in the bitvector are on. */ static really_inline int isAllExhausted(const struct RoseEngine *rose, const char *evec) { if (!rose->canExhaust) { return 0; /* pattern set is inexhaustible */ } return mmbit_all((const u8 *)evec, rose->ekeyCount); } /** \brief Mark key \a ekey on in the exhaustion vector. */ static really_inline void markAsMatched(const struct RoseEngine *rose, char *evec, u32 ekey) { DEBUG_PRINTF("marking as exhausted key %u\n", ekey); assert(ekey != INVALID_EKEY); assert(ekey < rose->ekeyCount); mmbit_set((u8 *)evec, rose->ekeyCount, ekey); } /** \brief Clear all keys in the exhaustion vector. */ static really_inline void clearEvec(const struct RoseEngine *rose, char *evec) { DEBUG_PRINTF("clearing evec %p %u\n", evec, rose->ekeyCount); mmbit_clear((u8 *)evec, rose->ekeyCount); } /** * \brief Deliver the given report to the user callback. * * Assumes all preconditions (bounds, exhaustion etc) have been checked and * that dedupe catchup has been done. */ static really_inline int roseDeliverReport(u64a offset, ReportID onmatch, s32 offset_adjust, struct hs_scratch *scratch, u32 ekey) { assert(scratch); assert(scratch->magic == SCRATCH_MAGIC); struct core_info *ci = &scratch->core_info; u32 flags = 0; #ifndef RELEASE_BUILD if (offset_adjust) { // alert testing tools that we've got adjusted matches flags |= HS_MATCH_FLAG_ADJUSTED; } #endif assert(!can_stop_matching(scratch)); assert(ekey == INVALID_EKEY || !isExhausted(ci->rose, ci->exhaustionVector, ekey)); u64a from_offset = 0; u64a to_offset = offset + offset_adjust; DEBUG_PRINTF(">> reporting match @[%llu,%llu] for sig %u ctxt %p <<\n", from_offset, to_offset, onmatch, ci->userContext); int halt = ci->userCallback(onmatch, from_offset, to_offset, flags, ci->userContext); if (halt) { DEBUG_PRINTF("callback requested to terminate matches\n"); ci->status |= STATUS_TERMINATED; return MO_HALT_MATCHING; } if (ekey != INVALID_EKEY) { markAsMatched(ci->rose, ci->exhaustionVector, ekey); return MO_CONTINUE_MATCHING; } else { return ROSE_CONTINUE_MATCHING_NO_EXHAUST; } } /** * \brief Deliver the given SOM report to the user callback. * * Assumes all preconditions (bounds, exhaustion etc) have been checked and * that dedupe catchup has been done. */ static really_inline int roseDeliverSomReport(u64a from_offset, u64a to_offset, ReportID onmatch, s32 offset_adjust, struct hs_scratch *scratch, u32 ekey) { assert(scratch); assert(scratch->magic == SCRATCH_MAGIC); struct core_info *ci = &scratch->core_info; u32 flags = 0; #ifndef RELEASE_BUILD if (offset_adjust) { // alert testing tools that we've got adjusted matches flags |= HS_MATCH_FLAG_ADJUSTED; } #endif assert(!can_stop_matching(scratch)); assert(ekey == INVALID_EKEY || !isExhausted(ci->rose, ci->exhaustionVector, ekey)); to_offset += offset_adjust; assert(from_offset == HS_OFFSET_PAST_HORIZON || from_offset <= to_offset); DEBUG_PRINTF(">> reporting match @[%llu,%llu] for sig %u ctxt %p <<\n", from_offset, to_offset, onmatch, ci->userContext); int halt = ci->userCallback(onmatch, from_offset, to_offset, flags, ci->userContext); if (halt) { DEBUG_PRINTF("callback requested to terminate matches\n"); ci->status |= STATUS_TERMINATED; return MO_HALT_MATCHING; } if (ekey != INVALID_EKEY) { markAsMatched(ci->rose, ci->exhaustionVector, ekey); return MO_CONTINUE_MATCHING; } else { return ROSE_CONTINUE_MATCHING_NO_EXHAUST; } } #endif // REPORT_H hyperscan-4.4.1/src/rose/0000755000175000017500000000000013055426554016036 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/rose/rose_build_infix.h0000644000175000017500000000402013055426554021527 0ustar sleuthkidsleuthkid/* * 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 ROSE_BUILD_INFIX_H #define ROSE_BUILD_INFIX_H #include "ue2common.h" #include #include namespace ue2 { class CharReach; struct left_id; struct ue2_literal; static constexpr u32 NO_MATCH_LIMIT = 0xffffffff; u32 findMaxInfixMatches(const left_id &left, const std::set &lits); void findCountingMiracleInfo(const left_id &left, const std::vector &stop, u8 *cm_count, CharReach *cm_cr); } // namespace ue2 #endif // ROSE_BUILD_INFIX_H hyperscan-4.4.1/src/rose/rose_build_lookaround.h0000644000175000017500000000606213055426554022577 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Rose compile-time analysis for lookaround masks. */ #ifndef ROSE_ROSE_BUILD_LOOKAROUND_H #define ROSE_ROSE_BUILD_LOOKAROUND_H #include "rose_graph.h" #include namespace ue2 { class CharReach; class RoseBuildImpl; /** \brief Lookaround entry prototype, describing the reachability at a given * distance from the end of a role match. */ struct LookEntry { LookEntry(s8 offset_in, const CharReach &reach_in) : offset(offset_in), reach(reach_in) {} s8 offset; //!< offset from role match location. CharReach reach; //!< reachability at given offset. bool operator==(const LookEntry &other) const { return offset == other.offset && reach == other.reach; } }; static inline size_t hash_value(const LookEntry &l) { size_t val = 0; boost::hash_combine(val, l.offset); boost::hash_combine(val, l.reach); return val; } void findLookaroundMasks(const RoseBuildImpl &tbi, const RoseVertex v, std::vector &lookaround); /** * \brief If possible, render the prefix of the given vertex as a lookaround. * * Given a prefix, returns true (and fills the lookaround vector) if * it can be satisfied with a lookaround alone. */ bool makeLeftfixLookaround(const RoseBuildImpl &build, const RoseVertex v, std::vector &lookaround); void mergeLookaround(std::vector &lookaround, const std::vector &more_lookaround); } // namespace ue2 #endif // ROSE_ROSE_BUILD_LOOKAROUND_H hyperscan-4.4.1/src/rose/rose_build_role_aliasing.h0000644000175000017500000000332213055426554023226 0ustar sleuthkidsleuthkid/* * 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 ROSE_BUILD_ROLE_ALIASING #define ROSE_BUILD_ROLE_ALIASING namespace ue2 { class RoseBuildImpl; void aliasRoles(RoseBuildImpl &build, bool mergeRoses); } // namespace ue2 #endif hyperscan-4.4.1/src/rose/runtime.h0000644000175000017500000001213313055426554017672 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Runtime functions shared between various Rose runtime code. */ #ifndef ROSE_RUNTIME_H #define ROSE_RUNTIME_H #include "rose_internal.h" #include "scratch.h" #include "util/partial_store.h" /* * ROSE STATE LAYOUT: * * - runtime status byte (halt status, delay rebuild dirty, etc) * - rose state multibit * - active leaf array (multibit) * - active leftfix array (multibit) * - leftfix lag table * - anchored matcher state * - literal groups * - history buffer * - exhausted bitvector * - som slots, som multibit arrays * - nfa stream state (for each nfa) */ #define rose_inline really_inline /* Maximum offset that we will eagerly run prefixes to. Beyond this point, eager * prefixes are always run in exactly the same way as normal prefixes. */ #define EAGER_STOP_OFFSET 64 static really_inline const void *getByOffset(const struct RoseEngine *t, u32 offset) { assert(offset < t->size); return (const u8 *)t + offset; } static really_inline void *getRoleState(char *state) { return state + sizeof(u8); // status flags } /** \brief Fetch the active array for suffix nfas. */ static really_inline u8 *getActiveLeafArray(const struct RoseEngine *t, char *state) { return (u8 *)(state + t->stateOffsets.activeLeafArray); } /** \brief Fetch the active array for rose nfas. */ static really_inline u8 *getActiveLeftArray(const struct RoseEngine *t, char *state) { return (u8 *)(state + t->stateOffsets.activeLeftArray); } static really_inline rose_group loadGroups(const struct RoseEngine *t, const char *state) { return partial_load_u64a(state + t->stateOffsets.groups, t->stateOffsets.groups_size); } static really_inline void storeGroups(const struct RoseEngine *t, char *state, rose_group groups) { partial_store_u64a(state + t->stateOffsets.groups, groups, t->stateOffsets.groups_size); } static really_inline u8 *getLongLitState(const struct RoseEngine *t, char *state) { return (u8 *)(state + t->stateOffsets.longLitState); } static really_inline u8 *getLeftfixLagTable(const struct RoseEngine *t, char *state) { return (u8 *)(state + t->stateOffsets.leftfixLagTable); } static really_inline const u8 *getLeftfixLagTableConst(const struct RoseEngine *t, const char *state) { return (const u8 *)(state + t->stateOffsets.leftfixLagTable); } static really_inline u32 has_chained_nfas(const struct RoseEngine *t) { return t->outfixBeginQueue; } static really_inline void updateLastMatchOffset(struct RoseContext *tctxt, u64a offset) { DEBUG_PRINTF("match @%llu, last match @%llu\n", offset, tctxt->lastMatchOffset); assert(offset >= tctxt->minMatchOffset); assert(offset >= tctxt->lastMatchOffset); tctxt->lastMatchOffset = offset; } static really_inline void updateMinMatchOffset(struct RoseContext *tctxt, u64a offset) { DEBUG_PRINTF("min match now @%llu, was @%llu\n", offset, tctxt->minMatchOffset); assert(offset >= tctxt->minMatchOffset); assert(offset >= tctxt->minNonMpvMatchOffset); tctxt->minMatchOffset = offset; tctxt->minNonMpvMatchOffset = offset; } static really_inline void updateMinMatchOffsetFromMpv(struct RoseContext *tctxt, u64a offset) { DEBUG_PRINTF("min match now @%llu, was @%llu\n", offset, tctxt->minMatchOffset); assert(offset >= tctxt->minMatchOffset); assert(tctxt->minNonMpvMatchOffset >= tctxt->minMatchOffset); tctxt->minMatchOffset = offset; tctxt->minNonMpvMatchOffset = MAX(tctxt->minNonMpvMatchOffset, offset); } #endif hyperscan-4.4.1/src/rose/rose_build_convert.h0000644000175000017500000000352513055426554022103 0ustar sleuthkidsleuthkid/* * 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 ROSE_BUILD_CONVERT_H #define ROSE_BUILD_CONVERT_H namespace ue2 { class RoseBuildImpl; void convertFloodProneSuffixes(RoseBuildImpl &tbi); void convertBadLeaves(RoseBuildImpl &tbi); void convertPrefixToBounds(RoseBuildImpl &tbi); void convertAnchPrefixToBounds(RoseBuildImpl &tbi); } // namespace ue2 #endif hyperscan-4.4.1/src/rose/rose_build_matchers.cpp0000644000175000017500000006677513055426554022604 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** * \file * \brief Rose build: code for constructing literal tables. */ #include "rose_build_matchers.h" #include "rose_build_impl.h" #include "rose_build_width.h" #include "hwlm/hwlm_build.h" #include "hwlm/hwlm_literal.h" #include "nfa/castlecompile.h" #include "nfa/nfa_api_queue.h" #include "util/charreach_util.h" #include "util/compile_context.h" #include "util/compile_error.h" #include "util/dump_charclass.h" #include "util/report.h" #include "util/report_manager.h" #include "util/verify_types.h" #include "ue2common.h" #include #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { #ifdef DEBUG static UNUSED string dumpMask(const vector &v) { ostringstream oss; for (u8 e : v) { oss << setfill('0') << setw(2) << hex << (unsigned int)e; } return oss.str(); } #endif static bool maskFromLeftGraph(const LeftEngInfo &left, vector &msk, vector &cmp) { const u32 lag = left.lag; const ReportID report = left.leftfix_report; DEBUG_PRINTF("leftfix with lag %u, report %u\n", lag, report); assert(left.graph); const NGHolder &h = *left.graph; assert(in_degree(h.acceptEod, h) == 1); // no eod reports // Start with the set of reporter vertices for this leftfix. set curr; for (auto u : inv_adjacent_vertices_range(h.accept, h)) { if (contains(h[u].reports, report)) { curr.insert(u); } } assert(!curr.empty()); size_t i = HWLM_MASKLEN - lag - 1; do { if (curr.empty() || contains(curr, h.start) || contains(curr, h.startDs)) { DEBUG_PRINTF("end of the road\n"); break; } set next; CharReach cr; for (NFAVertex v : curr) { const auto &v_cr = h[v].char_reach; DEBUG_PRINTF("vertex %zu, reach %s\n", h[v].index, describeClass(v_cr).c_str()); cr |= v_cr; insert(&next, inv_adjacent_vertices(v, h)); } make_and_cmp_mask(cr, &msk.at(i), &cmp.at(i)); DEBUG_PRINTF("%zu: reach=%s, msk=%u, cmp=%u\n", i, describeClass(cr).c_str(), msk[i], cmp[i]); curr.swap(next); } while (i-- > 0); return true; } static bool maskFromLeftCastle(const LeftEngInfo &left, vector &msk, vector &cmp) { const u32 lag = left.lag; const ReportID report = left.leftfix_report; DEBUG_PRINTF("leftfix with lag %u, report %u\n", lag, report); assert(left.castle); const CastleProto &c = *left.castle; depth min_width(depth::infinity()); for (const PureRepeat &repeat : c.repeats | map_values) { if (contains(repeat.reports, report)) { min_width = min(min_width, repeat.bounds.min); } } DEBUG_PRINTF("castle min width for this report is %s\n", min_width.str().c_str()); if (!min_width.is_finite() || min_width == depth(0)) { DEBUG_PRINTF("bad min width\n"); return false; } u32 len = min_width; u32 end = HWLM_MASKLEN - lag; for (u32 i = end; i > end - min(end, len); i--) { make_and_cmp_mask(c.reach(), &msk.at(i - 1), &cmp.at(i - 1)); } return true; } static bool maskFromLeft(const LeftEngInfo &left, vector &msk, vector &cmp) { if (left.lag >= HWLM_MASKLEN) { DEBUG_PRINTF("too much lag\n"); return false; } if (left.graph) { return maskFromLeftGraph(left, msk, cmp); } else if (left.castle) { return maskFromLeftCastle(left, msk, cmp); } return false; } static bool maskFromPreds(const RoseBuildImpl &build, const rose_literal_id &id, const RoseVertex v, vector &msk, vector &cmp) { const RoseGraph &g = build.g; // For right now, wuss out and only handle cases with one pred. if (in_degree(v, g) != 1) { return false; } // Root successors have no literal before them. if (build.isRootSuccessor(v)) { return false; } // If we have a single predecessor with a short bound, we may be able to // fill out a mask with the trailing bytes of the previous literal. This // allows us to improve literals like the 'bar' in 'fo.bar'. RoseEdge e = *(in_edges(v, g).first); u32 bound = g[e].maxBound; if (bound != g[e].minBound || bound >= HWLM_MASKLEN) { return false; } bound += id.s.length(); if (bound >= HWLM_MASKLEN) { return false; } DEBUG_PRINTF("bound %u\n", bound); RoseVertex u = source(e, g); if (g[u].literals.size() != 1) { DEBUG_PRINTF("u has %zu literals\n", g[u].literals.size()); return false; } u32 u_lit_id = *(g[u].literals.begin()); const rose_literal_id &u_id = build.literals.right.at(u_lit_id); DEBUG_PRINTF("u has lit: %s\n", escapeString(u_id.s).c_str()); // Number of characters to take from the back of u's literal. size_t u_len = u_id.s.length(); size_t u_sublen = min(u_len, (size_t)HWLM_MASKLEN - bound); size_t i = HWLM_MASKLEN - (bound + u_sublen); ue2_literal::const_iterator it, ite; for (it = u_id.s.begin() + (u_len - u_sublen), ite = u_id.s.end(); it != ite; ++it) { make_and_cmp_mask(*it, &msk.at(i), &cmp.at(i)); ++i; } return true; } static bool findHamsterMask(const RoseBuildImpl &build, const rose_literal_id &id, const rose_literal_info &info, const RoseVertex v, vector &msk, vector &cmp) { // Start with zero masks. msk.assign(HWLM_MASKLEN, 0); cmp.assign(HWLM_MASKLEN, 0); // Masks can come from literal benefits (for mixed-case literals). if (info.requires_benefits) { assert(mixed_sensitivity(id.s)); size_t j = 0; for (ue2_literal::const_reverse_iterator it = id.s.rbegin(), ite = id.s.rend(); it != ite && j < HWLM_MASKLEN; ++it, ++j) { size_t offset = HWLM_MASKLEN - j - 1; const CharReach &cr = *it; make_and_cmp_mask(cr, &msk[offset], &cmp[offset]); } return true; } const LeftEngInfo &left = build.g[v].left; if (left && left.lag < HWLM_MASKLEN) { if (maskFromLeft(left, msk, cmp)) { DEBUG_PRINTF("mask from a leftfix!\n"); return true; } } if (id.s.length() < HWLM_MASKLEN) { if (maskFromPreds(build, id, v, msk, cmp)) { DEBUG_PRINTF("mask from preds!\n"); return true; } } return false; } static bool hamsterMaskCombine(vector &msk, vector &cmp, const vector &v_msk, const vector &v_cmp) { assert(msk.size() == HWLM_MASKLEN && cmp.size() == HWLM_MASKLEN); assert(v_msk.size() == HWLM_MASKLEN && v_cmp.size() == HWLM_MASKLEN); u8 all_masks = 0; for (size_t i = 0; i < HWLM_MASKLEN; i++) { u8 filter = ~(cmp[i] ^ v_cmp[i]); msk[i] &= v_msk[i]; msk[i] &= filter; cmp[i] &= filter; all_masks |= msk[i]; } // Return false if we have no bits on in any mask elements. return all_masks != 0; } static bool findHamsterMask(const RoseBuildImpl &build, const rose_literal_id &id, const rose_literal_info &info, vector &msk, vector &cmp) { if (!build.cc.grey.roseHamsterMasks) { return false; } if (!info.delayed_ids.empty()) { // Not safe to add masks to delayed literals at this late stage. return false; } size_t num = 0; vector v_msk, v_cmp; for (RoseVertex v : info.vertices) { if (!findHamsterMask(build, id, info, v, v_msk, v_cmp)) { DEBUG_PRINTF("no mask\n"); return false; } if (!num++) { // First (or only) vertex, this becomes the mask/cmp pair. msk = v_msk; cmp = v_cmp; } else { // Multiple vertices with potentially different masks. We combine // them into an 'advisory' mask. if (!hamsterMaskCombine(msk, cmp, v_msk, v_cmp)) { DEBUG_PRINTF("mask went to zero\n"); return false; } } } normaliseLiteralMask(id.s, msk, cmp); if (msk.empty()) { DEBUG_PRINTF("no mask\n"); return false; } DEBUG_PRINTF("msk=%s, cmp=%s\n", dumpMask(msk).c_str(), dumpMask(cmp).c_str()); return true; } void findMoreLiteralMasks(RoseBuildImpl &build) { if (!build.cc.grey.roseHamsterMasks) { return; } vector candidates; for (const auto &e : build.literals.right) { const u32 id = e.first; const auto &lit = e.second; // This pass takes place before final IDs are assigned to literals. assert(!build.hasFinalId(id)); if (lit.delay || build.isDelayed(id)) { continue; } // Literal masks are only allowed for literals that will end up in an // HWLM table. switch (lit.table) { case ROSE_FLOATING: case ROSE_EOD_ANCHORED: case ROSE_ANCHORED_SMALL_BLOCK: break; default: continue; } if (!lit.msk.empty()) { continue; } const auto &lit_info = build.literal_info.at(id); if (lit_info.requires_benefits) { continue; } candidates.push_back(id); } for (const u32 &id : candidates) { const auto &lit = build.literals.right.at(id); auto &lit_info = build.literal_info.at(id); vector msk, cmp; if (!findHamsterMask(build, lit, lit_info, msk, cmp)) { continue; } assert(!msk.empty()); DEBUG_PRINTF("found advisory mask for lit_id=%u (%s)\n", id, dumpString(lit.s).c_str()); u32 new_id = build.getLiteralId(lit.s, msk, cmp, lit.delay, lit.table); assert(new_id != id); DEBUG_PRINTF("replacing with new lit_id=%u\n", new_id); // Note that our new literal may already exist and have vertices, etc. // We assume that this transform is happening prior to group assignment. assert(lit_info.group_mask == 0); auto &new_info = build.literal_info.at(new_id); // Move the vertices across. new_info.vertices.insert(begin(lit_info.vertices), end(lit_info.vertices)); for (auto v : lit_info.vertices) { build.g[v].literals.erase(id); build.g[v].literals.insert(new_id); } lit_info.vertices.clear(); // Preserve other properties. new_info.requires_explode = lit_info.requires_explode; new_info.requires_benefits = lit_info.requires_benefits; } } static bool isDirectHighlander(const RoseBuildImpl &build, const u32 id, const rose_literal_info &info) { if (!build.isDirectReport(id)) { return false; } auto is_simple_exhaustible = [&build](ReportID rid) { const Report &report = build.rm.getReport(rid); return isSimpleExhaustible(report); }; assert(!info.vertices.empty()); for (const auto &v : info.vertices) { const auto &reports = build.g[v].reports; assert(!reports.empty()); if (!all_of(begin(reports), end(reports), is_simple_exhaustible)) { return false; } } return true; } // Called by isNoRunsLiteral below. static bool isNoRunsVertex(const RoseBuildImpl &build, RoseVertex u) { const RoseGraph &g = build.g; if (!g[u].isBoring()) { DEBUG_PRINTF("u=%zu is not boring\n", g[u].index); return false; } if (!g[u].reports.empty()) { DEBUG_PRINTF("u=%zu has accept\n", g[u].index); return false; } /* TODO: handle non-root roles as well. It can't be that difficult... */ if (in_degree(u, g) != 1) { DEBUG_PRINTF("u=%zu is not a root role\n", g[u].index); return false; } RoseEdge e = edge(build.root, u, g); if (!e) { DEBUG_PRINTF("u=%zu is not a root role\n", g[u].index); return false; } if (g[e].minBound != 0 || g[e].maxBound != ROSE_BOUND_INF) { DEBUG_PRINTF("u=%zu has bounds from root\n", g[u].index); return false; } for (const auto &oe : out_edges_range(u, g)) { RoseVertex v = target(oe, g); if (g[oe].maxBound != ROSE_BOUND_INF) { DEBUG_PRINTF("edge (%zu,%zu) has max bound\n", g[u].index, g[v].index); return false; } if (g[v].left) { DEBUG_PRINTF("v=%zu has rose prefix\n", g[v].index); return false; } } return true; } static bool isNoRunsLiteral(const RoseBuildImpl &build, const u32 id, const rose_literal_info &info, const size_t max_len) { DEBUG_PRINTF("lit id %u\n", id); if (info.requires_benefits) { DEBUG_PRINTF("requires benefits\n"); // which would need confirm return false; } if (build.literals.right.at(id).s.length() > max_len) { DEBUG_PRINTF("requires literal check\n"); return false; } if (isDirectHighlander(build, id, info)) { DEBUG_PRINTF("highlander direct report\n"); return true; } // Undelayed vertices. for (RoseVertex v : info.vertices) { if (!isNoRunsVertex(build, v)) { return false; } } // Delayed vertices. for (u32 d : info.delayed_ids) { assert(d < build.literal_info.size()); const rose_literal_info &delayed_info = build.literal_info.at(d); assert(delayed_info.undelayed_id == id); for (RoseVertex v : delayed_info.vertices) { if (!isNoRunsVertex(build, v)) { return false; } } } DEBUG_PRINTF("is no-runs literal\n"); return true; } static const raw_puff &getChainedPuff(const RoseBuildImpl &build, const Report &report) { DEBUG_PRINTF("chained report, event %u\n", report.onmatch); // MPV has already been moved to the outfixes vector. assert(!build.mpv_outfix); auto mpv_outfix_it = find_if( begin(build.outfixes), end(build.outfixes), [](const OutfixInfo &outfix) { return outfix.is_nonempty_mpv(); }); assert(mpv_outfix_it != end(build.outfixes)); const auto *mpv = mpv_outfix_it->mpv(); u32 puff_index = report.onmatch - MQE_TOP_FIRST; assert(puff_index < mpv->triggered_puffettes.size()); return mpv->triggered_puffettes.at(puff_index); } /** * \brief Returns a conservative estimate of the minimum offset at which the * given literal can lead to a report. * * TODO: This could be made more precise by calculating a "distance to accept" * for every vertex in the graph; right now we're only accurate for leaf nodes. */ static u64a literalMinReportOffset(const RoseBuildImpl &build, const rose_literal_id &lit, const rose_literal_info &info) { const auto &g = build.g; const u32 lit_len = verify_u32(lit.elength()); u64a lit_min_offset = UINT64_MAX; for (const auto &v : info.vertices) { DEBUG_PRINTF("vertex %zu min_offset=%u\n", g[v].index, g[v].min_offset); u64a vert_offset = g[v].min_offset; if (vert_offset >= lit_min_offset) { continue; } u64a min_offset = UINT64_MAX; for (const auto &id : g[v].reports) { const Report &report = build.rm.getReport(id); DEBUG_PRINTF("report id %u, min offset=%llu\n", id, report.minOffset); if (report.type == INTERNAL_ROSE_CHAIN) { // This vertex triggers an MPV, which will fire reports after // repeating for a while. assert(report.minOffset == 0); // Should not have bounds. const auto &puff = getChainedPuff(build, report); DEBUG_PRINTF("chained puff repeats=%u\n", puff.repeats); const Report &puff_report = build.rm.getReport(puff.report); DEBUG_PRINTF("puff report %u, min offset=%llu\n", puff.report, puff_report.minOffset); min_offset = min(min_offset, max(vert_offset + puff.repeats, puff_report.minOffset)); } else { DEBUG_PRINTF("report min offset=%llu\n", report.minOffset); min_offset = min(min_offset, max(vert_offset, report.minOffset)); } } if (g[v].suffix) { depth suffix_width = findMinWidth(g[v].suffix, g[v].suffix.top); assert(suffix_width.is_reachable()); DEBUG_PRINTF("suffix with width %s\n", suffix_width.str().c_str()); min_offset = min(min_offset, vert_offset + suffix_width); } if (!isLeafNode(v, g) || min_offset == UINT64_MAX) { min_offset = vert_offset; } lit_min_offset = min(lit_min_offset, min_offset); } // If this literal in the undelayed literal corresponding to some delayed // literals, we must take their minimum offsets into account. for (const u32 &delayed_id : info.delayed_ids) { const auto &delayed_lit = build.literals.right.at(delayed_id); const auto &delayed_info = build.literal_info.at(delayed_id); u64a delayed_min_offset = literalMinReportOffset(build, delayed_lit, delayed_info); DEBUG_PRINTF("delayed_id=%u, min_offset = %llu\n", delayed_id, delayed_min_offset); lit_min_offset = min(lit_min_offset, delayed_min_offset); } // If we share a vertex with a shorter literal, our min offset might dip // below the length of this one. lit_min_offset = max(lit_min_offset, u64a{lit_len}); return lit_min_offset; } vector fillHamsterLiteralList(const RoseBuildImpl &build, rose_literal_table table, size_t max_len, u32 max_offset) { vector lits; for (const auto &e : build.literals.right) { const u32 id = e.first; if (!build.hasFinalId(id)) { continue; } if (e.second.delay) { continue; /* delay id's are virtual-ish */ } if (e.second.table != table) { continue; /* wrong table */ } assert(id < build.literal_info.size()); const rose_literal_info &info = build.literal_info[id]; u32 final_id = info.final_id; rose_group groups = info.group_mask; /* Note: requires_benefits are handled in the literal entries */ const ue2_literal &lit = e.second.s; DEBUG_PRINTF("lit='%s'\n", escapeString(lit).c_str()); if (max_offset != ROSE_BOUND_INF) { u64a min_report = literalMinReportOffset(build, e.second, info); if (min_report > max_offset) { DEBUG_PRINTF("min report offset=%llu exceeds max_offset=%u\n", min_report, max_offset); continue; } } const vector &msk = e.second.msk; const vector &cmp = e.second.cmp; bool noruns = isNoRunsLiteral(build, id, info, max_len); if (info.requires_explode) { DEBUG_PRINTF("exploding lit\n"); // We do not require_explode for long literals. assert(lit.length() <= max_len); case_iter cit = caseIterateBegin(lit); case_iter cite = caseIterateEnd(); for (; cit != cite; ++cit) { string s = *cit; bool nocase = false; DEBUG_PRINTF("id=%u, s='%s', nocase=%d, noruns=%d msk=%s, " "cmp=%s (exploded)\n", final_id, escapeString(s).c_str(), nocase, noruns, dumpMask(msk).c_str(), dumpMask(cmp).c_str()); if (!maskIsConsistent(s, nocase, msk, cmp)) { DEBUG_PRINTF("msk/cmp for literal can't match, skipping\n"); continue; } lits.emplace_back(move(s), nocase, noruns, final_id, groups, msk, cmp); } } else { string s = lit.get_string(); bool nocase = lit.any_nocase(); DEBUG_PRINTF("id=%u, s='%s', nocase=%d, noruns=%d, msk=%s, " "cmp=%s\n", final_id, escapeString(s).c_str(), (int)nocase, noruns, dumpMask(msk).c_str(), dumpMask(cmp).c_str()); if (s.length() > max_len) { DEBUG_PRINTF("truncating to tail of length %zu\n", max_len); s.erase(0, s.length() - max_len); // We shouldn't have set a threshold below 8 chars. assert(msk.size() <= max_len); } if (!maskIsConsistent(s, nocase, msk, cmp)) { DEBUG_PRINTF("msk/cmp for literal can't match, skipping\n"); continue; } lits.emplace_back(move(s), nocase, noruns, final_id, groups, msk, cmp); } } return lits; } aligned_unique_ptr buildFloatingMatcher(const RoseBuildImpl &build, size_t longLitLengthThreshold, rose_group *fgroups, size_t *fsize, size_t *historyRequired) { *fsize = 0; *fgroups = 0; auto fl = fillHamsterLiteralList(build, ROSE_FLOATING, longLitLengthThreshold); if (fl.empty()) { DEBUG_PRINTF("empty floating matcher\n"); return nullptr; } for (const hwlmLiteral &hlit : fl) { *fgroups |= hlit.groups; } hwlmStreamingControl ctl; hwlmStreamingControl *ctlp; if (build.cc.streaming) { ctl.history_max = build.cc.grey.maxHistoryAvailable; ctl.history_min = MAX(*historyRequired, build.cc.grey.minHistoryAvailable); DEBUG_PRINTF("streaming control, history max=%zu, min=%zu\n", ctl.history_max, ctl.history_min); ctlp = &ctl; } else { ctlp = nullptr; // Null for non-streaming. } aligned_unique_ptr ftable = hwlmBuild(fl, ctlp, false, build.cc, build.getInitialGroups()); if (!ftable) { throw CompileError("Unable to generate bytecode."); } if (build.cc.streaming) { DEBUG_PRINTF("literal_history_required=%zu\n", ctl.literal_history_required); assert(ctl.literal_history_required <= build.cc.grey.maxHistoryAvailable); *historyRequired = max(*historyRequired, ctl.literal_history_required); } *fsize = hwlmSize(ftable.get()); assert(*fsize); DEBUG_PRINTF("built floating literal table size %zu bytes\n", *fsize); return ftable; } aligned_unique_ptr buildSmallBlockMatcher(const RoseBuildImpl &build, size_t *sbsize) { *sbsize = 0; if (build.cc.streaming) { DEBUG_PRINTF("streaming mode\n"); return nullptr; } u32 float_min = findMinWidth(build, ROSE_FLOATING); if (float_min > ROSE_SMALL_BLOCK_LEN) { DEBUG_PRINTF("floating table has large min width %u, fail\n", float_min); return nullptr; } auto lits = fillHamsterLiteralList( build, ROSE_FLOATING, ROSE_SMALL_BLOCK_LEN, ROSE_SMALL_BLOCK_LEN); if (lits.empty()) { DEBUG_PRINTF("no floating table\n"); return nullptr; } else if (lits.size() == 1) { DEBUG_PRINTF("single floating literal, noodle will be fast enough\n"); return nullptr; } auto anchored_lits = fillHamsterLiteralList(build, ROSE_ANCHORED_SMALL_BLOCK, ROSE_SMALL_BLOCK_LEN, ROSE_SMALL_BLOCK_LEN); if (anchored_lits.empty()) { DEBUG_PRINTF("no small-block anchored literals\n"); return nullptr; } lits.insert(lits.end(), anchored_lits.begin(), anchored_lits.end()); // None of our literals should be longer than the small block limit. assert(all_of(begin(lits), end(lits), [](const hwlmLiteral &lit) { return lit.s.length() <= ROSE_SMALL_BLOCK_LEN; })); if (lits.empty()) { DEBUG_PRINTF("no literals shorter than small block len\n"); return nullptr; } aligned_unique_ptr hwlm = hwlmBuild(lits, nullptr, true, build.cc, build.getInitialGroups()); if (!hwlm) { throw CompileError("Unable to generate bytecode."); } *sbsize = hwlmSize(hwlm.get()); assert(*sbsize); DEBUG_PRINTF("built small block literal table size %zu bytes\n", *sbsize); return hwlm; } aligned_unique_ptr buildEodAnchoredMatcher(const RoseBuildImpl &build, size_t *esize) { *esize = 0; auto el = fillHamsterLiteralList(build, ROSE_EOD_ANCHORED, build.ematcher_region_size); if (el.empty()) { DEBUG_PRINTF("no eod anchored literals\n"); assert(!build.ematcher_region_size); return nullptr; } assert(build.ematcher_region_size); hwlmStreamingControl *ctlp = nullptr; // not a streaming case aligned_unique_ptr etable = hwlmBuild(el, ctlp, true, build.cc, build.getInitialGroups()); if (!etable) { throw CompileError("Unable to generate bytecode."); } *esize = hwlmSize(etable.get()); assert(*esize); DEBUG_PRINTF("built eod-anchored literal table size %zu bytes\n", *esize); return etable; } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_add_internal.h0000644000175000017500000000372513055426554023051 0ustar sleuthkidsleuthkid/* * 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 ROSE_BUILD_ADD_INTERNAL_H #define ROSE_BUILD_ADD_INTERNAL_H #include "rose_graph.h" #include "ue2common.h" #include namespace ue2 { class RoseBuildImpl; RoseVertex createVertex(RoseBuildImpl *build, const RoseVertex parent, u32 minBound, u32 maxBound, u32 literalId, size_t literalLength, const ue2::flat_set &reports); } // namespace ue2 #endif hyperscan-4.4.1/src/rose/rose_build_lookaround.cpp0000644000175000017500000005257713055426554023146 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ /** \file * \brief Rose compile-time analysis for lookaround masks. */ #include "rose_build_lookaround.h" #include "rose_build_impl.h" #include "nfa/castlecompile.h" #include "nfa/goughcompile.h" #include "nfa/rdfa.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_util.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include "util/verify_types.h" #include #include using namespace std; namespace ue2 { /** \brief Max search distance for reachability in front of a role. */ static const u32 MAX_FWD_LEN = 64; /** \brief Max search distance for reachability behind a role. */ static const u32 MAX_BACK_LEN = 64; /** \brief Max lookaround entries for a role. */ static const u32 MAX_LOOKAROUND_ENTRIES = 16; /** \brief We would rather have lookarounds with smaller reach than this. */ static const u32 LOOKAROUND_WIDE_REACH = 200; static void getForwardReach(const NGHolder &g, u32 top, map &look) { ue2::flat_set curr, next; // Consider only successors of start with the required top. for (const auto &e : out_edges_range(g.start, g)) { NFAVertex v = target(e, g); if (v == g.startDs) { continue; } if (contains(g[e].tops, top)) { curr.insert(v); } } for (u32 i = 0; i < MAX_FWD_LEN; i++) { if (curr.empty() || contains(curr, g.accept) || contains(curr, g.acceptEod)) { break; } next.clear(); CharReach cr; for (auto v : curr) { assert(!is_special(v, g)); cr |= g[v].char_reach; insert(&next, adjacent_vertices(v, g)); } assert(cr.any()); look[i] |= cr; curr.swap(next); } } static void getBackwardReach(const NGHolder &g, ReportID report, u32 lag, map &look) { ue2::flat_set curr, next; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { if (contains(g[v].reports, report)) { curr.insert(v); } } for (u32 i = lag + 1; i <= MAX_BACK_LEN; i++) { if (curr.empty() || contains(curr, g.start) || contains(curr, g.startDs)) { break; } next.clear(); CharReach cr; for (auto v : curr) { assert(!is_special(v, g)); cr |= g[v].char_reach; insert(&next, inv_adjacent_vertices(v, g)); } assert(cr.any()); look[0 - i] |= cr; curr.swap(next); } } static void getForwardReach(const CastleProto &castle, u32 top, map &look) { depth len = castle.repeats.at(top).bounds.min; len = min(len, depth(MAX_FWD_LEN)); assert(len.is_finite()); const CharReach &cr = castle.reach(); for (u32 i = 0; i < len; i++) { look[i] |= cr; } } static void getBackwardReach(const CastleProto &castle, ReportID report, u32 lag, map &look) { depth min_depth = depth::infinity(); for (const auto &m : castle.repeats) { const PureRepeat &pr = m.second; if (contains(pr.reports, report)) { min_depth = min(min_depth, pr.bounds.min); } } if (!min_depth.is_finite()) { assert(0); return; } const CharReach &cr = castle.reach(); for (u32 i = lag + 1; i <= min(lag + (u32)min_depth, MAX_BACK_LEN); i++) { look[0 - i] |= cr; } } static void getForwardReach(const raw_dfa &rdfa, map &look) { if (rdfa.states.size() < 2) { return; } ue2::flat_set curr, next; curr.insert(rdfa.start_anchored); for (u32 i = 0; i < MAX_FWD_LEN && !curr.empty(); i++) { next.clear(); CharReach cr; for (const auto state_id : curr) { const dstate &ds = rdfa.states[state_id]; if (!ds.reports.empty() || !ds.reports_eod.empty()) { return; } for (unsigned c = 0; c < N_CHARS; c++) { dstate_id_t succ = ds.next[rdfa.alpha_remap[c]]; if (succ != DEAD_STATE) { cr.set(c); next.insert(succ); } } } assert(cr.any()); look[i] |= cr; curr.swap(next); } } static void getSuffixForwardReach(const suffix_id &suff, u32 top, map &look) { if (suff.graph()) { getForwardReach(*suff.graph(), top, look); } else if (suff.castle()) { getForwardReach(*suff.castle(), top, look); } else if (suff.dfa()) { assert(top == 0); // DFA isn't multi-top capable. getForwardReach(*suff.dfa(), look); } else if (suff.haig()) { assert(top == 0); // DFA isn't multi-top capable. getForwardReach(*suff.haig(), look); } } static void getRoseForwardReach(const left_id &left, u32 top, map &look) { if (left.graph()) { getForwardReach(*left.graph(), top, look); } else if (left.castle()) { getForwardReach(*left.castle(), top, look); } else if (left.dfa()) { assert(top == 0); // DFA isn't multi-top capable. getForwardReach(*left.dfa(), look); } else if (left.haig()) { assert(top == 0); // DFA isn't multi-top capable. getForwardReach(*left.haig(), look); } } static void combineForwardMasks(const vector > &rose_look, map &look) { for (u32 i = 0; i < MAX_FWD_LEN; i++) { for (const auto &rlook : rose_look) { if (contains(rlook, i)) { look[i] |= rlook.at(i); } else { look[i].setall(); } } } } static void findForwardReach(const RoseGraph &g, const RoseVertex v, map &look) { if (!g[v].reports.empty()) { DEBUG_PRINTF("acceptor\n"); return; } // Non-leaf vertices can pick up a mask per successor prefix rose // engine. vector> rose_look; for (const auto &e : out_edges_range(v, g)) { RoseVertex t = target(e, g); if (!g[t].left) { DEBUG_PRINTF("successor %zu has no leftfix\n", g[t].index); return; } rose_look.push_back(map()); getRoseForwardReach(g[t].left, g[e].rose_top, rose_look.back()); } if (g[v].suffix) { DEBUG_PRINTF("suffix engine\n"); rose_look.push_back(map()); getSuffixForwardReach(g[v].suffix, g[v].suffix.top, rose_look.back()); } combineForwardMasks(rose_look, look); } static void findBackwardReach(const RoseGraph &g, const RoseVertex v, map &look) { if (!g[v].left) { return; } DEBUG_PRINTF("leftfix, report=%u, lag=%u\n", g[v].left.leftfix_report, g[v].left.lag); if (g[v].left.graph) { getBackwardReach(*g[v].left.graph, g[v].left.leftfix_report, g[v].left.lag, look); } else if (g[v].left.castle) { getBackwardReach(*g[v].left.castle, g[v].left.leftfix_report, g[v].left.lag, look); } // TODO: implement DFA variants if necessary. } #if defined(DEBUG) || defined(DUMP_SUPPORT) #include static UNUSED string dump(const map &look) { ostringstream oss; for (auto it = look.begin(), ite = look.end(); it != ite; ++it) { if (it != look.begin()) { oss << ", "; } oss << "{" << it->first << ": " << describeClass(it->second) << "}"; } return oss.str(); } #endif static void normalise(map &look) { // We can erase entries where the reach is "all characters". vector dead; for (const auto &m : look) { if (m.second.all()) { dead.push_back(m.first); } } erase_all(&look, dead); } namespace { struct LookPriority { explicit LookPriority(const map &look_in) : look(look_in) {} bool operator()(s32 a, s32 b) const { const CharReach &a_reach = look.at(a); const CharReach &b_reach = look.at(b); if (a_reach.count() != b_reach.count()) { return a_reach.count() < b_reach.count(); } return abs(a) < abs(b); } private: const map &look; }; } // namespace static bool isFloodProne(const map &look, const CharReach &flood_cr) { for (const auto &m : look) { const CharReach &look_cr = m.second; if (!overlaps(look_cr, flood_cr)) { return false; } } DEBUG_PRINTF("look can't escape flood on %s\n", describeClass(flood_cr).c_str()); return true; } static bool isFloodProne(const map &look, const set &flood_reach) { if (flood_reach.empty()) { return false; } for (const CharReach &flood_cr : flood_reach) { if (isFloodProne(look, flood_cr)) { return true; } } return false; } static void reduce(map &look, set &flood_reach) { if (look.size() <= MAX_LOOKAROUND_ENTRIES) { return; } DEBUG_PRINTF("before reduce: %s\n", dump(look).c_str()); // First, remove floods that we already can't escape; they shouldn't affect // the analysis below. for (auto it = flood_reach.begin(); it != flood_reach.end();) { if (isFloodProne(look, *it)) { DEBUG_PRINTF("removing inescapable flood on %s from analysis\n", describeClass(*it).c_str()); flood_reach.erase(it++); } else { ++it; } } LookPriority cmp(look); priority_queue, LookPriority> pq(cmp); for (const auto &m : look) { pq.push(m.first); } while (!pq.empty() && look.size() > MAX_LOOKAROUND_ENTRIES) { s32 d = pq.top(); assert(contains(look, d)); const CharReach cr(look[d]); // copy pq.pop(); DEBUG_PRINTF("erasing {%d: %s}\n", d, describeClass(cr).c_str()); look.erase(d); // If removing this entry would result in us becoming flood_prone on a // particular flood_reach case, reinstate it and move on. if (isFloodProne(look, flood_reach)) { DEBUG_PRINTF("reinstating {%d: %s} due to flood-prone check\n", d, describeClass(cr).c_str()); look.insert(make_pair(d, cr)); } } while (!pq.empty()) { s32 d = pq.top(); assert(contains(look, d)); const CharReach cr(look[d]); // copy pq.pop(); if (cr.count() < LOOKAROUND_WIDE_REACH) { continue; } DEBUG_PRINTF("erasing {%d: %s}\n", d, describeClass(cr).c_str()); look.erase(d); // If removing this entry would result in us becoming flood_prone on a // particular flood_reach case, reinstate it and move on. if (isFloodProne(look, flood_reach)) { DEBUG_PRINTF("reinstating {%d: %s} due to flood-prone check\n", d, describeClass(cr).c_str()); look.insert(make_pair(d, cr)); } } DEBUG_PRINTF("after reduce: %s\n", dump(look).c_str()); } static void findFloodReach(const RoseBuildImpl &tbi, const RoseVertex v, set &flood_reach) { for (u32 lit_id : tbi.g[v].literals) { const ue2_literal &s = tbi.literals.right.at(lit_id).s; if (s.empty()) { continue; } if (is_flood(s)) { CharReach cr(*s.begin()); DEBUG_PRINTF("flood-prone with reach: %s\n", describeClass(cr).c_str()); flood_reach.insert(cr); } } } static map findLiteralReach(const rose_literal_id &lit) { map look; u32 i = lit.delay + 1; for (auto it = lit.s.rbegin(), ite = lit.s.rend(); it != ite; ++it) { look[0 - i] |= *it; i++; } return look; } static map findLiteralReach(const RoseBuildImpl &build, const RoseVertex v) { bool first = true; map look; for (u32 lit_id : build.g[v].literals) { const rose_literal_id &lit = build.literals.right.at(lit_id); auto lit_look = findLiteralReach(lit); if (first) { look = move(lit_look); first = false; } else { for (auto it = look.begin(); it != look.end();) { auto l_it = lit_look.find(it->first); if (l_it == lit_look.end()) { it = look.erase(it); } else { it->second |= l_it->second; ++it; } } } } DEBUG_PRINTF("lit lookaround: %s\n", dump(look).c_str()); return look; } /** * Trim lookaround checks from the prefix that overlap with the literals * themselves. */ static void trimLiterals(const RoseBuildImpl &build, const RoseVertex v, map &look) { DEBUG_PRINTF("pre-trim lookaround: %s\n", dump(look).c_str()); for (const auto &m : findLiteralReach(build, v)) { auto it = look.find(m.first); if (it == end(look)) { continue; } if (m.second.isSubsetOf(it->second)) { DEBUG_PRINTF("can trim entry at %d\n", it->first); look.erase(it); } } DEBUG_PRINTF("post-trim lookaround: %s\n", dump(look).c_str()); } void findLookaroundMasks(const RoseBuildImpl &tbi, const RoseVertex v, vector &lookaround) { lookaround.clear(); const RoseGraph &g = tbi.g; map look; findBackwardReach(g, v, look); findForwardReach(g, v, look); trimLiterals(tbi, v, look); if (look.empty()) { return; } normalise(look); if (look.empty()) { return; } set flood_reach; findFloodReach(tbi, v, flood_reach); reduce(look, flood_reach); if (look.empty()) { return; } DEBUG_PRINTF("lookaround: %s\n", dump(look).c_str()); lookaround.reserve(look.size()); for (const auto &m : look) { s8 offset = verify_s8(m.first); lookaround.emplace_back(offset, m.second); } } static bool hasSingleFloatingStart(const NGHolder &g) { NFAVertex initial = NGHolder::null_vertex(); for (auto v : adjacent_vertices_range(g.startDs, g)) { if (v == g.startDs) { continue; } if (initial != NGHolder::null_vertex()) { DEBUG_PRINTF("more than one start\n"); return false; } initial = v; } if (initial == NGHolder::null_vertex()) { DEBUG_PRINTF("no floating starts\n"); return false; } // Anchored start must have no successors other than startDs and initial. for (auto v : adjacent_vertices_range(g.start, g)) { if (v != initial && v != g.startDs) { DEBUG_PRINTF("anchored start\n"); return false; } } return true; } static bool getTransientPrefixReach(const NGHolder &g, u32 lag, map &look) { if (in_degree(g.accept, g) != 1) { DEBUG_PRINTF("more than one accept\n"); return false; } // Must be a floating chain wired to startDs. if (!hasSingleFloatingStart(g)) { DEBUG_PRINTF("not a single floating start\n"); return false; } NFAVertex v = *(inv_adjacent_vertices(g.accept, g).first); u32 i = lag + 1; while (v != g.startDs) { DEBUG_PRINTF("i=%u, v=%zu\n", i, g[v].index); if (is_special(v, g)) { DEBUG_PRINTF("special\n"); return false; } look[0 - i] = g[v].char_reach; NFAVertex next = NGHolder::null_vertex(); for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == g.start) { continue; // Benign, checked by hasSingleFloatingStart } if (next == NGHolder::null_vertex()) { next = u; continue; } DEBUG_PRINTF("branch\n"); return false; } if (next == NGHolder::null_vertex() || next == v) { DEBUG_PRINTF("no predecessor or only self-loop\n"); // This graph is malformed -- all vertices in a graph that makes it // to this analysis should have predecessors. assert(0); return false; } v = next; i++; } DEBUG_PRINTF("done\n"); return true; } static void normaliseLeftfix(map &look) { // We can erase entries where the reach is "all characters", except for the // very first one -- this might be required to establish a minimum bound on // the literal's match offset. // TODO: It would be cleaner to use a literal program instruction to check // the minimum bound explicitly. if (look.empty()) { return; } const auto earliest = begin(look)->first; vector dead; for (const auto &m : look) { if (m.second.all() && m.first != earliest) { dead.push_back(m.first); } } erase_all(&look, dead); } bool makeLeftfixLookaround(const RoseBuildImpl &build, const RoseVertex v, vector &lookaround) { lookaround.clear(); const RoseGraph &g = build.g; const left_id leftfix(g[v].left); if (!contains(build.transient, leftfix)) { DEBUG_PRINTF("not transient\n"); return false; } if (!leftfix.graph()) { DEBUG_PRINTF("only supported for graphs so far\n"); return false; } map look; if (!getTransientPrefixReach(*leftfix.graph(), g[v].left.lag, look)) { DEBUG_PRINTF("not a chain\n"); return false; } trimLiterals(build, v, look); normaliseLeftfix(look); if (look.size() > MAX_LOOKAROUND_ENTRIES) { DEBUG_PRINTF("lookaround too big (%zu entries)\n", look.size()); return false; } if (look.empty()) { DEBUG_PRINTF("lookaround empty; this is weird\n"); return false; } lookaround.reserve(look.size()); for (const auto &m : look) { if (m.first < -128 || m.first > 127) { DEBUG_PRINTF("range too big\n"); return false; } s8 offset = verify_s8(m.first); lookaround.emplace_back(offset, m.second); } return true; } void mergeLookaround(vector &lookaround, const vector &more_lookaround) { if (lookaround.size() >= MAX_LOOKAROUND_ENTRIES) { DEBUG_PRINTF("big enough!\n"); return; } // Don't merge lookarounds at offsets we already have entries for. ue2::flat_set offsets; for (const auto &e : lookaround) { offsets.insert(e.offset); } map more; LookPriority cmp(more); priority_queue, LookPriority> pq(cmp); for (const auto &e : more_lookaround) { if (!contains(offsets, e.offset)) { more.emplace(e.offset, e.reach); pq.push(e.offset); } } while (!pq.empty() && lookaround.size() < MAX_LOOKAROUND_ENTRIES) { const s32 offset = pq.top(); pq.pop(); const auto &cr = more.at(offset); DEBUG_PRINTF("added {%d,%s}\n", offset, describeClass(cr).c_str()); lookaround.emplace_back(verify_s8(offset), cr); } // Order by offset. sort(begin(lookaround), end(lookaround), [](const LookEntry &a, const LookEntry &b) { return a.offset < b.offset; }); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_exclusive.cpp0000644000175000017500000003404713055426554022770 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "ue2common.h" #include "rose_build_exclusive.h" #include "rose_build_merge.h" #include "nfa/castlecompile.h" #include "nfagraph/ng_execute.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_util.h" #include "util/clique.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph.h" #include "util/make_unique.h" using namespace std; namespace ue2 { template struct RoleChunk { vector> roles; }; static CharReach getReachability(const NGHolder &h) { CharReach cr; for (const auto &v : vertices_range(h)) { if (!is_special(v, h)) { cr |= h[v].char_reach; } } return cr; } template static vector> divideIntoChunks(const RoseBuildImpl &build, set> &roleInfoSet) { u32 chunkSize = build.cc.grey.tamaChunkSize; u32 cnt = 1; vector> chunks; RoleChunk roleChunk; for (const auto &roleInfo : roleInfoSet) { if (cnt == chunkSize) { cnt -= chunkSize; chunks.push_back(roleChunk); roleChunk.roles.clear(); } roleChunk.roles.push_back(roleInfo); cnt++; } if (cnt > 1) { chunks.push_back(roleChunk); } return chunks; } /* add prefix literals to engine graph */ static bool addPrefixLiterals(NGHolder &h, ue2::unordered_set &tailId, const vector> &triggers) { DEBUG_PRINTF("add literals to graph\n"); NFAVertex start = h.start; vector heads; vector tails; for (const auto &lit : triggers) { NFAVertex last = start; if (lit.empty()) { return false; } u32 i = 0; for (const auto &c : lit) { DEBUG_PRINTF("lit:%s \n", c.to_string().c_str()); NFAVertex u = add_vertex(h); h[u].char_reach = c; if (!i++) { heads.push_back(u); last = u; continue; } add_edge(last, u, h); last = u; } tails.push_back(last); tailId.insert(h[last].index); } for (auto v : adjacent_vertices_range(start, h)) { if (v != h.startDs) { for (auto &t : tails) { add_edge(t, v, h); } } } clear_out_edges(start, h); add_edge(h.start, h.start, h); for (auto &t : heads) { add_edge(start, t, h); } DEBUG_PRINTF("literals addition done\n"); return true; } /* check if one literal is suffix of another */ static bool isSuffix(const vector> &triggers1, const vector> &triggers2) { // literal suffix test for (const auto &lit1 : triggers1) { for (const auto &lit2 : triggers2) { const size_t len = min(lit1.size(), lit2.size()); if (equal(lit1.rbegin(), lit1.rbegin() + len, lit2.rbegin(), overlaps)) { return true; } } } return false; } /* prepare initial infix or suffix graph used for exclusive analysis */ template static u32 prepareRoleGraph(NGHolder &h, const role_id &s1) { u32 num = 0; if (s1.castle()) { num = num_vertices(h); NFAVertex u = add_vertex(h); h[u].char_reach = s1.castle()->reach(); add_edge(h.startDs, u, h); // add self loop to repeat characters add_edge(u, u, h); } else if (s1.graph()) { const NGHolder &g = *s1.graph(); cloneHolder(h, g); num = num_vertices(h); } else { // only infixes and suffixes with graph properties are possible // candidates, already filtered out other cases before // exclusive analysis assert(0); } return num; } /* get a subset of literal if reset character is found */ static vector findStartPos(const CharReach &cr1, const vector &lit) { auto it = lit.rbegin(), ite = lit.rend(); u32 pos = lit.size(); for (; it != ite; it++) { if (!overlaps(cr1, *it)) { break; } pos--; } return vector (lit.begin() + pos, lit.end()); } template static bool isExclusive(const NGHolder &h, const u32 num, ue2::unordered_set &tailId, map> &skipList, const RoleInfo &role1, const RoleInfo &role2) { const u32 id1 = role1.id; const u32 id2 = role2.id; if (contains(skipList, id1) && contains(skipList[id1], id2)) { return false; } const auto &triggers1 = role1.literals; const auto &triggers2 = role2.literals; if (isSuffix(triggers1, triggers2)) { skipList[id2].insert(id1); return false; } DEBUG_PRINTF("role id2:%u\n", id2); const auto &cr1 = role1.cr; if (overlaps(cr1, role2.last_cr)) { CharReach cr = cr1 | role1.prefix_cr; for (const auto &lit : triggers2) { auto lit1 = findStartPos(cr, lit); if (lit1.empty()) { continue; } u32 lower_bound = 0; if (lit1.size() < lit.size()) { lower_bound = ~0U; } ue2::flat_set states; for (const auto &v : vertices_range(h)) { if (h[v].index >= lower_bound || h[v].index < 2) { states.insert(v); } } auto activeStates = execute_graph(h, lit1, states); // Check if has only literal states are on for (const auto &s : activeStates) { u32 stateId = h[s].index; if ((stateId > 1 && stateId <= num) || contains(tailId, stateId)) { skipList[id2].insert(id1); return false; } } } } return true; } template static ue2::unordered_set checkExclusivity(const NGHolder &h, const u32 num, ue2::unordered_set &tailId, map> &skipList, const RoleInfo &role1, const RoleChunk &roleChunk) { ue2::unordered_set info; const u32 id1 = role1.id; for (const auto &role2 : roleChunk.roles) { const u32 id2 = role2.id; if (id1 != id2 && isExclusive(h, num, tailId, skipList, role1, role2)) { info.insert(id2); } } return info; } static void findCliques(const map> &exclusiveGroups, vector> &exclusive_roles) { if (exclusiveGroups.empty()) { return; } // Construct the exclusivity graph map vertex_map; unique_ptr cg = make_unique(); // Add vertices representing infixes/suffixes for (const auto &e : exclusiveGroups) { const u32 id = e.first; CliqueVertex v1 = add_vertex(CliqueVertexProps(id), *cg); vertex_map[id] = v1; } // Wire exclusive pairs for (const auto &e1 : exclusiveGroups) { const u32 literalId1 = e1.first; CliqueVertex lv = vertex_map[literalId1]; const set &exclusiveSet = e1.second; for (const auto &e2 : exclusiveGroups) { const u32 literalId2 = e2.first; if (literalId1 < literalId2 && contains(exclusiveSet, literalId2)) { add_edge(lv, vertex_map[literalId2], *cg); DEBUG_PRINTF("Wire %u:%u\n", literalId1, literalId2); } } } // Find clique groups const auto &clique = removeClique(*cg); for (const auto &i : clique) { DEBUG_PRINTF("cliq:%zu\n", i.size()); if (i.size() > 1) { exclusive_roles.push_back(i); } } DEBUG_PRINTF("Clique graph size:%zu\n", exclusive_roles.size()); } static map> findExclusiveGroups(const RoseBuildImpl &build, const map> &exclusiveInfo, const map> &vertex_map, const bool is_infix) { map> exclusiveGroups; for (const auto &e : exclusiveInfo) { u32 i = e.first; const auto &s = e.second; set group; set q1(vertex_map.at(i).begin(), vertex_map.at(i).end()); DEBUG_PRINTF("vertex set:%zu\n", q1.size()); for (const auto &val : s) { set q2(vertex_map.at(val).begin(), vertex_map.at(val).end()); if (contains(exclusiveInfo.at(val), i) && (!is_infix || mergeableRoseVertices(build, q1, q2))) { group.insert(val); } } if (!group.empty()) { exclusiveGroups[i] = group; } } return exclusiveGroups; } template static bool setTriggerLiterals(RoleInfo &roleInfo, const map>> &triggers) { u32 minLiteralLen = ~0U; for (const auto &tr : triggers) { for (const auto &lit : tr.second) { if (lit.empty()) { return false; } minLiteralLen = min(minLiteralLen, (u32)lit.size()); roleInfo.last_cr |= lit.back(); for (const auto &c : lit) { roleInfo.prefix_cr |= c; } roleInfo.literals.push_back(lit); } } if (roleInfo.role.graph()) { const NGHolder &g = *roleInfo.role.graph(); roleInfo.cr = getReachability(g); } else if (roleInfo.role.castle()) { roleInfo.cr = roleInfo.role.castle()->reach(); } // test the score of this engine roleInfo.score = 256 - roleInfo.cr.count() + minLiteralLen; if (roleInfo.score < 20) { return false; } return true; } bool setTriggerLiteralsInfix(RoleInfo &roleInfo, const map>> &triggers) { return setTriggerLiterals(roleInfo, triggers); } bool setTriggerLiteralsSuffix(RoleInfo &roleInfo, const map>> &triggers) { return setTriggerLiterals(roleInfo, triggers); } template static void exclusiveAnalysis(const RoseBuildImpl &build, const map> &vertex_map, set> &roleInfoSet, vector> &exclusive_roles, const bool is_infix) { const auto &chunks = divideIntoChunks(build, roleInfoSet); DEBUG_PRINTF("Exclusivity analysis entry\n"); map> exclusiveInfo; for (const auto &roleChunk : chunks) { map> skipList; for (const auto &role1 : roleChunk.roles) { const u32 id1 = role1.id; const role_id &s1 = role1.role; const auto &triggers1 = role1.literals; NGHolder h; u32 num = prepareRoleGraph(h, s1); DEBUG_PRINTF("role id1:%u\n", id1); unordered_set tailId; if (!addPrefixLiterals(h, tailId, triggers1)) { continue; } exclusiveInfo[id1] = checkExclusivity(h, num, tailId, skipList, role1, roleChunk); } } // Create final candidate exclusive groups const auto exclusiveGroups = findExclusiveGroups(build, exclusiveInfo, vertex_map, is_infix); exclusiveInfo.clear(); // Find cliques for each exclusive groups findCliques(exclusiveGroups, exclusive_roles); } void exclusiveAnalysisInfix(const RoseBuildImpl &build, const map> &vertex_map, set> &roleInfoSet, vector> &exclusive_roles) { exclusiveAnalysis(build, vertex_map, roleInfoSet, exclusive_roles, true); } void exclusiveAnalysisSuffix(const RoseBuildImpl &build, const map> &vertex_map, set> &roleInfoSet, vector> &exclusive_roles) { exclusiveAnalysis(build, vertex_map, roleInfoSet, exclusive_roles, false); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_anchored.cpp0000644000175000017500000006466313055426554022553 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_anchored.h" #include "grey.h" #include "rose_build_impl.h" #include "rose_internal.h" #include "ue2common.h" #include "nfa/dfa_min.h" #include "nfa/mcclellancompile.h" #include "nfa/mcclellancompile_util.h" #include "nfa/nfa_build_util.h" #include "nfa/rdfa_merge.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_mcclellan_internal.h" #include "util/alloc.h" #include "util/bitfield.h" #include "util/charreach.h" #include "util/compile_context.h" #include "util/compile_error.h" #include "util/container.h" #include "util/determinise.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/ue2_containers.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include using namespace std; namespace ue2 { #define ANCHORED_NFA_STATE_LIMIT 512 #define MAX_DFA_STATES 16000 #define DFA_PAIR_MERGE_THRESHOLD 5000 #define MAX_SMALL_START_REACH 4 #define INIT_STATE (DEAD_STATE + 1) // Adds a vertex with the given reach. static NFAVertex add_vertex(NGHolder &h, const CharReach &cr) { NFAVertex v = add_vertex(h); h[v].char_reach = cr; return v; } static void add_edges(const set &parents, NFAVertex v, NGHolder &h) { for (auto p : parents) { add_edge(p, v, h); } } static set addDotsToGraph(NGHolder &h, NFAVertex start, u32 min, u32 max, const CharReach &cr) { DEBUG_PRINTF("adding [%u, %u] to graph\n", min, max); u32 i = 0; set curr; curr.insert(start); for (; i < min; i++) { NFAVertex next = add_vertex(h, cr); add_edges(curr, next, h); curr.clear(); curr.insert(next); } assert(max != ROSE_BOUND_INF); set orig = curr; for (; i < max; i++) { NFAVertex next = add_vertex(h, cr); add_edges(curr, next, h); curr.clear(); curr.insert(next); curr.insert(orig.begin(), orig.end()); } return curr; } static NFAVertex addToGraph(NGHolder &h, const set &curr, const ue2_literal &s) { DEBUG_PRINTF("adding %s to graph\n", dumpString(s).c_str()); assert(!s.empty()); ue2_literal::const_iterator it = s.begin(); NFAVertex u = add_vertex(h, *it); add_edges(curr, u, h); for (++it; it != s.end(); ++it) { NFAVertex next = add_vertex(h, *it); add_edge(u, next, h); u = next; } return u; } static void mergeAnchoredDfas(vector> &dfas, const RoseBuildImpl &build) { // First, group our DFAs into "small start" and "big start" sets. vector> small_starts, big_starts; for (auto &rdfa : dfas) { u32 start_size = mcclellanStartReachSize(rdfa.get()); if (start_size <= MAX_SMALL_START_REACH) { small_starts.push_back(move(rdfa)); } else { big_starts.push_back(move(rdfa)); } } dfas.clear(); DEBUG_PRINTF("%zu dfas with small starts, %zu dfas with big starts\n", small_starts.size(), big_starts.size()); mergeDfas(small_starts, MAX_DFA_STATES, nullptr, build.cc.grey); mergeDfas(big_starts, MAX_DFA_STATES, nullptr, build.cc.grey); // Rehome our groups into one vector. for (auto &rdfa : small_starts) { dfas.push_back(move(rdfa)); } for (auto &rdfa : big_starts) { dfas.push_back(move(rdfa)); } // Final test: if we've built two DFAs here that are small enough, we can // try to merge them. if (dfas.size() == 2) { size_t total_states = dfas[0]->states.size() + dfas[1]->states.size(); if (total_states < DFA_PAIR_MERGE_THRESHOLD) { DEBUG_PRINTF("doing small pair merge\n"); mergeDfas(dfas, MAX_DFA_STATES, nullptr, build.cc.grey); } } } static void remapAnchoredReports(raw_dfa &rdfa, const RoseBuildImpl &build) { for (dstate &ds : rdfa.states) { assert(ds.reports_eod.empty()); // Not used in anchored matcher. if (ds.reports.empty()) { continue; } flat_set new_reports; for (auto id : ds.reports) { assert(id < build.literal_info.size()); new_reports.insert(build.literal_info.at(id).final_id); } ds.reports = move(new_reports); } } /** * \brief Replaces the report ids currently in the dfas (rose graph literal * ids) with the final id for each literal. */ static void remapAnchoredReports(RoseBuildImpl &build) { for (auto &m : build.anchored_nfas) { for (auto &rdfa : m.second) { assert(rdfa); remapAnchoredReports(*rdfa, build); } } } /** * \brief Replace the reports (which are literal final_ids) in the given * raw_dfa with program offsets. */ static void remapIdsToPrograms(raw_dfa &rdfa, const vector &litPrograms) { for (dstate &ds : rdfa.states) { assert(ds.reports_eod.empty()); // Not used in anchored matcher. if (ds.reports.empty()) { continue; } flat_set new_reports; for (auto id : ds.reports) { assert(id < litPrograms.size()); new_reports.insert(litPrograms.at(id)); } ds.reports = move(new_reports); } } static void populate_holder(const simple_anchored_info &sai, const set &exit_ids, NGHolder *h_in) { DEBUG_PRINTF("populating holder for ^.{%u,%u}%s\n", sai.min_bound, sai.max_bound, dumpString(sai.literal).c_str()); NGHolder &h = *h_in; set ends = addDotsToGraph(h, h.start, sai.min_bound, sai.max_bound, CharReach::dot()); NFAVertex v = addToGraph(h, ends, sai.literal); add_edge(v, h.accept, h); h[v].reports.insert(exit_ids.begin(), exit_ids.end()); } u32 anchoredStateSize(const anchored_matcher_info &atable) { const struct anchored_matcher_info *curr = &atable; // Walk the list until we find the last element; total state size will be // that engine's state offset plus its state requirement. while (curr->next_offset) { curr = (const anchored_matcher_info *) ((const char *)curr + curr->next_offset); } const NFA *nfa = (const NFA *)((const char *)curr + sizeof(*curr)); return curr->state_offset + nfa->streamStateSize; } namespace { typedef bitfield nfa_state_set; struct Holder_StateSet { Holder_StateSet() : wdelay(0) {} nfa_state_set wrap_state; u32 wdelay; bool operator==(const Holder_StateSet &b) const { return wdelay == b.wdelay && wrap_state == b.wrap_state; } }; size_t hash_value(const Holder_StateSet &s) { size_t val = 0; boost::hash_combine(val, s.wrap_state); boost::hash_combine(val, s.wdelay); return val; } class Automaton_Holder { public: typedef Holder_StateSet StateSet; typedef ue2::unordered_map StateMap; explicit Automaton_Holder(const NGHolder &g_in) : g(g_in) { for (auto v : vertices_range(g)) { vertexToIndex[v] = indexToVertex.size(); indexToVertex.push_back(v); } assert(indexToVertex.size() <= ANCHORED_NFA_STATE_LIMIT); DEBUG_PRINTF("%zu states\n", indexToVertex.size()); init.wdelay = 0; init.wrap_state.set(vertexToIndex[g.start]); DEBUG_PRINTF("init wdelay %u\n", init.wdelay); calculateAlphabet(); cr_by_index = populateCR(g, indexToVertex, alpha); } private: void calculateAlphabet() { vector esets(1, CharReach::dot()); for (auto v : indexToVertex) { const CharReach &cr = g[v].char_reach; for (size_t i = 0; i < esets.size(); i++) { if (esets[i].count() == 1) { continue; } CharReach t = cr & esets[i]; if (t.any() && t != esets[i]) { esets[i] &= ~t; esets.push_back(t); } } } alphasize = buildAlphabetFromEquivSets(esets, alpha, unalpha); } public: void transition(const StateSet &in, StateSet *next) { /* track the dfa state, reset nfa states */ u32 wdelay = in.wdelay ? in.wdelay - 1 : 0; for (symbol_t s = 0; s < alphasize; s++) { next[s].wrap_state.reset(); next[s].wdelay = wdelay; } nfa_state_set succ; if (wdelay != in.wdelay) { DEBUG_PRINTF("enabling start\n"); succ.set(vertexToIndex[g.startDs]); } for (size_t i = in.wrap_state.find_first(); i != nfa_state_set::npos; i = in.wrap_state.find_next(i)) { NFAVertex v = indexToVertex[i]; for (auto w : adjacent_vertices_range(v, g)) { if (!contains(vertexToIndex, w) || w == g.accept || w == g.acceptEod) { continue; } if (w == g.startDs) { continue; } succ.set(vertexToIndex[w]); } } for (size_t j = succ.find_first(); j != nfa_state_set::npos; j = succ.find_next(j)) { const CharReach &cr = cr_by_index[j]; for (size_t s = cr.find_first(); s != CharReach::npos; s = cr.find_next(s)) { next[s].wrap_state.set(j); /* pre alpha'ed */ } } next[alpha[TOP]] = in; } const vector initial() { return {init}; } void reports(const StateSet &in, flat_set &rv) { rv.clear(); for (size_t i = in.wrap_state.find_first(); i != nfa_state_set::npos; i = in.wrap_state.find_next(i)) { NFAVertex v = indexToVertex[i]; if (edge(v, g.accept, g).second) { assert(!g[v].reports.empty()); insert(&rv, g[v].reports); } else { assert(g[v].reports.empty()); } } } void reportsEod(const StateSet &, flat_set &r) { r.clear(); } static bool canPrune(const flat_set &) { /* used by ng_ to prune states after highlander accepts */ return false; } private: const NGHolder &g; ue2::unordered_map vertexToIndex; vector indexToVertex; vector cr_by_index; StateSet init; public: StateSet dead; array alpha; array unalpha; u16 alphasize; }; } // namespace static bool check_dupe(const raw_dfa &rdfa, const vector> &existing, ReportID *remap) { if (!remap) { DEBUG_PRINTF("no remap\n"); return false; } set rdfa_reports; for (const auto &ds : rdfa.states) { rdfa_reports.insert(ds.reports.begin(), ds.reports.end()); } if (rdfa_reports.size() != 1) { return false; /* too complicated for now would need mapping TODO */ } for (const auto &e_rdfa : existing) { assert(e_rdfa); const raw_dfa &b = *e_rdfa; if (rdfa.start_anchored != b.start_anchored || rdfa.alpha_size != b.alpha_size || rdfa.states.size() != b.states.size() || rdfa.alpha_remap != b.alpha_remap) { continue; } set b_reports; for (u32 i = 0; i < b.states.size(); i++) { assert(b.states[i].reports_eod.empty()); assert(rdfa.states[i].reports_eod.empty()); if (rdfa.states[i].reports.size() != b.states[i].reports.size()) { goto next_dfa; } b_reports.insert(b.states[i].reports.begin(), b.states[i].reports.end()); assert(rdfa.states[i].next.size() == b.states[i].next.size()); if (!equal(rdfa.states[i].next.begin(), rdfa.states[i].next.end(), b.states[i].next.begin())) { goto next_dfa; } } if (b_reports.size() != 1) { continue; } *remap = *b_reports.begin(); DEBUG_PRINTF("dupe found remapping to %u\n", *remap); return true; next_dfa:; } return false; } static bool check_dupe_simple(const RoseBuildImpl &tbi, u32 min_bound, u32 max_bound, const ue2_literal &lit, ReportID *remap) { if (!remap) { DEBUG_PRINTF("no remap\n"); return false; } simple_anchored_info sai(min_bound, max_bound, lit); if (contains(tbi.anchored_simple, sai)) { *remap = *tbi.anchored_simple.at(sai).begin(); return true; } return false; } static NFAVertex extractLiteral(const NGHolder &h, ue2_literal *lit) { vector lit_verts; NFAVertex v = h.accept; while ((v = getSoleSourceVertex(h, v))) { const CharReach &cr = h[v].char_reach; if (cr.count() > 1 && !cr.isCaselessChar()) { break; } lit_verts.push_back(v); } if (lit_verts.empty()) { return NGHolder::null_vertex(); } bool nocase = false; bool case_set = false; for (auto it = lit_verts.rbegin(), ite = lit_verts.rend(); it != ite; ++it) { const CharReach &cr = h[*it].char_reach; if (cr.isAlpha()) { bool cr_nocase = cr.count() != 1; if (case_set && cr_nocase != nocase) { return NGHolder::null_vertex(); } case_set = true; nocase = cr_nocase; lit->push_back(cr.find_first(), nocase); } else { lit->push_back(cr.find_first(), false); } } return lit_verts.back(); } static bool isSimple(const NGHolder &h, u32 *min_bound, u32 *max_bound, ue2_literal *lit, u32 *report) { assert(!proper_out_degree(h.startDs, h)); assert(in_degree(h.acceptEod, h) == 1); DEBUG_PRINTF("looking for simple case\n"); NFAVertex lit_head = extractLiteral(h, lit); if (lit_head == NGHolder::null_vertex()) { DEBUG_PRINTF("no literal found\n"); return false; } const auto &reps = h[*inv_adjacent_vertices(h.accept, h).first].reports; if (reps.size() != 1) { return false; } *report = *reps.begin(); assert(!lit->empty()); set rep_exits; /* lit should only be connected to dot vertices */ for (auto u : inv_adjacent_vertices_range(lit_head, h)) { DEBUG_PRINTF("checking %zu\n", h[u].index); if (!h[u].char_reach.all()) { return false; } if (u != h.start) { rep_exits.insert(u); } } if (rep_exits.empty()) { DEBUG_PRINTF("direct anchored\n"); assert(edge(h.start, lit_head, h).second); *min_bound = 0; *max_bound = 0; return true; } NFAVertex key = *rep_exits.begin(); // Special-case the check for '^.foo' or '^.?foo'. if (rep_exits.size() == 1 && edge(h.start, key, h).second && out_degree(key, h) == 1) { DEBUG_PRINTF("one exit\n"); assert(edge(h.start, h.startDs, h).second); size_t num_enters = out_degree(h.start, h); if (num_enters == 2) { DEBUG_PRINTF("^.{1,1} prefix\n"); *min_bound = 1; *max_bound = 1; return true; } if (num_enters == 3 && edge(h.start, lit_head, h).second) { DEBUG_PRINTF("^.{0,1} prefix\n"); *min_bound = 0; *max_bound = 1; return true; } } vector repeats; findRepeats(h, 2, &repeats); vector::const_iterator it; for (it = repeats.begin(); it != repeats.end(); ++it) { DEBUG_PRINTF("checking.. %zu verts\n", it->vertices.size()); if (find(it->vertices.begin(), it->vertices.end(), key) != it->vertices.end()) { break; } } if (it == repeats.end()) { DEBUG_PRINTF("no repeat found\n"); return false; } set rep_verts; insert(&rep_verts, it->vertices); if (!is_subset_of(rep_exits, rep_verts)) { DEBUG_PRINTF("bad exit check\n"); return false; } set rep_enters; insert(&rep_enters, adjacent_vertices(h.start, h)); rep_enters.erase(lit_head); rep_enters.erase(h.startDs); if (!is_subset_of(rep_enters, rep_verts)) { DEBUG_PRINTF("bad entry check\n"); return false; } u32 min_b = it->repeatMin; if (edge(h.start, lit_head, h).second) { /* jump edge */ if (min_b != 1) { DEBUG_PRINTF("jump edge around repeat with min bound\n"); return false; } min_b = 0; } *min_bound = min_b; *max_bound = it->repeatMax; DEBUG_PRINTF("repeat %u %u before %s\n", *min_bound, *max_bound, dumpString(*lit).c_str()); return true; } static int finalise_out(RoseBuildImpl &tbi, const NGHolder &h, const Automaton_Holder &autom, unique_ptr out_dfa, ReportID *remap) { u32 min_bound = ~0U; u32 max_bound = ~0U; ue2_literal lit; u32 simple_report = MO_INVALID_IDX; if (isSimple(h, &min_bound, &max_bound, &lit, &simple_report)) { assert(simple_report != MO_INVALID_IDX); if (check_dupe_simple(tbi, min_bound, max_bound, lit, remap)) { DEBUG_PRINTF("found duplicate remapping to %u\n", *remap); return ANCHORED_REMAP; } DEBUG_PRINTF("add with report %u\n", simple_report); tbi.anchored_simple[simple_anchored_info(min_bound, max_bound, lit)] .insert(simple_report); return ANCHORED_SUCCESS; } out_dfa->start_anchored = INIT_STATE; out_dfa->start_floating = DEAD_STATE; out_dfa->alpha_size = autom.alphasize; out_dfa->alpha_remap = autom.alpha; auto hash = hash_dfa_no_reports(*out_dfa); if (check_dupe(*out_dfa, tbi.anchored_nfas[hash], remap)) { return ANCHORED_REMAP; } tbi.anchored_nfas[hash].push_back(move(out_dfa)); return ANCHORED_SUCCESS; } static int addAutomaton(RoseBuildImpl &tbi, const NGHolder &h, ReportID *remap) { if (num_vertices(h) > ANCHORED_NFA_STATE_LIMIT) { DEBUG_PRINTF("autom bad!\n"); return ANCHORED_FAIL; } Automaton_Holder autom(h); unique_ptr out_dfa = ue2::make_unique(NFA_OUTFIX_RAW); if (!determinise(autom, out_dfa->states, MAX_DFA_STATES)) { return finalise_out(tbi, h, autom, move(out_dfa), remap); } DEBUG_PRINTF("determinise failed\n"); return ANCHORED_FAIL; } static void setReports(NGHolder &h, const map> &reportMap, const ue2::unordered_map &orig_to_copy) { for (const auto &m : reportMap) { NFAVertex t = orig_to_copy.at(m.first); assert(!m.second.empty()); add_edge(t, h.accept, h); insert(&h[t].reports, m.second); } } int addAnchoredNFA(RoseBuildImpl &tbi, const NGHolder &wrapper, const map> &reportMap) { NGHolder h; ue2::unordered_map orig_to_copy; cloneHolder(h, wrapper, &orig_to_copy); clear_in_edges(h.accept, h); clear_in_edges(h.acceptEod, h); add_edge(h.accept, h.acceptEod, h); clearReports(h); setReports(h, reportMap, orig_to_copy); return addAutomaton(tbi, h, nullptr); } int addToAnchoredMatcher(RoseBuildImpl &tbi, const NGHolder &anchored, u32 exit_id, ReportID *remap) { NGHolder h; cloneHolder(h, anchored); clearReports(h); assert(in_degree(h.acceptEod, h) == 1); for (auto v : inv_adjacent_vertices_range(h.accept, h)) { h[v].reports.clear(); h[v].reports.insert(exit_id); } return addAutomaton(tbi, h, remap); } static void buildSimpleDfas(const RoseBuildImpl &tbi, vector> *anchored_dfas) { /* we should have determinised all of these before so there should be no * chance of failure. */ for (const auto &simple : tbi.anchored_simple) { set exit_ids; for (auto lit_id : simple.second) { exit_ids.insert(tbi.literal_info[lit_id].final_id); } NGHolder h; populate_holder(simple.first, exit_ids, &h); Automaton_Holder autom(h); unique_ptr rdfa = ue2::make_unique(NFA_OUTFIX_RAW); UNUSED int rv = determinise(autom, rdfa->states, MAX_DFA_STATES); assert(!rv); rdfa->start_anchored = INIT_STATE; rdfa->start_floating = DEAD_STATE; rdfa->alpha_size = autom.alphasize; rdfa->alpha_remap = autom.alpha; anchored_dfas->push_back(move(rdfa)); } } /** * Fill the given vector with all of the raw_dfas we need to compile into the * anchored matcher. Takes ownership of the input structures, clearing them * from RoseBuildImpl. */ static vector> getAnchoredDfas(RoseBuildImpl &build) { vector> dfas; // DFAs that already exist as raw_dfas. for (auto &anch_dfas : build.anchored_nfas) { for (auto &rdfa : anch_dfas.second) { dfas.push_back(move(rdfa)); } } build.anchored_nfas.clear(); // DFAs we currently have as simple literals. if (!build.anchored_simple.empty()) { buildSimpleDfas(build, &dfas); build.anchored_simple.clear(); } return dfas; } /** * \brief Builds our anchored DFAs into runtime NFAs. * * Constructs a vector of NFA structures and a vector of their start offsets * (number of dots removed from the prefix) from the raw_dfa structures given. * * Note: frees the raw_dfa structures on completion. * * \return Total bytes required for the complete anchored matcher. */ static size_t buildNfas(vector &anchored_dfas, vector> *nfas, vector *start_offset, const CompileContext &cc, const ReportManager &rm) { const size_t num_dfas = anchored_dfas.size(); nfas->reserve(num_dfas); start_offset->reserve(num_dfas); size_t total_size = 0; for (auto &rdfa : anchored_dfas) { u32 removed_dots = remove_leading_dots(rdfa); start_offset->push_back(removed_dots); minimize_hopcroft(rdfa, cc.grey); auto nfa = mcclellanCompile(rdfa, cc, rm); if (!nfa) { assert(0); throw std::bad_alloc(); } assert(nfa->length); total_size += ROUNDUP_CL(sizeof(anchored_matcher_info) + nfa->length); nfas->push_back(move(nfa)); } // We no longer need to keep the raw_dfa structures around. anchored_dfas.clear(); return total_size; } vector buildAnchoredDfas(RoseBuildImpl &build) { vector dfas; if (build.anchored_nfas.empty() && build.anchored_simple.empty()) { DEBUG_PRINTF("empty\n"); return dfas; } remapAnchoredReports(build); auto anch_dfas = getAnchoredDfas(build); mergeAnchoredDfas(anch_dfas, build); dfas.reserve(anch_dfas.size()); for (auto &rdfa : anch_dfas) { assert(rdfa); dfas.push_back(move(*rdfa)); } return dfas; } aligned_unique_ptr buildAnchoredMatcher(RoseBuildImpl &build, vector &dfas, const vector &litPrograms, size_t *asize) { const CompileContext &cc = build.cc; if (dfas.empty()) { DEBUG_PRINTF("empty\n"); *asize = 0; return nullptr; } for (auto &rdfa : dfas) { remapIdsToPrograms(rdfa, litPrograms); } vector> nfas; vector start_offset; // start offset for each dfa (dots removed) size_t total_size = buildNfas(dfas, &nfas, &start_offset, cc, build.rm); if (total_size > cc.grey.limitRoseAnchoredSize) { throw ResourceLimitError(); } *asize = total_size; auto atable = aligned_zmalloc_unique(total_size); char *curr = (char *)atable.get(); u32 state_offset = 0; for (size_t i = 0; i < nfas.size(); i++) { const NFA *nfa = nfas[i].get(); anchored_matcher_info *ami = (anchored_matcher_info *)curr; char *prev_curr = curr; curr += sizeof(anchored_matcher_info); memcpy(curr, nfa, nfa->length); curr += nfa->length; curr = ROUNDUP_PTR(curr, 64); if (i + 1 == nfas.size()) { ami->next_offset = 0U; } else { ami->next_offset = verify_u32(curr - prev_curr); } ami->state_offset = state_offset; state_offset += nfa->streamStateSize; ami->anchoredMinDistance = start_offset[i]; } DEBUG_PRINTF("success %zu\n", *asize); return atable; } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_infix.cpp0000644000175000017500000002314213055426554022070 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose/rose_build_infix.h" #include "ue2common.h" #include "nfa/castlecompile.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng_width.h" #include "nfagraph/ng_util.h" #include "rose/rose_build_impl.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/graph.h" #include "util/ue2_containers.h" #include "util/ue2string.h" #include #include using namespace std; namespace ue2 { static bool couldEndLiteral(const ue2_literal &s, NFAVertex initial, const NGHolder &h) { ue2::flat_set curr, next; curr.insert(initial); for (auto it = s.rbegin(), ite = s.rend(); it != ite; ++it) { const CharReach &cr_s = *it; bool matched = false; next.clear(); for (auto v : curr) { if (v == h.start) { // We can't see what we had before the start, so we must assume // the literal could overlap with it. return true; } const CharReach &cr_v = h[v].char_reach; if (overlaps(cr_v, cr_s)) { insert(&next, inv_adjacent_vertices(v, h)); matched = true; } } if (!matched) { return false; } curr.swap(next); } return true; } static void contractVertex(NGHolder &g, NFAVertex v, ue2::unordered_set> &all_edges) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; // self-edge } for (auto w : adjacent_vertices_range(v, g)) { if (w == v) { continue; // self-edge } // Construct edge (u, v) only if it doesn't already exist. We use // the all_edges container here, as checking existence inside the // graph is expensive when u or v have large degree. if (all_edges.emplace(u, w).second) { add_edge(u, w, g); } } } // Note that edges to/from v will remain in all_edges. clear_vertex(v, g); } static u32 findMaxLiteralMatches(const NGHolder &h, const set &lits) { DEBUG_PRINTF("h=%p, %zu literals\n", &h, lits.size()); //dumpGraph("infix.dot", h); // Indices of vertices that could terminate any of the literals in 'lits'. set terms; for (const auto &s : lits) { DEBUG_PRINTF("lit s='%s'\n", escapeString(s).c_str()); if (s.empty()) { // Likely an anchored case, be conservative here. return NO_MATCH_LIMIT; } for (auto v : vertices_range(h)) { if (is_special(v, h)) { continue; } if (couldEndLiteral(s, v, h)) { u32 idx = h[v].index; DEBUG_PRINTF("vertex %u could terminate lit\n", idx); terms.insert(idx); } } } if (terms.empty()) { DEBUG_PRINTF("literals cannot match inside infix\n"); return 0; } NGHolder g; cloneHolder(g, h); vector dead; // The set of all edges in the graph is used for existence checks in contractVertex. ue2::unordered_set> all_edges; for (const auto &e : edges_range(g)) { all_edges.emplace(source(e, g), target(e, g)); } for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } if (contains(terms, g[v].index)) { continue; } contractVertex(g, v, all_edges); dead.push_back(v); } remove_vertices(dead, g); //dumpGraph("relaxed.dot", g); depth maxWidth = findMaxWidth(g); DEBUG_PRINTF("maxWidth=%s\n", maxWidth.str().c_str()); assert(maxWidth.is_reachable()); if (maxWidth.is_infinite()) { // Cycle detected, so we can likely squeeze an unlimited number of // matches into this graph. return NO_MATCH_LIMIT; } assert(terms.size() >= maxWidth); return maxWidth; } namespace { struct ReachMismatch { explicit ReachMismatch(const CharReach &cr_in) : cr(cr_in) {} bool operator()(const CharReach &a) const { return !overlaps(cr, a); } private: CharReach cr; }; } static u32 findMaxInfixMatches(const CastleProto &castle, const set &lits) { DEBUG_PRINTF("castle=%p, %zu literals\n", &castle, lits.size()); if (castle.repeats.size() > 1) { DEBUG_PRINTF("more than one top!\n"); return NO_MATCH_LIMIT; } assert(!castle.repeats.empty()); const PureRepeat &pr = castle.repeats.begin()->second; DEBUG_PRINTF("repeat=%s reach=%s\n", pr.bounds.str().c_str(), describeClass(pr.reach).c_str()); size_t max_count = 0; for (const auto &s : lits) { DEBUG_PRINTF("lit s='%s'\n", escapeString(s).c_str()); if (s.empty()) { // Likely an anchored case, be conservative here. return NO_MATCH_LIMIT; } size_t count = 0; auto f = find_if(s.rbegin(), s.rend(), ReachMismatch(pr.reach)); if (f == s.rbegin()) { DEBUG_PRINTF("lit can't terminate inside infix\n"); count = 0; } else if (f != s.rend()) { size_t suffix_len = distance(s.rbegin(), f); DEBUG_PRINTF("suffix of len %zu matches at start\n", suffix_len); if (pr.bounds.max.is_finite()) { count = min(suffix_len, (size_t)pr.bounds.max); } else { count = suffix_len; } } else { DEBUG_PRINTF("whole lit can match inside infix (repeatedly)\n"); if (pr.bounds.max.is_finite()) { count = pr.bounds.max; } else { DEBUG_PRINTF("inf bound\n"); return NO_MATCH_LIMIT; } } DEBUG_PRINTF("count=%zu\n", count); max_count = max(max_count, count); } DEBUG_PRINTF("max_count %zu\n", max_count); if (max_count > NO_MATCH_LIMIT) { assert(0); // This would be a surprise. return NO_MATCH_LIMIT; } return (u32)max_count; } u32 findMaxInfixMatches(const left_id &left, const set &lits) { if (left.castle()) { return findMaxInfixMatches(*left.castle(), lits); } if (left.graph()) { if (!onlyOneTop(*left.graph())) { DEBUG_PRINTF("more than one top!n"); return NO_MATCH_LIMIT; } return findMaxLiteralMatches(*left.graph(), lits); } return NO_MATCH_LIMIT; } void findCountingMiracleInfo(const left_id &left, const vector &stopTable, u8 *cm_count, CharReach *cm_cr) { DEBUG_PRINTF("hello\n"); *cm_count = 0; cm_cr->clear(); if (!left.graph()) { return; } const NGHolder &g = *left.graph(); auto cyclics = find_vertices_in_cycles(g); if (!proper_out_degree(g.startDs, g)) { cyclics.erase(g.startDs); } CharReach cyclic_cr; for (NFAVertex v : cyclics) { DEBUG_PRINTF("considering %zu ||=%zu\n", g[v].index, g[v].char_reach.count()); cyclic_cr |= g[v].char_reach; } if (cyclic_cr.none() || cyclic_cr.all()) { DEBUG_PRINTF("cyclic cr width %zu\n", cyclic_cr.count()); return; /* useless */ } *cm_cr = ~cyclic_cr; /* stop character will be part of normal miracles, no need to look for them * here too */ assert(stopTable.size() == N_CHARS); for (u32 i = 0; i < N_CHARS; i++) { if (stopTable[i]) { cm_cr->clear(i); } } set lits; for (size_t c = cm_cr->find_first(); c != CharReach::npos; c = cm_cr->find_next(c)) { DEBUG_PRINTF("considering %hhx as stop character\n", (u8)c); lits.insert(ue2_literal(c, false)); } u32 count = findMaxLiteralMatches(*left.graph(), lits); DEBUG_PRINTF("counting miracle %u\n", count + 1); if (count && count < 50) { *cm_count = count + 1; } } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_long_lit.cpp0000644000175000017500000004026613055426554022570 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "rose_build_long_lit.h" #include "rose_build_engine_blob.h" #include "rose_build_impl.h" #include "stream_long_lit_hash.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/verify_types.h" #include "util/compile_context.h" #include #include using namespace std; namespace ue2 { /** \brief Minimum size for a non-empty hash table. Must be a power of two. */ static constexpr u32 MIN_HASH_TABLE_SIZE = 128; /** \brief Maximum load factor (between zero and one) for a hash table. */ static constexpr double MAX_HASH_TABLE_LOAD = 0.7; /** \brief Minimum size (in bits) for a bloom filter. Must be a power of two. */ static constexpr u32 MIN_BLOOM_FILTER_SIZE = 256; /** \brief Maximum load factor (between zero and one) for a bloom filter. */ static constexpr double MAX_BLOOM_FILTER_LOAD = 0.25; struct LongLitModeInfo { u32 num_literals = 0; //!< Number of strings for this mode. u32 hashed_positions = 0; //!< Number of hashable string positions. }; struct LongLitInfo { LongLitModeInfo caseful; LongLitModeInfo nocase; }; static u32 roundUpToPowerOfTwo(u32 x) { assert(x != 0); u32 bits = lg2(x - 1) + 1; assert(bits < 32); return 1U << bits; } static LongLitInfo analyzeLongLits(const vector &lits, size_t max_len) { LongLitInfo info; for (const auto &lit : lits) { auto &lit_info = lit.nocase ? info.nocase : info.caseful; assert(lit.s.size() > max_len); lit_info.num_literals++; lit_info.hashed_positions += lit.s.size() - max_len; } DEBUG_PRINTF("case: hashed %u positions\n", info.caseful.hashed_positions); DEBUG_PRINTF("nocase: hashed %u positions\n", info.nocase.hashed_positions); return info; } static void addToBloomFilter(vector &bloom, const u8 *substr, bool nocase) { const u32 num_keys = verify_u32(bloom.size() * 8); const u32 key_mask = (1U << lg2(num_keys)) -1; const auto hash_functions = { bloomHash_1, bloomHash_2, bloomHash_3 }; for (const auto &hash_func : hash_functions) { u32 hash = hash_func(substr, nocase); u32 key = hash & key_mask; DEBUG_PRINTF("set key %u (of %zu)\n", key, bloom.size() * 8); bloom[key / 8] |= 1U << (key % 8); } } static size_t bloomOccupancy(const vector &bloom) { return accumulate(begin(bloom), end(bloom), 0, [](const size_t &sum, const u8 &elem) { return sum + popcount32(elem); }); } static double bloomLoad(const vector &bloom) { return (double)bloomOccupancy(bloom) / (double)(bloom.size() * 8); } static vector buildBloomFilter(const vector &lits, size_t max_len, size_t num_entries, bool nocase) { assert(num_entries % 8 == 0); assert((num_entries & (num_entries - 1)) == 0); // Must be power of two. vector bloom(num_entries / 8, 0); if (!num_entries) { return bloom; } for (const auto &lit : lits) { if (nocase != lit.nocase) { continue; } for (u32 offset = 1; offset < lit.s.size() - max_len + 1; offset++) { const u8 *substr = (const u8 *)lit.s.c_str() + offset; addToBloomFilter(bloom, substr, nocase); } } DEBUG_PRINTF("%s bloom filter occupancy %zu of %zu entries\n", nocase ? "nocase" : "caseful", bloomOccupancy(bloom), num_entries); return bloom; } static vector makeBloomFilter(const vector &lits, size_t max_len, bool nocase) { vector bloom; size_t num_entries = MIN_BLOOM_FILTER_SIZE; for (;;) { bloom = buildBloomFilter(lits, max_len, num_entries, nocase); DEBUG_PRINTF("built %s bloom for %zu entries: load %f\n", nocase ? "nocase" : "caseful", num_entries, bloomLoad(bloom)); if (bloomLoad(bloom) < MAX_BLOOM_FILTER_LOAD) { break; } num_entries *= 2; } return bloom; } static size_t hashTableOccupancy(const vector &tab) { return count_if(begin(tab), end(tab), [](const RoseLongLitHashEntry &ent) { return ent.str_offset != 0; }); } static double hashTableLoad(const vector &tab) { return (double)hashTableOccupancy(tab) / (double)(tab.size()); } static vector buildHashTable(const vector &lits, size_t max_len, const vector &litToOffsetVal, size_t numEntries, bool nocase) { vector tab(numEntries, {0,0}); if (!numEntries) { return tab; } map>> hashToLitOffPairs; for (u32 lit_id = 0; lit_id < lits.size(); lit_id++) { const ue2_case_string &lit = lits[lit_id]; if (nocase != lit.nocase) { continue; } for (u32 offset = 1; offset < lit.s.size() - max_len + 1; offset++) { const u8 *substr = (const u8 *)lit.s.c_str() + offset; u32 hash = hashLongLiteral(substr, max_len, lit.nocase); hashToLitOffPairs[hash].emplace_back(lit_id, offset); } } for (auto &m : hashToLitOffPairs) { u32 hash = m.first; vector> &d = m.second; // Sort by (offset, string) so that we'll be able to remove identical // string prefixes. stable_sort(begin(d), end(d), [&](const pair &a, const pair &b) { const auto &str_a = lits[a.first].s; const auto &str_b = lits[b.first].s; return tie(a.second, str_a) < tie(b.second, str_b); }); // Remove entries that point to the same literal prefix. d.erase(unique(begin(d), end(d), [&](const pair &a, const pair &b) { if (a.second != b.second) { return false; } const auto &str_a = lits[a.first].s; const auto &str_b = lits[b.first].s; const size_t len = max_len + a.second; return equal(begin(str_a), begin(str_a) + len, begin(str_b)); }), end(d)); // Sort d by distance of the residual string (len minus our depth into // the string). We need to put the 'furthest back' string first. stable_sort(begin(d), end(d), [](const pair &a, const pair &b) { if (a.second != b.second) { return a.second > b.second; /* longest is first */ } return a.first < b.first; }); u32 bucket = hash % numEntries; // Placement via linear probing. for (const auto &lit_offset : d) { while (tab[bucket].str_offset != 0) { bucket++; if (bucket == numEntries) { bucket = 0; } } u32 lit_id = lit_offset.first; u32 offset = lit_offset.second; DEBUG_PRINTF("hash 0x%08x lit_id %u offset %u bucket %u\n", hash, lit_id, offset, bucket); auto &entry = tab[bucket]; entry.str_offset = verify_u32(litToOffsetVal.at(lit_id)); assert(entry.str_offset != 0); entry.str_len = offset + max_len; } } DEBUG_PRINTF("%s hash table occupancy %zu of %zu entries\n", nocase ? "nocase" : "caseful", hashTableOccupancy(tab), numEntries); return tab; } static vector makeHashTable(const vector &lits, size_t max_len, const vector &litToOffsetVal, u32 numPositions, bool nocase) { vector tab; // Note: for the hash table, we must always have at least enough entries // for the number of hashable positions. size_t num_entries = roundUpToPowerOfTwo(max(MIN_HASH_TABLE_SIZE, numPositions)); for (;;) { tab = buildHashTable(lits, max_len, litToOffsetVal, num_entries, nocase); DEBUG_PRINTF("built %s hash table for %zu entries: load %f\n", nocase ? "nocase" : "caseful", num_entries, hashTableLoad(tab)); if (hashTableLoad(tab) < MAX_HASH_TABLE_LOAD) { break; } num_entries *= 2; } return tab; } static vector buildLits(const vector &lits, u32 baseOffset, vector &litToOffsetVal) { vector blob; litToOffsetVal.resize(lits.size(), 0); u32 lit_id = 0; for (const auto &lit : lits) { u32 offset = baseOffset + verify_u32(blob.size()); blob.insert(blob.end(), begin(lit.s), end(lit.s)); litToOffsetVal[lit_id] = offset; lit_id++; } DEBUG_PRINTF("built %zu bytes of strings\n", blob.size()); return blob; } u32 buildLongLiteralTable(const RoseBuildImpl &build, RoseEngineBlob &blob, vector &lits, size_t longLitLengthThreshold, size_t *historyRequired, size_t *longLitStreamStateRequired) { // Work in terms of history requirement (i.e. literal len - 1). const size_t max_len = longLitLengthThreshold - 1; // We should only be building the long literal hash table in streaming mode. if (!build.cc.streaming) { return 0; } if (lits.empty()) { DEBUG_PRINTF("no long literals\n"); return 0; } // The last char of each literal is trimmed as we're not interested in full // matches, only partial matches. for (auto &lit : lits) { assert(!lit.s.empty()); lit.s.pop_back(); } // Sort by caseful/caseless and in lexicographical order. stable_sort(begin(lits), end(lits), [](const ue2_case_string &a, const ue2_case_string &b) { if (a.nocase != b.nocase) { return a.nocase < b.nocase; } return a.s < b.s; }); // Find literals that are prefixes of other literals (including // duplicates). Note that we iterate in reverse, since we want to retain // only the longest string from a set of prefixes. auto it = unique(lits.rbegin(), lits.rend(), [](const ue2_case_string &a, const ue2_case_string &b) { return a.nocase == b.nocase && a.s.size() >= b.s.size() && equal(b.s.begin(), b.s.end(), a.s.begin()); }); // Erase dupes found by unique(). lits.erase(lits.begin(), it.base()); LongLitInfo info = analyzeLongLits(lits, max_len); vector litToOffsetVal; const size_t headerSize = ROUNDUP_16(sizeof(RoseLongLitTable)); vector lit_blob = buildLits(lits, headerSize, litToOffsetVal); // Build caseful bloom filter and hash table. vector bloom_case; vector tab_case; if (info.caseful.num_literals) { bloom_case = makeBloomFilter(lits, max_len, false); tab_case = makeHashTable(lits, max_len, litToOffsetVal, info.caseful.hashed_positions, false); } // Build nocase bloom filter and hash table. vector bloom_nocase; vector tab_nocase; if (info.nocase.num_literals) { bloom_nocase = makeBloomFilter(lits, max_len, true); tab_nocase = makeHashTable(lits, max_len, litToOffsetVal, info.nocase.hashed_positions, true); } size_t wholeLitTabSize = ROUNDUP_16(byte_length(lit_blob)); size_t htOffsetCase = headerSize + wholeLitTabSize; size_t htOffsetNocase = htOffsetCase + byte_length(tab_case); size_t bloomOffsetCase = htOffsetNocase + byte_length(tab_nocase); size_t bloomOffsetNocase = bloomOffsetCase + byte_length(bloom_case); size_t tabSize = ROUNDUP_16(bloomOffsetNocase + byte_length(bloom_nocase)); // need to add +2 to both of these to allow space for the actual largest // value as well as handling the fact that we add one to the space when // storing out a position to allow zero to mean "no stream state value" u8 streamBitsCase = lg2(roundUpToPowerOfTwo(tab_case.size() + 2)); u8 streamBitsNocase = lg2(roundUpToPowerOfTwo(tab_nocase.size() + 2)); u32 tot_state_bytes = ROUNDUP_N(streamBitsCase + streamBitsNocase, 8) / 8; auto table = aligned_zmalloc_unique(tabSize); assert(table); // otherwise would have thrown std::bad_alloc // Fill in the RoseLongLitTable header structure. RoseLongLitTable *header = (RoseLongLitTable *)(table.get()); header->size = verify_u32(tabSize); header->maxLen = verify_u8(max_len); // u8 so doesn't matter; won't go > 255 header->caseful.hashOffset = verify_u32(htOffsetCase); header->caseful.hashBits = lg2(tab_case.size()); header->caseful.streamStateBits = streamBitsCase; header->caseful.bloomOffset = verify_u32(bloomOffsetCase); header->caseful.bloomBits = lg2(bloom_case.size() * 8); header->nocase.hashOffset = verify_u32(htOffsetNocase); header->nocase.hashBits = lg2(tab_nocase.size()); header->nocase.streamStateBits = streamBitsNocase; header->nocase.bloomOffset = verify_u32(bloomOffsetNocase); header->nocase.bloomBits = lg2(bloom_nocase.size() * 8); assert(tot_state_bytes < sizeof(u64a)); header->streamStateBytes = verify_u8(tot_state_bytes); // u8 // Copy in the literal strings, hash tables and bloom filters, copy_bytes(table.get() + headerSize, lit_blob); copy_bytes(table.get() + htOffsetCase, tab_case); copy_bytes(table.get() + bloomOffsetCase, bloom_case); copy_bytes(table.get() + htOffsetNocase, tab_nocase); copy_bytes(table.get() + bloomOffsetNocase, bloom_nocase); DEBUG_PRINTF("built streaming table, size=%zu\n", tabSize); DEBUG_PRINTF("requires %zu bytes of history\n", max_len); DEBUG_PRINTF("requires %u bytes of stream state\n", tot_state_bytes); *historyRequired = max(*historyRequired, max_len); *longLitStreamStateRequired = tot_state_bytes; return blob.add(table.get(), tabSize, 16); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_internal.h0000644000175000017500000005460013055426554021060 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose data structures. */ #ifndef ROSE_INTERNAL_H #define ROSE_INTERNAL_H #include "ue2common.h" #include "rose_common.h" #include "util/scatter.h" #define ROSE_OFFSET_INVALID 0xffffffff // Group constants typedef u64a rose_group; // Delayed literal stuff #define DELAY_BITS 5 #define DELAY_SLOT_COUNT (1U << DELAY_BITS) #define MAX_DELAY (DELAY_SLOT_COUNT - 1) #define DELAY_MASK (DELAY_SLOT_COUNT - 1) /* Allocation of Rose literal ids * * The rose literal id space is segmented: * * ---- 0 * | | 'Normal' undelayed literals in either e or f tables * | | * | | * | | * ---- anchored_base_id * | | literals from the a table * | | * ---- delay_base_id * | | Delayed version of normal literals * | | * ---- literalCount */ /* Rose Literal Sources * * Rose currently gets events (mainly roseProcessMatch calls) from a number of * sources: * 1) The floating table * 2) The anchored table * 3) Delayed literals * 4) Suffix NFAs * 5) Literal masks * 5) End anchored table * 6) Prefix / Infix nfas * * Care is required to ensure that events appear to come into Rose in order * (or sufficiently ordered for Rose to cope). Generally the progress of the * floating table is considered the canonical position in the buffer. * * Anchored table: * The anchored table is run before the floating table as nothing in it can * depend on a floating literal. Order is achieved by two measures: * a) user matches^1 are logged and held until the floating matcher passes that * point; * b) any floating role with an anchored predecessor has a history relationship * to enforce the ordering. * * Delayed literals: * Delayed literal ordering is handled by delivering any pending delayed * literals before processing any floating match. * * Suffix: * Suffixes are always pure terminal roles. Prior to raising a match^2, pending * NFA queues are run to the current point (floating or delayed literal) as * appropriate. * * Literal Masks: * These are triggered from either floating literals or delayed literals and * inspect the data behind them. Matches are raised at the same location as the * trigger literal so there are no ordering issues. Masks are always pure * terminal roles. * * Lookaround: * These are tests run on receipt of a role that "look around" the match, * checking characters at nearby offsets against reachability masks. Each role * can have a list of these lookaround offset/reach pairs, ordered in offset * order, and any failure will prevent the role from being switched on. Offsets * are relative to the byte after a literal match, and can be negative. * * Prefix / Infix: * TODO: remember / discuss * * End anchored table: * All user matches occur at the last byte. We do this last, so no problems * (yippee) * * ^1 User matches which occur before any possible match from the other tables * are not delayed. * ^2 Queues may also be run to the current location if a queue is full and * needs to be emptied. * ^3 There is no need to catch up at the end of a block scan as it contains no * terminals. */ struct RoseCountingMiracle { char shufti; /** 1: count shufti class; 0: count a single character */ u8 count; /** minimum number of occurrences for the counting * miracle char to kill the leftfix. */ u8 c; /** character to look for if not shufti */ u8 poison; /** character not in the shufti mask */ m128 lo; /** shufti lo mask */ m128 hi; /** shufti hi mask */ }; struct LeftNfaInfo { u32 maxQueueLen; u32 maxLag; // maximum of successor roles' lag u32 lagIndex; // iff lag != 0, index into leftfixLagTable u32 stopTable; // stop table index, or ROSE_OFFSET_INVALID u8 transient; /**< 0 if not transient, else max width of transient prefix */ char infix; /* TODO: make flags */ char eager; /**< nfa should be run eagerly to first match or death */ char eod_check; /**< nfa is used by the event eod literal */ u32 countingMiracleOffset; /** if not 0, offset to RoseCountingMiracle. */ rose_group squash_mask; /* & mask applied when rose nfa dies */ }; struct NfaInfo { u32 nfaOffset; u32 stateOffset; u32 fullStateOffset; /* offset in scratch, relative to ??? */ u32 ekeyListOffset; /* suffix, relative to base of rose, 0 if no ekeys */ u8 no_retrigger; /* TODO */ u8 in_sbmatcher; /**< this outfix should not be run in small-block * execution, as it will be handled by the sbmatcher * HWLM table. */ u8 eod; /* suffix is triggered by the etable --> can only produce eod * matches */ }; #define MAX_STORED_LEFTFIX_LAG 127 /* max leftfix lag that we can store in one * whole byte (OWB) (streaming only). Other * values in OWB are reserved for zombie * status */ #define OWB_ZOMBIE_ALWAYS_YES 128 /* nfa will always answer yes to any rose * prefix checks */ /** * \brief Rose state offsets. * * Stores pre-calculated offsets (in bytes) to MOST of the state structures * used by Rose, relative to the start of stream state. * * State not covered by this structure includes: * * -# the first byte, containing the status bitmask * -# the role state multibit */ struct RoseStateOffsets { /** History buffer. * * First byte is an 8-bit count of the number of valid history bytes * available, followed by the history itself. Max size of history is * RoseEngine::historyRequired. */ u32 history; /** Exhausted bitvector. * * 1 bit per exhaustible key (used by Highlander mode). If a bit is set, * reports with that ekey should not be delivered to the user. */ u32 exhausted; /** Multibit for active suffix/outfix engines. */ u32 activeLeafArray; /** Multibit for active Rose (prefix/infix) engines. */ u32 activeLeftArray; /** Size of the active Rose array multibit, in bytes. */ u32 activeLeftArray_size; /** Table of lag information (stored as one byte per engine) for active * Rose leftfix engines. */ u32 leftfixLagTable; /** State for anchored matchers (McClellan DFAs). */ u32 anchorState; /** Packed Rose groups value. */ u32 groups; /** Size of packed Rose groups value, in bytes. */ u32 groups_size; /** State for long literal support. */ u32 longLitState; /** Packed SOM location slots. */ u32 somLocation; /** Multibit guarding SOM location slots. */ u32 somValid; /** Multibit guarding SOM location slots. */ u32 somWritable; /** Total size of Rose state, in bytes. */ u32 end; }; struct RoseBoundaryReports { /** \brief 0 if no reports list, otherwise offset of program to run to * deliver reports at EOD. */ u32 reportEodOffset; /** \brief 0 if no reports list, otherwise offset of program to run to * deliver reports at offset 0. */ u32 reportZeroOffset; /** \brief 0 if no reports list, otherwise offset of program to run to * deliver reports if EOD is at offset 0. Superset of other programs. */ u32 reportZeroEodOffset; }; /* NFA Queue Assignment * * --- 0 * (|) chained mpv (if present) * # * --- outfixBeginQueue - * | outfixes. enabled at offset 0. * | * # * --- outfixEndQueue - * | suffixes. enabled by rose roles. * | * # * --- leftfixBeginQueue - * | prefixes * | * # * --- ? * | infixes * | * # */ #define ROSE_RUNTIME_FULL_ROSE 0 #define ROSE_RUNTIME_PURE_LITERAL 1 #define ROSE_RUNTIME_SINGLE_OUTFIX 2 /** * \brief Runtime structure header for Rose. * * Runtime structure header for Rose. * In memory, we follow this with: * -# the "engine blob" * -# anchored 'literal' matcher table * -# floating literal matcher table * -# eod-anchored literal matcher table * -# small block table * -# array of NFA offsets, one per queue * -# array of state offsets, one per queue (+) * * (+) stateOffset array note: Offsets in the array are either into the stream * state (normal case) or into the tstate region of scratch (for transient rose * nfas). Rose nfa info table can distinguish the cases. */ struct RoseEngine { u8 noFloatingRoots; /* only need to run the anchored table if something * matched in the anchored table */ u8 requiresEodCheck; /* stuff happens at eod time */ u8 hasOutfixesInSmallBlock; /**< has at least one outfix that must run even in small block scans. */ u8 runtimeImpl; /**< can we just run the floating table or a single outfix? * or do we need a full rose? */ u8 mpvTriggeredByLeaf; /**< need to check (suf|out)fixes for mpv trigger */ u8 canExhaust; /**< every pattern has an exhaustion key */ u8 hasSom; /**< has at least one pattern which tracks SOM. */ u8 somHorizon; /**< width in bytes of SOM offset storage (governed by SOM precision) */ u8 needsCatchup; /** catch up needs to be run on every report. */ u32 mode; /**< scanning mode, one of HS_MODE_{BLOCK,STREAM,VECTORED} */ u32 historyRequired; /**< max amount of history required for streaming */ u32 ekeyCount; /**< number of exhaustion keys */ u32 dkeyCount; /**< number of dedupe keys */ u32 dkeyLogSize; /**< size of fatbit for storing dkey log (bytes) */ u32 invDkeyOffset; /**< offset to table mapping from dkeys to the external * report ids */ u32 somLocationCount; /**< number of som locations required */ u32 somLocationFatbitSize; /**< size of SOM location fatbit (bytes) */ u32 rolesWithStateCount; // number of roles with entries in state bitset u32 stateSize; /* size of the state bitset * WARNING: not the size of the rose state */ u32 anchorStateSize; /* size of the state for the anchor dfas */ u32 nfaStateSize; /* total size of the state for the mask/rose nfas */ u32 tStateSize; /* total size of the state for transient rose nfas */ u32 scratchStateSize; /**< uncompressed state req'd for NFAs in scratch; * used for sizing scratch only. */ u32 smallWriteOffset; /**< offset of small-write matcher */ u32 amatcherOffset; // offset of the anchored literal matcher (bytes) u32 ematcherOffset; // offset of the eod-anchored literal matcher (bytes) u32 fmatcherOffset; // offset of the floating literal matcher (bytes) u32 sbmatcherOffset; // offset of the small-block literal matcher (bytes) u32 longLitTableOffset; // offset of the long literal table u32 amatcherMinWidth; /**< minimum number of bytes required for a pattern * involved with the anchored table to produce a full * match. */ u32 fmatcherMinWidth; /**< minimum number of bytes required for a pattern * involved with the floating table to produce a full * match. */ u32 eodmatcherMinWidth; /**< minimum number of bytes required for a pattern * involved with the eod table to produce a full * match. */ u32 amatcherMaxBiAnchoredWidth; /**< maximum number of bytes that can still * produce a match for a pattern involved * with the anchored table. */ u32 fmatcherMaxBiAnchoredWidth; /**< maximum number of bytes that can still * produce a match for a pattern involved * with the anchored table. */ /** \brief Offset of u32 array of program offsets for literals. */ u32 litProgramOffset; /** \brief Offset of u32 array of delay rebuild program offsets for * literals. */ u32 litDelayRebuildProgramOffset; /** * \brief Offset of u32 array of program offsets for reports used by * output-exposed engines. */ u32 reportProgramOffset; /** * \brief Number of programs for reports used by output-exposed engines. */ u32 reportProgramCount; /** * \brief Number of entries in the arrays pointed to by litProgramOffset, * litDelayRebuildProgramOffset. * * Note: NOT the total number of literals. */ u32 literalCount; u32 activeArrayCount; //number of nfas tracked in the active array u32 activeLeftCount; //number of nfas tracked in the active rose array u32 queueCount; /**< number of nfa queues */ u32 activeQueueArraySize; //!< size of fatbit for active queues (bytes) u32 eagerIterOffset; /**< offset to sparse iter for eager prefixes or 0 if * none */ /** \brief Number of keys used by CHECK_SET_HANDLED instructions in role * programs. */ u32 handledKeyCount; /** \brief Size of the handled keys fatbit in scratch (bytes). */ u32 handledKeyFatbitSize; u32 leftOffset; u32 roseCount; u32 lookaroundTableOffset; //!< base of lookaround offset list (of s8 values) u32 lookaroundReachOffset; /**< base of lookaround reach bitvectors (32 * bytes each) */ u32 eodProgramOffset; //!< EOD program, otherwise 0. u32 lastByteHistoryIterOffset; // if non-zero /** \brief Minimum number of bytes required to match. */ u32 minWidth; /** \brief Minimum number of bytes required to match, excluding boundary * reports. */ u32 minWidthExcludingBoundaries; u32 maxBiAnchoredWidth; /* ROSE_BOUND_INF if any non bianchored patterns * present */ u32 anchoredDistance; // region to run the anchored table over u32 anchoredMinDistance; /* start of region to run anchored table over */ u32 floatingDistance; /* end of region to run the floating table over ROSE_BOUND_INF if not bounded */ u32 floatingMinDistance; /* start of region to run floating table over */ u32 smallBlockDistance; /* end of region to run the floating table over ROSE_BOUND_INF if not bounded */ u32 floatingMinLiteralMatchOffset; /* the minimum offset that we can get a * 'valid' match from the floating * table */ u32 nfaInfoOffset; /* offset to the nfa info offset array */ rose_group initialGroups; rose_group floating_group_mask; /* groups that are used by the ftable */ u32 size; // (bytes) u32 delay_count; /* number of delayed literal ids. */ u32 delay_fatbit_size; //!< size of each delay fatbit in scratch (bytes) u32 delay_base_id; /* literal id of the first delayed literal. * delayed literal ids are contiguous */ u32 anchored_count; /* number of anchored literal ids */ u32 anchored_fatbit_size; //!< size of each anch fatbit in scratch (bytes) u32 anchored_base_id; /* literal id of the first literal in the A table. * anchored literal ids are contiguous */ u32 maxFloatingDelayedMatch; /* max offset that a delayed literal can * usefully be reported */ u32 delayRebuildLength; /* length of the history region which needs to be * rescanned when we are doing a delayed literal * rebuild scan. */ struct RoseStateOffsets stateOffsets; struct RoseBoundaryReports boundary; u32 totalNumLiterals; /* total number of literals including dr */ u32 asize; /* size of the atable */ u32 outfixBeginQueue; /* first outfix queue */ u32 outfixEndQueue; /* one past the last outfix queue */ u32 leftfixBeginQueue; /* first prefix/infix queue */ u32 initMpvNfa; /* (allegedly chained) mpv to force on at init */ u32 rosePrefixCount; /* number of rose prefixes */ u32 activeLeftIterOffset; /* mmbit_sparse_iter over non-transient roses */ u32 ematcherRegionSize; /* max region size to pass to ematcher */ u32 somRevCount; /**< number of som reverse nfas */ u32 somRevOffsetOffset; /**< offset to array of offsets to som rev nfas */ u32 longLitStreamState; // size in bytes struct scatter_full_plan state_init; }; struct ALIGN_CL_DIRECTIVE anchored_matcher_info { u32 next_offset; /* relative to this, 0 for end */ u32 state_offset; /* relative to anchorState */ u32 anchoredMinDistance; /* start of region to run anchored table over */ }; /** * \brief Long literal subtable for a particular mode (caseful or nocase). */ struct RoseLongLitSubtable { /** * \brief Offset of the hash table (relative to RoseLongLitTable base). * * Offset is zero if no such table exists. */ u32 hashOffset; /** * \brief Offset of the bloom filter (relative to RoseLongLitTable base). * * Offset is zero if no such table exists. */ u32 bloomOffset; /** \brief lg2 of the size of the hash table. */ u8 hashBits; /** \brief Size of the bloom filter in bits. */ u8 bloomBits; /** \brief Number of bits of packed stream state used. */ u8 streamStateBits; }; /** * \brief Long literal table header. */ struct RoseLongLitTable { /** * \brief Total size of the whole table (including strings, bloom filters, * hash tables). */ u32 size; /** \brief Caseful sub-table (hash table and bloom filter). */ struct RoseLongLitSubtable caseful; /** \brief Caseless sub-table (hash table and bloom filter). */ struct RoseLongLitSubtable nocase; /** \brief Total size of packed stream state in bytes. */ u8 streamStateBytes; /** \brief Max length of literal prefixes. */ u8 maxLen; }; /** * \brief One of these structures per hash table entry in our long literal * table. */ struct RoseLongLitHashEntry { /** * \brief Offset of the literal string itself, relative to * RoseLongLitTable base. Zero if this bucket is empty. */ u32 str_offset; /** \brief Length of the literal string. */ u32 str_len; }; static really_inline const struct anchored_matcher_info *getALiteralMatcher( const struct RoseEngine *t) { if (!t->amatcherOffset) { return NULL; } const char *lt = (const char *)t + t->amatcherOffset; assert(ISALIGNED_CL(lt)); return (const struct anchored_matcher_info *)lt; } struct HWLM; static really_inline const struct HWLM *getFLiteralMatcher(const struct RoseEngine *t) { if (!t->fmatcherOffset) { return NULL; } const char *lt = (const char *)t + t->fmatcherOffset; assert(ISALIGNED_CL(lt)); return (const struct HWLM *)lt; } static really_inline const void *getSBLiteralMatcher(const struct RoseEngine *t) { if (!t->sbmatcherOffset) { return NULL; } const char *matcher = (const char *)t + t->sbmatcherOffset; assert(ISALIGNED_N(matcher, 8)); return matcher; } static really_inline const struct LeftNfaInfo *getLeftTable(const struct RoseEngine *t) { const struct LeftNfaInfo *r = (const struct LeftNfaInfo *)((const char *)t + t->leftOffset); assert(ISALIGNED_N(r, 4)); return r; } struct mmbit_sparse_iter; // forward decl static really_inline const struct mmbit_sparse_iter *getActiveLeftIter(const struct RoseEngine *t) { assert(t->activeLeftIterOffset); const struct mmbit_sparse_iter *it = (const struct mmbit_sparse_iter *) ((const char *)t + t->activeLeftIterOffset); assert(ISALIGNED_N(it, 4)); return it; } static really_inline const struct NfaInfo *getNfaInfoByQueue(const struct RoseEngine *t, u32 qi) { const struct NfaInfo *infos = (const struct NfaInfo *)((const char *)t + t->nfaInfoOffset); assert(ISALIGNED_N(infos, sizeof(u32))); return &infos[qi]; } static really_inline const struct NFA *getNfaByInfo(const struct RoseEngine *t, const struct NfaInfo *info) { return (const struct NFA *)((const char *)t + info->nfaOffset); } static really_inline const struct NFA *getNfaByQueue(const struct RoseEngine *t, u32 qi) { const struct NfaInfo *info = getNfaInfoByQueue(t, qi); return getNfaByInfo(t, info); } static really_inline u32 queueToLeftIndex(const struct RoseEngine *t, u32 qi) { assert(qi >= t->leftfixBeginQueue); return qi - t->leftfixBeginQueue; } static really_inline const struct LeftNfaInfo *getLeftInfoByQueue(const struct RoseEngine *t, u32 qi) { const struct LeftNfaInfo *infos = getLeftTable(t); return &infos[queueToLeftIndex(t, qi)]; } struct SmallWriteEngine; static really_inline const struct SmallWriteEngine *getSmallWrite(const struct RoseEngine *t) { if (!t->smallWriteOffset) { return NULL; } const struct SmallWriteEngine *smwr = (const struct SmallWriteEngine *)((const char *)t + t->smallWriteOffset); return smwr; } #endif // ROSE_INTERNAL_H hyperscan-4.4.1/src/rose/rose_build_util.h0000644000175000017500000000427213055426554021400 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ROSE_BUILD_UTIL_H #define ROSE_BUILD_UTIL_H #include "rose_graph.h" #include "util/graph.h" #include namespace ue2 { /** Max allowed width for transient graphs in block mode */ #define ROSE_BLOCK_TRANSIENT_MAX_WIDTH 255U /** * \brief Add two Rose depths together, coping correctly with infinity at * ROSE_BOUND_INF. */ static inline u32 add_rose_depth(u32 a, u32 b) { assert(a <= ROSE_BOUND_INF); assert(b <= ROSE_BOUND_INF); if (a == ROSE_BOUND_INF || b == ROSE_BOUND_INF) { return ROSE_BOUND_INF; } u32 rv = a + b; assert(rv >= a && rv >= b); return rv; } } // namespace ue2 #endif // ROSE_BUILD_UTIL_H hyperscan-4.4.1/src/rose/rose_build_role_aliasing.cpp0000644000175000017500000020321313055426554023562 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_role_aliasing.h" #include "ue2common.h" #include "rose_build_impl.h" #include "rose_build_merge.h" #include "rose_build_util.h" #include "grey.h" #include "nfa/castlecompile.h" #include "nfa/goughcompile.h" #include "nfa/mcclellancompile_util.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_is_equal.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_prune.h" #include "nfagraph/ng_uncalc_components.h" #include "nfagraph/ng_util.h" #include "util/bitutils.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/order_check.h" #include "util/ue2_containers.h" #include #include #include #include #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { namespace { // Used for checking edge sets (both in- and out-) against each other. struct EdgeAndVertex { EdgeAndVertex(const RoseEdge &e, const RoseVertex v_, const RoseGraph &g) : v(v_), eprops(g[e]) {} virtual ~EdgeAndVertex() {} virtual bool operator<(const EdgeAndVertex &a) const { if (v != a.v) { return v < a.v; } if (eprops.minBound != a.eprops.minBound) { return eprops.minBound < a.eprops.minBound; } if (eprops.maxBound != a.eprops.maxBound) { return eprops.maxBound < a.eprops.maxBound; } if (eprops.rose_top != a.eprops.rose_top) { return eprops.rose_top < a.eprops.rose_top; } return eprops.history < a.eprops.history; } virtual bool operator==(const EdgeAndVertex &a) const { return v == a.v && eprops.minBound == a.eprops.minBound && eprops.maxBound == a.eprops.maxBound && eprops.rose_top == a.eprops.rose_top && eprops.history == a.eprops.history; } private: RoseVertex v; const RoseEdgeProps &eprops; }; struct AliasOutEdge : EdgeAndVertex { AliasOutEdge(const RoseEdge &e, const RoseGraph &g) : EdgeAndVertex(e, target(e, g), g) {} }; struct AliasInEdge : EdgeAndVertex { AliasInEdge(const RoseEdge &e, const RoseGraph &g) : EdgeAndVertex(e, source(e, g), g) {} }; class CandidateSet { public: typedef set::iterator iterator; typedef RoseVertex key_type; iterator begin() { return main_cont.begin(); } iterator end() { return main_cont.end(); } bool contains(RoseVertex a) const { return hash_cont.find(a) != hash_cont.end(); } void insert(RoseVertex a) { main_cont.insert(a); hash_cont.insert(a); } void erase(iterator aa) { RoseVertex a = *aa; main_cont.erase(aa); hash_cont.erase(a); } void erase(RoseVertex a) { main_cont.erase(a); hash_cont.erase(a); } size_t size() const { assert(hash_cont.size() == main_cont.size()); return main_cont.size(); } bool empty() const { assert(hash_cont.size() == main_cont.size()); return main_cont.empty(); } private: /* if a vertex is worth storing, it is worth storing twice */ set main_cont; /* deterministic iterator */ ue2::unordered_set hash_cont; /* member checks */ }; struct RoseAliasingInfo { RoseAliasingInfo(const RoseBuildImpl &build) { const auto &g = build.g; // Populate reverse leftfix map. for (auto v : vertices_range(g)) { if (g[v].left) { rev_leftfix[g[v].left].insert(v); } } // Populate reverse ghost vertex map. for (const auto &m : build.ghost) { rev_ghost[m.second].insert(m.first); } } /** \brief Mapping from leftfix to vertices. */ ue2::unordered_map> rev_leftfix; /** \brief Mapping from undelayed ghost to delayed vertices. */ ue2::unordered_map> rev_ghost; }; } // namespace // Check successor set: must lead to the same vertices via edges with the // same properties. static bool sameSuccessors(RoseVertex a, RoseVertex b, const RoseGraph &g) { if (out_degree(a, g) != out_degree(b, g)) { return false; } set succs_a, succs_b; for (const auto &e : out_edges_range(a, g)) { succs_a.insert(AliasOutEdge(e, g)); } for (const auto &e : out_edges_range(b, g)) { succs_b.insert(AliasOutEdge(e, g)); } return (succs_a == succs_b); } /* unlike LeftEngInfo::==, this does a deep check to see if the leftfixes are * equivalent rather than checking for pointer equality. */ static bool hasEqualLeftfixes(RoseVertex a, RoseVertex b, const RoseGraph &g) { assert(g[a].left || g[b].left); if (!g[a].left || !g[b].left) { return false; } const LeftEngInfo &a_left = g[a].left; const LeftEngInfo &b_left = g[b].left; if (a_left.castle && b_left.castle) { return is_equal(*a_left.castle, a_left.leftfix_report, *b_left.castle, b_left.leftfix_report); } if (a_left.graph && b_left.graph) { /* non-castle engines have graphs */ return is_equal(*a_left.graph, a_left.leftfix_report, *b_left.graph, b_left.leftfix_report); } /* graph <-> castle cases are not equal */ return false; } // Check predecessor set: must come from the same vertices via edges with // the same properties. static bool samePredecessors(RoseVertex a, RoseVertex b, const RoseGraph &g) { if (in_degree(a, g) != in_degree(b, g)) { return false; } set preds_a, preds_b; for (const auto &e : in_edges_range(a, g)) { preds_a.insert(AliasInEdge(e, g)); } for (const auto &e : in_edges_range(b, g)) { preds_b.insert(AliasInEdge(e, g)); } if (preds_a != preds_b) { return false; } if (g[a].left || g[b].left) { if (!hasEqualLeftfixes(a, b, g)) { return false; } for (const auto &e_a : in_edges_range(a, g)) { RoseEdge e = edge(source(e_a, g), b, g); if (!e || g[e].rose_top != g[e_a].rose_top) { DEBUG_PRINTF("bad tops\n"); return false; } } } return true; } static bool hasCommonSuccWithBadBounds(RoseVertex a, RoseVertex b, const RoseGraph &g) { for (const auto &e_a : out_edges_range(a, g)) { if (RoseEdge e = edge(b, target(e_a, g), g)) { if (g[e_a].maxBound < g[e].minBound || g[e].maxBound < g[e_a].minBound) { return true; } if (g[e_a].rose_top != g[e].rose_top) { // Can't trigger two tops on the same leftfix, we can't merge // this. return true; } } } return false; } static bool hasCommonPredWithBadBounds(RoseVertex a, RoseVertex b, const RoseGraph &g) { for (const auto &e_a : in_edges_range(a, g)) { if (RoseEdge e = edge(source(e_a, g), b, g)) { if (g[e_a].maxBound < g[e].minBound || g[e].maxBound < g[e_a].minBound) { return true; } // XXX: if we're merging two vertices with different roses, we // cannot allow them to share a pred, as we would be unable to // merge the (necessarily different) tops on the in-edges. This // could be relaxed if we made the tops mergeable (by making // edge_top a bitfield, for example). if (g[a].left != g[b].left) { return true; } } } return false; } static bool canMergeLiterals(RoseVertex a, RoseVertex b, const RoseBuildImpl &build) { const auto &lits_a = build.g[a].literals; const auto &lits_b = build.g[b].literals; assert(!lits_a.empty() && !lits_b.empty()); // If both vertices have only pseudo-dotstar in-edges, we can merge // literals of different lengths and can avoid the check below. if (build.hasOnlyPseudoStarInEdges(a) && build.hasOnlyPseudoStarInEdges(b)) { DEBUG_PRINTF("both have pseudo-dotstar in-edges\n"); return true; } // Otherwise, all the literals involved must have the same length. for (u32 a_id : lits_a) { const rose_literal_id &la = build.literals.right.at(a_id); for (u32 b_id : lits_b) { const rose_literal_id &lb = build.literals.right.at(b_id); if (la.elength() != lb.elength()) { DEBUG_PRINTF("bad merge %zu!=%zu '%s', '%s'\n", la.elength(), lb.elength(), la.s.c_str(), lb.s.c_str()); return false; } } } return true; } static bool isAliasingCandidate(RoseVertex v, const RoseBuildImpl &build) { const RoseVertexProps &props = build.g[v]; // Must have literals. if (props.literals.empty()) { return false; } assert(*props.literals.begin() != MO_INVALID_IDX); return true; } static bool sameGhostProperties(const RoseBuildImpl &build, const RoseAliasingInfo &rai, RoseVertex a, RoseVertex b) { // If these are ghost mapping keys, then they must map to the same vertex. if (contains(build.ghost, a) || contains(build.ghost, b)) { DEBUG_PRINTF("checking ghost key compat\n"); if (!contains(build.ghost, a) || !contains(build.ghost, b)) { DEBUG_PRINTF("missing ghost mapping\n"); return false; } if (build.ghost.at(a) != build.ghost.at(b)) { DEBUG_PRINTF("diff ghost mapping\n"); return false; } DEBUG_PRINTF("ghost mappings ok\n"); return true; } // If they are ghost vertices, then they must have the same literals. if (contains(rai.rev_ghost, a) || contains(rai.rev_ghost, b)) { if (!contains(rai.rev_ghost, a) || !contains(rai.rev_ghost, b)) { DEBUG_PRINTF("missing ghost reverse mapping\n"); return false; } return build.g[a].literals == build.g[b].literals; } return true; } static bool sameRoleProperties(const RoseBuildImpl &build, const RoseAliasingInfo &rai, RoseVertex a, RoseVertex b) { const RoseGraph &g = build.g; const RoseVertexProps &aprops = g[a], &bprops = g[b]; if (aprops.eod_accept != bprops.eod_accept) { return false; } // We don't want to merge a role with LAST_BYTE history with one without, // as a role that can only be triggered at EOD cannot safely precede // "ordinary" roles. if (hasLastByteHistorySucc(g, a) != hasLastByteHistorySucc(g, b)) { return false; } // We certainly don't want to merge root roles with non-root roles. /* TODO: explain */ if (build.isRootSuccessor(a) != build.isRootSuccessor(b)) { return false; } if (aprops.som_adjust != bprops.som_adjust) { return false; } if (!sameGhostProperties(build, rai, a, b)) { return false; } /* "roses are mergeable" check are handled elsewhere */ return true; } /* Checks compatibility of role properties if we require that two roles are * right equiv. */ static bool sameRightRoleProperties(const RoseBuildImpl &build, RoseVertex a, RoseVertex b) { const RoseGraph &g = build.g; const RoseVertexProps &aprops = g[a], &bprops = g[b]; if (aprops.reports != bprops.reports) { return false; } if (hasAnchHistorySucc(g, a) != hasAnchHistorySucc(g, b)) { return false; } // If the history type is ANCH, then we need to be careful that we only // merge literals that occur at the same offsets. if (hasAnchHistorySucc(g, a) || hasAnchHistorySucc(g, b)) { if (aprops.min_offset != bprops.min_offset || aprops.max_offset != bprops.max_offset) { return false; } } if (aprops.suffix != bprops.suffix) { return false; } return true; } /** * Hash on some deterministic props checked in sameRoleProperties + properties * required for right equivalence. */ static size_t hashRightRoleProperties(RoseVertex v, const RoseGraph &g) { using boost::hash_combine; using boost::hash_range; const RoseVertexProps &props = g[v]; size_t val = 0; hash_combine(val, hash_range(begin(props.reports), end(props.reports))); if (props.suffix) { const auto &suffix = props.suffix; if (suffix.castle) { hash_combine(val, suffix.castle->reach()); hash_combine(val, suffix.castle->repeats.size()); } if (suffix.graph) { hash_combine(val, num_vertices(*suffix.graph)); } if (suffix.haig) { hash_combine(val, hash_dfa(*suffix.haig)); } } return val; } static void mergeEdgeAdd(RoseVertex u, RoseVertex v, const RoseEdge &from_edge, const RoseEdge *to_edge, RoseGraph &g) { const RoseEdgeProps &from_props = g[from_edge]; if (!to_edge) { DEBUG_PRINTF("adding edge [%zu,%zu]\n", g[u].index, g[v].index); add_edge(u, v, from_props, g); } else { // union of the two edges. DEBUG_PRINTF("updating edge [%zu,%zu]\n", g[u].index, g[v].index); RoseEdgeProps &to_props = g[*to_edge]; to_props.minBound = min(to_props.minBound, from_props.minBound); to_props.maxBound = max(to_props.maxBound, from_props.maxBound); assert(to_props.rose_top == from_props.rose_top); } } /* clone a's edges onto b */ static void mergeEdges(RoseVertex a, RoseVertex b, RoseGraph &g) { // All the edges to or from b for quick lookup. typedef map EdgeCache; EdgeCache b_edges; // Cache b's in-edges so we can look them up by source quickly. for (const auto &e : in_edges_range(b, g)) { RoseVertex u = source(e, g); b_edges.emplace(u, e); } // Add a's in-edges to b, merging them in where b already has the new edge. // Once handled, the in-edges to a are removed. RoseGraph::in_edge_iterator ei, ee; tie(ei, ee) = in_edges(a, g); while (ei != ee) { RoseVertex u = source(*ei, g); EdgeCache::const_iterator it = b_edges.find(u); const RoseEdge *to_edge = (it == b_edges.end() ? nullptr : &it->second); mergeEdgeAdd(u, b, *ei, to_edge, g); remove_edge(*ei++, g); } // Cache b's out-edges so we can look them up by target quickly. b_edges.clear(); for (const auto &e : out_edges_range(b, g)) { RoseVertex v = target(e, g); b_edges.emplace(v, e); } // Add a's out-edges to b, merging them in where b already has the new edge. // Once handled, the out-edges to a are removed. RoseGraph::out_edge_iterator oi, oe; tie(oi, oe) = out_edges(a, g); while (oi != oe) { RoseVertex v = target(*oi, g); EdgeCache::const_iterator it = b_edges.find(v); const RoseEdge *to_edge = (it == b_edges.end() ? nullptr : &it->second); mergeEdgeAdd(b, v, *oi, to_edge, g); remove_edge(*oi++, g); } // Vertex a should no longer have any in- or out-edges. assert(degree(a, g) == 0); } static void mergeLiteralSets(RoseVertex a, RoseVertex b, RoseBuildImpl &build) { RoseGraph &g = build.g; const auto &a_literals = g[a].literals; for (u32 lit_id : a_literals) { auto &lit_vertices = build.literal_info[lit_id].vertices; lit_vertices.erase(a); lit_vertices.insert(b); } insert(&g[b].literals, a_literals); } static void updateAliasingInfo(RoseBuildImpl &build, RoseAliasingInfo &rai, RoseVertex a, RoseVertex b) { if (build.g[a].left) { const left_id left(build.g[a].left); assert(contains(rai.rev_leftfix[left], a)); rai.rev_leftfix[left].erase(a); } if (contains(build.ghost, a)) { auto ghost = build.ghost.at(a); assert(contains(build.ghost, b) && ghost == build.ghost.at(b)); build.ghost.erase(a); rai.rev_ghost[ghost].erase(a); } if (contains(rai.rev_ghost, a)) { for (const auto &v : rai.rev_ghost[a]) { build.ghost[v] = b; rai.rev_ghost[b].insert(v); } rai.rev_ghost.erase(a); } } /** \brief Common role merge code used by variants below. */ static void mergeCommon(RoseBuildImpl &build, RoseAliasingInfo &rai, RoseVertex a, RoseVertex b) { RoseGraph &g = build.g; assert(g[a].eod_accept == g[b].eod_accept); assert(g[a].left == g[b].left); assert(!g[a].suffix || g[a].suffix == g[b].suffix); // In some situations (ghost roles etc), we can have different groups. assert(!g[a].groups && !g[b].groups); /* current structure means groups * haven't been assigned yet */ g[b].groups |= g[a].groups; mergeLiteralSets(a, b, build); updateAliasingInfo(build, rai, a, b); // Our min and max_offsets should be sane. assert(g[b].min_offset <= g[b].max_offset); // Safety check: we should not have created through a merge a vertex that // has an out-edge with ANCH history but is not fixed-offset. assert(!hasAnchHistorySucc(g, b) || g[b].fixedOffset()); } /** \brief Merge role 'a' into 'b', left merge path. */ static void mergeVerticesLeft(RoseVertex a, RoseVertex b, RoseBuildImpl &build, RoseAliasingInfo &rai) { RoseGraph &g = build.g; DEBUG_PRINTF("merging vertex %zu into %zu\n", g[a].index, g[b].index); insert(&g[b].reports, g[a].reports); // Since it is a left merge (identical LHS) we should pick the tighter // bound. g[b].min_offset = max(g[a].min_offset, g[b].min_offset); g[b].max_offset = min(g[a].max_offset, g[b].max_offset); if (!g[b].suffix) { g[b].suffix = g[a].suffix; } mergeEdges(a, b, g); mergeCommon(build, rai, a, b); } /** \brief Merge role 'a' into 'b', right merge path. */ static void mergeVerticesRight(RoseVertex a, RoseVertex b, RoseBuildImpl &build, RoseAliasingInfo &rai) { RoseGraph &g = build.g; DEBUG_PRINTF("merging vertex %zu into %zu\n", g[a].index, g[b].index); insert(&g[b].reports, g[a].reports); g[b].min_offset = min(g[a].min_offset, g[b].min_offset); g[b].max_offset = max(g[a].max_offset, g[b].max_offset); mergeEdges(a, b, g); mergeCommon(build, rai, a, b); } /** * Faster version of \ref mergeVertices for diamond merges, for which we know * that the in- and out-edge sets, reports and suffixes are identical. */ static void mergeVerticesDiamond(RoseVertex a, RoseVertex b, RoseBuildImpl &build, RoseAliasingInfo &rai) { RoseGraph &g = build.g; DEBUG_PRINTF("merging vertex %zu into %zu\n", g[a].index, g[b].index); // For a diamond merge, most properties are already the same (with the // notable exception of the literal set). assert(g[a].reports == g[b].reports); assert(g[a].suffix == g[b].suffix); g[b].min_offset = min(g[a].min_offset, g[b].min_offset); g[b].max_offset = max(g[a].max_offset, g[b].max_offset); mergeCommon(build, rai, a, b); } static never_inline void findCandidates(const RoseBuildImpl &build, CandidateSet *candidates) { for (auto v : vertices_range(build.g)) { if (isAliasingCandidate(v, build)) { DEBUG_PRINTF("candidate %zu\n", build.g[v].index); DEBUG_PRINTF("lits: %u\n", *build.g[v].literals.begin()); candidates->insert(v); } } assert(candidates->size() <= num_vertices(build.g)); DEBUG_PRINTF("found %zu/%zu candidates\n", candidates->size(), num_vertices(build.g)); } static RoseVertex pickSucc(const RoseVertex v, const RoseGraph &g) { RoseGraph::adjacency_iterator ai, ae; tie(ai, ae) = adjacent_vertices(v, g); if (ai == ae) { return RoseGraph::null_vertex(); } return *ai; } static RoseVertex pickPred(const RoseVertex v, const RoseGraph &g, const RoseBuildImpl &build) { RoseGraph::in_edge_iterator ei, ee; tie(ei, ee) = in_edges(v, g); if (ei == ee) { assert(0); // every candidate should have in-degree! return RoseGraph::null_vertex(); } // Avoid roots if we have other options, since it doesn't matter to the // merge pass which predecessor we pick. RoseVertex u = source(*ei, g); while (build.isAnyStart(u) && ++ei != ee) { u = source(*ei, g); } return u; } template<> bool contains<>(const CandidateSet &container, const RoseVertex &key) { return container.contains(key); } // Simplified version of hasCommonPredWithBadBounds for diamond merges. static bool hasCommonPredWithDiffRoses(RoseVertex a, RoseVertex b, const RoseGraph &g) { if (!g[a].left || !g[b].left) { DEBUG_PRINTF("one of (a, b) doesn't have a prefix\n"); return true; } // XXX: if we're merging two vertices with different leftfixes, we // cannot allow them to share a pred, as we would be unable to // merge the (necessarily different) tops on the in-edges. This // could be relaxed if we made the tops mergeable (by making // edge_top a bitfield, for example). const bool equal_roses = hasEqualLeftfixes(a, b, g); for (const auto &e_a : in_edges_range(a, g)) { if (RoseEdge e = edge(source(e_a, g), b, g)) { DEBUG_PRINTF("common pred, e_r=%d r_t %u,%u\n", (int)equal_roses, g[e].rose_top, g[e_a].rose_top); if (!equal_roses) { DEBUG_PRINTF("different roses\n"); return true; } if (g[e].rose_top != g[e_a].rose_top) { DEBUG_PRINTF("bad tops\n"); return true; } } } DEBUG_PRINTF("ok\n"); return false; } static void pruneReportIfUnused(const RoseBuildImpl &build, shared_ptr h, const set &verts, ReportID report) { DEBUG_PRINTF("trying to prune %u from %p (v %zu)\n", report, h.get(), verts.size()); for (RoseVertex v : verts) { if (build.g[v].left.graph == h && build.g[v].left.leftfix_report == report) { DEBUG_PRINTF("report %u still in use\n", report); return; } } if (!verts.empty()) { // Report no longer in use, but graph h is still alive: we should prune // the report if we can do so without rendering the graph // unimplementable. DEBUG_PRINTF("report %u has been merged away, pruning\n", report); assert(h->kind == (build.isRootSuccessor(*verts.begin()) ? NFA_PREFIX : NFA_INFIX)); unique_ptr h_new = cloneHolder(*h); pruneReport(*h_new, report); if (isImplementableNFA(*h_new, nullptr, build.cc)) { clear_graph(*h); cloneHolder(*h, *h_new); } else { DEBUG_PRINTF("prune produced unimplementable graph, " "leaving as-is\n"); } } } /** \brief Remove any tops that don't lead to the given report from this * Castle. */ static void pruneCastle(CastleProto &castle, ReportID report) { unordered_set dead; // tops to remove. for (const auto &m : castle.repeats) { if (!contains(m.second.reports, report)) { dead.insert(m.first); } } for (const auto &top : dead) { castle.erase(top); } assert(!castle.repeats.empty()); } /** \brief Set all reports to the given one. */ static void setReports(CastleProto &castle, ReportID report) { for (auto &repeat : castle.repeats | map_values) { repeat.reports.clear(); repeat.reports.insert(report); } } static void updateEdgeTops(RoseGraph &g, RoseVertex v, const map &top_map) { for (const auto &e : in_edges_range(v, g)) { g[e].rose_top = top_map.at(g[e].rose_top); } } static void pruneUnusedTops(CastleProto &castle, const RoseGraph &g, const set &verts) { ue2::unordered_set used_tops; for (auto v : verts) { assert(g[v].left.castle.get() == &castle); for (const auto &e : in_edges_range(v, g)) { u32 top = g[e].rose_top; assert(contains(castle.repeats, top)); used_tops.insert(top); } } DEBUG_PRINTF("castle has %zu tops, graph has %zu tops\n", castle.repeats.size(), used_tops.size()); for (u32 top : assoc_keys(castle.repeats)) { if (!contains(used_tops, top)) { DEBUG_PRINTF("removing unused top %u\n", top); castle.erase(top); } } } static void pruneUnusedTops(NGHolder &h, const RoseGraph &g, const set &verts) { if (!is_triggered(h)) { DEBUG_PRINTF("not triggered, no tops\n"); return; } assert(isCorrectlyTopped(h)); DEBUG_PRINTF("prunning unused tops\n"); ue2::flat_set used_tops; for (auto v : verts) { assert(g[v].left.graph.get() == &h); for (const auto &e : in_edges_range(v, g)) { u32 top = g[e].rose_top; used_tops.insert(top); } } vector dead; for (const auto &e : out_edges_range(h.start, h)) { NFAVertex v = target(e, h); if (v == h.startDs) { continue; // stylised edge, leave it alone. } flat_set pruned_tops; auto pt_inserter = inserter(pruned_tops, pruned_tops.end()); set_intersection(h[e].tops.begin(), h[e].tops.end(), used_tops.begin(), used_tops.end(), pt_inserter); h[e].tops = move(pruned_tops); if (h[e].tops.empty()) { DEBUG_PRINTF("edge (start,%zu) has only unused tops\n", h[v].index); dead.push_back(e); } } if (dead.empty()) { return; } remove_edges(dead, h); pruneUseless(h); clearReports(h); // As we may have removed vacuous edges. } static bool mergeSameCastle(RoseBuildImpl &build, RoseVertex a, RoseVertex b, RoseAliasingInfo &rai) { RoseGraph &g = build.g; LeftEngInfo &a_left = g[a].left; LeftEngInfo &b_left = g[b].left; CastleProto &castle = *a_left.castle; DEBUG_PRINTF("a report=%u, b report=%u\n", a_left.leftfix_report, b_left.leftfix_report); u32 merge_count = 0; for (const auto &c : castle.repeats) { DEBUG_PRINTF("top %u -> %s report %u\n", c.first, c.second.bounds.str().c_str(), *c.second.reports.begin()); if (contains(c.second.reports, a_left.leftfix_report) || contains(c.second.reports, b_left.leftfix_report)) { merge_count++; } } if (castle.repeats.size() + merge_count > castle.max_occupancy) { DEBUG_PRINTF("too big to merge\n"); return false; } const ReportID new_report = build.getNewNfaReport(); map a_top_map, b_top_map; for (const auto &c : castle.repeats) { u32 old_top = c.first; if (contains(c.second.reports, a_left.leftfix_report)) { PureRepeat pr = c.second; pr.reports.clear(); pr.reports.insert(new_report); u32 new_top = castle.merge(pr); assert(new_top < castle.max_occupancy); a_top_map[old_top] = new_top; } else if (contains(c.second.reports, b_left.leftfix_report)) { PureRepeat pr = c.second; pr.reports.clear(); pr.reports.insert(new_report); u32 new_top = castle.merge(pr); assert(new_top < castle.max_occupancy); b_top_map[old_top] = new_top; } } assert(contains(rai.rev_leftfix[b_left], b)); rai.rev_leftfix[b_left].erase(b); rai.rev_leftfix[a_left].insert(b); a_left.leftfix_report = new_report; b_left.leftfix_report = new_report; assert(a_left == b_left); updateEdgeTops(g, a, a_top_map); updateEdgeTops(g, b, b_top_map); pruneUnusedTops(castle, g, rai.rev_leftfix[a_left]); return true; } static bool attemptRoseCastleMerge(RoseBuildImpl &build, bool preds_same, RoseVertex a, RoseVertex b, bool trivialCasesOnly, RoseAliasingInfo &rai) { RoseGraph &g = build.g; LeftEngInfo &a_left = g[a].left; LeftEngInfo &b_left = g[b].left; left_id a_left_id(a_left); left_id b_left_id(b_left); CastleProto &a_castle = *a_left_id.castle(); CastleProto &b_castle = *b_left_id.castle(); if (a_castle.reach() != b_castle.reach()) { DEBUG_PRINTF("different reach\n"); return false; } DEBUG_PRINTF("a castle=%p, report=%u\n", &a_castle, a_left.leftfix_report); DEBUG_PRINTF("b castle=%p, report=%u\n", &b_castle, b_left.leftfix_report); if (&a_castle == &b_castle) { DEBUG_PRINTF("castles are the same\n"); return mergeSameCastle(build, a, b, rai); } if (is_equal(a_castle, a_left.leftfix_report, b_castle, b_left.leftfix_report)) { DEBUG_PRINTF("castles are equiv with respect to reports\n"); if (rai.rev_leftfix[a_left_id].size() == 1) { /* nobody else is using a_castle */ rai.rev_leftfix[b_left_id].erase(b); rai.rev_leftfix[a_left_id].insert(b); pruneUnusedTops(b_castle, g, rai.rev_leftfix[b_left_id]); b_left.castle = a_left.castle; b_left.leftfix_report = a_left.leftfix_report; DEBUG_PRINTF("OK -> only user of a_castle\n"); return true; } if (rai.rev_leftfix[b_left_id].size() == 1) { /* nobody else is using b_castle */ rai.rev_leftfix[a_left_id].erase(a); rai.rev_leftfix[b_left_id].insert(a); pruneUnusedTops(a_castle, g, rai.rev_leftfix[a_left_id]); a_left.castle = b_left.castle; a_left.leftfix_report = b_left.leftfix_report; DEBUG_PRINTF("OK -> only user of b_castle\n"); return true; } if (preds_same) { /* preds are the same anyway in diamond/left merges just need to * check that all the literals in rev_leftfix[b_h] can handle a_h */ for (auto v : rai.rev_leftfix[b_left_id]) { if (!mergeableRoseVertices(build, a, v)) { goto literal_mismatch_1; } } rai.rev_leftfix[a_left_id].erase(a); rai.rev_leftfix[b_left_id].insert(a); pruneUnusedTops(a_castle, g, rai.rev_leftfix[a_left_id]); a_left.castle = b_left.castle; a_left.leftfix_report = b_left.leftfix_report; DEBUG_PRINTF("OK -> same preds ???\n"); return true; literal_mismatch_1: /* preds are the same anyway in diamond/left merges just need to * check that all the literals in rev_leftfix[a_h] can handle b_h */ for (auto v : rai.rev_leftfix[a_left_id]) { if (!mergeableRoseVertices(build, v, b)) { goto literal_mismatch_2; } } rai.rev_leftfix[b_left_id].erase(b); rai.rev_leftfix[a_left_id].insert(b); pruneUnusedTops(b_castle, g, rai.rev_leftfix[b_left_id]); b_left.castle = a_left.castle; b_left.leftfix_report = a_left.leftfix_report; DEBUG_PRINTF("OK -> same preds ???\n"); return true; literal_mismatch_2:; } DEBUG_PRINTF("OK -> create new\n"); /* we need to create a new graph as there may be other people * using b_left and it would be bad if a's preds started triggering it */ ReportID new_report = build.getNewNfaReport(); shared_ptr new_castle = make_shared(a_castle); pruneCastle(*new_castle, a_left.leftfix_report); setReports(*new_castle, new_report); rai.rev_leftfix[a_left_id].erase(a); rai.rev_leftfix[b_left_id].erase(b); pruneUnusedTops(*a_left.castle, g, rai.rev_leftfix[a_left_id]); pruneUnusedTops(*b_left.castle, g, rai.rev_leftfix[b_left_id]); a_left.leftfix_report = new_report; b_left.leftfix_report = new_report; a_left.castle = new_castle; b_left.castle = new_castle; assert(a_left == b_left); rai.rev_leftfix[a_left].insert(a); rai.rev_leftfix[a_left].insert(b); pruneUnusedTops(*new_castle, g, rai.rev_leftfix[a_left]); return true; } // Everything after this point requires more work, so we guard it with the // trivial cases argument.. if (trivialCasesOnly) { return false; } // Only infixes. Prefixes require special care when doing non-trivial // merges. if (!build.isNonRootSuccessor(a) || !build.isNonRootSuccessor(b)) { return false; } set &b_verts = rai.rev_leftfix[b_left_id]; set aa; aa.insert(a); if (!mergeableRoseVertices(build, aa, b_verts)) { DEBUG_PRINTF("vertices not mergeable\n"); return false; } if (!build.cc.grey.roseMultiTopRoses || !build.cc.grey.allowCastle) { return false; } DEBUG_PRINTF("merging into new castle\n"); // Clone new castle with a's repeats in it, set to a new report. ReportID new_report = build.getNewNfaReport(); shared_ptr m_castle = make_shared(a_castle); pruneCastle(*m_castle, a_left.leftfix_report); setReports(*m_castle, new_report); // Merge in the relevant repeats from b with the new report. Note that // we'll have to remap tops appropriately. map b_top_map; for (const auto &e : in_edges_range(b, g)) { u32 top = g[e].rose_top; assert(contains(b_castle.repeats, top)); PureRepeat pr = b_castle.repeats[top]; // mutable copy pr.reports.clear(); pr.reports.insert(new_report); // We should be protected from merging common preds with tops leading // to completely different repeats by earlier checks, but just in // case... if (RoseEdge a_edge = edge(source(e, g), a, g)) { u32 a_top = g[a_edge].rose_top; const PureRepeat &a_pr = m_castle->repeats[a_top]; // new report if (pr != a_pr) { DEBUG_PRINTF("merge failed, common pred with diff repeat\n"); return false; } } u32 new_top = m_castle->merge(pr); if (new_top == CastleProto::max_occupancy) { DEBUG_PRINTF("merge failed\n"); return false; } b_top_map[top] = new_top; } updateEdgeTops(g, b, b_top_map); DEBUG_PRINTF("merged into castle containing %zu repeats\n", m_castle->repeats.size()); rai.rev_leftfix[a_left_id].erase(a); rai.rev_leftfix[b_left_id].erase(b); pruneUnusedTops(*a_left.castle, g, rai.rev_leftfix[a_left_id]); pruneUnusedTops(*b_left.castle, g, rai.rev_leftfix[b_left_id]); a_left.castle = m_castle; a_left.leftfix_report = new_report; b_left.castle = m_castle; b_left.leftfix_report = new_report; assert(a_left == b_left); rai.rev_leftfix[a_left].insert(a); rai.rev_leftfix[a_left].insert(b); pruneUnusedTops(*m_castle, g, rai.rev_leftfix[a_left]); return true; } static bool attemptRoseGraphMerge(RoseBuildImpl &build, bool preds_same, RoseVertex a, RoseVertex b, bool trivialCasesOnly, RoseAliasingInfo &rai) { RoseGraph &g = build.g; LeftEngInfo &a_left = g[a].left; LeftEngInfo &b_left = g[b].left; left_id a_left_id(a_left); left_id b_left_id(b_left); shared_ptr a_h = a_left.graph; shared_ptr b_h = b_left.graph; assert(a_h && b_h); // If we only differ in reports, this is a very easy merge. Just use b's // report for both. /* Actually not so easy, there may be other poor suckers using a and/or b's * reports who will be surprised by this change */ if (a_h == b_h) { DEBUG_PRINTF("OK -> same actual holder\n"); ReportID a_oldreport = a_left.leftfix_report; ReportID b_oldreport = b_left.leftfix_report; ReportID new_report = build.getNewNfaReport(); duplicateReport(*a_h, a_left.leftfix_report, new_report); duplicateReport(*b_h, b_left.leftfix_report, new_report); a_left.leftfix_report = new_report; b_left.leftfix_report = new_report; pruneReportIfUnused(build, b_h, rai.rev_leftfix[b_left_id], a_oldreport); pruneReportIfUnused(build, b_h, rai.rev_leftfix[b_left_id], b_oldreport); pruneUnusedTops(*b_h, g, rai.rev_leftfix[b_left_id]); assert(a_left == b_left); return true; } /* if it is the same graph, it is also fairly easy */ if (is_equal(*a_h, a_left.leftfix_report, *b_h, b_left.leftfix_report)) { if (rai.rev_leftfix[a_left_id].size() == 1) { /* nobody else is using a_h */ rai.rev_leftfix[b_left_id].erase(b); rai.rev_leftfix[a_left_id].insert(b); b_left.graph = a_h; b_left.leftfix_report = a_left.leftfix_report; pruneUnusedTops(*b_h, g, rai.rev_leftfix[b_left_id]); DEBUG_PRINTF("OK -> only user of a_h\n"); return true; } if (rai.rev_leftfix[b_left_id].size() == 1) { /* nobody else is using b_h */ rai.rev_leftfix[a_left_id].erase(a); rai.rev_leftfix[b_left_id].insert(a); a_left.graph = b_h; a_left.leftfix_report = b_left.leftfix_report; pruneUnusedTops(*a_h, g, rai.rev_leftfix[a_left_id]); DEBUG_PRINTF("OK -> only user of b_h\n"); return true; } if (preds_same) { /* preds are the same anyway in diamond/left merges just need to * check that all the literals in rev_leftfix[b_h] can handle a_h */ for (auto v : rai.rev_leftfix[b_left_id]) { if (!mergeableRoseVertices(build, a, v)) { goto literal_mismatch_1; } } rai.rev_leftfix[a_left_id].erase(a); rai.rev_leftfix[b_left_id].insert(a); a_left.graph = b_h; a_left.leftfix_report = b_left.leftfix_report; pruneUnusedTops(*a_h, g, rai.rev_leftfix[a_left_id]); DEBUG_PRINTF("OK -> same preds ???\n"); return true; literal_mismatch_1: /* preds are the same anyway in diamond/left merges just need to * check that all the literals in rev_leftfix[a_h] can handle b_h */ for (auto v : rai.rev_leftfix[a_left_id]) { if (!mergeableRoseVertices(build, v, b)) { goto literal_mismatch_2; } } rai.rev_leftfix[b_left_id].erase(b); rai.rev_leftfix[a_left_id].insert(b); b_left.graph = a_h; b_left.leftfix_report = a_left.leftfix_report; pruneUnusedTops(*b_h, g, rai.rev_leftfix[b_left_id]); DEBUG_PRINTF("OK -> same preds ???\n"); return true; literal_mismatch_2:; } DEBUG_PRINTF("OK -> create new\n"); /* we need to create a new graph as there may be other people * using b_left and it would be bad if a's preds started triggering it */ ReportID new_report = build.getNewNfaReport(); shared_ptr new_graph = cloneHolder(*b_h); duplicateReport(*new_graph, b_left.leftfix_report, new_report); pruneAllOtherReports(*new_graph, new_report); rai.rev_leftfix[a_left_id].erase(a); rai.rev_leftfix[b_left_id].erase(b); pruneUnusedTops(*a_h, g, rai.rev_leftfix[a_left_id]); pruneUnusedTops(*b_h, g, rai.rev_leftfix[b_left_id]); a_left.leftfix_report = new_report; b_left.leftfix_report = new_report; a_left.graph = new_graph; b_left.graph = new_graph; rai.rev_leftfix[a_left].insert(a); rai.rev_leftfix[a_left].insert(b); pruneUnusedTops(*new_graph, g, rai.rev_leftfix[a_left]); return true; } // Everything after this point requires merging via the uncalc code, so we // guard it with the trivial cases arg. if (trivialCasesOnly) { return false; } // Only infixes. Prefixes require special care when doing non-trivial // merges. if (!build.isNonRootSuccessor(a) || !build.isNonRootSuccessor(b)) { return false; } DEBUG_PRINTF("attempting merge of roses on vertices %zu and %zu\n", g[a].index, g[b].index); set &b_verts = rai.rev_leftfix[b_left]; set aa; aa.insert(a); if (!mergeableRoseVertices(build, aa, b_verts)) { DEBUG_PRINTF("vertices not mergeable\n"); return false; } if (!build.cc.grey.roseMultiTopRoses) { return false; } // Clone a copy of a's NFA to operate on, and store a copy of its in-edge // properties. /* We need to allocate a new report id because */ ReportID a_oldreport = a_left.leftfix_report; ReportID b_oldreport = b_left.leftfix_report; ReportID new_report = build.getNewNfaReport(); duplicateReport(*b_h, b_left.leftfix_report, new_report); b_left.leftfix_report = new_report; pruneReportIfUnused(build, b_h, rai.rev_leftfix[b_left_id], b_oldreport); NGHolder victim; cloneHolder(victim, *a_h); duplicateReport(victim, a_left.leftfix_report, new_report); pruneAllOtherReports(victim, new_report); map a_props; for (const auto &e : in_edges_range(a, g)) { a_props[source(e, g)] = g[e]; } DEBUG_PRINTF("victim %zu states\n", num_vertices(*a_h)); DEBUG_PRINTF("winner %zu states\n", num_vertices(*b_h)); if (!setDistinctRoseTops(g, victim, *b_h, deque(1, a))) { assert(roseHasTops(build, a)); assert(roseHasTops(build, b)); return false; } assert(victim.kind == b_h->kind); assert(!generates_callbacks(*b_h)); if (!mergeNfaPair(victim, *b_h, nullptr, build.cc)) { DEBUG_PRINTF("merge failed\n"); // Restore in-edge properties. for (const auto &e : in_edges_range(a, g)) { g[e] = a_props[source(e, g)]; } assert(roseHasTops(build, a)); assert(roseHasTops(build, b)); return false; } DEBUG_PRINTF("merge succeeded -> %zu vertices\n", num_vertices(*b_h)); // update A's rose data to point to the merged graph. a_left.graph = b_h; a_left.leftfix_report = new_report; assert(contains(rai.rev_leftfix[a_left_id], a)); assert(contains(rai.rev_leftfix[b_left_id], b)); rai.rev_leftfix[a_left_id].erase(a); rai.rev_leftfix[b_left_id].insert(a); pruneUnusedTops(*a_h, g, rai.rev_leftfix[a_left_id]); pruneUnusedTops(*b_h, g, rai.rev_leftfix[b_left_id]); // Prune A's report from its old prefix if it was only used by A. pruneReportIfUnused(build, a_h, rai.rev_leftfix[a_left_id], a_oldreport); reduceImplementableGraph(*b_h, SOM_NONE, nullptr, build.cc); assert(roseHasTops(build, a)); assert(roseHasTops(build, b)); assert(isImplementableNFA(*b_h, nullptr, build.cc)); return true; } // Called by the role aliasing pass: Attempt to merge rose a into b, updating // the two LeftEngInfo structures to be the same. Returns false if the merge // is not possible. static bool attemptRoseMerge(RoseBuildImpl &build, bool preds_same, RoseVertex a, RoseVertex b, bool trivialCasesOnly, RoseAliasingInfo &rai) { DEBUG_PRINTF("attempting rose merge, vertices a=%zu, b=%zu\n", build.g[a].index, build.g[b].index); assert(a != b); RoseGraph &g = build.g; LeftEngInfo &a_left = g[a].left; LeftEngInfo &b_left = g[b].left; // Trivial case. if (a_left == b_left) { DEBUG_PRINTF("roses are identical, no leftfix or already merged\n"); return true; } const left_id a_left_id(a_left); const left_id b_left_id(b_left); /* Haig merges not supported at the moment */ if (a_left.haig || b_left.haig) { return false; } /* dfa merges not supported at the moment (no multitop) */ if (a_left.dfa || b_left.dfa) { return false; } // Only non-transients for the moment. if (contains(build.transient, a_left_id) || contains(build.transient, b_left_id)) { return false; } /* It is not possible to merge roles with different lags as we can only * test the leftfix at one location relative to the literal match */ if (a_left.lag != b_left.lag) { return false; } assert(roseHasTops(build, a)); assert(roseHasTops(build, b)); if (a_left_id.graph() && b_left_id.graph()) { return attemptRoseGraphMerge(build, preds_same, a, b, trivialCasesOnly, rai); } if (a_left_id.castle() && b_left_id.castle()) { return attemptRoseCastleMerge(build, preds_same, a, b, trivialCasesOnly, rai); } return false; } static void splitByReportSuffixBehaviour(const RoseGraph &g, vector> &buckets, ue2::unordered_map &inv) { /* vertices with different report/suffixes can never be considered for right * merge. */ vector> out; for (const vector &b : buckets) { assert(!b.empty()); map, RoseSuffixInfo>, size_t> dest_map; for (RoseVertex v : b) { auto key = decltype(dest_map)::key_type(g[v].reports, g[v].suffix); size_t out_bucket; if (contains(dest_map, key)) { out_bucket = dest_map[key]; } else { out_bucket = out.size(); out.push_back(vector()); dest_map[key] = out_bucket; } out[out_bucket].push_back(v); inv[v] = out_bucket; } } buckets.swap(out); } static void splitByLiteralTable(const RoseBuildImpl &build, vector> &buckets, ue2::unordered_map &inv) { const RoseGraph &g = build.g; vector> out; for (const auto &bucket : buckets) { assert(!bucket.empty()); map dest_map; for (RoseVertex v : bucket) { auto table = build.literals.right.at(*g[v].literals.begin()).table; size_t out_bucket; if (contains(dest_map, table)) { out_bucket = dest_map[table]; } else { out_bucket = out.size(); out.push_back(vector()); dest_map[table] = out_bucket; } out[out_bucket].push_back(v); inv[v] = out_bucket; } } buckets.swap(out); } static void splitByNeighbour(const RoseGraph &g, vector> &buckets, ue2::unordered_map &inv, bool succ) { vector> extras; map> neighbours_by_bucket; set picked; vector leftovers; for (RoseVertex u : vertices_range(g)) { /* once split by v, stays split. also keeps iterator in buckets valid */ extras.clear(); neighbours_by_bucket.clear(); if (succ) { /* forward pass */ for (RoseVertex v : adjacent_vertices_range(u, g)) { auto it = inv.find(v); if (it != end(inv)) { neighbours_by_bucket[it->second].push_back(v); } } } else { /* backward pass */ for (RoseVertex v : inv_adjacent_vertices_range(u, g)) { auto it = inv.find(v); if (it != end(inv)) { neighbours_by_bucket[it->second].push_back(v); } } } for (const auto &e : neighbours_by_bucket) { size_t old_key = e.first; if (buckets[old_key].size() == e.second.size()) { /* did not split */ continue; } assert(!e.second.empty()); picked.clear(); picked.insert(begin(e.second), end(e.second)); size_t new_key = buckets.size() + extras.size(); leftovers.clear(); for (RoseVertex v : buckets[old_key]) { if (contains(picked, v)) { inv[v] = new_key; } else { leftovers.push_back(v); } } assert(!leftovers.empty()); assert(e.second.size() + leftovers.size() == buckets[old_key].size()); extras.push_back(e.second); buckets[old_key].swap(leftovers); } insert(&buckets, buckets.end(), extras); } } static vector> splitDiamondMergeBuckets(CandidateSet &candidates, const RoseBuildImpl &build) { const RoseGraph &g = build.g; vector> buckets(1); ue2::unordered_map inv; for (RoseVertex v : candidates) { buckets[0].push_back(v); inv[v] = 0; } splitByReportSuffixBehaviour(g, buckets, inv); splitByLiteralTable(build, buckets, inv); splitByNeighbour(g, buckets, inv, true); splitByNeighbour(g, buckets, inv, false); return buckets; } static never_inline void diamondMergePass(CandidateSet &candidates, RoseBuildImpl &build, vector *dead, bool mergeRoses, RoseAliasingInfo &rai) { DEBUG_PRINTF("begin\n"); RoseGraph &g = build.g; if (candidates.empty()) { return; } /* Vertices may only be diamond merged with others in the same bucket */ auto cand_buckets = splitDiamondMergeBuckets(candidates, build); for (const vector &siblings : cand_buckets) { for (auto it = siblings.begin(); it != siblings.end();) { RoseVertex a = *it; ++it; assert(contains(candidates, a)); DEBUG_PRINTF("trying to merge %zu into somebody\n", g[a].index); for (auto jt = it; jt != siblings.end(); ++jt) { RoseVertex b = *jt; assert(contains(candidates, b)); if (!sameRoleProperties(build, rai, a, b)) { DEBUG_PRINTF("diff role prop\n"); continue; } // Check "diamond" requirements: must have same right side // (successors, reports) and left side (predecessors). /* Note: bucketing does not check edge properties (bounds, tops) * so we still have to checks successors and predecessors. */ if (!sameSuccessors(a, b, g) || !sameRightRoleProperties(build, a, b) || !samePredecessors(a, b, g)) { DEBUG_PRINTF("not diamond\n"); continue; } if (!canMergeLiterals(a, b, build)) { DEBUG_PRINTF("incompatible lits\n"); continue; } if (!attemptRoseMerge(build, true, a, b, !mergeRoses, rai)) { DEBUG_PRINTF("rose fail\n"); continue; } mergeVerticesDiamond(a, b, build, rai); dead->push_back(a); candidates.erase(a); break; // next a } } } DEBUG_PRINTF("%zu candidates remaining\n", candidates.size()); } static vector::iterator findLeftMergeSibling( vector::iterator it, const vector::iterator &end, const RoseVertex a, const RoseBuildImpl &build, const RoseAliasingInfo &rai, const CandidateSet &candidates) { const RoseGraph &g = build.g; for (; it != end; ++it) { RoseVertex b = *it; if (a == b) { continue; } if (!contains(candidates, b)) { continue; } if (!sameRoleProperties(build, rai, a, b)) { continue; } // Check left-equivalence: must have same predecessors and same // literals. if (g[a].literals != g[b].literals) { continue; } if (!samePredecessors(a, b, g)) { continue; } if (hasCommonSuccWithBadBounds(a, b, g)) { continue; } if (g[a].suffix && g[b].suffix && g[a].suffix != g[b].suffix) { continue; /* we can only trigger one suffix */ } return it; } return end; } static never_inline void leftMergePass(CandidateSet &candidates, RoseBuildImpl &build, vector *dead, RoseAliasingInfo &rai) { DEBUG_PRINTF("begin (%zu)\n", candidates.size()); RoseGraph &g = build.g; vector siblings; CandidateSet::iterator it = candidates.begin(); while (it != candidates.end()) { RoseVertex a = *it; CandidateSet::iterator ait = it; ++it; // We have to find a sibling to merge `a' with, and we select between // two approaches to minimize the number of vertices we have to // examine; which we use depends on the shape of the graph. assert(!g[a].literals.empty()); u32 lit_id = *g[a].literals.begin(); const auto &verts = build.literal_info.at(lit_id).vertices; RoseVertex pred = pickPred(a, g, build); siblings.clear(); if (pred == RoseGraph::null_vertex() || build.isAnyStart(pred) || out_degree(pred, g) > verts.size()) { // Select sibling from amongst the vertices that share a literal. siblings.insert(siblings.end(), verts.begin(), verts.end()); } else { // Select sibling from amongst the vertices that share a // predecessor. insert(&siblings, siblings.end(), adjacent_vertices(pred, g)); } auto jt = findLeftMergeSibling(siblings.begin(), siblings.end(), a, build, rai, candidates); if (jt == siblings.end()) { continue; } RoseVertex b = *jt; if (!attemptRoseMerge(build, true, a, b, 0, rai)) { DEBUG_PRINTF("rose fail\n"); continue; } mergeVerticesLeft(a, b, build, rai); dead->push_back(a); candidates.erase(ait); } DEBUG_PRINTF("%zu candidates remaining\n", candidates.size()); assert(!hasOrphanedTops(build)); } // Can't merge vertices with different root predecessors. static bool safeRootPreds(RoseVertex a, RoseVertex b, const RoseGraph &g) { set a_roots, b_roots; for (auto u : inv_adjacent_vertices_range(a, g)) { if (!in_degree(u, g)) { a_roots.insert(u); } } for (auto u : inv_adjacent_vertices_range(b, g)) { if (!in_degree(u, g)) { b_roots.insert(u); } } assert(a_roots.size() <= 1); assert(b_roots.size() <= 1); return a_roots == b_roots; } static never_inline vector::const_iterator findRightMergeSibling( vector::const_iterator it, const vector::const_iterator &end, const RoseVertex a, const RoseBuildImpl &build, const RoseAliasingInfo &rai, const CandidateSet &candidates) { const RoseGraph &g = build.g; for (; it != end; ++it) { RoseVertex b = *it; if (a == b) { continue; } if (!contains(candidates, b)) { continue; } if (!sameRoleProperties(build, rai, a, b)) { continue; } // Check right-equivalence: must have same successors, reports and same // literals. if (g[a].literals != g[b].literals) { continue; } if (!sameSuccessors(a, b, g) || !sameRightRoleProperties(build, a, b)) { continue; } // An extra wrinkle: we cannot merge two vertices that are root // successors if their preds are different. (e.g. one is anchored and // one is not) if (!safeRootPreds(a, b, g)) { continue; } if (hasCommonPredWithBadBounds(a, b, g)) { continue; } if (hasCommonPredWithDiffRoses(a, b, g)) { continue; } return it; } return end; } template static void split(map &keys, size_t *next_key, Iter it, const Iter end) { map new_keys; for (; it != end; ++it) { RoseVertex v = *it; size_t ok = keys[v]; size_t nk; if (contains(new_keys, ok)) { nk = new_keys[ok]; } else { nk = (*next_key)++; new_keys[ok] = nk; } keys[v] = nk; } } static never_inline void buildCandidateRightSiblings(CandidateSet &candidates, RoseBuildImpl &build, map> &sibling_cache, map &keys_ext) { RoseGraph &g = build.g; size_t next_key = 1; map keys; for (const auto &c : candidates) { keys[c] = 0; } set done_succ; set done_lit; for (auto a : candidates) { assert(!g[a].literals.empty()); u32 lit_id = *g[a].literals.begin(); RoseVertex succ = pickSucc(a, g); const auto &verts = build.literal_info.at(lit_id).vertices; if (succ != RoseGraph::null_vertex() && in_degree(succ, g) < verts.size()) { if (!done_succ.insert(succ).second) { continue; // succ already in done_succ. } RoseGraph::inv_adjacency_iterator ai, ae; tie (ai, ae) = inv_adjacent_vertices(succ, g); split(keys, &next_key, ai, ae); } else { if (!done_lit.insert(lit_id).second) { continue; // lit_id already in done_lit. } split(keys, &next_key, verts.begin(), verts.end()); } } map> int_to_ext; for (const auto &key : keys) { RoseVertex v = key.first; u32 ext; size_t rph = hashRightRoleProperties(v, g); if (contains(int_to_ext[key.second], rph)) { ext = int_to_ext[key.second][rph]; } else { ext = keys_ext.size(); int_to_ext[key.second][rph] = ext; } keys_ext[v] = ext; sibling_cache[ext].push_back(v); } for (auto &siblings : sibling_cache | map_values) { sort(siblings.begin(), siblings.end()); } } static const vector &getCandidateRightSiblings( const map> &sibling_cache, map &keys, RoseVertex a) { size_t key = keys.at(a); return sibling_cache.at(key); } static never_inline void rightMergePass(CandidateSet &candidates, RoseBuildImpl &build, vector *dead, bool mergeRoses, RoseAliasingInfo &rai) { DEBUG_PRINTF("begin\n"); map> sibling_cache; map keys; buildCandidateRightSiblings(candidates, build, sibling_cache, keys); CandidateSet::iterator it = candidates.begin(); while (it != candidates.end()) { RoseVertex a = *it; CandidateSet::iterator ait = it; ++it; // We have to find a sibling to merge `a' with, and we select between // two approaches to minimize the number of vertices we have to // examine; which we use depends on the shape of the graph. const vector &siblings = getCandidateRightSiblings(sibling_cache, keys, a); auto jt = siblings.begin(); while (jt != siblings.end()) { jt = findRightMergeSibling(jt, siblings.end(), a, build, rai, candidates); if (jt == siblings.end()) { break; } if (attemptRoseMerge(build, false, a, *jt, !mergeRoses, rai)) { break; } ++jt; } if (jt == siblings.end()) { continue; } RoseVertex b = *jt; mergeVerticesRight(a, b, build, rai); dead->push_back(a); candidates.erase(ait); } DEBUG_PRINTF("%zu candidates remaining\n", candidates.size()); assert(!hasOrphanedTops(build)); } /** * \brief True if the given vertex has no siblings for the purposes of a * diamond merge. * * This is the case if it has no successors with more than one predecessor * (itself), or no predecessors with more than one successor (itself). */ static bool hasNoDiamondSiblings(const RoseGraph &g, RoseVertex v) { if (has_successor(v, g)) { bool only_succ = true; for (const auto &w : adjacent_vertices_range(v, g)) { if (in_degree(w, g) > 1) { only_succ = false; break; } } if (only_succ) { return true; } } // Any candidate vertex will have a predecessor; the only vertices without // preds are the root vertices. assert(in_edges(v, g).first != in_edges(v, g).second); bool only_pred = true; for (const auto &u : inv_adjacent_vertices_range(v, g)) { if (out_degree(u, g) > 1) { only_pred = false; break; } } return only_pred; } /** * \brief Filter out some merge candidates that are not mergeable by a diamond * merge. */ static void filterDiamondCandidates(RoseGraph &g, CandidateSet &candidates) { DEBUG_PRINTF("%zu candidates enter\n", candidates.size()); vector dead; for (const auto &v : candidates) { if (hasNoDiamondSiblings(g, v)) { dead.push_back(v); } } for (const auto &v : dead) { candidates.erase(v); } DEBUG_PRINTF("pruned %zu candidates, leaving %zu\n", dead.size(), candidates.size()); } void aliasRoles(RoseBuildImpl &build, bool mergeRoses) { const CompileContext &cc = build.cc; RoseGraph &g = build.g; assert(!hasOrphanedTops(build)); assert(canImplementGraphs(build)); if (!cc.grey.roseRoleAliasing || !cc.grey.roseGraphReduction) { return; } DEBUG_PRINTF("doing role aliasing mr=%d\n", (int)mergeRoses); RoseAliasingInfo rai(build); mergeRoses &= cc.grey.mergeRose & cc.grey.roseMergeRosesDuringAliasing; CandidateSet candidates; findCandidates(build, &candidates); DEBUG_PRINTF("candidates %zu\n", candidates.size()); vector dead; size_t old_dead_size = 0; do { old_dead_size = dead.size(); leftMergePass(candidates, build, &dead, rai); rightMergePass(candidates, build, &dead, mergeRoses, rai); } while (old_dead_size != dead.size()); /* Diamond merge passes cannot create extra merges as they require the same * succ and preds before merging --> that if a succ/pred was ineligible due * to a merge to different pred/succ before a diamond merge, it will still * be afterwards. */ filterDiamondCandidates(g, candidates); diamondMergePass(candidates, build, &dead, mergeRoses, rai); DEBUG_PRINTF("killed %zu vertices\n", dead.size()); build.removeVertices(dead); assert(!hasOrphanedTops(build)); assert(canImplementGraphs(build)); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_bytecode.cpp0000644000175000017500000055150113055426554022556 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_impl.h" #include "ue2common.h" #include "grey.h" #include "hs_compile.h" // for HS_MODE_* #include "rose_build_add_internal.h" #include "rose_build_anchored.h" #include "rose_build_engine_blob.h" #include "rose_build_exclusive.h" #include "rose_build_groups.h" #include "rose_build_infix.h" #include "rose_build_long_lit.h" #include "rose_build_lookaround.h" #include "rose_build_matchers.h" #include "rose_build_program.h" #include "rose_build_scatter.h" #include "rose_build_util.h" #include "rose_build_width.h" #include "rose_internal.h" #include "rose_program.h" #include "hwlm/hwlm.h" /* engine types */ #include "hwlm/hwlm_literal.h" #include "nfa/castlecompile.h" #include "nfa/goughcompile.h" #include "nfa/mcclellancompile.h" #include "nfa/mcclellancompile_util.h" #include "nfa/mcsheng_compile.h" #include "nfa/nfa_api_queue.h" #include "nfa/nfa_build_util.h" #include "nfa/nfa_internal.h" #include "nfa/shengcompile.h" #include "nfa/shufticompile.h" #include "nfa/tamaramacompile.h" #include "nfa/tamarama_internal.h" #include "nfagraph/ng_execute.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_lbr.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_mcclellan.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_reports.h" #include "nfagraph/ng_revacc.h" #include "nfagraph/ng_stop.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_width.h" #include "smallwrite/smallwrite_build.h" #include "som/slot_manager.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/boundary_reports.h" #include "util/charreach.h" #include "util/charreach_util.h" #include "util/compile_context.h" #include "util/compile_error.h" #include "util/container.h" #include "util/fatbit_build.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/multibit_build.h" #include "util/order_check.h" #include "util/popcount.h" #include "util/queue_index_factory.h" #include "util/report_manager.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include #include #include #include #include #include using namespace std; using boost::adaptors::map_values; using boost::adaptors::map_keys; namespace ue2 { /* The rose bytecode construction is a giant cesspit. * * One issue is that bits and pieces are constructed piecemeal and these * sections are used by later in the construction process. Until the very end of * the construction there is no useful invariant holding for the bytecode. This * makes reordering / understanding the construction process awkward as there * are hidden dependencies everywhere. We should start by shifting towards * a model where the bytecode is only written to during the construction so that * the dependencies can be understood by us mere mortals. * * I am sure the construction process is also bad from a number of other * standpoints as well but the can come later. * * Actually, one other annoying issues the plague of member functions on the * impl which tightly couples the internals of this file to all the other rose * build files. Need more egregiously awesome free functions. */ namespace /* anon */ { struct left_build_info { // Constructor for an engine implementation. left_build_info(u32 q, u32 l, u32 t, rose_group sm, const std::vector &stops, u32 max_ql, u8 cm_count, const CharReach &cm_cr) : queue(q), lag(l), transient(t), squash_mask(sm), stopAlphabet(stops), max_queuelen(max_ql), countingMiracleCount(cm_count), countingMiracleReach(cm_cr) {} // Constructor for a lookaround implementation. explicit left_build_info(const vector &look) : has_lookaround(true), lookaround(look) {} u32 queue = 0; /* uniquely idents the left_build_info */ u32 lag = 0; u32 transient = 0; rose_group squash_mask = ~rose_group{0}; vector stopAlphabet; u32 max_queuelen = 0; u8 countingMiracleCount = 0; CharReach countingMiracleReach; u32 countingMiracleOffset = 0; /* populated later when laying out bytecode */ bool has_lookaround = false; vector lookaround; // alternative implementation to the NFA }; /** * \brief Structure tracking which resources are used by this Rose instance at * runtime. * * We use this to control how much initialisation we need to do at the * beginning of a stream/block at runtime. */ struct RoseResources { bool has_outfixes = false; bool has_suffixes = false; bool has_leftfixes = false; bool has_literals = false; bool has_states = false; bool checks_groups = false; bool has_lit_delay = false; bool has_lit_check = false; // long literal support bool has_anchored = false; bool has_eod = false; }; struct build_context : boost::noncopyable { /** \brief information about engines to the left of a vertex */ map leftfix_info; /** \brief mapping from suffix to queue index. */ map suffixes; /** \brief Mapping from vertex to key, for vertices with a * CHECK_NOT_HANDLED instruction. */ ue2::unordered_map handledKeys; /** \brief Number of roles with a state bit. * * This is set by assignStateIndices() and should be constant throughout * the rest of the compile. */ size_t numStates = 0; /** \brief Simple cache of programs written to engine blob, used for * deduplication. */ ue2::unordered_map program_cache; /** \brief LookEntry list cache, so that we don't have to go scanning * through the full list to find cases we've used already. */ ue2::unordered_map, size_t> lookaround_cache; /** \brief Lookaround table for Rose roles. */ vector lookaround; /** \brief State indices, for those roles that have them. */ ue2::unordered_map roleStateIndices; /** \brief Mapping from queue index to bytecode offset for built engines * that have already been pushed into the engine_blob. */ ue2::unordered_map engineOffsets; /** \brief Literal programs, indexed by final_id, after they have been * written to the engine_blob. */ vector litPrograms; /** \brief List of long literals (ones with CHECK_LITERAL instructions) * that need hash table support. */ vector longLiterals; /** \brief Minimum offset of a match from the floating table. */ u32 floatingMinLiteralMatchOffset = 0; /** \brief Long literal length threshold, used in streaming mode. */ size_t longLitLengthThreshold = 0; /** \brief Contents of the Rose bytecode immediately following the * RoseEngine. */ RoseEngineBlob engine_blob; /** \brief True if reports need CATCH_UP instructions, to catch up anchored * matches, suffixes, outfixes etc. */ bool needs_catchup = false; /** \brief True if this Rose engine has an MPV engine. */ bool needs_mpv_catchup = false; /** \brief Resources in use (tracked as programs are added). */ RoseResources resources; /** \brief Mapping from every vertex to the groups that must be on for that * vertex to be reached. */ ue2::unordered_map vertex_group_map; /** \brief Global bitmap of groups that can be squashed. */ rose_group squashable_groups = 0; }; } static const NFA *get_nfa_from_blob(const build_context &bc, u32 qi) { assert(contains(bc.engineOffsets, qi)); u32 nfa_offset = bc.engineOffsets.at(qi); assert(nfa_offset >= bc.engine_blob.base_offset); const NFA *n = (const NFA *)(bc.engine_blob.data() + nfa_offset - bc.engine_blob.base_offset); assert(n->queueIndex == qi); return n; } static const NFA *add_nfa_to_blob(build_context &bc, NFA &nfa) { u32 qi = nfa.queueIndex; u32 nfa_offset = bc.engine_blob.add(nfa, nfa.length); DEBUG_PRINTF("added nfa qi=%u, type=%u, length=%u at offset=%u\n", qi, nfa.type, nfa.length, nfa_offset); assert(!contains(bc.engineOffsets, qi)); bc.engineOffsets.emplace(qi, nfa_offset); const NFA *n = get_nfa_from_blob(bc, qi); assert(memcmp(&nfa, n, nfa.length) == 0); return n; } static u32 countRosePrefixes(const vector &roses) { u32 num = 0; for (const auto &r : roses) { if (!r.infix) { num++; } } return num; } /** * \brief True if this Rose engine needs to run a catch up whenever a report is * generated. * * Catch up is necessary if there are output-exposed engines (suffixes, * outfixes) or an anchored table (anchored literals, acyclic DFAs). */ static bool needsCatchup(const RoseBuildImpl &build, const vector &anchored_dfas) { if (!build.outfixes.empty()) { DEBUG_PRINTF("has outfixes\n"); return true; } if (!anchored_dfas.empty()) { DEBUG_PRINTF("has anchored dfas\n"); return true; } const RoseGraph &g = build.g; for (auto v : vertices_range(g)) { if (build.root == v) { continue; } if (build.anchored_root == v) { continue; } if (g[v].suffix) { DEBUG_PRINTF("vertex %zu has suffix\n", g[v].index); return true; } } DEBUG_PRINTF("no need for catch-up on report\n"); return false; } static bool isPureFloating(const RoseResources &resources, const CompileContext &cc) { if (resources.has_outfixes || resources.has_suffixes || resources.has_leftfixes) { DEBUG_PRINTF("has engines\n"); return false; } if (resources.has_anchored) { DEBUG_PRINTF("has anchored matcher\n"); return false; } if (resources.has_eod) { DEBUG_PRINTF("has eod work to do\n"); return false; } if (resources.has_states) { DEBUG_PRINTF("has states\n"); return false; } if (resources.has_lit_delay) { DEBUG_PRINTF("has delayed literals\n"); return false; } if (cc.streaming && resources.has_lit_check) { DEBUG_PRINTF("has long literals in streaming mode, which needs " "long literal table support\n"); return false; } if (resources.checks_groups) { DEBUG_PRINTF("has group checks\n"); return false; } DEBUG_PRINTF("pure floating literals\n"); return true; } static bool isSingleOutfix(const RoseBuildImpl &tbi) { for (auto v : vertices_range(tbi.g)) { if (tbi.isAnyStart(v)) { continue; } if (tbi.hasLiteralInTable(v, ROSE_ANCHORED_SMALL_BLOCK)) { continue; } DEBUG_PRINTF("has role\n"); return false; } if (tbi.ssm.numSomSlots()) { return false; } if (!tbi.boundary.report_at_eod.empty()) { return false; /* streaming runtime makes liberal use of broken flag */ } return tbi.outfixes.size() == 1; } static u8 pickRuntimeImpl(const RoseBuildImpl &build, const build_context &bc, UNUSED u32 outfixEndQueue) { DEBUG_PRINTF("has_outfixes=%d\n", bc.resources.has_outfixes); DEBUG_PRINTF("has_suffixes=%d\n", bc.resources.has_suffixes); DEBUG_PRINTF("has_leftfixes=%d\n", bc.resources.has_leftfixes); DEBUG_PRINTF("has_literals=%d\n", bc.resources.has_literals); DEBUG_PRINTF("has_states=%d\n", bc.resources.has_states); DEBUG_PRINTF("checks_groups=%d\n", bc.resources.checks_groups); DEBUG_PRINTF("has_lit_delay=%d\n", bc.resources.has_lit_delay); DEBUG_PRINTF("has_lit_check=%d\n", bc.resources.has_lit_check); DEBUG_PRINTF("has_anchored=%d\n", bc.resources.has_anchored); DEBUG_PRINTF("has_eod=%d\n", bc.resources.has_eod); if (isPureFloating(bc.resources, build.cc)) { return ROSE_RUNTIME_PURE_LITERAL; } if (isSingleOutfix(build)) { return ROSE_RUNTIME_SINGLE_OUTFIX; } return ROSE_RUNTIME_FULL_ROSE; } /** * \brief True if this Rose engine needs to run MPV catch up in front of * non-MPV reports. */ static bool needsMpvCatchup(const RoseBuildImpl &build) { const auto &outfixes = build.outfixes; bool has_mpv = any_of(begin(outfixes), end(outfixes), [](const OutfixInfo &outfix) { return outfix.is_nonempty_mpv(); }); if (!has_mpv) { DEBUG_PRINTF("no mpv\n"); return false; } if (isSingleOutfix(build)) { DEBUG_PRINTF("single outfix\n"); return false; } return true; } static void fillStateOffsets(const RoseBuildImpl &tbi, u32 rolesWithStateCount, u32 anchorStateSize, u32 activeArrayCount, u32 activeLeftCount, u32 laggedRoseCount, u32 longLitStreamStateRequired, u32 historyRequired, RoseStateOffsets *so) { u32 curr_offset = 0; // First, runtime status (stores per-stream state, like whether we need a // delay rebuild or have been told to halt matching.) curr_offset += sizeof(u8); // Role state storage. curr_offset += mmbit_size(rolesWithStateCount); so->activeLeafArray = curr_offset; /* TODO: limit size of array */ curr_offset += mmbit_size(activeArrayCount); so->activeLeftArray = curr_offset; /* TODO: limit size of array */ so->activeLeftArray_size = mmbit_size(activeLeftCount); curr_offset += so->activeLeftArray_size; so->longLitState = curr_offset; curr_offset += longLitStreamStateRequired; // ONE WHOLE BYTE for each active leftfix with lag. so->leftfixLagTable = curr_offset; curr_offset += laggedRoseCount; so->anchorState = curr_offset; curr_offset += anchorStateSize; so->groups = curr_offset; so->groups_size = (tbi.group_end + 7) / 8; assert(so->groups_size <= sizeof(u64a)); curr_offset += so->groups_size; // The history consists of the bytes in the history only. YAY so->history = curr_offset; curr_offset += historyRequired; // Exhaustion multibit. so->exhausted = curr_offset; curr_offset += mmbit_size(tbi.rm.numEkeys()); // SOM locations and valid/writeable multibit structures. if (tbi.ssm.numSomSlots()) { const u32 somWidth = tbi.ssm.somPrecision(); if (somWidth) { // somWidth is zero in block mode. curr_offset = ROUNDUP_N(curr_offset, somWidth); so->somLocation = curr_offset; curr_offset += tbi.ssm.numSomSlots() * somWidth; } else { so->somLocation = 0; } so->somValid = curr_offset; curr_offset += mmbit_size(tbi.ssm.numSomSlots()); so->somWritable = curr_offset; curr_offset += mmbit_size(tbi.ssm.numSomSlots()); } else { // No SOM handling, avoid growing the stream state any further. so->somLocation = 0; so->somValid = 0; so->somWritable = 0; } // note: state space for mask nfas is allocated later so->end = curr_offset; } // Get the mask of initial vertices due to root and anchored_root. rose_group RoseBuildImpl::getInitialGroups() const { rose_group groups = getSuccGroups(root) | getSuccGroups(anchored_root); DEBUG_PRINTF("initial groups = %016llx\n", groups); return groups; } static bool nfaStuckOn(const NGHolder &g) { assert(!proper_out_degree(g.startDs, g)); set succ; insert(&succ, adjacent_vertices(g.start, g)); succ.erase(g.startDs); set asucc; set tops; set done_tops; for (const auto &e : out_edges_range(g.start, g)) { insert(&tops, g[e].tops); if (!g[target(e, g)].char_reach.all()) { continue; } asucc.clear(); insert(&asucc, adjacent_vertices(target(e, g), g)); if (asucc == succ) { insert(&done_tops, g[e].tops); } } return tops == done_tops; } namespace { struct PredTopPair { PredTopPair(RoseVertex v, u32 t) : pred(v), top(t) {} bool operator<(const PredTopPair &b) const { const PredTopPair &a = *this; ORDER_CHECK(pred); ORDER_CHECK(top); return false; } RoseVertex pred; u32 top; }; } static void findFixedDepthTops(const RoseGraph &g, const set &triggers, map *fixed_depth_tops) { DEBUG_PRINTF("|trig| %zu\n", triggers.size()); /* find all pred roles for this holder, group by top */ /* if all pred roles for a given top have the same min and max offset, we * add the top to the fixed_depth_top map */ map > pred_by_top; for (const auto &ptp : triggers) { u32 top = ptp.top; RoseVertex u = ptp.pred; pred_by_top[top].insert(u); } for (const auto &e : pred_by_top) { u32 top = e.first; const set &preds = e.second; if (!g[*preds.begin()].fixedOffset()) { continue; } u32 depth = g[*preds.begin()].min_offset; for (RoseVertex u : preds) { if (g[u].min_offset != depth || g[u].max_offset != depth) { goto next_top; } } DEBUG_PRINTF("%u at depth %u\n", top, depth); (*fixed_depth_tops)[top] = depth; next_top:; } } /** * \brief Heuristic for picking between a DFA or NFA implementation of an * engine. */ static aligned_unique_ptr pickImpl(aligned_unique_ptr dfa_impl, aligned_unique_ptr nfa_impl) { assert(nfa_impl); assert(dfa_impl); assert(isDfaType(dfa_impl->type)); // If our NFA is an LBR, it always wins. if (isLbrType(nfa_impl->type)) { return nfa_impl; } // if our DFA is an accelerated Sheng, it always wins. if (isShengType(dfa_impl->type) && has_accel(*dfa_impl)) { return dfa_impl; } bool d_accel = has_accel(*dfa_impl); bool n_accel = has_accel(*nfa_impl); bool d_big = isBigDfaType(dfa_impl->type); bool n_vsmall = nfa_impl->nPositions <= 32; bool n_br = has_bounded_repeats(*nfa_impl); DEBUG_PRINTF("da %d na %d db %d nvs %d nbr %d\n", (int)d_accel, (int)n_accel, (int)d_big, (int)n_vsmall, (int)n_br); if (d_big) { if (!n_vsmall) { if (d_accel || !n_accel) { return dfa_impl; } else { return nfa_impl; } } else { if (n_accel) { return nfa_impl; } else { return dfa_impl; } } } else { /* favour a McClellan 8, unless the nfa looks really good and the dfa * looks like trouble */ if (!d_accel && n_vsmall && n_accel && !n_br) { return nfa_impl; } else { return dfa_impl; } } } /** * \brief Builds an LBR if there's one repeat in the given CastleProto, * otherwise a Castle. */ static aligned_unique_ptr buildRepeatEngine(const CastleProto &proto, const map>> &triggers, const CompileContext &cc, const ReportManager &rm) { // If we only have one repeat, the LBR should always be the best possible // implementation. if (proto.repeats.size() == 1 && cc.grey.allowLbr) { return constructLBR(proto, triggers.at(0), cc, rm); } auto castle_nfa = buildCastle(proto, triggers, cc, rm); assert(castle_nfa); // Should always be constructible. return castle_nfa; } static aligned_unique_ptr getDfa(raw_dfa &rdfa, bool is_transient, const CompileContext &cc, const ReportManager &rm) { // Unleash the Sheng!! auto dfa = shengCompile(rdfa, cc, rm); if (!dfa && !is_transient) { // Sheng wasn't successful, so unleash McClellan! /* We don't try the hybrid for transient prefixes due to the extra * bytecode and that they are usually run on small blocks */ dfa = mcshengCompile(rdfa, cc, rm); } if (!dfa) { // Sheng wasn't successful, so unleash McClellan! dfa = mcclellanCompile(rdfa, cc, rm); } return dfa; } /* builds suffix nfas */ static aligned_unique_ptr buildSuffix(const ReportManager &rm, const SomSlotManager &ssm, const map &fixed_depth_tops, const map>> &triggers, suffix_id suff, const CompileContext &cc) { if (suff.castle()) { auto n = buildRepeatEngine(*suff.castle(), triggers, cc, rm); assert(n); return n; } if (suff.haig()) { auto n = goughCompile(*suff.haig(), ssm.somPrecision(), cc, rm); assert(n); return n; } if (suff.dfa()) { auto d = getDfa(*suff.dfa(), false, cc, rm); assert(d); return d; } assert(suff.graph()); NGHolder &holder = *suff.graph(); assert(holder.kind == NFA_SUFFIX); const bool oneTop = onlyOneTop(holder); bool compress_state = cc.streaming; // Take a shot at the LBR engine. if (oneTop) { auto lbr = constructLBR(holder, triggers.at(0), cc, rm); if (lbr) { return lbr; } } auto n = constructNFA(holder, &rm, fixed_depth_tops, triggers, compress_state, cc); assert(n); if (oneTop && cc.grey.roseMcClellanSuffix) { if (cc.grey.roseMcClellanSuffix == 2 || n->nPositions > 128 || !has_bounded_repeats_other_than_firsts(*n)) { auto rdfa = buildMcClellan(holder, &rm, false, triggers.at(0), cc.grey); if (rdfa) { auto d = getDfa(*rdfa, false, cc, rm); assert(d); if (cc.grey.roseMcClellanSuffix != 2) { n = pickImpl(move(d), move(n)); } else { n = move(d); } assert(n); if (isMcClellanType(n->type)) { // DFA chosen. We may be able to set some more properties // in the NFA structure here. u64a maxOffset = findMaxOffset(holder, rm); if (maxOffset != MAX_OFFSET && maxOffset < 0xffffffffull) { n->maxOffset = (u32)maxOffset; DEBUG_PRINTF("dfa max offset %llu\n", maxOffset); } else { n->maxOffset = 0; // inf } } } } } return n; } static void findInfixTriggers(const RoseBuildImpl &build, map > *infixTriggers) { const RoseGraph &g = build.g; for (auto v : vertices_range(g)) { if (!g[v].left) { continue; } set &triggers = (*infixTriggers)[left_id(g[v].left)]; for (const auto &e : in_edges_range(v, g)) { RoseVertex u = source(e, g); if (build.isAnyStart(u)) { continue; } triggers.insert(PredTopPair(u, g[e].rose_top)); } } } static vector as_cr_seq(const rose_literal_id &lit) { vector rv = as_cr_seq(lit.s); for (u32 i = 0; i < lit.delay; i++) { rv.push_back(CharReach::dot()); } /* TODO: take into account cmp/msk */ return rv; } /** * \brief Returns a map of trigger literals as sequences of CharReach, grouped * by top index. */ static void findTriggerSequences(const RoseBuildImpl &tbi, const set &triggers, map > > *trigger_lits) { map > lit_ids_by_top; for (const PredTopPair &t : triggers) { insert(&lit_ids_by_top[t.top], tbi.g[t.pred].literals); } for (const auto &e : lit_ids_by_top) { const u32 top = e.first; const set &lit_ids = e.second; for (u32 id : lit_ids) { const rose_literal_id &lit = tbi.literals.right.at(id); (*trigger_lits)[top].push_back(as_cr_seq(lit)); } } } static aligned_unique_ptr makeLeftNfa(const RoseBuildImpl &tbi, left_id &left, const bool is_prefix, const bool is_transient, const map > &infixTriggers, const CompileContext &cc) { const ReportManager &rm = tbi.rm; aligned_unique_ptr n; // Should compress state if this rose is non-transient and we're in // streaming mode. const bool compress_state = !is_transient; assert(is_prefix || !left.graph() || left.graph()->kind == NFA_INFIX); assert(!is_prefix || !left.graph() || left.graph()->kind == NFA_PREFIX || left.graph()->kind == NFA_EAGER_PREFIX); // Holder should be implementable as an NFA at the very least. if (!left.dfa() && left.graph()) { assert(isImplementableNFA(*left.graph(), nullptr, cc)); } map fixed_depth_tops; if (!is_prefix /* infix */) { const set &triggers = infixTriggers.at(left); findFixedDepthTops(tbi.g, triggers, &fixed_depth_tops); } if (left.castle()) { assert(!is_prefix); map > > triggers; findTriggerSequences(tbi, infixTriggers.at(left), &triggers); n = buildRepeatEngine(*left.castle(), triggers, cc, rm); assert(n); return n; // Castles/LBRs are always best! } if (left.dfa()) { n = getDfa(*left.dfa(), is_transient, cc, rm); } else if (left.graph() && cc.grey.roseMcClellanPrefix == 2 && is_prefix && !is_transient) { auto rdfa = buildMcClellan(*left.graph(), nullptr, cc.grey); if (rdfa) { n = getDfa(*rdfa, is_transient, cc, rm); assert(n); } } // We can attempt to build LBRs for infixes. if (!n && !is_prefix && left.graph() && onlyOneTop(*left.graph())) { map > > triggers; findTriggerSequences(tbi, infixTriggers.at(left), &triggers); assert(triggers.size() == 1); // single top n = constructLBR(*left.graph(), triggers.begin()->second, cc, rm); } if (!n && left.graph()) { map>> triggers; if (left.graph()->kind == NFA_INFIX) { findTriggerSequences(tbi, infixTriggers.at(left), &triggers); } n = constructNFA(*left.graph(), nullptr, fixed_depth_tops, triggers, compress_state, cc); } if (cc.grey.roseMcClellanPrefix == 1 && is_prefix && !left.dfa() && left.graph() && (!n || !has_bounded_repeats_other_than_firsts(*n) || !is_fast(*n))) { auto rdfa = buildMcClellan(*left.graph(), nullptr, cc.grey); if (rdfa) { auto d = getDfa(*rdfa, is_transient, cc, rm); assert(d); n = pickImpl(move(d), move(n)); } } return n; } static void setLeftNfaProperties(NFA &n, const left_id &left) { depth min_width = findMinWidth(left); DEBUG_PRINTF("min_width=%s\n", min_width.str().c_str()); u32 min_width_value = min_width.is_finite() ? (u32)min_width : 0; n.minWidth = min_width_value; depth max_width = findMaxWidth(left); DEBUG_PRINTF("max_width=%s\n", max_width.str().c_str()); u32 max_width_value = max_width.is_finite() ? (u32)max_width : 0; n.maxWidth = max_width_value; // FIXME: NFA::maxOffset in Rose can't be found from reports as they don't // map to internal_report structures; it would have to come from the Rose // graph. } static void appendTailToHolder(NGHolder &h, const flat_set &reports, const vector &starts, const vector &tail) { assert(!tail.empty()); NFAVertex curr = add_vertex(h); for (NFAVertex v : starts) { assert(!edge(v, h.acceptEod, h).second); assert(h[v].reports == reports); h[v].reports.clear(); remove_edge(v, h.accept, h); add_edge(v, curr, h); } auto it = tail.begin(); h[curr].char_reach = *it; ++it; while (it != tail.end()) { NFAVertex old = curr; curr = add_vertex(h); add_edge(old, curr, h); assert(!it->none()); h[curr].char_reach = *it; ++it; } h[curr].reports = reports; add_edge(curr, h.accept, h); } static void appendTailToHolder(NGHolder &h, const vector &tail) { assert(in_degree(h.acceptEod, h) == 1); assert(!tail.empty()); map, vector > reporters; for (auto v : inv_adjacent_vertices_range(h.accept, h)) { reporters[h[v].reports].push_back(v); } for (const auto &e : reporters) { appendTailToHolder(h, e.first, e.second, tail); } renumber_edges(h); } static u32 decreaseLag(const RoseBuildImpl &build, NGHolder &h, const vector &succs) { const RoseGraph &rg = build.g; static const size_t MAX_RESTORE_LEN = 5; vector restored(MAX_RESTORE_LEN); for (RoseVertex v : succs) { u32 lag = rg[v].left.lag; for (u32 lit_id : rg[v].literals) { u32 delay = build.literals.right.at(lit_id).delay; const ue2_literal &literal = build.literals.right.at(lit_id).s; assert(lag <= literal.length() + delay); size_t base = literal.length() + delay - lag; if (base >= literal.length()) { return 0; } size_t len = literal.length() - base; len = MIN(len, restored.size()); restored.resize(len); auto lit_it = literal.begin() + base; for (u32 i = 0; i < len; i++) { assert(lit_it != literal.end()); restored[i] |= *lit_it; ++lit_it; } } } assert(!restored.empty()); appendTailToHolder(h, restored); return restored.size(); } #define EAGER_DIE_BEFORE_LIMIT 10 struct eager_info { shared_ptr new_graph; u32 lag_adjust = 0; }; static bool checkSuitableForEager(bool is_prefix, const left_id &left, const RoseBuildImpl &build, const vector &succs, rose_group squash_mask, rose_group initial_groups, eager_info &ei, const CompileContext &cc) { DEBUG_PRINTF("checking prefix --> %016llx...\n", squash_mask); const RoseGraph &rg = build.g; if (!is_prefix) { DEBUG_PRINTF("not prefix\n"); return false; /* only prefixes (for now...) */ } if ((initial_groups & squash_mask) == initial_groups) { DEBUG_PRINTF("no squash -- useless\n"); return false; } for (RoseVertex s : succs) { if (build.isInETable(s) || contains(rg[s].literals, build.eod_event_literal_id)) { return false; /* Ignore EOD related prefixes */ } } if (left.dfa()) { const raw_dfa &dfa = *left.dfa(); if (dfa.start_floating != DEAD_STATE) { return false; /* not purely anchored */ } if (!dfa.states[dfa.start_anchored].reports.empty()) { return false; /* vacuous (todo: handle?) */ } if (!can_die_early(dfa, EAGER_DIE_BEFORE_LIMIT)) { return false; } ei.new_graph = rg[succs[0]].left.graph; } else if (left.graph()) { const NGHolder &g = *left.graph(); if (proper_out_degree(g.startDs, g)) { return false; /* not purely anchored */ } ei.new_graph = cloneHolder(*left.graph()); auto gg = ei.new_graph; gg->kind = NFA_EAGER_PREFIX; ei.lag_adjust = decreaseLag(build, *gg, succs); if (is_match_vertex(gg->start, *gg)) { return false; /* should not still be vacuous as lag decreased */ } if (!can_die_early(*gg, EAGER_DIE_BEFORE_LIMIT)) { DEBUG_PRINTF("not eager as stuck alive\n"); return false; } /* We need to ensure that adding in the literals does not cause us to no * longer be able to build an nfa. */ bool ok = isImplementableNFA(*gg, nullptr, cc); if (!ok) { return false; } } else { DEBUG_PRINTF("unable to determine if good for eager running\n"); return false; } DEBUG_PRINTF("eager prefix\n"); return true; } static left_id updateLeftfixWithEager(RoseGraph &g, const eager_info &ei, const vector &succs) { u32 lag_adjust = ei.lag_adjust; auto gg = ei.new_graph; for (RoseVertex v : succs) { g[v].left.graph = gg; assert(g[v].left.lag >= lag_adjust); g[v].left.lag -= lag_adjust; DEBUG_PRINTF("added %u literal chars back, new lag %u\n", lag_adjust, g[v].left.lag); } left_id leftfix = g[succs[0]].left; if (leftfix.graph()) { assert(leftfix.graph()->kind == NFA_PREFIX || leftfix.graph()->kind == NFA_EAGER_PREFIX); leftfix.graph()->kind = NFA_EAGER_PREFIX; } if (leftfix.dfa()) { assert(leftfix.dfa()->kind == NFA_PREFIX); leftfix.dfa()->kind = NFA_EAGER_PREFIX; } return leftfix; } static bool buildLeftfix(RoseBuildImpl &build, build_context &bc, bool prefix, u32 qi, const map > &infixTriggers, set *no_retrigger_queues, set *eager_queues, const map &eager, const vector &succs, left_id leftfix) { RoseGraph &g = build.g; const CompileContext &cc = build.cc; const ReportManager &rm = build.rm; bool is_transient = contains(build.transient, leftfix); rose_group squash_mask = build.rose_squash_masks.at(leftfix); DEBUG_PRINTF("making %sleftfix\n", is_transient ? "transient " : ""); if (contains(eager, leftfix)) { eager_queues->insert(qi); leftfix = updateLeftfixWithEager(g, eager.at(leftfix), succs); } aligned_unique_ptr nfa; // Need to build NFA, which is either predestined to be a Haig (in SOM mode) // or could be all manner of things. if (leftfix.haig()) { nfa = goughCompile(*leftfix.haig(), build.ssm.somPrecision(), cc, rm); } else { nfa = makeLeftNfa(build, leftfix, prefix, is_transient, infixTriggers, cc); } if (!nfa) { assert(!"failed to build leftfix"); return false; } setLeftNfaProperties(*nfa, leftfix); build.leftfix_queue_map.emplace(leftfix, qi); nfa->queueIndex = qi; if (!prefix && !leftfix.haig() && leftfix.graph() && nfaStuckOn(*leftfix.graph())) { DEBUG_PRINTF("%u sticks on\n", qi); no_retrigger_queues->insert(qi); } DEBUG_PRINTF("built leftfix, qi=%u\n", qi); add_nfa_to_blob(bc, *nfa); // Leftfixes can have stop alphabets. vector stop(N_CHARS, 0); /* haigs track som information - need more care */ som_type som = leftfix.haig() ? SOM_LEFT : SOM_NONE; if (leftfix.graph()) { stop = findLeftOffsetStopAlphabet(*leftfix.graph(), som); } else if (leftfix.castle()) { stop = findLeftOffsetStopAlphabet(*leftfix.castle(), som); } // Infix NFAs can have bounds on their queue lengths. u32 max_queuelen = UINT32_MAX; if (!prefix) { set lits; for (RoseVertex v : succs) { for (auto u : inv_adjacent_vertices_range(v, g)) { for (u32 lit_id : g[u].literals) { lits.insert(build.literals.right.at(lit_id).s); } } } DEBUG_PRINTF("%zu literals\n", lits.size()); max_queuelen = findMaxInfixMatches(leftfix, lits); if (max_queuelen < UINT32_MAX) { max_queuelen++; } } u32 max_width; if (is_transient) { depth d = findMaxWidth(leftfix); assert(d.is_finite()); max_width = d; } else { max_width = 0; } u8 cm_count = 0; CharReach cm_cr; if (cc.grey.allowCountingMiracles) { findCountingMiracleInfo(leftfix, stop, &cm_count, &cm_cr); } for (RoseVertex v : succs) { bc.leftfix_info.emplace(v, left_build_info(qi, g[v].left.lag, max_width, squash_mask, stop, max_queuelen, cm_count, cm_cr)); } return true; } static unique_ptr constructTamaInfo(const RoseGraph &g, const vector &subengines, const bool is_suffix) { unique_ptr tamaInfo = ue2::make_unique(); for (const auto &sub : subengines) { const auto &rose_vertices = sub.vertices; NFA *nfa = sub.nfa.get(); set tops; for (const auto &v : rose_vertices) { if (is_suffix) { tops.insert(g[v].suffix.top); } else { for (const auto &e : in_edges_range(v, g)) { tops.insert(g[e].rose_top); } } } tamaInfo->add(nfa, tops); } return tamaInfo; } static void updateTops(const RoseGraph &g, const TamaInfo &tamaInfo, TamaProto &tamaProto, const vector &subengines, const map, u32> &out_top_remap, const bool is_suffix) { u32 i = 0; for (const auto &n : tamaInfo.subengines) { for (const auto &v : subengines[i].vertices) { if (is_suffix) { tamaProto.add(n, g[v].index, g[v].suffix.top, out_top_remap); } else { for (const auto &e : in_edges_range(v, g)) { tamaProto.add(n, g[v].index, g[e].rose_top, out_top_remap); } } } i++; } } static shared_ptr constructContainerEngine(const RoseGraph &g, build_context &bc, const ExclusiveInfo &info, const u32 queue, const bool is_suffix) { const auto &subengines = info.subengines; auto tamaInfo = constructTamaInfo(g, subengines, is_suffix); map, u32> out_top_remap; auto n = buildTamarama(*tamaInfo, queue, out_top_remap); add_nfa_to_blob(bc, *n); DEBUG_PRINTF("queue id:%u\n", queue); shared_ptr tamaProto = make_shared(); tamaProto->reports = info.reports; updateTops(g, *tamaInfo, *tamaProto, subengines, out_top_remap, is_suffix); return tamaProto; } static void buildInfixContainer(RoseGraph &g, build_context &bc, const vector &exclusive_info) { // Build tamarama engine for (const auto &info : exclusive_info) { const u32 queue = info.queue; const auto &subengines = info.subengines; auto tamaProto = constructContainerEngine(g, bc, info, queue, false); for (const auto &sub : subengines) { const auto &verts = sub.vertices; for (const auto &v : verts) { DEBUG_PRINTF("vert id:%zu\n", g[v].index); g[v].left.tamarama = tamaProto; } } } } static void buildSuffixContainer(RoseGraph &g, build_context &bc, const vector &exclusive_info) { // Build tamarama engine for (const auto &info : exclusive_info) { const u32 queue = info.queue; const auto &subengines = info.subengines; auto tamaProto = constructContainerEngine(g, bc, info, queue, true); for (const auto &sub : subengines) { const auto &verts = sub.vertices; for (const auto &v : verts) { DEBUG_PRINTF("vert id:%zu\n", g[v].index); g[v].suffix.tamarama = tamaProto; } const auto &v = verts[0]; suffix_id newSuffix(g[v].suffix); bc.suffixes.emplace(newSuffix, queue); } } } static void updateExclusiveInfixProperties(const RoseBuildImpl &build, build_context &bc, const vector &exclusive_info, set *no_retrigger_queues) { const RoseGraph &g = build.g; for (const auto &info : exclusive_info) { // Set leftfix optimisations, disabled for tamarama subengines rose_group squash_mask = ~rose_group{0}; // Leftfixes can have stop alphabets. vector stop(N_CHARS, 0); // Infix NFAs can have bounds on their queue lengths. u32 max_queuelen = 0; u32 max_width = 0; u8 cm_count = 0; CharReach cm_cr; const auto &qi = info.queue; const auto &subengines = info.subengines; bool no_retrigger = true; for (const auto &sub : subengines) { const auto &verts = sub.vertices; const auto &v_first = verts[0]; left_id leftfix(g[v_first].left); if (leftfix.haig() || !leftfix.graph() || !nfaStuckOn(*leftfix.graph())) { no_retrigger = false; } for (const auto &v : verts) { set lits; for (auto u : inv_adjacent_vertices_range(v, build.g)) { for (u32 lit_id : build.g[u].literals) { lits.insert(build.literals.right.at(lit_id).s); } } DEBUG_PRINTF("%zu literals\n", lits.size()); u32 queuelen = findMaxInfixMatches(leftfix, lits); if (queuelen < UINT32_MAX) { queuelen++; } max_queuelen = max(max_queuelen, queuelen); } } if (no_retrigger) { no_retrigger_queues->insert(qi); } for (const auto &sub : subengines) { const auto &verts = sub.vertices; for (const auto &v : verts) { u32 lag = g[v].left.lag; bc.leftfix_info.emplace( v, left_build_info(qi, lag, max_width, squash_mask, stop, max_queuelen, cm_count, cm_cr)); } } } } static void updateExclusiveSuffixProperties(const RoseBuildImpl &build, const vector &exclusive_info, set *no_retrigger_queues) { const RoseGraph &g = build.g; for (auto &info : exclusive_info) { const auto &qi = info.queue; const auto &subengines = info.subengines; bool no_retrigger = true; for (const auto &sub : subengines) { const auto &v_first = sub.vertices[0]; suffix_id suffix(g[v_first].suffix); if (!suffix.graph() || !nfaStuckOn(*suffix.graph())) { no_retrigger = false; break; } } if (no_retrigger) { no_retrigger_queues->insert(qi); } } } static void buildExclusiveInfixes(RoseBuildImpl &build, build_context &bc, QueueIndexFactory &qif, const map> &infixTriggers, const map> &vertex_map, const vector> &groups, set *no_retrigger_queues) { RoseGraph &g = build.g; const CompileContext &cc = build.cc; vector exclusive_info; for (const auto &gp : groups) { ExclusiveInfo info; for (const auto &id : gp) { const auto &verts = vertex_map.at(id); left_id leftfix(g[verts[0]].left); bool is_transient = false; auto n = makeLeftNfa(build, leftfix, false, is_transient, infixTriggers, cc); assert(n); setLeftNfaProperties(*n, leftfix); ExclusiveSubengine engine; engine.nfa = move(n); engine.vertices = verts; info.subengines.push_back(move(engine)); } info.queue = qif.get_queue(); exclusive_info.push_back(move(info)); } updateExclusiveInfixProperties(build, bc, exclusive_info, no_retrigger_queues); buildInfixContainer(g, bc, exclusive_info); } static void findExclusiveInfixes(RoseBuildImpl &build, build_context &bc, QueueIndexFactory &qif, const map> &infixTriggers, set *no_retrigger_queues) { const RoseGraph &g = build.g; set> roleInfoSet; map> vertex_map; u32 role_id = 0; map leftfixes; for (auto v : vertices_range(g)) { if (!g[v].left || build.isRootSuccessor(v)) { continue; } left_id leftfix(g[v].left); // Sanity check: our NFA should contain each of the tops mentioned on // our in-edges. assert(roseHasTops(build, v)); if (contains(leftfixes, leftfix)) { // NFA already built. u32 id = leftfixes[leftfix]; if (contains(vertex_map, id)) { vertex_map[id].push_back(v); } DEBUG_PRINTF("sharing leftfix, id=%u\n", id); continue; } if (leftfix.graph() || leftfix.castle()) { leftfixes.emplace(leftfix, role_id); vertex_map[role_id].push_back(v); map>> triggers; findTriggerSequences(build, infixTriggers.at(leftfix), &triggers); RoleInfo info(leftfix, role_id); if (setTriggerLiteralsInfix(info, triggers)) { roleInfoSet.insert(info); } role_id++; } } if (leftfixes.size() > 1) { DEBUG_PRINTF("leftfix size:%zu\n", leftfixes.size()); vector> groups; exclusiveAnalysisInfix(build, vertex_map, roleInfoSet, groups); buildExclusiveInfixes(build, bc, qif, infixTriggers, vertex_map, groups, no_retrigger_queues); } } static bool buildLeftfixes(RoseBuildImpl &tbi, build_context &bc, QueueIndexFactory &qif, set *no_retrigger_queues, set *eager_queues, bool do_prefix) { RoseGraph &g = tbi.g; const CompileContext &cc = tbi.cc; map > infixTriggers; vector order; unordered_map > succs; findInfixTriggers(tbi, &infixTriggers); if (cc.grey.allowTamarama && cc.streaming && !do_prefix) { findExclusiveInfixes(tbi, bc, qif, infixTriggers, no_retrigger_queues); } for (auto v : vertices_range(g)) { if (!g[v].left || g[v].left.tamarama) { continue; } assert(tbi.isNonRootSuccessor(v) != tbi.isRootSuccessor(v)); bool is_prefix = tbi.isRootSuccessor(v); if (do_prefix != is_prefix) { /* we require prefixes and then infixes */ continue; } left_id leftfix(g[v].left); // Sanity check: our NFA should contain each of the tops mentioned on // our in-edges. assert(roseHasTops(tbi, v)); bool is_transient = contains(tbi.transient, leftfix); // Transient leftfixes can sometimes be implemented solely with // lookarounds, in which case we don't need to build an engine. // TODO: Handle SOM-tracking cases as well. if (cc.grey.roseLookaroundMasks && is_transient && !g[v].left.tracksSom()) { vector lookaround; if (makeLeftfixLookaround(tbi, v, lookaround)) { DEBUG_PRINTF("implementing as lookaround!\n"); bc.leftfix_info.emplace(v, left_build_info(lookaround)); continue; } } if (!contains(succs, leftfix)) { order.push_back(leftfix); } succs[leftfix].push_back(v); } rose_group initial_groups = tbi.getInitialGroups(); rose_group combined_eager_squashed_mask = ~0ULL; map eager; for (const left_id &leftfix : order) { const auto &left_succs = succs[leftfix]; rose_group squash_mask = tbi.rose_squash_masks.at(leftfix); eager_info ei; if (checkSuitableForEager(do_prefix, leftfix, tbi, left_succs, squash_mask, initial_groups, ei, cc)) { eager[leftfix] = ei; combined_eager_squashed_mask &= squash_mask; DEBUG_PRINTF("combo %016llx...\n", combined_eager_squashed_mask); } } if (do_prefix && combined_eager_squashed_mask & initial_groups) { DEBUG_PRINTF("eager groups won't squash everyone - be lazy\n"); eager_queues->clear(); eager.clear(); } for (const left_id &leftfix : order) { buildLeftfix(tbi, bc, do_prefix, qif.get_queue(), infixTriggers, no_retrigger_queues, eager_queues, eager, succs[leftfix], leftfix); } return true; } static void findSuffixTriggers(const RoseBuildImpl &tbi, map > *suffixTriggers) { const RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { if (!g[v].suffix) { continue; } PredTopPair ptp(v, g[v].suffix.top); (*suffixTriggers)[g[v].suffix].insert(ptp); } } static bool hasNonSmallBlockOutfix(const vector &outfixes) { for (const auto &out : outfixes) { if (!out.in_sbmatcher) { return true; } } return false; } namespace { class OutfixBuilder : public boost::static_visitor> { public: explicit OutfixBuilder(const RoseBuildImpl &build_in) : build(build_in) {} aligned_unique_ptr operator()(boost::blank&) const { return nullptr; }; aligned_unique_ptr operator()(unique_ptr &rdfa) const { // Unleash the mighty DFA! return getDfa(*rdfa, false, build.cc, build.rm); } aligned_unique_ptr operator()(unique_ptr &haig) const { // Unleash the Goughfish! return goughCompile(*haig, build.ssm.somPrecision(), build.cc, build.rm); } aligned_unique_ptr operator()(unique_ptr &holder) const { const CompileContext &cc = build.cc; const ReportManager &rm = build.rm; NGHolder &h = *holder; assert(h.kind == NFA_OUTFIX); // Build NFA. const map fixed_depth_tops; /* no tops */ const map>> triggers; /* no tops */ bool compress_state = cc.streaming; auto n = constructNFA(h, &rm, fixed_depth_tops, triggers, compress_state, cc); // Try for a DFA upgrade. if (n && cc.grey.roseMcClellanOutfix && !has_bounded_repeats_other_than_firsts(*n)) { auto rdfa = buildMcClellan(h, &rm, cc.grey); if (rdfa) { auto d = getDfa(*rdfa, false, cc, rm); if (d) { n = pickImpl(move(d), move(n)); } } } return n; } aligned_unique_ptr operator()(UNUSED MpvProto &mpv) const { // MPV construction handled separately. assert(mpv.puffettes.empty()); return nullptr; } private: const RoseBuildImpl &build; }; } static aligned_unique_ptr buildOutfix(RoseBuildImpl &build, OutfixInfo &outfix) { assert(!outfix.is_dead()); // should not be marked dead. auto n = boost::apply_visitor(OutfixBuilder(build), outfix.proto); if (n && build.cc.grey.reverseAccelerate) { buildReverseAcceleration(n.get(), outfix.rev_info, outfix.minWidth); } return n; } static void prepMpv(RoseBuildImpl &tbi, build_context &bc, size_t *historyRequired, bool *mpv_as_outfix) { assert(bc.engineOffsets.empty()); // MPV should be first *mpv_as_outfix = false; OutfixInfo *mpv_outfix = nullptr; /* assume outfixes are just above chain tails in queue indices */ for (auto &out : tbi.outfixes) { if (out.is_nonempty_mpv()) { assert(!mpv_outfix); mpv_outfix = &out; } else { assert(!out.mpv()); } } if (!mpv_outfix) { return; } auto *mpv = mpv_outfix->mpv(); auto nfa = mpvCompile(mpv->puffettes, mpv->triggered_puffettes, tbi.rm); assert(nfa); if (!nfa) { throw CompileError("Unable to generate bytecode."); } if (tbi.cc.grey.reverseAccelerate) { buildReverseAcceleration(nfa.get(), mpv_outfix->rev_info, mpv_outfix->minWidth); } u32 qi = mpv_outfix->get_queue(tbi.qif); nfa->queueIndex = qi; DEBUG_PRINTF("built mpv\n"); if (!*historyRequired && requires_decompress_key(*nfa)) { *historyRequired = 1; } add_nfa_to_blob(bc, *nfa); *mpv_as_outfix = !mpv->puffettes.empty(); } static void setOutfixProperties(NFA &n, const OutfixInfo &outfix) { depth min_width = outfix.minWidth; DEBUG_PRINTF("min_width=%s\n", min_width.str().c_str()); u32 min_width_value = min_width.is_finite() ? (u32)min_width : 0; n.minWidth = min_width_value; depth max_width = outfix.maxWidth; DEBUG_PRINTF("max_width=%s\n", max_width.str().c_str()); u32 max_width_value = max_width.is_finite() ? (u32)max_width : 0; n.maxWidth = max_width_value; DEBUG_PRINTF("max_offset=%llu\n", outfix.maxOffset); u32 max_offset_value = outfix.maxOffset < ~0U ? (u32)outfix.maxOffset : 0; n.maxOffset = max_offset_value; DEBUG_PRINTF("maxBAWidth=%u\n", outfix.maxBAWidth); if (outfix.maxBAWidth != ROSE_BOUND_INF && outfix.maxBAWidth < 256) { n.maxBiAnchoredWidth = verify_u8(outfix.maxBAWidth); } } static bool prepOutfixes(RoseBuildImpl &tbi, build_context &bc, size_t *historyRequired) { if (tbi.cc.grey.onlyOneOutfix && tbi.outfixes.size() > 1) { DEBUG_PRINTF("we have %zu outfixes, but Grey::onlyOneOutfix is set\n", tbi.outfixes.size()); throw ResourceLimitError(); } assert(tbi.qif.allocated_count() == bc.engineOffsets.size()); for (auto &out : tbi.outfixes) { if (out.mpv()) { continue; /* already done */ } DEBUG_PRINTF("building outfix %zd\n", &out - &tbi.outfixes[0]); auto n = buildOutfix(tbi, out); if (!n) { assert(0); return false; } setOutfixProperties(*n, out); n->queueIndex = out.get_queue(tbi.qif); if (!*historyRequired && requires_decompress_key(*n)) { *historyRequired = 1; } add_nfa_to_blob(bc, *n); } return true; } static void assignSuffixQueues(RoseBuildImpl &build, build_context &bc) { const RoseGraph &g = build.g; for (auto v : vertices_range(g)) { if (!g[v].suffix) { continue; } const suffix_id s(g[v].suffix); DEBUG_PRINTF("vertex %zu triggers suffix %p\n", g[v].index, s.graph()); // We may have already built this NFA. if (contains(bc.suffixes, s)) { continue; } u32 queue = build.qif.get_queue(); DEBUG_PRINTF("assigning %p to queue %u\n", s.graph(), queue); bc.suffixes.emplace(s, queue); build.suffix_queue_map.emplace(s, queue); } } static void setSuffixProperties(NFA &n, const suffix_id &suff, const ReportManager &rm) { depth min_width = findMinWidth(suff); DEBUG_PRINTF("min_width=%s\n", min_width.str().c_str()); u32 min_width_value = min_width.is_finite() ? (u32)min_width : 0; n.minWidth = min_width_value; depth max_width = findMaxWidth(suff); DEBUG_PRINTF("max_width=%s\n", max_width.str().c_str()); u32 max_width_value = max_width.is_finite() ? (u32)max_width : 0; n.maxWidth = max_width_value; u64a max_offset = findMaxOffset(all_reports(suff), rm); DEBUG_PRINTF("max_offset=%llu\n", max_offset); u32 max_offset_value = max_offset < ~0U ? (u32)max_offset : 0; n.maxOffset = max_offset_value; } static void buildExclusiveSuffixes(RoseBuildImpl &build, build_context &bc, QueueIndexFactory &qif, map> &suffixTriggers, const map> &vertex_map, const vector> &groups, set *no_retrigger_queues) { RoseGraph &g = build.g; vector exclusive_info; for (const auto &gp : groups) { ExclusiveInfo info; for (const auto &id : gp) { const auto &verts = vertex_map.at(id); suffix_id s(g[verts[0]].suffix); const set &s_triggers = suffixTriggers.at(s); map fixed_depth_tops; findFixedDepthTops(g, s_triggers, &fixed_depth_tops); map>> triggers; findTriggerSequences(build, s_triggers, &triggers); auto n = buildSuffix(build.rm, build.ssm, fixed_depth_tops, triggers, s, build.cc); assert(n); setSuffixProperties(*n, s, build.rm); ExclusiveSubengine engine; engine.nfa = move(n); engine.vertices = verts; info.subengines.push_back(move(engine)); const auto &reports = all_reports(s); info.reports.insert(reports.begin(), reports.end()); } info.queue = qif.get_queue(); exclusive_info.push_back(move(info)); } updateExclusiveSuffixProperties(build, exclusive_info, no_retrigger_queues); buildSuffixContainer(g, bc, exclusive_info); } static void findExclusiveSuffixes(RoseBuildImpl &tbi, build_context &bc, QueueIndexFactory &qif, map> &suffixTriggers, set *no_retrigger_queues) { const RoseGraph &g = tbi.g; map suffixes; set> roleInfoSet; map> vertex_map; u32 role_id = 0; for (auto v : vertices_range(g)) { if (!g[v].suffix) { continue; } const suffix_id s(g[v].suffix); DEBUG_PRINTF("vertex %zu triggers suffix %p\n", g[v].index, s.graph()); // We may have already built this NFA. if (contains(suffixes, s)) { u32 id = suffixes[s]; if (!tbi.isInETable(v)) { vertex_map[id].push_back(v); } continue; } // Currently disable eod suffixes for exclusive analysis if (!tbi.isInETable(v) && (s.graph() || s.castle())) { DEBUG_PRINTF("assigning %p to id %u\n", s.graph(), role_id); suffixes.emplace(s, role_id); vertex_map[role_id].push_back(v); const set &s_triggers = suffixTriggers.at(s); map>> triggers; findTriggerSequences(tbi, s_triggers, &triggers); RoleInfo info(s, role_id); if (setTriggerLiteralsSuffix(info, triggers)) { roleInfoSet.insert(info); } role_id++; } } if (suffixes.size() > 1) { DEBUG_PRINTF("suffix size:%zu\n", suffixes.size()); vector> groups; exclusiveAnalysisSuffix(tbi, vertex_map, roleInfoSet, groups); buildExclusiveSuffixes(tbi, bc, qif, suffixTriggers, vertex_map, groups, no_retrigger_queues); } } static bool buildSuffixes(const RoseBuildImpl &tbi, build_context &bc, set *no_retrigger_queues, const map> &suffixTriggers) { // To ensure compile determinism, build suffix engines in order of their // (unique) queue indices, so that we call add_nfa_to_blob in the same // order. vector> ordered; for (const auto &e : bc.suffixes) { ordered.emplace_back(e.second, e.first); } sort(begin(ordered), end(ordered)); for (const auto &e : ordered) { const u32 queue = e.first; const suffix_id &s = e.second; if (s.tamarama()) { continue; } const set &s_triggers = suffixTriggers.at(s); map fixed_depth_tops; findFixedDepthTops(tbi.g, s_triggers, &fixed_depth_tops); map>> triggers; findTriggerSequences(tbi, s_triggers, &triggers); auto n = buildSuffix(tbi.rm, tbi.ssm, fixed_depth_tops, triggers, s, tbi.cc); if (!n) { return false; } setSuffixProperties(*n, s, tbi.rm); n->queueIndex = queue; if (s.graph() && nfaStuckOn(*s.graph())) { /* todo: have corresponding * haig analysis */ assert(!s.haig()); DEBUG_PRINTF("%u sticks on\n", queue); no_retrigger_queues->insert(queue); } add_nfa_to_blob(bc, *n); } return true; } static void buildCountingMiracles(build_context &bc) { map, u32> pre_built; for (left_build_info &lbi : bc.leftfix_info | map_values) { if (!lbi.countingMiracleCount) { continue; } const CharReach &cr = lbi.countingMiracleReach; assert(!cr.all() && !cr.none()); auto key = make_pair(cr, lbi.countingMiracleCount); if (contains(pre_built, key)) { lbi.countingMiracleOffset = pre_built[key]; continue; } RoseCountingMiracle rcm; memset(&rcm, 0, sizeof(rcm)); if (cr.count() == 1) { rcm.c = cr.find_first(); } else { rcm.shufti = 1; int rv = shuftiBuildMasks(cr, (u8 *)&rcm.lo, (u8 *)&rcm.hi); if (rv == -1) { DEBUG_PRINTF("failed to build shufti\n"); lbi.countingMiracleCount = 0; /* remove counting miracle */ continue; } rcm.poison = (~cr).find_first(); } rcm.count = lbi.countingMiracleCount; lbi.countingMiracleOffset = bc.engine_blob.add(rcm); pre_built[key] = lbi.countingMiracleOffset; DEBUG_PRINTF("built cm for count of %u @ %u\n", rcm.count, lbi.countingMiracleOffset); } } /* Note: buildNfas may reduce the lag for vertices that have prefixes */ static bool buildNfas(RoseBuildImpl &tbi, build_context &bc, QueueIndexFactory &qif, set *no_retrigger_queues, set *eager_queues, u32 *leftfixBeginQueue) { map> suffixTriggers; findSuffixTriggers(tbi, &suffixTriggers); if (tbi.cc.grey.allowTamarama && tbi.cc.streaming) { findExclusiveSuffixes(tbi, bc, qif, suffixTriggers, no_retrigger_queues); } assignSuffixQueues(tbi, bc); if (!buildSuffixes(tbi, bc, no_retrigger_queues, suffixTriggers)) { return false; } suffixTriggers.clear(); *leftfixBeginQueue = qif.allocated_count(); if (!buildLeftfixes(tbi, bc, qif, no_retrigger_queues, eager_queues, true)) { return false; } if (!buildLeftfixes(tbi, bc, qif, no_retrigger_queues, eager_queues, false)) { return false; } return true; } static void allocateStateSpace(const NFA *nfa, const set &transient_queues, RoseStateOffsets *so, NfaInfo *nfa_infos, u32 *currFullStateSize, u32 *maskStateSize, u32 *tStateSize) { u32 qi = nfa->queueIndex; bool transient = transient_queues.find(qi) != transient_queues.end(); u32 stateSize = verify_u32(nfa->streamStateSize); u32 state_offset; if (transient) { state_offset = *tStateSize; *tStateSize += stateSize; } else { // Pack NFA state on to the end of the Rose state. state_offset = so->end; so->end += stateSize; *maskStateSize += stateSize; } nfa_infos[qi].stateOffset = state_offset; // Uncompressed state must be aligned. u32 scratchStateSize = verify_u32(nfa->scratchStateSize); u32 alignReq = state_alignment(*nfa); assert(alignReq); while (*currFullStateSize % alignReq) { (*currFullStateSize)++; } nfa_infos[qi].fullStateOffset = *currFullStateSize; *currFullStateSize += scratchStateSize; } static void findTransientQueues(const map &leftfix_info, set *out) { DEBUG_PRINTF("curating transient queues\n"); for (const auto &build : leftfix_info | map_values) { if (build.transient) { DEBUG_PRINTF("q %u is transient\n", build.queue); out->insert(build.queue); } } } static void updateNfaState(const build_context &bc, RoseStateOffsets *so, NfaInfo *nfa_infos, u32 *fullStateSize, u32 *nfaStateSize, u32 *tStateSize) { *nfaStateSize = 0; *tStateSize = 0; *fullStateSize = 0; set transient_queues; findTransientQueues(bc.leftfix_info, &transient_queues); for (const auto &m : bc.engineOffsets) { const NFA *n = get_nfa_from_blob(bc, m.first); allocateStateSpace(n, transient_queues, so, nfa_infos, fullStateSize, nfaStateSize, tStateSize); } } /* does not include history requirements for outfixes or literal matchers */ u32 RoseBuildImpl::calcHistoryRequired() const { u32 m = cc.grey.minHistoryAvailable; for (auto v : vertices_range(g)) { if (g[v].suffix) { m = MAX(m, 2); // so that history req is at least 1, for state // compression. /* TODO: check if suffix uses state compression */ } if (g[v].left) { const u32 lag = g[v].left.lag; const left_id leftfix(g[v].left); if (contains(transient, leftfix)) { u32 mv = lag + findMaxWidth(leftfix); // If this vertex has an event literal, we need to add one to // cope with it. if (hasLiteralInTable(v, ROSE_EVENT)) { mv++; } m = MAX(m, mv); } else { /* rose will be caught up from (lag - 1), also need an extra * byte behind that to find the decompression key */ m = MAX(m, lag + 1); m = MAX(m, 2); // so that history req is at least 1, for state // compression. } } } // Delayed literals contribute to history requirement as well. for (const auto &e : literals.right) { const u32 id = e.first; const auto &lit = e.second; if (lit.delay) { // If the literal is delayed _and_ has a mask that is longer than // the literal, we need enough history to match the whole mask as // well when rebuilding delayed matches. size_t len = std::max(lit.elength(), lit.msk.size() + lit.delay); ENSURE_AT_LEAST(&m, verify_u32(len)); } /* Benefit checks require data is available. */ if (literal_info.at(id).requires_benefits) { ENSURE_AT_LEAST(&m, MIN(verify_u32(lit.elength()), MAX_MASK2_WIDTH)); } } m = MAX(m, max_rose_anchored_floating_overlap); DEBUG_PRINTF("m=%u, ematcher_region_size=%u\n", m, ematcher_region_size); if (ematcher_region_size >= m) { return ematcher_region_size; } return m ? m - 1 : 0; } static u32 buildLastByteIter(const RoseGraph &g, build_context &bc) { vector lb_roles; for (auto v : vertices_range(g)) { if (!hasLastByteHistorySucc(g, v)) { continue; } // Eager EOD reporters won't have state indices. auto it = bc.roleStateIndices.find(v); if (it != end(bc.roleStateIndices)) { lb_roles.push_back(it->second); } } if (lb_roles.empty()) { return 0; /* invalid offset */ } vector iter; mmbBuildSparseIterator(iter, lb_roles, bc.numStates); return bc.engine_blob.add_iterator(iter); } static void enforceEngineSizeLimit(const NFA *n, const size_t nfa_size, const Grey &grey) { // Global limit. if (nfa_size > grey.limitEngineSize) { throw ResourceLimitError(); } // Type-specific limit checks follow. if (isDfaType(n->type)) { if (nfa_size > grey.limitDFASize) { throw ResourceLimitError(); } } else if (isNfaType(n->type)) { if (nfa_size > grey.limitNFASize) { throw ResourceLimitError(); } } else if (isLbrType(n->type)) { if (nfa_size > grey.limitLBRSize) { throw ResourceLimitError(); } } } static u32 findMinFloatingLiteralMatch(const RoseBuildImpl &build, const vector &anchored_dfas) { if (anchored_dfas.size() > 1) { DEBUG_PRINTF("multiple anchored dfas\n"); /* We must regard matches from other anchored tables as unordered, as * we do for floating matches. */ return 1; } const RoseGraph &g = build.g; u32 minWidth = ROSE_BOUND_INF; for (auto v : vertices_range(g)) { if (build.isAnchored(v) || build.isVirtualVertex(v)) { DEBUG_PRINTF("skipping %zu anchored or root\n", g[v].index); continue; } u32 w = g[v].min_offset; DEBUG_PRINTF("%zu m_o = %u\n", g[v].index, w); if (w < minWidth) { minWidth = w; } } return minWidth; } static void buildSuffixEkeyLists(const RoseBuildImpl &tbi, build_context &bc, const QueueIndexFactory &qif, vector *out) { out->resize(qif.allocated_count()); map > qi_to_ekeys; /* for determinism */ for (const auto &e : bc.suffixes) { const suffix_id &s = e.first; u32 qi = e.second; set ekeys = reportsToEkeys(all_reports(s), tbi.rm); if (!ekeys.empty()) { qi_to_ekeys[qi] = {ekeys.begin(), ekeys.end()}; } } /* for each outfix also build elists */ for (const auto &outfix : tbi.outfixes) { u32 qi = outfix.get_queue(); set ekeys = reportsToEkeys(all_reports(outfix), tbi.rm); if (!ekeys.empty()) { qi_to_ekeys[qi] = {ekeys.begin(), ekeys.end()}; } } for (auto &e : qi_to_ekeys) { assert(!e.second.empty()); e.second.push_back(INVALID_EKEY); /* terminator */ (*out)[e.first] = bc.engine_blob.add(e.second.begin(), e.second.end()); } } /** Returns sparse iter offset in engine blob. */ static u32 buildEodNfaIterator(build_context &bc, const u32 activeQueueCount) { vector keys; for (u32 qi = 0; qi < activeQueueCount; ++qi) { const NFA *n = get_nfa_from_blob(bc, qi); if (nfaAcceptsEod(n)) { DEBUG_PRINTF("nfa qi=%u accepts eod\n", qi); keys.push_back(qi); } } if (keys.empty()) { return 0; } DEBUG_PRINTF("building iter for %zu nfas\n", keys.size()); vector iter; mmbBuildSparseIterator(iter, keys, activeQueueCount); return bc.engine_blob.add_iterator(iter); } static bool hasMpvTrigger(const set &reports, const ReportManager &rm) { for (u32 r : reports) { if (rm.getReport(r).type == INTERNAL_ROSE_CHAIN) { return true; } } return false; } static bool anyEndfixMpvTriggers(const RoseBuildImpl &tbi) { const RoseGraph &g = tbi.g; ue2::unordered_set done; /* suffixes */ for (auto v : vertices_range(g)) { if (!g[v].suffix) { continue; } if (contains(done, g[v].suffix)) { continue; /* already done */ } done.insert(g[v].suffix); if (hasMpvTrigger(all_reports(g[v].suffix), tbi.rm)) { return true; } } /* outfixes */ for (const auto &out : tbi.outfixes) { if (hasMpvTrigger(all_reports(out), tbi.rm)) { return true; } } return false; } static void populateNfaInfoBasics(const RoseBuildImpl &build, const build_context &bc, const vector &outfixes, const vector &ekeyListOffsets, const set &no_retrigger_queues, NfaInfo *infos) { const u32 num_queues = build.qif.allocated_count(); for (u32 qi = 0; qi < num_queues; qi++) { const NFA *n = get_nfa_from_blob(bc, qi); enforceEngineSizeLimit(n, n->length, build.cc.grey); NfaInfo &info = infos[qi]; info.nfaOffset = bc.engineOffsets.at(qi); info.ekeyListOffset = ekeyListOffsets[qi]; info.no_retrigger = contains(no_retrigger_queues, qi) ? 1 : 0; } // Mark outfixes that are in the small block matcher. for (const auto &out : outfixes) { const u32 qi = out.get_queue(); infos[qi].in_sbmatcher = out.in_sbmatcher; } // Mark suffixes triggered by EOD table literals. const RoseGraph &g = build.g; for (auto v : vertices_range(g)) { if (!g[v].suffix) { continue; } u32 qi = bc.suffixes.at(g[v].suffix); if (build.isInETable(v)) { infos[qi].eod = 1; } } } struct DerivedBoundaryReports { explicit DerivedBoundaryReports(const BoundaryReports &boundary) { insert(&report_at_0_eod_full, boundary.report_at_0_eod); insert(&report_at_0_eod_full, boundary.report_at_eod); insert(&report_at_0_eod_full, boundary.report_at_0); } set report_at_0_eod_full; }; static void prepSomRevNfas(const SomSlotManager &ssm, u32 *rev_nfa_table_offset, vector *nfa_offsets, u32 *currOffset) { const deque> &nfas = ssm.getRevNfas(); *currOffset = ROUNDUP_N(*currOffset, alignof(u32)); *rev_nfa_table_offset = *currOffset; *currOffset += sizeof(u32) * nfas.size(); *currOffset = ROUNDUP_CL(*currOffset); for (const auto &n : nfas) { u32 bs_offset; bs_offset = *currOffset; nfa_offsets->push_back(bs_offset); *currOffset += ROUNDUP_CL(n->length); /* note: som rev nfas don't need a queue assigned as only run in block * mode reverse */ } assert(nfa_offsets->size() == nfas.size()); } static void fillInSomRevNfas(RoseEngine *engine, const SomSlotManager &ssm, u32 rev_nfa_table_offset, const vector &nfa_offsets) { const deque> &nfas = ssm.getRevNfas(); assert(nfa_offsets.size() == nfas.size()); engine->somRevCount = (u32)nfas.size(); engine->somRevOffsetOffset = rev_nfa_table_offset; if (nfas.empty()) { return; } char *out = (char *)engine + rev_nfa_table_offset; size_t table_size = sizeof(u32) * nfa_offsets.size(); memcpy(out, nfa_offsets.data(), table_size); out = (char *)engine + ROUNDUP_CL(rev_nfa_table_offset + table_size); // Write the SOM reverse NFAs into place. UNUSED size_t i = 0; for (const auto &n : nfas) { assert(n != nullptr); assert(out == (char *)engine + nfa_offsets[i]); memcpy(out, n.get(), n->length); out += ROUNDUP_CL(n->length); DEBUG_PRINTF("wrote som rev nfa with len %u\n", n->length); ++i; } } static vector getLiteralInfoByFinalId(const RoseBuildImpl &build, u32 final_id) { vector out; const auto &final_id_to_literal = build.final_id_to_literal; assert(contains(final_id_to_literal, final_id)); const auto &lits = final_id_to_literal.find(final_id)->second; assert(!lits.empty()); for (const auto &lit_id : lits) { const rose_literal_info &li = build.literal_info[lit_id]; assert(li.final_id == final_id); out.push_back(&li); } return out; } static void applyFinalSpecialisation(RoseProgram &program) { assert(!program.empty()); assert(program.back().code() == ROSE_INSTR_END); if (program.size() < 2) { return; } /* Replace the second-to-last instruction (before END) with a one-shot * specialisation if available. */ auto it = next(program.rbegin()); if (auto *ri = dynamic_cast(it->get())) { DEBUG_PRINTF("replacing REPORT with FINAL_REPORT\n"); program.replace(it, make_unique( ri->onmatch, ri->offset_adjust)); } } static void recordResources(RoseResources &resources, const RoseProgram &program) { for (const auto &ri : program) { switch (ri->code()) { case ROSE_INSTR_TRIGGER_SUFFIX: resources.has_suffixes = true; break; case ROSE_INSTR_TRIGGER_INFIX: case ROSE_INSTR_CHECK_INFIX: case ROSE_INSTR_CHECK_PREFIX: case ROSE_INSTR_SOM_LEFTFIX: resources.has_leftfixes = true; break; case ROSE_INSTR_SET_STATE: case ROSE_INSTR_CHECK_STATE: case ROSE_INSTR_SPARSE_ITER_BEGIN: case ROSE_INSTR_SPARSE_ITER_NEXT: resources.has_states = true; break; case ROSE_INSTR_CHECK_GROUPS: resources.checks_groups = true; break; case ROSE_INSTR_PUSH_DELAYED: resources.has_lit_delay = true; break; case ROSE_INSTR_CHECK_LONG_LIT: case ROSE_INSTR_CHECK_LONG_LIT_NOCASE: resources.has_lit_check = true; break; default: break; } } } static void recordResources(RoseResources &resources, const RoseBuildImpl &build) { if (!build.outfixes.empty()) { resources.has_outfixes = true; } for (u32 i = 0; i < build.literal_info.size(); i++) { if (build.hasFinalId(i)) { resources.has_literals = true; break; } } const auto &g = build.g; for (const auto &v : vertices_range(g)) { if (g[v].eod_accept) { resources.has_eod = true; break; } if (g[v].suffix && has_eod_accepts(g[v].suffix)) { resources.has_eod = true; break; } } } static void recordLongLiterals(build_context &bc, const RoseProgram &program) { for (const auto &ri : program) { if (const auto *ri_check = dynamic_cast(ri.get())) { DEBUG_PRINTF("found CHECK_LITERAL for string '%s'\n", escapeString(ri_check->literal).c_str()); bc.longLiterals.emplace_back(ri_check->literal, false); continue; } if (const auto *ri_check = dynamic_cast(ri.get())) { DEBUG_PRINTF("found CHECK_LITERAL_NOCASE for string '%s'\n", escapeString(ri_check->literal).c_str()); bc.longLiterals.emplace_back(ri_check->literal, true); } } } static u32 writeProgram(build_context &bc, RoseProgram &&program) { if (program.empty()) { DEBUG_PRINTF("no program\n"); return 0; } auto it = bc.program_cache.find(program); if (it != end(bc.program_cache)) { DEBUG_PRINTF("reusing cached program at %u\n", it->second); return it->second; } recordResources(bc.resources, program); recordLongLiterals(bc, program); u32 len = 0; auto prog_bytecode = writeProgram(bc.engine_blob, program, &len); u32 offset = bc.engine_blob.add(prog_bytecode.get(), len, ROSE_INSTR_MIN_ALIGN); DEBUG_PRINTF("prog len %u written at offset %u\n", len, offset); bc.program_cache.emplace(move(program), offset); return offset; } static void buildActiveLeftIter(const vector &leftTable, vector &out) { vector keys; for (size_t i = 0; i < leftTable.size(); i++) { if (!leftTable[i].transient) { DEBUG_PRINTF("rose %zu is active\n", i); keys.push_back(verify_u32(i)); } } DEBUG_PRINTF("%zu active roses\n", keys.size()); if (keys.empty()) { out.clear(); return; } mmbBuildSparseIterator(out, keys, leftTable.size()); } static bool canEagerlyReportAtEod(const RoseBuildImpl &build, const RoseEdge &e) { const auto &g = build.g; const auto v = target(e, g); if (!build.g[v].eod_accept) { return false; } // If there's a graph between us and EOD, we shouldn't be eager. if (build.g[v].left) { return false; } // Must be exactly at EOD. if (g[e].minBound != 0 || g[e].maxBound != 0) { return false; } // In streaming mode, we can only eagerly report EOD for literals in the // EOD-anchored table, as that's the only time we actually know where EOD // is. In block mode, we always have this information. const auto u = source(e, g); if (build.cc.streaming && !build.isInETable(u)) { return false; } return true; } static bool hasEodAnchors(const RoseBuildImpl &build, const build_context &bc, u32 outfixEndQueue) { for (u32 i = 0; i < outfixEndQueue; i++) { if (nfaAcceptsEod(get_nfa_from_blob(bc, i))) { DEBUG_PRINTF("outfix has eod\n"); return true; } } if (build.eod_event_literal_id != MO_INVALID_IDX) { DEBUG_PRINTF("eod is an event to be celebrated\n"); return true; } const RoseGraph &g = build.g; for (auto v : vertices_range(g)) { if (g[v].eod_accept) { DEBUG_PRINTF("literally report eod\n"); return true; } if (g[v].suffix && has_eod_accepts(g[v].suffix)) { DEBUG_PRINTF("eod suffix\n"); return true; } } DEBUG_PRINTF("yawn\n"); return false; } static void fillLookaroundTables(char *look_base, char *reach_base, const vector &look_vec) { DEBUG_PRINTF("%zu lookaround table entries\n", look_vec.size()); s8 *look = (s8 *)look_base; u8 *reach = (u8 *)reach_base; // base for 256-bit bitvectors for (const auto &le : look_vec) { *look = verify_s8(le.offset); const CharReach &cr = le.reach; assert(cr.any()); // Should be at least one character! fill_bitvector(cr, reach); ++look; reach += REACH_BITVECTOR_LEN; } } static bool hasBoundaryReports(const BoundaryReports &boundary) { if (!boundary.report_at_0.empty()) { DEBUG_PRINTF("has boundary reports at 0\n"); return true; } if (!boundary.report_at_0_eod.empty()) { DEBUG_PRINTF("has boundary reports at 0 eod\n"); return true; } if (!boundary.report_at_eod.empty()) { DEBUG_PRINTF("has boundary reports at eod\n"); return true; } DEBUG_PRINTF("no boundary reports\n"); return false; } /** * \brief True if the given vertex is a role that can only be switched on at * EOD. */ static bool onlyAtEod(const RoseBuildImpl &tbi, RoseVertex v) { const RoseGraph &g = tbi.g; // All such roles have only (0,0) edges to vertices with the eod_accept // property, and no other effects (suffixes, ordinary reports, etc, etc). if (isLeafNode(v, g) || !g[v].reports.empty() || g[v].suffix) { return false; } for (const auto &e : out_edges_range(v, g)) { RoseVertex w = target(e, g); if (!g[w].eod_accept) { return false; } assert(!g[w].reports.empty()); assert(g[w].literals.empty()); if (g[e].minBound || g[e].maxBound) { return false; } } /* There is no pointing enforcing this check at runtime if * this role is only fired by the eod event literal */ if (tbi.eod_event_literal_id != MO_INVALID_IDX && g[v].literals.size() == 1 && *g[v].literals.begin() == tbi.eod_event_literal_id) { return false; } return true; } static u32 addLookaround(build_context &bc, const vector &look) { // Check the cache. auto it = bc.lookaround_cache.find(look); if (it != bc.lookaround_cache.end()) { DEBUG_PRINTF("reusing look at idx %zu\n", it->second); return verify_u32(it->second); } // Linear scan for sequence. auto seq_it = search(begin(bc.lookaround), end(bc.lookaround), begin(look), end(look)); if (seq_it != end(bc.lookaround)) { size_t idx = distance(begin(bc.lookaround), seq_it); DEBUG_PRINTF("linear scan found look at idx %zu\n", idx); bc.lookaround_cache.emplace(look, idx); return verify_u32(idx); } // New sequence. size_t idx = bc.lookaround.size(); bc.lookaround_cache.emplace(look, idx); insert(&bc.lookaround, bc.lookaround.end(), look); DEBUG_PRINTF("adding look at idx %zu\n", idx); return verify_u32(idx); } static bool checkReachMask(const CharReach &cr, u8 &andmask, u8 &cmpmask) { size_t reach_size = cr.count(); assert(reach_size > 0); // check whether entry_size is some power of 2. if ((reach_size - 1) & reach_size) { return false; } make_and_cmp_mask(cr, &andmask, &cmpmask); if ((1 << popcount32((u8)(~andmask))) ^ reach_size) { return false; } return true; } static bool checkReachWithFlip(const CharReach &cr, u8 &andmask, u8 &cmpmask, u8 &flip) { if (checkReachMask(cr, andmask, cmpmask)) { flip = 0; return true; } if (checkReachMask(~cr, andmask, cmpmask)) { flip = 1; return true; } return false; } static bool makeRoleByte(const vector &look, RoseProgram &program) { if (look.size() == 1) { const auto &entry = look[0]; u8 andmask_u8, cmpmask_u8; u8 flip; if (!checkReachWithFlip(entry.reach, andmask_u8, cmpmask_u8, flip)) { return false; } s32 checkbyte_offset = verify_s32(entry.offset); DEBUG_PRINTF("CHECK BYTE offset=%d\n", checkbyte_offset); const auto *end_inst = program.end_instruction(); auto ri = make_unique(andmask_u8, cmpmask_u8, flip, checkbyte_offset, end_inst); program.add_before_end(move(ri)); return true; } return false; } static bool makeRoleMask(const vector &look, RoseProgram &program) { if (look.back().offset < look.front().offset + 8) { s32 base_offset = verify_s32(look.front().offset); u64a and_mask = 0; u64a cmp_mask = 0; u64a neg_mask = 0; for (const auto &entry : look) { u8 andmask_u8, cmpmask_u8, flip; if (!checkReachWithFlip(entry.reach, andmask_u8, cmpmask_u8, flip)) { return false; } DEBUG_PRINTF("entry offset %d\n", entry.offset); u32 shift = (entry.offset - base_offset) << 3; and_mask |= (u64a)andmask_u8 << shift; cmp_mask |= (u64a)cmpmask_u8 << shift; if (flip) { neg_mask |= 0xffLLU << shift; } } DEBUG_PRINTF("CHECK MASK and_mask=%llx cmp_mask=%llx\n", and_mask, cmp_mask); const auto *end_inst = program.end_instruction(); auto ri = make_unique(and_mask, cmp_mask, neg_mask, base_offset, end_inst); program.add_before_end(move(ri)); return true; } return false; } static UNUSED string convertMaskstoString(u8 *p, int byte_len) { string s; for (int i = 0; i < byte_len; i++) { u8 hi = *p >> 4; u8 lo = *p & 0xf; s += (char)(hi + (hi < 10 ? 48 : 87)); s += (char)(lo + (lo < 10 ? 48 : 87)); p++; } return s; } static bool makeRoleMask32(const vector &look, RoseProgram &program) { if (look.back().offset >= look.front().offset + 32) { return false; } s32 base_offset = verify_s32(look.front().offset); array and_mask, cmp_mask; and_mask.fill(0); cmp_mask.fill(0); u32 neg_mask = 0; for (const auto &entry : look) { u8 andmask_u8, cmpmask_u8, flip; if (!checkReachWithFlip(entry.reach, andmask_u8, cmpmask_u8, flip)) { return false; } u32 shift = entry.offset - base_offset; assert(shift < 32); and_mask[shift] = andmask_u8; cmp_mask[shift] = cmpmask_u8; if (flip) { neg_mask |= 1 << shift; } } DEBUG_PRINTF("and_mask %s\n", convertMaskstoString(and_mask.data(), 32).c_str()); DEBUG_PRINTF("cmp_mask %s\n", convertMaskstoString(cmp_mask.data(), 32).c_str()); DEBUG_PRINTF("neg_mask %08x\n", neg_mask); DEBUG_PRINTF("base_offset %d\n", base_offset); const auto *end_inst = program.end_instruction(); auto ri = make_unique(and_mask, cmp_mask, neg_mask, base_offset, end_inst); program.add_before_end(move(ri)); return true; } // Sorting by the size of every bucket. // Used in map, cmpNibble>. struct cmpNibble { bool operator()(const u32 data1, const u32 data2) const{ u32 size1 = popcount32(data1 >> 16) * popcount32(data1 << 16); u32 size2 = popcount32(data2 >> 16) * popcount32(data2 << 16); return std::tie(size1, data1) < std::tie(size2, data2); } }; // Insert all pairs of bucket and offset into buckets. static really_inline void getAllBuckets(const vector &look, map, cmpNibble> &buckets, u32 &neg_mask) { s32 base_offset = verify_s32(look.front().offset); for (const auto &entry : look) { CharReach cr = entry.reach; // Flip heavy character classes to save buckets. if (cr.count() > 128 ) { cr.flip(); } else { neg_mask ^= 1 << (entry.offset - base_offset); } map lo2hi; // We treat Ascii Table as a 16x16 grid. // Push every row in cr into lo2hi and mark the row number. for (size_t i = cr.find_first(); i != CharReach::npos;) { u8 it_hi = i >> 4; u16 low_encode = 0; while (i != CharReach::npos && (i >> 4) == it_hi) { low_encode |= 1 << (i & 0xf); i = cr.find_next(i); } lo2hi[low_encode] |= 1 << it_hi; } for (const auto &it : lo2hi) { u32 hi_lo = (it.second << 16) | it.first; buckets[hi_lo].push_back(entry.offset); } } } // Once we have a new bucket, we'll try to combine it with all old buckets. static really_inline void nibUpdate(map &nib, u32 hi_lo) { u16 hi = hi_lo >> 16; u16 lo = hi_lo & 0xffff; for (const auto pairs : nib) { u32 old = pairs.first; if ((old >> 16) == hi || (old & 0xffff) == lo) { if (!nib[old | hi_lo]) { nib[old | hi_lo] = nib[old] | nib[hi_lo]; } } } } static really_inline void nibMaskUpdate(array &mask, u32 data, u8 bit_index) { for (u8 index = 0; data > 0; data >>= 1, index++) { if (data & 1) { // 0 ~ 7 bucket in first 16 bytes, // 8 ~ 15 bucket in second 16 bytes. if (bit_index >= 8) { mask[index + 16] |= 1 << (bit_index - 8); } else { mask[index] |= 1 << bit_index; } } } } static bool makeRoleShufti(const vector &look, RoseProgram &program) { s32 base_offset = verify_s32(look.front().offset); if (look.back().offset >= base_offset + 32) { return false; } array hi_mask, lo_mask; hi_mask.fill(0); lo_mask.fill(0); array bucket_select_hi, bucket_select_lo; bucket_select_hi.fill(0); // will not be used in 16x8 and 32x8. bucket_select_lo.fill(0); u8 bit_index = 0; // number of buckets map nib; // map every bucket to its bucket number. map, cmpNibble> bucket2offsets; u32 neg_mask = ~0u; getAllBuckets(look, bucket2offsets, neg_mask); for (const auto &it : bucket2offsets) { u32 hi_lo = it.first; // New bucket. if (!nib[hi_lo]) { if (bit_index >= 16) { return false; } nib[hi_lo] = 1 << bit_index; nibUpdate(nib, hi_lo); nibMaskUpdate(hi_mask, hi_lo >> 16, bit_index); nibMaskUpdate(lo_mask, hi_lo & 0xffff, bit_index); bit_index++; } DEBUG_PRINTF("hi_lo %x bucket %x\n", hi_lo, nib[hi_lo]); // Update bucket_select_mask. u8 nib_hi = nib[hi_lo] >> 8; u8 nib_lo = nib[hi_lo] & 0xff; for (const auto offset : it.second) { bucket_select_hi[offset - base_offset] |= nib_hi; bucket_select_lo[offset - base_offset] |= nib_lo; } } DEBUG_PRINTF("hi_mask %s\n", convertMaskstoString(hi_mask.data(), 32).c_str()); DEBUG_PRINTF("lo_mask %s\n", convertMaskstoString(lo_mask.data(), 32).c_str()); DEBUG_PRINTF("bucket_select_hi %s\n", convertMaskstoString(bucket_select_hi.data(), 32).c_str()); DEBUG_PRINTF("bucket_select_lo %s\n", convertMaskstoString(bucket_select_lo.data(), 32).c_str()); const auto *end_inst = program.end_instruction(); if (bit_index < 8) { if (look.back().offset < base_offset + 16) { neg_mask &= 0xffff; array nib_mask; array bucket_select_mask_16; copy(lo_mask.begin(), lo_mask.begin() + 16, nib_mask.begin()); copy(hi_mask.begin(), hi_mask.begin() + 16, nib_mask.begin() + 16); copy(bucket_select_lo.begin(), bucket_select_lo.begin() + 16, bucket_select_mask_16.begin()); auto ri = make_unique (nib_mask, bucket_select_mask_16, neg_mask, base_offset, end_inst); program.add_before_end(move(ri)); } else { array hi_mask_16; array lo_mask_16; copy(hi_mask.begin(), hi_mask.begin() + 16, hi_mask_16.begin()); copy(lo_mask.begin(), lo_mask.begin() + 16, lo_mask_16.begin()); auto ri = make_unique (hi_mask_16, lo_mask_16, bucket_select_lo, neg_mask, base_offset, end_inst); program.add_before_end(move(ri)); } } else { if (look.back().offset < base_offset + 16) { neg_mask &= 0xffff; array bucket_select_mask_32; copy(bucket_select_lo.begin(), bucket_select_lo.begin() + 16, bucket_select_mask_32.begin()); copy(bucket_select_hi.begin(), bucket_select_hi.begin() + 16, bucket_select_mask_32.begin() + 16); auto ri = make_unique (hi_mask, lo_mask, bucket_select_mask_32, neg_mask, base_offset, end_inst); program.add_before_end(move(ri)); } else { auto ri = make_unique (hi_mask, lo_mask, bucket_select_hi, bucket_select_lo, neg_mask, base_offset, end_inst); program.add_before_end(move(ri)); } } return true; } /** * Builds a lookaround instruction, or an appropriate specialization if one is * available. */ static void makeLookaroundInstruction(build_context &bc, const vector &look, RoseProgram &program) { assert(!look.empty()); if (makeRoleByte(look, program)) { return; } if (look.size() == 1) { s8 offset = look.begin()->offset; u32 look_idx = addLookaround(bc, look); auto ri = make_unique(offset, look_idx, program.end_instruction()); program.add_before_end(move(ri)); return; } if (makeRoleMask(look, program)) { return; } if (makeRoleMask32(look, program)) { return; } if (makeRoleShufti(look, program)) { return; } u32 look_idx = addLookaround(bc, look); u32 look_count = verify_u32(look.size()); auto ri = make_unique(look_idx, look_count, program.end_instruction()); program.add_before_end(move(ri)); } static void makeRoleLookaround(RoseBuildImpl &build, build_context &bc, RoseVertex v, RoseProgram &program) { if (!build.cc.grey.roseLookaroundMasks) { return; } vector look; // Lookaround from leftfix (mandatory). if (contains(bc.leftfix_info, v) && bc.leftfix_info.at(v).has_lookaround) { DEBUG_PRINTF("using leftfix lookaround\n"); look = bc.leftfix_info.at(v).lookaround; } // We may be able to find more lookaround info (advisory) and merge it // in. vector look_more; findLookaroundMasks(build, v, look_more); mergeLookaround(look, look_more); if (look.empty()) { return; } makeLookaroundInstruction(bc, look, program); } static void makeRoleCheckLeftfix(RoseBuildImpl &build, build_context &bc, RoseVertex v, RoseProgram &program) { auto it = bc.leftfix_info.find(v); if (it == end(bc.leftfix_info)) { return; } const left_build_info &lni = it->second; if (lni.has_lookaround) { return; // Leftfix completely implemented by lookaround. } assert(!build.cc.streaming || build.g[v].left.lag <= MAX_STORED_LEFTFIX_LAG); bool is_prefix = build.isRootSuccessor(v); const auto *end_inst = program.end_instruction(); unique_ptr ri; if (is_prefix) { ri = make_unique(lni.queue, build.g[v].left.lag, build.g[v].left.leftfix_report, end_inst); } else { ri = make_unique(lni.queue, build.g[v].left.lag, build.g[v].left.leftfix_report, end_inst); } program.add_before_end(move(ri)); } static void makeRoleAnchoredDelay(RoseBuildImpl &build, build_context &bc, RoseVertex v, RoseProgram &program) { // Only relevant for roles that can be triggered by the anchored table. if (!build.isAnchored(v)) { return; } // If this match cannot occur after floatingMinLiteralMatchOffset, we do // not need this check. if (build.g[v].max_offset <= bc.floatingMinLiteralMatchOffset) { return; } const auto *end_inst = program.end_instruction(); auto ri = make_unique(build.g[v].groups, end_inst); program.add_before_end(move(ri)); } static void makeDedupe(const RoseBuildImpl &build, const Report &report, RoseProgram &program) { const auto *end_inst = program.end_instruction(); auto ri = make_unique(report.quashSom, build.rm.getDkey(report), report.offsetAdjust, end_inst); program.add_before_end(move(ri)); } static void makeDedupeSom(const RoseBuildImpl &build, const Report &report, RoseProgram &program) { const auto *end_inst = program.end_instruction(); auto ri = make_unique(report.quashSom, build.rm.getDkey(report), report.offsetAdjust, end_inst); program.add_before_end(move(ri)); } static void makeCatchup(RoseBuildImpl &build, build_context &bc, const flat_set &reports, RoseProgram &program) { if (!bc.needs_catchup) { return; } // Everything except the INTERNAL_ROSE_CHAIN report needs catchup to run // before reports are triggered. auto report_needs_catchup = [&](const ReportID &id) { const Report &report = build.rm.getReport(id); return report.type != INTERNAL_ROSE_CHAIN; }; if (!any_of(begin(reports), end(reports), report_needs_catchup)) { DEBUG_PRINTF("none of the given reports needs catchup\n"); return; } program.add_before_end(make_unique()); } static void makeCatchupMpv(RoseBuildImpl &build, build_context &bc, ReportID id, RoseProgram &program) { if (!bc.needs_mpv_catchup) { return; } const Report &report = build.rm.getReport(id); if (report.type == INTERNAL_ROSE_CHAIN) { return; } program.add_before_end(make_unique()); } static void writeSomOperation(const Report &report, som_operation *op) { assert(op); memset(op, 0, sizeof(*op)); switch (report.type) { case EXTERNAL_CALLBACK_SOM_REL: op->type = SOM_EXTERNAL_CALLBACK_REL; break; case INTERNAL_SOM_LOC_SET: op->type = SOM_INTERNAL_LOC_SET; break; case INTERNAL_SOM_LOC_SET_IF_UNSET: op->type = SOM_INTERNAL_LOC_SET_IF_UNSET; break; case INTERNAL_SOM_LOC_SET_IF_WRITABLE: op->type = SOM_INTERNAL_LOC_SET_IF_WRITABLE; break; case INTERNAL_SOM_LOC_SET_SOM_REV_NFA: op->type = SOM_INTERNAL_LOC_SET_REV_NFA; break; case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET: op->type = SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET; break; case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE: op->type = SOM_INTERNAL_LOC_SET_REV_NFA_IF_WRITABLE; break; case INTERNAL_SOM_LOC_COPY: op->type = SOM_INTERNAL_LOC_COPY; break; case INTERNAL_SOM_LOC_COPY_IF_WRITABLE: op->type = SOM_INTERNAL_LOC_COPY_IF_WRITABLE; break; case INTERNAL_SOM_LOC_MAKE_WRITABLE: op->type = SOM_INTERNAL_LOC_MAKE_WRITABLE; break; case EXTERNAL_CALLBACK_SOM_STORED: op->type = SOM_EXTERNAL_CALLBACK_STORED; break; case EXTERNAL_CALLBACK_SOM_ABS: op->type = SOM_EXTERNAL_CALLBACK_ABS; break; case EXTERNAL_CALLBACK_SOM_REV_NFA: op->type = SOM_EXTERNAL_CALLBACK_REV_NFA; break; case INTERNAL_SOM_LOC_SET_FROM: op->type = SOM_INTERNAL_LOC_SET_FROM; break; case INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE: op->type = SOM_INTERNAL_LOC_SET_FROM_IF_WRITABLE; break; default: // This report doesn't correspond to a SOM operation. assert(0); throw CompileError("Unable to generate bytecode."); } op->onmatch = report.onmatch; switch (report.type) { case EXTERNAL_CALLBACK_SOM_REV_NFA: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE: op->aux.revNfaIndex = report.revNfaIndex; break; default: op->aux.somDistance = report.somDistance; break; } } static void makeReport(RoseBuildImpl &build, const ReportID id, const bool has_som, RoseProgram &program) { assert(id < build.rm.numReports()); const Report &report = build.rm.getReport(id); RoseProgram report_block; const RoseInstruction *end_inst = report_block.end_instruction(); // Handle min/max offset checks. if (report.minOffset > 0 || report.maxOffset < MAX_OFFSET) { auto ri = make_unique(report.minOffset, report.maxOffset, end_inst); report_block.add_before_end(move(ri)); } // If this report has an exhaustion key, we can check it in the program // rather than waiting until we're in the callback adaptor. if (report.ekey != INVALID_EKEY) { auto ri = make_unique(report.ekey, end_inst); report_block.add_before_end(move(ri)); } // External SOM reports that aren't passthrough need their SOM value // calculated. if (isExternalSomReport(report) && report.type != EXTERNAL_CALLBACK_SOM_PASS) { auto ri = make_unique(); writeSomOperation(report, &ri->som); report_block.add_before_end(move(ri)); } // Min length constraint. if (report.minLength > 0) { assert(build.hasSom); auto ri = make_unique( report.offsetAdjust, report.minLength, end_inst); report_block.add_before_end(move(ri)); } if (report.quashSom) { report_block.add_before_end(make_unique()); } switch (report.type) { case EXTERNAL_CALLBACK: if (!has_som) { // Dedupe is only necessary if this report has a dkey, or if there // are SOM reports to catch up. bool needs_dedupe = build.rm.getDkey(report) != ~0U || build.hasSom; if (report.ekey == INVALID_EKEY) { if (needs_dedupe) { report_block.add_before_end( make_unique( report.quashSom, build.rm.getDkey(report), report.onmatch, report.offsetAdjust, end_inst)); } else { report_block.add_before_end(make_unique( report.onmatch, report.offsetAdjust)); } } else { if (needs_dedupe) { makeDedupe(build, report, report_block); } report_block.add_before_end(make_unique( report.onmatch, report.offsetAdjust, report.ekey)); } } else { // has_som makeDedupeSom(build, report, report_block); if (report.ekey == INVALID_EKEY) { report_block.add_before_end(make_unique( report.onmatch, report.offsetAdjust)); } else { report_block.add_before_end( make_unique( report.onmatch, report.offsetAdjust, report.ekey)); } } break; case INTERNAL_SOM_LOC_SET: case INTERNAL_SOM_LOC_SET_IF_UNSET: case INTERNAL_SOM_LOC_SET_IF_WRITABLE: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE: case INTERNAL_SOM_LOC_COPY: case INTERNAL_SOM_LOC_COPY_IF_WRITABLE: case INTERNAL_SOM_LOC_MAKE_WRITABLE: case INTERNAL_SOM_LOC_SET_FROM: case INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE: if (has_som) { auto ri = make_unique(); writeSomOperation(report, &ri->som); report_block.add_before_end(move(ri)); } else { auto ri = make_unique(); writeSomOperation(report, &ri->som); report_block.add_before_end(move(ri)); } break; case INTERNAL_ROSE_CHAIN: { report_block.add_before_end(make_unique( report.onmatch, report.topSquashDistance)); break; } case EXTERNAL_CALLBACK_SOM_REL: case EXTERNAL_CALLBACK_SOM_STORED: case EXTERNAL_CALLBACK_SOM_ABS: case EXTERNAL_CALLBACK_SOM_REV_NFA: makeDedupeSom(build, report, report_block); if (report.ekey == INVALID_EKEY) { report_block.add_before_end(make_unique( report.onmatch, report.offsetAdjust)); } else { report_block.add_before_end(make_unique( report.onmatch, report.offsetAdjust, report.ekey)); } break; case EXTERNAL_CALLBACK_SOM_PASS: makeDedupeSom(build, report, report_block); if (report.ekey == INVALID_EKEY) { report_block.add_before_end(make_unique( report.onmatch, report.offsetAdjust)); } else { report_block.add_before_end(make_unique( report.onmatch, report.offsetAdjust, report.ekey)); } break; default: assert(0); throw CompileError("Unable to generate bytecode."); } assert(!report_block.empty()); program.add_block(move(report_block)); } static void makeRoleReports(RoseBuildImpl &build, build_context &bc, RoseVertex v, RoseProgram &program) { const auto &g = build.g; /* we are a suffaig - need to update role to provide som to the * suffix. */ bool has_som = false; if (g[v].left.tracksSom()) { assert(contains(bc.leftfix_info, v)); const left_build_info &lni = bc.leftfix_info.at(v); program.add_before_end( make_unique(lni.queue, g[v].left.lag)); has_som = true; } else if (g[v].som_adjust) { program.add_before_end( make_unique(g[v].som_adjust)); has_som = true; } const auto &reports = g[v].reports; makeCatchup(build, bc, reports, program); RoseProgram report_block; for (ReportID id : reports) { makeReport(build, id, has_som, report_block); } program.add_before_end(move(report_block)); } static void makeRoleSuffix(RoseBuildImpl &build, build_context &bc, RoseVertex v, RoseProgram &program) { const auto &g = build.g; if (!g[v].suffix) { return; } assert(contains(bc.suffixes, g[v].suffix)); u32 qi = bc.suffixes.at(g[v].suffix); assert(contains(bc.engineOffsets, qi)); const NFA *nfa = get_nfa_from_blob(bc, qi); u32 suffixEvent; if (isContainerType(nfa->type)) { auto tamaProto = g[v].suffix.tamarama.get(); assert(tamaProto); u32 top = (u32)MQE_TOP_FIRST + tamaProto->top_remap.at(make_pair(g[v].index, g[v].suffix.top)); assert(top < MQE_INVALID); suffixEvent = top; } else if (isMultiTopType(nfa->type)) { assert(!g[v].suffix.haig); u32 top = (u32)MQE_TOP_FIRST + g[v].suffix.top; assert(top < MQE_INVALID); suffixEvent = top; } else { // DFAs/Puffs have no MQE_TOP_N support, so they get a classic TOP // event. assert(!g[v].suffix.graph || onlyOneTop(*g[v].suffix.graph)); suffixEvent = MQE_TOP; } program.add_before_end( make_unique(qi, suffixEvent)); } static void makeRoleGroups(RoseBuildImpl &build, build_context &bc, RoseVertex v, RoseProgram &program) { const auto &g = build.g; rose_group groups = g[v].groups; if (!groups) { return; } // The set of "already on" groups as we process this vertex is the // intersection of the groups set by our predecessors. assert(in_degree(v, g) > 0); rose_group already_on = ~rose_group{0}; for (const auto &u : inv_adjacent_vertices_range(v, g)) { already_on &= bc.vertex_group_map.at(u); } DEBUG_PRINTF("already_on=0x%llx\n", already_on); DEBUG_PRINTF("squashable=0x%llx\n", bc.squashable_groups); DEBUG_PRINTF("groups=0x%llx\n", groups); already_on &= ~bc.squashable_groups; DEBUG_PRINTF("squashed already_on=0x%llx\n", already_on); // We don't *have* to mask off the groups that we know are already on, but // this will make bugs more apparent. groups &= ~already_on; if (!groups) { DEBUG_PRINTF("no new groups to set, skipping\n"); return; } program.add_before_end(make_unique(groups)); } static void makeRoleInfixTriggers(RoseBuildImpl &build, build_context &bc, RoseVertex u, RoseProgram &program) { const auto &g = build.g; vector infix_program; for (const auto &e : out_edges_range(u, g)) { RoseVertex v = target(e, g); if (!g[v].left) { continue; } assert(contains(bc.leftfix_info, v)); const left_build_info &lbi = bc.leftfix_info.at(v); if (lbi.has_lookaround) { continue; } const NFA *nfa = get_nfa_from_blob(bc, lbi.queue); // DFAs have no TOP_N support, so they get a classic MQE_TOP event. u32 top; if (isContainerType(nfa->type)) { auto tamaProto = g[v].left.tamarama.get(); assert(tamaProto); top = MQE_TOP_FIRST + tamaProto->top_remap.at( make_pair(g[v].index, g[e].rose_top)); assert(top < MQE_INVALID); } else if (!isMultiTopType(nfa->type)) { assert(num_tops(g[v].left) == 1); top = MQE_TOP; } else { top = MQE_TOP_FIRST + g[e].rose_top; assert(top < MQE_INVALID); } infix_program.emplace_back(g[e].rose_cancel_prev_top, lbi.queue, top); } if (infix_program.empty()) { return; } // Order, de-dupe and add instructions to the end of program. sort(begin(infix_program), end(infix_program), [](const RoseInstrTriggerInfix &a, const RoseInstrTriggerInfix &b) { return tie(a.cancel, a.queue, a.event) < tie(b.cancel, b.queue, b.event); }); infix_program.erase(unique(begin(infix_program), end(infix_program)), end(infix_program)); for (const auto &ri : infix_program) { program.add_before_end(make_unique(ri)); } } static void makeRoleSetState(const build_context &bc, RoseVertex v, RoseProgram &program) { // We only need this instruction if a state index has been assigned to this // vertex. auto it = bc.roleStateIndices.find(v); if (it == end(bc.roleStateIndices)) { return; } program.add_before_end(make_unique(it->second)); } static void makeRoleCheckBounds(const RoseBuildImpl &build, RoseVertex v, const RoseEdge &e, RoseProgram &program) { const RoseGraph &g = build.g; const RoseVertex u = source(e, g); // We know that we can trust the anchored table (DFA) to always deliver us // literals at the correct offset. if (build.isAnchored(v)) { DEBUG_PRINTF("literal in anchored table, skipping bounds check\n"); return; } // Use the minimum literal length. u32 lit_length = g[v].eod_accept ? 0 : verify_u32(build.minLiteralLen(v)); u64a min_bound = g[e].minBound + lit_length; u64a max_bound = g[e].maxBound == ROSE_BOUND_INF ? ROSE_BOUND_INF : g[e].maxBound + lit_length; if (g[e].history == ROSE_ROLE_HISTORY_ANCH) { assert(g[u].fixedOffset()); // Make offsets absolute. min_bound += g[u].max_offset; if (max_bound != ROSE_BOUND_INF) { max_bound += g[u].max_offset; } } assert(max_bound <= ROSE_BOUND_INF); assert(min_bound <= max_bound); // CHECK_BOUNDS instruction uses 64-bit bounds, so we can use MAX_OFFSET // (max value of a u64a) to represent ROSE_BOUND_INF. if (max_bound == ROSE_BOUND_INF) { max_bound = MAX_OFFSET; } // This instruction should be doing _something_ -- bounds should be tighter // than just {length, inf}. assert(min_bound > lit_length || max_bound < MAX_OFFSET); const auto *end_inst = program.end_instruction(); program.add_before_end( make_unique(min_bound, max_bound, end_inst)); } static void makeRoleCheckNotHandled(build_context &bc, RoseVertex v, RoseProgram &program) { u32 handled_key; if (contains(bc.handledKeys, v)) { handled_key = bc.handledKeys.at(v); } else { handled_key = verify_u32(bc.handledKeys.size()); bc.handledKeys.emplace(v, handled_key); } const auto *end_inst = program.end_instruction(); auto ri = make_unique(handled_key, end_inst); program.add_before_end(move(ri)); } static void makeRoleEagerEodReports(RoseBuildImpl &build, build_context &bc, RoseVertex v, RoseProgram &program) { RoseProgram eod_program; for (const auto &e : out_edges_range(v, build.g)) { if (canEagerlyReportAtEod(build, e)) { RoseProgram block; makeRoleReports(build, bc, target(e, build.g), block); eod_program.add_block(move(block)); } } if (eod_program.empty()) { return; } if (!onlyAtEod(build, v)) { // The rest of our program wasn't EOD anchored, so we need to guard // these reports with a check. const auto *end_inst = eod_program.end_instruction(); eod_program.insert(begin(eod_program), make_unique(end_inst)); } program.add_before_end(move(eod_program)); } static RoseProgram makeProgram(RoseBuildImpl &build, build_context &bc, const RoseEdge &e) { const RoseGraph &g = build.g; auto v = target(e, g); RoseProgram program; // First, add program instructions that enforce preconditions without // effects. makeRoleAnchoredDelay(build, bc, v, program); if (onlyAtEod(build, v)) { DEBUG_PRINTF("only at eod\n"); const auto *end_inst = program.end_instruction(); program.add_before_end(make_unique(end_inst)); } if (g[e].history == ROSE_ROLE_HISTORY_ANCH) { makeRoleCheckBounds(build, v, e, program); } // This program may be triggered by different predecessors, with different // offset bounds. We must ensure we put this check/set operation after the // bounds check to deal with this case. if (in_degree(v, g) > 1) { makeRoleCheckNotHandled(bc, v, program); } makeRoleLookaround(build, bc, v, program); makeRoleCheckLeftfix(build, bc, v, program); // Next, we can add program instructions that have effects. This must be // done as a series of blocks, as some of them (like reports) are // escapable. RoseProgram effects_block; RoseProgram reports_block; makeRoleReports(build, bc, v, reports_block); effects_block.add_block(move(reports_block)); RoseProgram infix_block; makeRoleInfixTriggers(build, bc, v, infix_block); effects_block.add_block(move(infix_block)); // Note: SET_GROUPS instruction must be after infix triggers, as an infix // going dead may switch off groups. RoseProgram groups_block; makeRoleGroups(build, bc, v, groups_block); effects_block.add_block(move(groups_block)); RoseProgram suffix_block; makeRoleSuffix(build, bc, v, suffix_block); effects_block.add_block(move(suffix_block)); RoseProgram state_block; makeRoleSetState(bc, v, state_block); effects_block.add_block(move(state_block)); // Note: EOD eager reports may generate a CHECK_ONLY_EOD instruction (if // the program doesn't have one already). RoseProgram eod_block; makeRoleEagerEodReports(build, bc, v, eod_block); effects_block.add_block(move(eod_block)); program.add_before_end(move(effects_block)); return program; } static u32 writeBoundaryProgram(RoseBuildImpl &build, build_context &bc, const set &reports) { if (reports.empty()) { return 0; } // Note: no CATCHUP instruction is necessary in the boundary case, as we // should always be caught up (and may not even have the resources in // scratch to support it). const bool has_som = false; RoseProgram program; for (const auto &id : reports) { makeReport(build, id, has_som, program); } applyFinalSpecialisation(program); return writeProgram(bc, move(program)); } static RoseBoundaryReports makeBoundaryPrograms(RoseBuildImpl &build, build_context &bc, const BoundaryReports &boundary, const DerivedBoundaryReports &dboundary) { RoseBoundaryReports out; memset(&out, 0, sizeof(out)); DEBUG_PRINTF("report ^: %zu\n", boundary.report_at_0.size()); DEBUG_PRINTF("report $: %zu\n", boundary.report_at_eod.size()); DEBUG_PRINTF("report ^$: %zu\n", dboundary.report_at_0_eod_full.size()); out.reportEodOffset = writeBoundaryProgram(build, bc, boundary.report_at_eod); out.reportZeroOffset = writeBoundaryProgram(build, bc, boundary.report_at_0); out.reportZeroEodOffset = writeBoundaryProgram(build, bc, dboundary.report_at_0_eod_full); return out; } static void assignStateIndices(const RoseBuildImpl &build, build_context &bc) { const auto &g = build.g; u32 state = 0; for (auto v : vertices_range(g)) { // Virtual vertices (starts, EOD accept vertices) never need state // indices. if (build.isVirtualVertex(v)) { continue; } // We only need a state index if we have successors that are not // eagerly-reported EOD vertices. bool needs_state_index = false; for (const auto &e : out_edges_range(v, g)) { if (!canEagerlyReportAtEod(build, e)) { needs_state_index = true; break; } } if (!needs_state_index) { continue; } /* TODO: also don't need a state index if all edges are nfa based */ bc.roleStateIndices.emplace(v, state++); } DEBUG_PRINTF("assigned %u states (from %zu vertices)\n", state, num_vertices(g)); bc.numStates = state; } static bool hasUsefulStops(const left_build_info &build) { for (u32 i = 0; i < N_CHARS; i++) { if (build.stopAlphabet[i]) { return true; } } return false; } static void buildLeftInfoTable(const RoseBuildImpl &tbi, build_context &bc, const set &eager_queues, u32 leftfixBeginQueue, u32 leftfixCount, vector &leftTable, u32 *laggedRoseCount, size_t *history) { const RoseGraph &g = tbi.g; const CompileContext &cc = tbi.cc; ue2::unordered_set done_core; leftTable.resize(leftfixCount); u32 lagIndex = 0; for (RoseVertex v : vertices_range(g)) { if (!g[v].left) { continue; } assert(contains(bc.leftfix_info, v)); const left_build_info &lbi = bc.leftfix_info.at(v); if (lbi.has_lookaround) { continue; } assert(lbi.queue >= leftfixBeginQueue); u32 left_index = lbi.queue - leftfixBeginQueue; assert(left_index < leftfixCount); /* seedy hack to make miracles more effective. * * TODO: make miracle seeking not depend on history length and have * runt scans */ if (hasUsefulStops(lbi)) { ENSURE_AT_LEAST(history, (size_t)MIN(cc.grey.maxHistoryAvailable, g[v].left.lag + 1 + cc.grey.miracleHistoryBonus)); } LeftNfaInfo &left = leftTable[left_index]; if (!contains(done_core, left_index)) { done_core.insert(left_index); memset(&left, 0, sizeof(left)); left.squash_mask = ~0ULL; DEBUG_PRINTF("populating info for %u\n", left_index); left.maxQueueLen = lbi.max_queuelen; if (hasUsefulStops(lbi)) { assert(lbi.stopAlphabet.size() == N_CHARS); left.stopTable = bc.engine_blob.add(lbi.stopAlphabet.begin(), lbi.stopAlphabet.end()); } assert(lbi.countingMiracleOffset || !lbi.countingMiracleCount); left.countingMiracleOffset = lbi.countingMiracleOffset; DEBUG_PRINTF("mw = %u\n", lbi.transient); left.transient = verify_u8(lbi.transient); left.infix = tbi.isNonRootSuccessor(v); left.eager = contains(eager_queues, lbi.queue); // A rose has a lagIndex if it's non-transient and we are // streaming. if (!lbi.transient && cc.streaming) { assert(lagIndex < ROSE_OFFSET_INVALID); left.lagIndex = lagIndex++; } else { left.lagIndex = ROSE_OFFSET_INVALID; } DEBUG_PRINTF("rose %u is %s\n", left_index, left.infix ? "infix" : "prefix"); } // Update squash mask. left.squash_mask &= lbi.squash_mask; // Update the max delay. ENSURE_AT_LEAST(&left.maxLag, lbi.lag); if (contains(g[v].literals, tbi.eod_event_literal_id)) { left.eod_check = 1; } } DEBUG_PRINTF("built %u roses with lag indices\n", lagIndex); *laggedRoseCount = lagIndex; } static void addPredBlockSingle(u32 pred_state, RoseProgram &pred_block, RoseProgram &program) { // Prepend an instruction to check the pred state is on. const auto *end_inst = pred_block.end_instruction(); pred_block.insert(begin(pred_block), make_unique(pred_state, end_inst)); program.add_block(move(pred_block)); } static void addPredBlocksAny(build_context &bc, map &pred_blocks, RoseProgram &program) { RoseProgram sparse_program; vector keys; for (const u32 &key : pred_blocks | map_keys) { keys.push_back(key); } const RoseInstruction *end_inst = sparse_program.end_instruction(); auto ri = make_unique(bc.numStates, keys, end_inst); sparse_program.add_before_end(move(ri)); RoseProgram &block = pred_blocks.begin()->second; sparse_program.add_before_end(move(block)); program.add_block(move(sparse_program)); } static void addPredBlocksMulti(build_context &bc, map &pred_blocks, RoseProgram &program) { assert(!pred_blocks.empty()); RoseProgram sparse_program; const RoseInstruction *end_inst = sparse_program.end_instruction(); vector> jump_table; // BEGIN instruction. auto ri_begin = make_unique(bc.numStates, end_inst); RoseInstrSparseIterBegin *begin_inst = ri_begin.get(); sparse_program.add_before_end(move(ri_begin)); // NEXT instructions, one per pred program. u32 prev_key = pred_blocks.begin()->first; for (auto it = next(begin(pred_blocks)); it != end(pred_blocks); ++it) { auto ri = make_unique(prev_key, begin_inst, end_inst); sparse_program.add_before_end(move(ri)); prev_key = it->first; } // Splice in each pred program after its BEGIN/NEXT. auto out_it = begin(sparse_program); for (auto &m : pred_blocks) { u32 key = m.first; RoseProgram &flat_prog = m.second; assert(!flat_prog.empty()); const size_t block_len = flat_prog.size() - 1; // without INSTR_END. assert(dynamic_cast(out_it->get()) || dynamic_cast(out_it->get())); out_it = sparse_program.insert(++out_it, move(flat_prog)); // Jump table target for this key is the beginning of the block we just // spliced in. jump_table.emplace_back(key, out_it->get()); assert(distance(begin(sparse_program), out_it) + block_len <= sparse_program.size()); advance(out_it, block_len); } // Write the jump table back into the SPARSE_ITER_BEGIN instruction. begin_inst->jump_table = move(jump_table); program.add_block(move(sparse_program)); } static void addPredBlocks(build_context &bc, map &pred_blocks, RoseProgram &program) { // Trim empty blocks, if any exist. for (auto it = pred_blocks.begin(); it != pred_blocks.end();) { if (it->second.empty()) { it = pred_blocks.erase(it); } else { ++it; } } const size_t num_preds = pred_blocks.size(); if (num_preds == 0) { return; } if (num_preds == 1) { const auto head = pred_blocks.begin(); addPredBlockSingle(head->first, head->second, program); return; } // First, see if all our blocks are equivalent, in which case we can // collapse them down into one. const auto &blocks = pred_blocks | map_values; if (all_of(begin(blocks), end(blocks), [&](const RoseProgram &block) { return RoseProgramEquivalence()(*begin(blocks), block); })) { DEBUG_PRINTF("all blocks equiv\n"); addPredBlocksAny(bc, pred_blocks, program); return; } addPredBlocksMulti(bc, pred_blocks, program); } static void makePushDelayedInstructions(const RoseBuildImpl &build, u32 final_id, RoseProgram &program) { const auto &lit_infos = getLiteralInfoByFinalId(build, final_id); const auto &arb_lit_info = **lit_infos.begin(); if (arb_lit_info.delayed_ids.empty()) { return; } for (const auto &int_id : arb_lit_info.delayed_ids) { const auto &child_literal = build.literals.right.at(int_id); u32 child_id = build.literal_info[int_id].final_id; u32 delay_index = child_id - build.delay_base_id; DEBUG_PRINTF("final_id=%u delay=%u child_id=%u\n", final_id, child_literal.delay, child_id); auto ri = make_unique( verify_u8(child_literal.delay), delay_index); program.add_before_end(move(ri)); } } static rose_group getFinalIdGroupsUnion(const RoseBuildImpl &build, u32 final_id) { assert(contains(build.final_id_to_literal, final_id)); const auto &lit_infos = getLiteralInfoByFinalId(build, final_id); rose_group groups = 0; for (const auto &li : lit_infos) { groups |= li->group_mask; } return groups; } static void makeGroupCheckInstruction(const RoseBuildImpl &build, u32 final_id, RoseProgram &program) { rose_group groups = getFinalIdGroupsUnion(build, final_id); if (!groups) { return; } program.add_before_end(make_unique(groups)); } static void makeCheckLitMaskInstruction(const RoseBuildImpl &build, build_context &bc, u32 final_id, RoseProgram &program) { assert(contains(build.final_id_to_literal, final_id)); const auto &lit_infos = getLiteralInfoByFinalId(build, final_id); assert(!lit_infos.empty()); if (!lit_infos.front()->requires_benefits) { return; } vector look; assert(build.final_id_to_literal.at(final_id).size() == 1); u32 lit_id = *build.final_id_to_literal.at(final_id).begin(); const ue2_literal &s = build.literals.right.at(lit_id).s; DEBUG_PRINTF("building mask for lit %u (final id %u) %s\n", lit_id, final_id, dumpString(s).c_str()); assert(s.length() <= MAX_MASK2_WIDTH); s32 i = 0 - s.length(); for (const auto &e : s) { if (!e.nocase) { look.emplace_back(verify_s8(i), e); } i++; } assert(!look.empty()); makeLookaroundInstruction(bc, look, program); } static void makeGroupSquashInstruction(const RoseBuildImpl &build, u32 final_id, RoseProgram &program) { assert(contains(build.final_id_to_literal, final_id)); const auto &lit_infos = getLiteralInfoByFinalId(build, final_id); if (!lit_infos.front()->squash_group) { return; } rose_group groups = getFinalIdGroupsUnion(build, final_id); if (!groups) { return; } DEBUG_PRINTF("final_id %u squashes 0x%llx\n", final_id, groups); program.add_before_end( make_unique(~groups)); // Note negated. } static u32 findMaxOffset(const RoseBuildImpl &build, u32 lit_id) { const auto &lit_vertices = build.literal_info.at(lit_id).vertices; assert(!lit_vertices.empty()); u32 max_offset = 0; for (const auto &v : lit_vertices) { max_offset = max(max_offset, build.g[v].max_offset); } return max_offset; } static void makeRecordAnchoredInstruction(const RoseBuildImpl &build, build_context &bc, u32 final_id, RoseProgram &program) { assert(contains(build.final_id_to_literal, final_id)); const auto &lit_ids = build.final_id_to_literal.at(final_id); // Must be anchored. assert(!lit_ids.empty()); if (build.literals.right.at(*begin(lit_ids)).table != ROSE_ANCHORED) { return; } // If this anchored literal can never match past // floatingMinLiteralMatchOffset, we will never have to record it. u32 max_offset = 0; for (u32 lit_id : lit_ids) { assert(build.literals.right.at(lit_id).table == ROSE_ANCHORED); max_offset = max(max_offset, findMaxOffset(build, lit_id)); } if (max_offset <= bc.floatingMinLiteralMatchOffset) { return; } program.add_before_end(make_unique(final_id)); } static u32 findMinOffset(const RoseBuildImpl &build, u32 lit_id) { const auto &lit_vertices = build.literal_info.at(lit_id).vertices; assert(!lit_vertices.empty()); u32 min_offset = UINT32_MAX; for (const auto &v : lit_vertices) { min_offset = min(min_offset, build.g[v].min_offset); } return min_offset; } static void makeCheckLitEarlyInstruction(const RoseBuildImpl &build, build_context &bc, u32 final_id, const vector &lit_edges, RoseProgram &program) { if (lit_edges.empty()) { return; } if (bc.floatingMinLiteralMatchOffset == 0) { return; } RoseVertex v = target(lit_edges.front(), build.g); if (!build.isFloating(v)) { return; } const auto &lit_ids = build.final_id_to_literal.at(final_id); if (lit_ids.empty()) { return; } size_t min_len = SIZE_MAX; u32 min_offset = UINT32_MAX; for (u32 lit_id : lit_ids) { const auto &lit = build.literals.right.at(lit_id); size_t lit_min_len = lit.elength(); u32 lit_min_offset = findMinOffset(build, lit_id); DEBUG_PRINTF("lit_id=%u has min_len=%zu, min_offset=%u\n", lit_id, lit_min_len, lit_min_offset); min_len = min(min_len, lit_min_len); min_offset = min(min_offset, lit_min_offset); } DEBUG_PRINTF("final_id=%u has min_len=%zu, min_offset=%u, " "global min is %u\n", final_id, min_len, min_offset, bc.floatingMinLiteralMatchOffset); // If we can't match before the min offset, we don't need the check. if (min_len >= bc.floatingMinLiteralMatchOffset) { DEBUG_PRINTF("no need for check, min is %u\n", bc.floatingMinLiteralMatchOffset); return; } assert(min_offset >= bc.floatingMinLiteralMatchOffset); assert(min_offset < UINT32_MAX); DEBUG_PRINTF("adding lit early check, min_offset=%u\n", min_offset); program.add_before_end(make_unique(min_offset)); } static void makeCheckLiteralInstruction(const RoseBuildImpl &build, const build_context &bc, u32 final_id, RoseProgram &program) { const auto &lits = build.final_id_to_literal.at(final_id); if (lits.size() != 1) { // Long literals should not share a final_id. assert(all_of(begin(lits), end(lits), [&](u32 lit_id) { const rose_literal_id &lit = build.literals.right.at(lit_id); return lit.table != ROSE_FLOATING || lit.s.length() <= bc.longLitLengthThreshold; })); return; } u32 lit_id = *lits.begin(); if (build.isDelayed(lit_id)) { return; } const rose_literal_id &lit = build.literals.right.at(lit_id); if (lit.table != ROSE_FLOATING) { return; } assert(bc.longLitLengthThreshold > 0); if (lit.s.length() <= bc.longLitLengthThreshold) { return; } // Check resource limits as well. if (lit.s.length() > build.cc.grey.limitLiteralLength) { throw ResourceLimitError(); } unique_ptr ri; if (lit.s.any_nocase()) { ri = make_unique(lit.s.get_string()); } else { ri = make_unique(lit.s.get_string()); } program.add_before_end(move(ri)); } static bool hasDelayedLiteral(RoseBuildImpl &build, const vector &lit_edges) { auto is_delayed = bind(&RoseBuildImpl::isDelayed, &build, _1); for (const auto &e : lit_edges) { auto v = target(e, build.g); const auto &lits = build.g[v].literals; if (any_of(begin(lits), end(lits), is_delayed)) { return true; } } return false; } static RoseProgram buildLitInitialProgram(RoseBuildImpl &build, build_context &bc, u32 final_id, const vector &lit_edges) { RoseProgram program; // No initial program for EOD. if (final_id == MO_INVALID_IDX) { return program; } DEBUG_PRINTF("final_id %u\n", final_id); // Check long literal info. makeCheckLiteralInstruction(build, bc, final_id, program); // Check lit mask. makeCheckLitMaskInstruction(build, bc, final_id, program); // Check literal groups. This is an optimisation that we only perform for // delayed literals, as their groups may be switched off; ordinarily, we // can trust the HWLM matcher. if (hasDelayedLiteral(build, lit_edges)) { makeGroupCheckInstruction(build, final_id, program); } // Add instructions for pushing delayed matches, if there are any. makePushDelayedInstructions(build, final_id, program); // Add pre-check for early literals in the floating table. makeCheckLitEarlyInstruction(build, bc, final_id, lit_edges, program); return program; } static RoseProgram buildLiteralProgram(RoseBuildImpl &build, build_context &bc, u32 final_id, const vector &lit_edges) { const auto &g = build.g; DEBUG_PRINTF("final id %u, %zu lit edges\n", final_id, lit_edges.size()); RoseProgram program; // Predecessor state id -> program block. map pred_blocks; // Construct sparse iter sub-programs. for (const auto &e : lit_edges) { const auto &u = source(e, g); if (build.isAnyStart(u)) { continue; // Root roles are not handled with sparse iterator. } DEBUG_PRINTF("sparse iter edge (%zu,%zu)\n", g[u].index, g[target(e, g)].index); assert(contains(bc.roleStateIndices, u)); u32 pred_state = bc.roleStateIndices.at(u); pred_blocks[pred_state].add_block(makeProgram(build, bc, e)); } // Add blocks to deal with non-root edges (triggered by sparse iterator or // mmbit_isset checks). addPredBlocks(bc, pred_blocks, program); // Add blocks to handle root roles. for (const auto &e : lit_edges) { const auto &u = source(e, g); if (!build.isAnyStart(u)) { continue; } DEBUG_PRINTF("root edge (%zu,%zu)\n", g[u].index, g[target(e, g)].index); program.add_block(makeProgram(build, bc, e)); } if (final_id != MO_INVALID_IDX) { RoseProgram root_block; // Literal may squash groups. makeGroupSquashInstruction(build, final_id, root_block); // Literal may be anchored and need to be recorded. makeRecordAnchoredInstruction(build, bc, final_id, root_block); program.add_block(move(root_block)); } // Construct initial program up front, as its early checks must be able to // jump to end and terminate processing for this literal. auto lit_program = buildLitInitialProgram(build, bc, final_id, lit_edges); lit_program.add_before_end(move(program)); return lit_program; } static u32 writeLiteralProgram(RoseBuildImpl &build, build_context &bc, u32 final_id, const vector &lit_edges) { RoseProgram program = buildLiteralProgram(build, bc, final_id, lit_edges); if (program.empty()) { return 0; } applyFinalSpecialisation(program); return writeProgram(bc, move(program)); } static u32 buildDelayRebuildProgram(RoseBuildImpl &build, build_context &bc, u32 final_id) { const auto &lit_infos = getLiteralInfoByFinalId(build, final_id); const auto &arb_lit_info = **lit_infos.begin(); if (arb_lit_info.delayed_ids.empty()) { return 0; // No delayed IDs, no work to do. } RoseProgram program; makeCheckLitMaskInstruction(build, bc, final_id, program); makePushDelayedInstructions(build, final_id, program); assert(!program.empty()); applyFinalSpecialisation(program); return writeProgram(bc, move(program)); } static map> findEdgesByLiteral(const RoseBuildImpl &build) { // Use a set of edges while building the map to cull duplicates. map> unique_lit_edge_map; const auto &g = build.g; for (const auto &e : edges_range(g)) { const auto &v = target(e, g); for (const auto &lit_id : g[v].literals) { assert(lit_id < build.literal_info.size()); u32 final_id = build.literal_info.at(lit_id).final_id; if (final_id == MO_INVALID_IDX) { // Unused, special report IDs are handled elsewhere. continue; } unique_lit_edge_map[final_id].insert(e); } } // Build output map, sorting edges by (source, target) vertex index. map> lit_edge_map; for (const auto &m : unique_lit_edge_map) { auto edge_list = vector(begin(m.second), end(m.second)); sort(begin(edge_list), end(edge_list), [&g](const RoseEdge &a, const RoseEdge &b) { return tie(g[source(a, g)].index, g[target(a, g)].index) < tie(g[source(b, g)].index, g[target(b, g)].index); }); lit_edge_map.emplace(m.first, edge_list); } return lit_edge_map; } /** * \brief Build the interpreter programs for each literal. * * Returns the base of the literal program list and the base of the delay * rebuild program list. */ static pair buildLiteralPrograms(RoseBuildImpl &build, build_context &bc) { const u32 num_literals = build.final_id_to_literal.size(); auto lit_edge_map = findEdgesByLiteral(build); bc.litPrograms.resize(num_literals); vector delayRebuildPrograms(num_literals); for (u32 finalId = 0; finalId != num_literals; ++finalId) { const auto &lit_edges = lit_edge_map[finalId]; bc.litPrograms[finalId] = writeLiteralProgram(build, bc, finalId, lit_edges); delayRebuildPrograms[finalId] = buildDelayRebuildProgram(build, bc, finalId); } u32 litProgramsOffset = bc.engine_blob.add(begin(bc.litPrograms), end(bc.litPrograms)); u32 delayRebuildProgramsOffset = bc.engine_blob.add( begin(delayRebuildPrograms), end(delayRebuildPrograms)); return {litProgramsOffset, delayRebuildProgramsOffset}; } /** * \brief Returns all reports used by output-exposed engines, for which we need * to generate programs. */ static set findEngineReports(const RoseBuildImpl &build) { set reports; // The small write engine uses these engine report programs. insert(&reports, build.smwr.all_reports()); for (const auto &outfix : build.outfixes) { insert(&reports, all_reports(outfix)); } const auto &g = build.g; for (auto v : vertices_range(g)) { if (g[v].suffix) { insert(&reports, all_reports(g[v].suffix)); } } DEBUG_PRINTF("%zu engine reports (of %zu)\n", reports.size(), build.rm.numReports()); return reports; } static pair buildReportPrograms(RoseBuildImpl &build, build_context &bc) { const auto reports = findEngineReports(build); vector programs; programs.reserve(reports.size()); for (ReportID id : reports) { RoseProgram program; const bool has_som = false; makeCatchupMpv(build, bc, id, program); makeReport(build, id, has_som, program); applyFinalSpecialisation(program); u32 offset = writeProgram(bc, move(program)); programs.push_back(offset); build.rm.setProgramOffset(id, offset); DEBUG_PRINTF("program for report %u @ %u (%zu instructions)\n", id, programs.back(), program.size()); } u32 offset = bc.engine_blob.add(begin(programs), end(programs)); u32 count = verify_u32(programs.size()); return {offset, count}; } static RoseProgram makeEodAnchorProgram(RoseBuildImpl &build, build_context &bc, const RoseEdge &e, const bool multiple_preds) { const RoseGraph &g = build.g; const RoseVertex v = target(e, g); RoseProgram program; if (g[e].history == ROSE_ROLE_HISTORY_ANCH) { makeRoleCheckBounds(build, v, e, program); } if (multiple_preds) { // Only necessary when there is more than one pred. makeRoleCheckNotHandled(bc, v, program); } const auto &reports = g[v].reports; makeCatchup(build, bc, reports, program); const bool has_som = false; RoseProgram report_block; for (const auto &id : reports) { makeReport(build, id, has_som, report_block); } program.add_before_end(move(report_block)); return program; } static bool hasEodAnchoredSuffix(const RoseBuildImpl &build) { const RoseGraph &g = build.g; for (auto v : vertices_range(g)) { if (g[v].suffix && build.isInETable(v)) { DEBUG_PRINTF("vertex %zu is in eod table and has a suffix\n", g[v].index); return true; } } return false; } static bool hasEodMatcher(const RoseBuildImpl &build) { const RoseGraph &g = build.g; for (auto v : vertices_range(g)) { if (build.isInETable(v)) { DEBUG_PRINTF("vertex %zu is in eod table\n", g[v].index); return true; } } return false; } static void addEodAnchorProgram(RoseBuildImpl &build, build_context &bc, bool in_etable, RoseProgram &program) { const RoseGraph &g = build.g; // Predecessor state id -> program block. map pred_blocks; for (auto v : vertices_range(g)) { if (!g[v].eod_accept) { continue; } DEBUG_PRINTF("vertex %zu (with %zu preds) fires on EOD\n", g[v].index, in_degree(v, g)); vector edge_list; for (const auto &e : in_edges_range(v, g)) { RoseVertex u = source(e, g); if (build.isInETable(u) != in_etable) { DEBUG_PRINTF("pred %zu %s in etable\n", g[u].index, in_etable ? "is not" : "is"); continue; } if (canEagerlyReportAtEod(build, e)) { DEBUG_PRINTF("already done report for vertex %zu\n", g[u].index); continue; } edge_list.push_back(e); } const bool multiple_preds = edge_list.size() > 1; for (const auto &e : edge_list) { RoseVertex u = source(e, g); assert(contains(bc.roleStateIndices, u)); u32 pred_state = bc.roleStateIndices.at(u); pred_blocks[pred_state].add_block( makeEodAnchorProgram(build, bc, e, multiple_preds)); } } addPredBlocks(bc, pred_blocks, program); } static void addEodEventProgram(RoseBuildImpl &build, build_context &bc, RoseProgram &program) { if (build.eod_event_literal_id == MO_INVALID_IDX) { return; } const RoseGraph &g = build.g; const auto &lit_info = build.literal_info.at(build.eod_event_literal_id); assert(lit_info.delayed_ids.empty()); assert(!lit_info.squash_group); assert(!lit_info.requires_benefits); // Collect all edges leading into EOD event literal vertices. vector edge_list; for (const auto &v : lit_info.vertices) { for (const auto &e : in_edges_range(v, g)) { edge_list.push_back(e); } } // Sort edge list for determinism, prettiness. sort(begin(edge_list), end(edge_list), [&g](const RoseEdge &a, const RoseEdge &b) { return tie(g[source(a, g)].index, g[target(a, g)].index) < tie(g[source(b, g)].index, g[target(b, g)].index); }); program.add_block( buildLiteralProgram(build, bc, MO_INVALID_IDX, edge_list)); } static void addEnginesEodProgram(u32 eodNfaIterOffset, RoseProgram &program) { if (!eodNfaIterOffset) { return; } RoseProgram block; block.add_before_end(make_unique(eodNfaIterOffset)); program.add_block(move(block)); } static void addSuffixesEodProgram(const RoseBuildImpl &build, RoseProgram &program) { if (!hasEodAnchoredSuffix(build)) { return; } RoseProgram block; block.add_before_end(make_unique()); program.add_block(move(block)); } static void addMatcherEodProgram(const RoseBuildImpl &build, RoseProgram &program) { if (!hasEodMatcher(build)) { return; } RoseProgram block; block.add_before_end(make_unique()); program.add_block(move(block)); } static u32 writeEodProgram(RoseBuildImpl &build, build_context &bc, u32 eodNfaIterOffset) { RoseProgram program; addEodEventProgram(build, bc, program); addEnginesEodProgram(eodNfaIterOffset, program); addEodAnchorProgram(build, bc, false, program); addMatcherEodProgram(build, program); addEodAnchorProgram(build, bc, true, program); addSuffixesEodProgram(build, program); if (program.empty()) { return 0; } applyFinalSpecialisation(program); return writeProgram(bc, move(program)); } static u32 history_required(const rose_literal_id &key) { if (key.msk.size() < key.s.length()) { return key.elength() - 1; } else { return key.msk.size() + key.delay - 1; } } static void fillMatcherDistances(const RoseBuildImpl &build, RoseEngine *engine) { const RoseGraph &g = build.g; engine->floatingDistance = 0; engine->floatingMinDistance = ROSE_BOUND_INF; engine->anchoredDistance = 0; engine->maxFloatingDelayedMatch = 0; u32 delayRebuildLength = 0; engine->smallBlockDistance = 0; for (auto v : vertices_range(g)) { if (g[v].literals.empty()) { continue; } assert(g[v].min_offset < ROSE_BOUND_INF); // cannot == ROSE_BOUND_INF assert(g[v].min_offset <= g[v].max_offset); for (u32 lit_id : g[v].literals) { const rose_literal_id &key = build.literals.right.at(lit_id); u32 max_d = g[v].max_offset; u32 min_d = g[v].min_offset; DEBUG_PRINTF("checking %u: elen %zu min/max %u/%u\n", lit_id, key.elength_including_mask(), min_d, max_d); if (build.literal_info[lit_id].undelayed_id != lit_id) { /* this is a delayed match; need to update delay properties */ /* TODO: can delayed literals ever be in another table ? */ if (key.table == ROSE_FLOATING) { ENSURE_AT_LEAST(&engine->maxFloatingDelayedMatch, max_d); ENSURE_AT_LEAST(&delayRebuildLength, history_required(key)); } } /* for the FloatingDistances we need the true max depth of the string */ if (max_d != ROSE_BOUND_INF && key.table != ROSE_ANCHORED) { assert(max_d >= key.delay); max_d -= key.delay; } switch (key.table) { case ROSE_FLOATING: ENSURE_AT_LEAST(&engine->floatingDistance, max_d); if (min_d >= key.elength_including_mask()) { LIMIT_TO_AT_MOST(&engine->floatingMinDistance, min_d - (u32)key.elength_including_mask()); } else { /* overlapped literals from rose + anchored table can * cause us to underflow due to sloppiness in * estimates */ engine->floatingMinDistance = 0; } break; case ROSE_ANCHORED_SMALL_BLOCK: ENSURE_AT_LEAST(&engine->smallBlockDistance, max_d); break; case ROSE_ANCHORED: ENSURE_AT_LEAST(&engine->anchoredDistance, max_d); break; case ROSE_EOD_ANCHORED: // EOD anchored literals are in another table, so they // don't contribute to these calculations. break; case ROSE_EVENT: break; // Not a real literal. } } } // Floating literals go in the small block table too. ENSURE_AT_LEAST(&engine->smallBlockDistance, engine->floatingDistance); // Clipped by its very nature. LIMIT_TO_AT_MOST(&engine->smallBlockDistance, 32U); engine->delayRebuildLength = delayRebuildLength; DEBUG_PRINTF("anchoredDistance = %u\n", engine->anchoredDistance); DEBUG_PRINTF("floatingDistance = %u\n", engine->floatingDistance); DEBUG_PRINTF("smallBlockDistance = %u\n", engine->smallBlockDistance); assert(engine->anchoredDistance <= build.cc.grey.maxAnchoredRegion); /* anchored->floating squash literals may lower floating min distance */ /* TODO: find actual value */ if (!engine->anchoredDistance) { return; } } static u32 buildEagerQueueIter(const set &eager, u32 leftfixBeginQueue, u32 queue_count, build_context &bc) { if (eager.empty()) { return 0; } vector vec; for (u32 q : eager) { assert(q >= leftfixBeginQueue); vec.push_back(q - leftfixBeginQueue); } vector iter; mmbBuildSparseIterator(iter, vec, queue_count - leftfixBeginQueue); return bc.engine_blob.add_iterator(iter); } static void allocateFinalIdToSet(RoseBuildImpl &build, const set &lits, size_t longLitLengthThreshold, u32 *next_final_id) { const auto &g = build.g; auto &literal_info = build.literal_info; auto &final_id_to_literal = build.final_id_to_literal; /* We can allocate the same final id to multiple literals of the same type * if they share the same vertex set and trigger the same delayed literal * ids and squash the same roles and have the same group squashing * behaviour. Benefits literals cannot be merged. */ assert(longLitLengthThreshold > 0); for (u32 int_id : lits) { rose_literal_info &curr_info = literal_info[int_id]; const rose_literal_id &lit = build.literals.right.at(int_id); const auto &verts = curr_info.vertices; // Literals with benefits cannot be merged. if (curr_info.requires_benefits) { DEBUG_PRINTF("id %u has benefits\n", int_id); goto assign_new_id; } // Long literals (that require CHECK_LITERAL instructions) cannot be // merged. if (lit.s.length() > longLitLengthThreshold) { DEBUG_PRINTF("id %u is a long literal\n", int_id); goto assign_new_id; } if (!verts.empty() && curr_info.delayed_ids.empty()) { vector cand; insert(&cand, cand.end(), g[*verts.begin()].literals); for (auto v : verts) { vector temp; set_intersection(cand.begin(), cand.end(), g[v].literals.begin(), g[v].literals.end(), inserter(temp, temp.end())); cand.swap(temp); } for (u32 cand_id : cand) { if (cand_id >= int_id) { break; } const auto &cand_info = literal_info[cand_id]; const auto &cand_lit = build.literals.right.at(cand_id); if (cand_lit.s.length() > longLitLengthThreshold) { continue; } if (cand_info.requires_benefits) { continue; } if (!cand_info.delayed_ids.empty()) { /* TODO: allow cases where delayed ids are equivalent. * This is awkward currently as the have not had their * final ids allocated yet */ continue; } if (lits.find(cand_id) == lits.end() || cand_info.vertices.size() != verts.size() || cand_info.squash_group != curr_info.squash_group) { continue; } /* if we are squashing groups we need to check if they are the * same group */ if (cand_info.squash_group && cand_info.group_mask != curr_info.group_mask) { continue; } u32 final_id = cand_info.final_id; assert(final_id != MO_INVALID_IDX); assert(curr_info.final_id == MO_INVALID_IDX); curr_info.final_id = final_id; final_id_to_literal[final_id].insert(int_id); goto next_lit; } } assign_new_id: /* oh well, have to give it a fresh one, hang the expense */ DEBUG_PRINTF("allocating final id %u to %u\n", *next_final_id, int_id); assert(curr_info.final_id == MO_INVALID_IDX); curr_info.final_id = *next_final_id; final_id_to_literal[*next_final_id].insert(int_id); (*next_final_id)++; next_lit:; } } static bool isUsedLiteral(const RoseBuildImpl &build, u32 lit_id) { assert(lit_id < build.literal_info.size()); const auto &info = build.literal_info[lit_id]; if (!info.vertices.empty()) { return true; } for (const u32 &delayed_id : info.delayed_ids) { assert(delayed_id < build.literal_info.size()); const rose_literal_info &delayed_info = build.literal_info[delayed_id]; if (!delayed_info.vertices.empty()) { return true; } } DEBUG_PRINTF("literal %u has no refs\n", lit_id); return false; } /** \brief Allocate final literal IDs for all literals. */ static void allocateFinalLiteralId(RoseBuildImpl &build, size_t longLitLengthThreshold) { set anch; set norm; set delay; /* undelayed ids come first */ assert(build.final_id_to_literal.empty()); u32 next_final_id = 0; for (u32 i = 0; i < build.literal_info.size(); i++) { assert(!build.hasFinalId(i)); if (!isUsedLiteral(build, i)) { /* what is this literal good for? absolutely nothing */ continue; } // The special EOD event literal has its own program and does not need // a real literal ID. if (i == build.eod_event_literal_id) { assert(build.eod_event_literal_id != MO_INVALID_IDX); continue; } if (build.isDelayed(i)) { assert(!build.literal_info[i].requires_benefits); delay.insert(i); } else if (build.literals.right.at(i).table == ROSE_ANCHORED) { anch.insert(i); } else { norm.insert(i); } } /* normal lits */ allocateFinalIdToSet(build, norm, longLitLengthThreshold, &next_final_id); /* next anchored stuff */ build.anchored_base_id = next_final_id; allocateFinalIdToSet(build, anch, longLitLengthThreshold, &next_final_id); /* delayed ids come last */ build.delay_base_id = next_final_id; allocateFinalIdToSet(build, delay, longLitLengthThreshold, &next_final_id); } static aligned_unique_ptr addSmallWriteEngine(RoseBuildImpl &build, aligned_unique_ptr rose) { assert(rose); if (roseIsPureLiteral(rose.get())) { DEBUG_PRINTF("pure literal case, not adding smwr\n"); return rose; } u32 qual = roseQuality(rose.get()); auto smwr_engine = build.smwr.build(qual); if (!smwr_engine) { DEBUG_PRINTF("no smwr built\n"); return rose; } const size_t mainSize = roseSize(rose.get()); const size_t smallWriteSize = smwrSize(smwr_engine.get()); DEBUG_PRINTF("adding smwr engine, size=%zu\n", smallWriteSize); const size_t smwrOffset = ROUNDUP_CL(mainSize); const size_t newSize = smwrOffset + smallWriteSize; auto rose2 = aligned_zmalloc_unique(newSize); char *ptr = (char *)rose2.get(); memcpy(ptr, rose.get(), mainSize); memcpy(ptr + smwrOffset, smwr_engine.get(), smallWriteSize); rose2->smallWriteOffset = verify_u32(smwrOffset); rose2->size = verify_u32(newSize); return rose2; } /** * \brief Returns the pair (number of literals, max length) for all real * literals in the floating table that are in-use. */ static pair floatingCountAndMaxLen(const RoseBuildImpl &build) { size_t num = 0; size_t max_len = 0; for (const auto &e : build.literals.right) { const u32 id = e.first; const rose_literal_id &lit = e.second; if (lit.table != ROSE_FLOATING) { continue; } if (lit.delay) { // Skip delayed literals, so that we only count the undelayed // version that ends up in the HWLM table. continue; } if (!isUsedLiteral(build, id)) { continue; } num++; max_len = max(max_len, lit.s.length()); } DEBUG_PRINTF("%zu floating literals with max_len=%zu\n", num, max_len); return {num, max_len}; } size_t calcLongLitThreshold(const RoseBuildImpl &build, const size_t historyRequired) { const auto &cc = build.cc; // In block mode, we should only use the long literal support for literals // that cannot be handled by HWLM. if (!cc.streaming) { return HWLM_LITERAL_MAX_LEN; } size_t longLitLengthThreshold = ROSE_LONG_LITERAL_THRESHOLD_MIN; // Expand to size of history we've already allocated. Note that we need N-1 // bytes of history to match a literal of length N. longLitLengthThreshold = max(longLitLengthThreshold, historyRequired + 1); // If we only have one literal, allow for a larger value in order to avoid // building a long literal table for a trivial Noodle case that we could // fit in history. const auto num_len = floatingCountAndMaxLen(build); if (num_len.first == 1) { if (num_len.second > longLitLengthThreshold) { DEBUG_PRINTF("expanding for single literal of length %zu\n", num_len.second); longLitLengthThreshold = num_len.second; } } // Clamp to max history available. longLitLengthThreshold = min(longLitLengthThreshold, size_t{cc.grey.maxHistoryAvailable} + 1); return longLitLengthThreshold; } aligned_unique_ptr RoseBuildImpl::buildFinalEngine(u32 minWidth) { DerivedBoundaryReports dboundary(boundary); size_t historyRequired = calcHistoryRequired(); // Updated by HWLM. size_t longLitLengthThreshold = calcLongLitThreshold(*this, historyRequired); DEBUG_PRINTF("longLitLengthThreshold=%zu\n", longLitLengthThreshold); allocateFinalLiteralId(*this, longLitLengthThreshold); auto anchored_dfas = buildAnchoredDfas(*this); build_context bc; bc.floatingMinLiteralMatchOffset = findMinFloatingLiteralMatch(*this, anchored_dfas); bc.longLitLengthThreshold = longLitLengthThreshold; bc.needs_catchup = needsCatchup(*this, anchored_dfas); recordResources(bc.resources, *this); if (!anchored_dfas.empty()) { bc.resources.has_anchored = true; } bc.needs_mpv_catchup = needsMpvCatchup(*this); bc.vertex_group_map = getVertexGroupMap(*this); bc.squashable_groups = getSquashableGroups(*this); auto boundary_out = makeBoundaryPrograms(*this, bc, boundary, dboundary); u32 reportProgramOffset; u32 reportProgramCount; tie(reportProgramOffset, reportProgramCount) = buildReportPrograms(*this, bc); // Build NFAs set no_retrigger_queues; bool mpv_as_outfix; prepMpv(*this, bc, &historyRequired, &mpv_as_outfix); u32 outfixBeginQueue = qif.allocated_count(); if (!prepOutfixes(*this, bc, &historyRequired)) { return nullptr; } u32 outfixEndQueue = qif.allocated_count(); u32 leftfixBeginQueue = outfixEndQueue; set eager_queues; /* Note: buildNfas may reduce the lag for vertices that have prefixes */ if (!buildNfas(*this, bc, qif, &no_retrigger_queues, &eager_queues, &leftfixBeginQueue)) { return nullptr; } u32 eodNfaIterOffset = buildEodNfaIterator(bc, leftfixBeginQueue); buildCountingMiracles(bc); u32 queue_count = qif.allocated_count(); /* excludes anchored matcher q; * som rev nfas */ if (queue_count > cc.grey.limitRoseEngineCount) { throw ResourceLimitError(); } vector suffixEkeyLists; buildSuffixEkeyLists(*this, bc, qif, &suffixEkeyLists); assignStateIndices(*this, bc); u32 laggedRoseCount = 0; vector leftInfoTable; buildLeftInfoTable(*this, bc, eager_queues, leftfixBeginQueue, queue_count - leftfixBeginQueue, leftInfoTable, &laggedRoseCount, &historyRequired); u32 litProgramOffset; u32 litDelayRebuildProgramOffset; tie(litProgramOffset, litDelayRebuildProgramOffset) = buildLiteralPrograms(*this, bc); u32 eodProgramOffset = writeEodProgram(*this, bc, eodNfaIterOffset); size_t longLitStreamStateRequired = 0; u32 longLitTableOffset = buildLongLiteralTable(*this, bc.engine_blob, bc.longLiterals, longLitLengthThreshold, &historyRequired, &longLitStreamStateRequired); vector activeLeftIter; buildActiveLeftIter(leftInfoTable, activeLeftIter); u32 lastByteOffset = buildLastByteIter(g, bc); u32 eagerIterOffset = buildEagerQueueIter(eager_queues, leftfixBeginQueue, queue_count, bc); // Enforce role table resource limit. if (num_vertices(g) > cc.grey.limitRoseRoleCount) { throw ResourceLimitError(); } u32 currOffset; /* relative to base of RoseEngine */ if (!bc.engine_blob.empty()) { currOffset = bc.engine_blob.base_offset + bc.engine_blob.size(); } else { currOffset = sizeof(RoseEngine); } UNUSED const size_t engineBlobSize = bc.engine_blob.size(); // test later currOffset = ROUNDUP_CL(currOffset); DEBUG_PRINTF("currOffset %u\n", currOffset); // Build anchored matcher. size_t asize = 0; u32 amatcherOffset = 0; auto atable = buildAnchoredMatcher(*this, anchored_dfas, bc.litPrograms, &asize); if (atable) { currOffset = ROUNDUP_CL(currOffset); amatcherOffset = currOffset; currOffset += verify_u32(asize); } // Build floating HWLM matcher. rose_group fgroups = 0; size_t fsize = 0; auto ftable = buildFloatingMatcher(*this, bc.longLitLengthThreshold, &fgroups, &fsize, &historyRequired); u32 fmatcherOffset = 0; if (ftable) { currOffset = ROUNDUP_CL(currOffset); fmatcherOffset = currOffset; currOffset += verify_u32(fsize); } // Build EOD-anchored HWLM matcher. size_t esize = 0; auto etable = buildEodAnchoredMatcher(*this, &esize); u32 ematcherOffset = 0; if (etable) { currOffset = ROUNDUP_CL(currOffset); ematcherOffset = currOffset; currOffset += verify_u32(esize); } // Build small-block HWLM matcher. size_t sbsize = 0; auto sbtable = buildSmallBlockMatcher(*this, &sbsize); u32 sbmatcherOffset = 0; if (sbtable) { currOffset = ROUNDUP_CL(currOffset); sbmatcherOffset = currOffset; currOffset += verify_u32(sbsize); } u32 leftOffset = ROUNDUP_N(currOffset, alignof(LeftNfaInfo)); u32 roseLen = sizeof(LeftNfaInfo) * leftInfoTable.size(); currOffset = leftOffset + roseLen; u32 lookaroundReachOffset = currOffset; u32 lookaroundReachLen = REACH_BITVECTOR_LEN * bc.lookaround.size(); currOffset = lookaroundReachOffset + lookaroundReachLen; u32 lookaroundTableOffset = currOffset; u32 lookaroundTableLen = sizeof(s8) * bc.lookaround.size(); currOffset = lookaroundTableOffset + lookaroundTableLen; u32 nfaInfoOffset = ROUNDUP_N(currOffset, sizeof(u32)); u32 nfaInfoLen = sizeof(NfaInfo) * queue_count; currOffset = nfaInfoOffset + nfaInfoLen; currOffset = ROUNDUP_N(currOffset, alignof(mmbit_sparse_iter)); u32 activeLeftIterOffset = currOffset; currOffset += activeLeftIter.size() * sizeof(mmbit_sparse_iter); u32 activeArrayCount = leftfixBeginQueue; u32 activeLeftCount = leftInfoTable.size(); u32 rosePrefixCount = countRosePrefixes(leftInfoTable); u32 rev_nfa_table_offset; vector rev_nfa_offsets; prepSomRevNfas(ssm, &rev_nfa_table_offset, &rev_nfa_offsets, &currOffset); // Build engine header and copy tables into place. u32 anchorStateSize = atable ? anchoredStateSize(*atable) : 0; DEBUG_PRINTF("rose history required %zu\n", historyRequired); assert(!cc.streaming || historyRequired <= cc.grey.maxHistoryAvailable); // Some SOM schemes (reverse NFAs, for example) may require more history. historyRequired = max(historyRequired, (size_t)ssm.somHistoryRequired()); assert(!cc.streaming || historyRequired <= max(cc.grey.maxHistoryAvailable, cc.grey.somMaxRevNfaLength)); RoseStateOffsets stateOffsets; memset(&stateOffsets, 0, sizeof(stateOffsets)); fillStateOffsets(*this, bc.numStates, anchorStateSize, activeArrayCount, activeLeftCount, laggedRoseCount, longLitStreamStateRequired, historyRequired, &stateOffsets); scatter_plan_raw state_scatter; buildStateScatterPlan(sizeof(u8), bc.numStates, activeLeftCount, rosePrefixCount, stateOffsets, cc.streaming, activeArrayCount, outfixBeginQueue, outfixEndQueue, &state_scatter); currOffset = ROUNDUP_N(currOffset, alignof(scatter_unit_u64a)); u32 state_scatter_aux_offset = currOffset; currOffset += aux_size(state_scatter); currOffset = ROUNDUP_N(currOffset, alignof(ReportID)); u32 dkeyOffset = currOffset; currOffset += rm.numDkeys() * sizeof(ReportID); aligned_unique_ptr engine = aligned_zmalloc_unique(currOffset); assert(engine); // will have thrown bad_alloc otherwise. char *ptr = (char *)engine.get(); assert(ISALIGNED_CL(ptr)); if (atable) { assert(amatcherOffset); memcpy(ptr + amatcherOffset, atable.get(), asize); } if (ftable) { assert(fmatcherOffset); memcpy(ptr + fmatcherOffset, ftable.get(), fsize); } if (etable) { assert(ematcherOffset); memcpy(ptr + ematcherOffset, etable.get(), esize); } if (sbtable) { assert(sbmatcherOffset); memcpy(ptr + sbmatcherOffset, sbtable.get(), sbsize); } memcpy(&engine->stateOffsets, &stateOffsets, sizeof(stateOffsets)); engine->historyRequired = verify_u32(historyRequired); engine->ekeyCount = rm.numEkeys(); engine->dkeyCount = rm.numDkeys(); engine->dkeyLogSize = fatbit_size(engine->dkeyCount); engine->invDkeyOffset = dkeyOffset; copy_bytes(ptr + dkeyOffset, rm.getDkeyToReportTable()); engine->somHorizon = ssm.somPrecision(); engine->somLocationCount = ssm.numSomSlots(); engine->somLocationFatbitSize = fatbit_size(engine->somLocationCount); engine->needsCatchup = bc.needs_catchup ? 1 : 0; engine->literalCount = verify_u32(final_id_to_literal.size()); engine->litProgramOffset = litProgramOffset; engine->litDelayRebuildProgramOffset = litDelayRebuildProgramOffset; engine->reportProgramOffset = reportProgramOffset; engine->reportProgramCount = reportProgramCount; engine->runtimeImpl = pickRuntimeImpl(*this, bc, outfixEndQueue); engine->mpvTriggeredByLeaf = anyEndfixMpvTriggers(*this); engine->activeArrayCount = activeArrayCount; engine->activeLeftCount = activeLeftCount; engine->queueCount = queue_count; engine->activeQueueArraySize = fatbit_size(queue_count); engine->eagerIterOffset = eagerIterOffset; engine->handledKeyCount = bc.handledKeys.size(); engine->handledKeyFatbitSize = fatbit_size(engine->handledKeyCount); engine->rolesWithStateCount = bc.numStates; engine->leftOffset = leftOffset; engine->roseCount = verify_u32(leftInfoTable.size()); engine->lookaroundTableOffset = lookaroundTableOffset; engine->lookaroundReachOffset = lookaroundReachOffset; engine->outfixBeginQueue = outfixBeginQueue; engine->outfixEndQueue = outfixEndQueue; engine->leftfixBeginQueue = leftfixBeginQueue; engine->initMpvNfa = mpv_as_outfix ? 0 : MO_INVALID_IDX; engine->stateSize = mmbit_size(bc.numStates); engine->anchorStateSize = anchorStateSize; engine->nfaInfoOffset = nfaInfoOffset; engine->eodProgramOffset = eodProgramOffset; engine->lastByteHistoryIterOffset = lastByteOffset; engine->delay_count = verify_u32(final_id_to_literal.size() - delay_base_id); engine->delay_fatbit_size = fatbit_size(engine->delay_count); engine->delay_base_id = delay_base_id; engine->anchored_base_id = anchored_base_id; engine->anchored_count = delay_base_id - anchored_base_id; engine->anchored_fatbit_size = fatbit_size(engine->anchored_count); engine->rosePrefixCount = rosePrefixCount; engine->activeLeftIterOffset = activeLeftIter.empty() ? 0 : activeLeftIterOffset; // Set scanning mode. if (!cc.streaming) { engine->mode = HS_MODE_BLOCK; } else if (cc.vectored) { engine->mode = HS_MODE_VECTORED; } else { engine->mode = HS_MODE_STREAM; } // The Small Write matcher is (conditionally) added to the RoseEngine in // another pass by the caller. Set to zero (meaning no SMWR engine) for // now. engine->smallWriteOffset = 0; engine->amatcherOffset = amatcherOffset; engine->ematcherOffset = ematcherOffset; engine->sbmatcherOffset = sbmatcherOffset; engine->fmatcherOffset = fmatcherOffset; engine->longLitTableOffset = longLitTableOffset; engine->amatcherMinWidth = findMinWidth(*this, ROSE_ANCHORED); engine->fmatcherMinWidth = findMinWidth(*this, ROSE_FLOATING); engine->eodmatcherMinWidth = findMinWidth(*this, ROSE_EOD_ANCHORED); engine->amatcherMaxBiAnchoredWidth = findMaxBAWidth(*this, ROSE_ANCHORED); engine->fmatcherMaxBiAnchoredWidth = findMaxBAWidth(*this, ROSE_FLOATING); engine->size = currOffset; engine->minWidth = hasBoundaryReports(boundary) ? 0 : minWidth; engine->minWidthExcludingBoundaries = minWidth; engine->floatingMinLiteralMatchOffset = bc.floatingMinLiteralMatchOffset; engine->maxBiAnchoredWidth = findMaxBAWidth(*this); engine->noFloatingRoots = hasNoFloatingRoots(); engine->requiresEodCheck = hasEodAnchors(*this, bc, outfixEndQueue); engine->hasOutfixesInSmallBlock = hasNonSmallBlockOutfix(outfixes); engine->canExhaust = rm.patternSetCanExhaust(); engine->hasSom = hasSom; /* populate anchoredDistance, floatingDistance, floatingMinDistance, etc */ fillMatcherDistances(*this, engine.get()); engine->initialGroups = getInitialGroups(); engine->floating_group_mask = fgroups; engine->totalNumLiterals = verify_u32(literal_info.size()); engine->asize = verify_u32(asize); engine->ematcherRegionSize = ematcher_region_size; engine->longLitStreamState = verify_u32(longLitStreamStateRequired); engine->boundary.reportEodOffset = boundary_out.reportEodOffset; engine->boundary.reportZeroOffset = boundary_out.reportZeroOffset; engine->boundary.reportZeroEodOffset = boundary_out.reportZeroEodOffset; write_out(&engine->state_init, (char *)engine.get(), state_scatter, state_scatter_aux_offset); NfaInfo *nfa_infos = (NfaInfo *)(ptr + nfaInfoOffset); populateNfaInfoBasics(*this, bc, outfixes, suffixEkeyLists, no_retrigger_queues, nfa_infos); updateNfaState(bc, &engine->stateOffsets, nfa_infos, &engine->scratchStateSize, &engine->nfaStateSize, &engine->tStateSize); // Copy in other tables bc.engine_blob.write_bytes(engine.get()); copy_bytes(ptr + engine->leftOffset, leftInfoTable); fillLookaroundTables(ptr + lookaroundTableOffset, ptr + lookaroundReachOffset, bc.lookaround); fillInSomRevNfas(engine.get(), ssm, rev_nfa_table_offset, rev_nfa_offsets); copy_bytes(ptr + engine->activeLeftIterOffset, activeLeftIter); // Safety check: we shouldn't have written anything to the engine blob // after we copied it into the engine bytecode. assert(bc.engine_blob.size() == engineBlobSize); // Add a small write engine if appropriate. engine = addSmallWriteEngine(*this, move(engine)); DEBUG_PRINTF("rose done %p\n", engine.get()); return engine; } } // namespace ue2 hyperscan-4.4.1/src/rose/rose.h0000644000175000017500000000465613055426554017172 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ROSE_H #define ROSE_H #include "ue2common.h" struct RoseEngine; struct hs_scratch; // Initialise state space for engine use. void roseInitState(const struct RoseEngine *t, char *state); /* assumes core_info in scratch has been init to point to data */ void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch); /* assumes core_info in scratch has been init to point to data */ void roseStreamExec(const struct RoseEngine *t, struct hs_scratch *scratch); void roseStreamEodExec(const struct RoseEngine *t, u64a offset, struct hs_scratch *scratch); hwlmcb_rv_t roseCallback(size_t start, size_t end, u32 id, void *context); int roseReportAdaptor(u64a start, u64a end, ReportID id, void *context); int roseRunBoundaryProgram(const struct RoseEngine *rose, u32 program, u64a stream_offset, struct hs_scratch *scratch); #endif // ROSE_H hyperscan-4.4.1/src/rose/rose_build_impl.h0000644000175000017500000004777413055426554021402 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ROSE_BUILD_IMPL_H_17E20A3C6935D6 #define ROSE_BUILD_IMPL_H_17E20A3C6935D6 #include "rose_build.h" #include "rose_build_util.h" #include "rose_graph.h" #include "nfa/mpvcompile.h" #include "nfa/goughcompile.h" #include "nfa/nfa_internal.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_revacc.h" #include "util/alloc.h" #include "util/order_check.h" #include "util/queue_index_factory.h" #include "util/ue2_containers.h" #include #include #include #include #include #include #include struct RoseEngine; namespace ue2 { #define ROSE_GROUPS_MAX 64 #define ROSE_LONG_LITERAL_THRESHOLD_MIN 33 struct BoundaryReports; struct CastleProto; struct CompileContext; class ReportManager; class SmallWriteBuild; class SomSlotManager; struct suffix_id { suffix_id(const RoseSuffixInfo &in) : g(in.graph.get()), c(in.castle.get()), d(in.rdfa.get()), h(in.haig.get()), t(in.tamarama.get()), dfa_min_width(in.dfa_min_width), dfa_max_width(in.dfa_max_width) { assert(!g || g->kind == NFA_SUFFIX); } bool operator==(const suffix_id &b) const { bool rv = g == b.g && c == b.c && h == b.h && d == b.d && t == b.t; assert(!rv || dfa_min_width == b.dfa_min_width); assert(!rv || dfa_max_width == b.dfa_max_width); return rv; } bool operator!=(const suffix_id &b) const { return !(*this == b); } bool operator<(const suffix_id &b) const { const suffix_id &a = *this; ORDER_CHECK(g); ORDER_CHECK(c); ORDER_CHECK(d); ORDER_CHECK(h); ORDER_CHECK(t); return false; } NGHolder *graph() { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return g; } const NGHolder *graph() const { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return g; } CastleProto *castle() { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return c; } const CastleProto *castle() const { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return c; } TamaProto *tamarama() { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return t; } const TamaProto *tamarama() const { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return t; } raw_som_dfa *haig() { return h; } const raw_som_dfa *haig() const { return h; } raw_dfa *dfa() { return d; } const raw_dfa *dfa() const { return d; } size_t hash() const; private: NGHolder *g; CastleProto *c; raw_dfa *d; raw_som_dfa *h; TamaProto *t; depth dfa_min_width; depth dfa_max_width; friend depth findMinWidth(const suffix_id &s); friend depth findMaxWidth(const suffix_id &s); friend depth findMinWidth(const suffix_id &s, u32 top); friend depth findMaxWidth(const suffix_id &s, u32 top); }; std::set all_reports(const suffix_id &s); std::set all_tops(const suffix_id &s); bool has_eod_accepts(const suffix_id &s); bool has_non_eod_accepts(const suffix_id &s); depth findMinWidth(const suffix_id &s); depth findMaxWidth(const suffix_id &s); depth findMinWidth(const suffix_id &s, u32 top); depth findMaxWidth(const suffix_id &s, u32 top); size_t hash_value(const suffix_id &s); /** \brief represents an engine to the left of a rose role */ struct left_id { left_id(const LeftEngInfo &in) : g(in.graph.get()), c(in.castle.get()), d(in.dfa.get()), h(in.haig.get()), dfa_min_width(in.dfa_min_width), dfa_max_width(in.dfa_max_width) { assert(!g || !has_managed_reports(*g)); } bool operator==(const left_id &b) const { bool rv = g == b.g && c == b.c && h == b.h && d == b.d; assert(!rv || dfa_min_width == b.dfa_min_width); assert(!rv || dfa_max_width == b.dfa_max_width); return rv; } bool operator!=(const left_id &b) const { return !(*this == b); } bool operator<(const left_id &b) const { const left_id &a = *this; ORDER_CHECK(g); ORDER_CHECK(c); ORDER_CHECK(d); ORDER_CHECK(h); return false; } NGHolder *graph() { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return g; } const NGHolder *graph() const { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return g; } CastleProto *castle() { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return c; } const CastleProto *castle() const { if (!d && !h) { assert(dfa_min_width == depth(0)); assert(dfa_max_width == depth::infinity()); } return c; } raw_som_dfa *haig() { return h; } const raw_som_dfa *haig() const { return h; } raw_dfa *dfa() { return d; } const raw_dfa *dfa() const { return d; } size_t hash() const; private: NGHolder *g; CastleProto *c; raw_dfa *d; raw_som_dfa *h; depth dfa_min_width; depth dfa_max_width; friend bool isAnchored(const left_id &r); friend depth findMinWidth(const left_id &r); friend depth findMaxWidth(const left_id &r); }; std::set all_tops(const left_id &r); bool isAnchored(const left_id &r); depth findMinWidth(const left_id &r); depth findMaxWidth(const left_id &r); u32 num_tops(const left_id &r); size_t hash_value(const left_id &r); struct rose_literal_info { ue2::flat_set delayed_ids; ue2::flat_set vertices; rose_group group_mask = 0; u32 undelayed_id = MO_INVALID_IDX; u32 final_id = MO_INVALID_IDX; /* id reported by fdr */ bool squash_group = false; bool requires_explode = false; bool requires_benefits = false; }; /** * \brief Main literal struct used at Rose build time. Numeric literal IDs * used at build time point at these (via the RoseBuildImpl::literals map). */ struct rose_literal_id { rose_literal_id(const ue2_literal &s_in, rose_literal_table table_in, u32 delay_in) : s(s_in), table(table_in), delay(delay_in), distinctiveness(0) {} rose_literal_id(const ue2_literal &s_in, const std::vector &msk_in, const std::vector &cmp_in, rose_literal_table table_in, u32 delay_in); ue2_literal s; std::vector msk; std::vector cmp; rose_literal_table table; u32 delay; u32 distinctiveness; size_t elength(void) const { return s.length() + delay; } size_t elength_including_mask(void) const { size_t mask_len = msk.size(); for (u8 c : msk) { if (!c) { mask_len--; } else { break; } } return MAX(mask_len, s.length()) + delay; } }; static inline bool operator<(const rose_literal_id &a, const rose_literal_id &b) { ORDER_CHECK(distinctiveness); ORDER_CHECK(table); ORDER_CHECK(s); ORDER_CHECK(delay); ORDER_CHECK(msk); ORDER_CHECK(cmp); return 0; } // Literals are stored in a map from (string, nocase) -> ID typedef boost::bimap RoseLiteralMap; struct simple_anchored_info { simple_anchored_info(u32 min_b, u32 max_b, const ue2_literal &lit) : min_bound(min_b), max_bound(max_b), literal(lit) {} u32 min_bound; /**< min number of characters required before literal can * start matching */ u32 max_bound; /**< max number of characters allowed before literal can * start matching */ ue2_literal literal; }; static really_inline bool operator<(const simple_anchored_info &a, const simple_anchored_info &b) { ORDER_CHECK(min_bound); ORDER_CHECK(max_bound); ORDER_CHECK(literal); return 0; } struct MpvProto { bool empty() const { return puffettes.empty() && triggered_puffettes.empty(); } void reset() { puffettes.clear(); triggered_puffettes.clear(); } std::vector puffettes; std::vector triggered_puffettes; }; struct OutfixInfo { template explicit OutfixInfo(std::unique_ptr x) : proto(std::move(x)) {} explicit OutfixInfo(MpvProto mpv_in) : proto(std::move(mpv_in)) {} u32 get_queue(QueueIndexFactory &qif); u32 get_queue() const { assert(queue != ~0U); return queue; } bool is_nonempty_mpv() const { auto *m = boost::get(&proto); return m && !m->empty(); } bool is_dead() const { auto *m = boost::get(&proto); if (m) { return m->empty(); } return boost::get(&proto) != nullptr; } void clear() { proto = boost::blank(); } // Convenience accessor functions. NGHolder *holder() { auto *up = boost::get>(&proto); return up ? up->get() : nullptr; } raw_dfa *rdfa() { auto *up = boost::get>(&proto); return up ? up->get() : nullptr; } raw_som_dfa *haig() { auto *up = boost::get>(&proto); return up ? up->get() : nullptr; } MpvProto *mpv() { return boost::get(&proto); } // Convenience const accessor functions. const NGHolder *holder() const { auto *up = boost::get>(&proto); return up ? up->get() : nullptr; } const raw_dfa *rdfa() const { auto *up = boost::get>(&proto); return up ? up->get() : nullptr; } const raw_som_dfa *haig() const { auto *up = boost::get>(&proto); return up ? up->get() : nullptr; } const MpvProto *mpv() const { return boost::get(&proto); } /** * \brief Variant wrapping the various engine types. If this is * boost::blank, it means that this outfix is unused (dead). */ boost::variant< boost::blank, std::unique_ptr, std::unique_ptr, std::unique_ptr, MpvProto> proto = boost::blank(); RevAccInfo rev_info; u32 maxBAWidth = 0; //!< max bi-anchored width depth minWidth = depth::infinity(); depth maxWidth = 0; u64a maxOffset = 0; bool in_sbmatcher = false; //!< handled by small-block matcher. private: u32 queue = ~0U; }; std::set all_reports(const OutfixInfo &outfix); // Concrete impl class class RoseBuildImpl : public RoseBuild { public: RoseBuildImpl(ReportManager &rm, SomSlotManager &ssm, SmallWriteBuild &smwr, const CompileContext &cc, const BoundaryReports &boundary); ~RoseBuildImpl() override; // Adds a single literal. void add(bool anchored, bool eod, const ue2_literal &lit, const ue2::flat_set &ids) override; bool addRose(const RoseInGraph &ig, bool prefilter, bool finalChance = false) override; bool addSombeRose(const RoseInGraph &ig) override; bool addOutfix(const NGHolder &h) override; bool addOutfix(const NGHolder &h, const raw_som_dfa &haig) override; bool addOutfix(const raw_puff &rp) override; bool addChainTail(const raw_puff &rp, u32 *queue_out, u32 *event_out) override; // Returns true if we were able to add it as a mask bool add(bool anchored, const std::vector &mask, const ue2::flat_set &reports) override; bool addAnchoredAcyclic(const NGHolder &graph) override; bool validateMask(const std::vector &mask, const ue2::flat_set &reports, bool anchored, bool eod) const override; void addMask(const std::vector &mask, const ue2::flat_set &reports, bool anchored, bool eod) override; // Construct a runtime implementation. aligned_unique_ptr buildRose(u32 minWidth) override; aligned_unique_ptr buildFinalEngine(u32 minWidth); void setSom() override { hasSom = true; } std::unique_ptr generateDedupeAux() const override; // Find the maximum bound on the edges to this vertex's successors. u32 calcSuccMaxBound(RoseVertex u) const; /* Returns the ID of the given literal in the literal map, adding it if * necessary. */ u32 getLiteralId(const ue2_literal &s, u32 delay, rose_literal_table table); // Variant with msk/cmp. u32 getLiteralId(const ue2_literal &s, const std::vector &msk, const std::vector &cmp, u32 delay, rose_literal_table table); bool hasLiteral(const ue2_literal &s, rose_literal_table table) const; u32 getNewLiteralId(void); void removeVertices(const std::vector &dead); // Is the Rose anchored? bool hasNoFloatingRoots() const; RoseVertex cloneVertex(RoseVertex v); u32 calcHistoryRequired() const; rose_group getInitialGroups() const; rose_group getSuccGroups(RoseVertex start) const; rose_group getGroups(RoseVertex v) const; bool hasDelayedLiteral(RoseVertex v) const; bool hasDelayPred(RoseVertex v) const; bool hasLiteralInTable(RoseVertex v, enum rose_literal_table t) const; bool hasAnchoredTablePred(RoseVertex v) const; // Is the given vertex a successor of either root or anchored_root? bool isRootSuccessor(const RoseVertex &v) const; /* Is the given vertex a successor of something other than root or * anchored_root? */ bool isNonRootSuccessor(const RoseVertex &v) const; bool isDirectReport(u32 id) const; bool isDelayed(u32 id) const; bool hasFinalId(u32 id) const; bool isAnchored(RoseVertex v) const; /* true iff has literal in anchored * table */ bool isFloating(RoseVertex v) const; /* true iff has literal in floating * table */ bool isInETable(RoseVertex v) const; /* true iff has literal in eod * table */ size_t maxLiteralLen(RoseVertex v) const; size_t minLiteralLen(RoseVertex v) const; // max overlap considered for every pair (ulit, vlit). size_t maxLiteralOverlap(RoseVertex u, RoseVertex v) const; bool isPseudoStar(const RoseEdge &e) const; bool isPseudoStarOrFirstOnly(const RoseEdge &e) const; bool hasOnlyPseudoStarInEdges(RoseVertex v) const; bool isAnyStart(const RoseVertex &v) const { return v == root || v == anchored_root; } bool isVirtualVertex(const RoseVertex &v) const { return g[v].eod_accept || isAnyStart(v); } void handleMixedSensitivity(void); void findTransientLeftfixes(void); const CompileContext &cc; RoseGraph g; const RoseVertex root; const RoseVertex anchored_root; RoseLiteralMap literals; std::map ghost; ReportID getNewNfaReport() override { return next_nfa_report++; } std::deque literal_info; u32 delay_base_id; bool hasSom; //!< at least one pattern requires SOM. std::map>> anchored_nfas; std::map> anchored_simple; std::map > group_to_literal; u32 group_end; u32 anchored_base_id; u32 ematcher_region_size; /**< number of bytes the eod table runs over */ /** \brief Mapping from leftfix to queue ID (used in dump code). */ unordered_map leftfix_queue_map; /** \brief Mapping from suffix to queue ID (used in dump code). */ unordered_map suffix_queue_map; /** \brief Mapping from anchored literal ID to the original literal suffix * present when the literal was added to the literal matcher. Used for * overlap calculation in history assignment. */ std::map anchoredLitSuffix; std::map > final_id_to_literal; /* final literal id to * literal id */ unordered_set transient; unordered_map rose_squash_masks; std::vector outfixes; /** \brief MPV outfix entry. Null if not used, and moved into the outfixes * list before we start building the bytecode (at which point it is set to * null again). */ std::unique_ptr mpv_outfix = nullptr; u32 eod_event_literal_id; // ID of EOD event literal, or MO_INVALID_IDX. u32 max_rose_anchored_floating_overlap; QueueIndexFactory qif; ReportManager &rm; SomSlotManager &ssm; SmallWriteBuild &smwr; const BoundaryReports &boundary; private: ReportID next_nfa_report; }; size_t calcLongLitThreshold(const RoseBuildImpl &build, const size_t historyRequired); // Free functions, in rose_build_misc.cpp bool hasAnchHistorySucc(const RoseGraph &g, RoseVertex v); bool hasLastByteHistorySucc(const RoseGraph &g, RoseVertex v); size_t maxOverlap(const rose_literal_id &a, const rose_literal_id &b); ue2_literal findNonOverlappingTail(const std::set &lits, const ue2_literal &s); void setReportId(NGHolder &g, ReportID id); #ifndef NDEBUG bool roseHasTops(const RoseBuildImpl &build, RoseVertex v); bool hasOrphanedTops(const RoseBuildImpl &build); #endif u64a findMaxOffset(const std::set &reports, const ReportManager &rm); // Function that operates on a msk/cmp pair and a literal, as used in // hwlmLiteral, and zeroes msk elements that don't add any power to the // literal. void normaliseLiteralMask(const ue2_literal &s, std::vector &msk, std::vector &cmp); #ifndef NDEBUG bool canImplementGraphs(const RoseBuildImpl &tbi); #endif } // namespace ue2 #endif /* ROSE_BUILD_IMPL_H_17E20A3C6935D6 */ hyperscan-4.4.1/src/rose/stream_long_lit_hash.h0000644000175000017500000000735613055426554022407 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 STREAM_LONG_LIT_HASH_H #define STREAM_LONG_LIT_HASH_H #include "ue2common.h" #include "util/bitutils.h" #include "util/unaligned.h" /** \brief Length of the buffer operated on by \ref hashLongLiteral(). */ #define LONG_LIT_HASH_LEN 24 /** \brief Multiplier used by al the hash functions below. */ #define HASH_MULTIPLIER 0x0b4e0ef37bc32127ULL /** \brief Hash function used for long literal table in streaming mode. */ static really_inline u32 hashLongLiteral(const u8 *ptr, UNUSED size_t len, char nocase) { // We unconditionally hash LONG_LIT_HASH_LEN bytes; all use cases of this // hash are for strings longer than this. assert(len >= 24); u64a v1 = unaligned_load_u64a(ptr); u64a v2 = unaligned_load_u64a(ptr + 8); u64a v3 = unaligned_load_u64a(ptr + 16); if (nocase) { v1 &= OCTO_CASE_CLEAR; v2 &= OCTO_CASE_CLEAR; v3 &= OCTO_CASE_CLEAR; } v1 *= HASH_MULTIPLIER; v2 *= HASH_MULTIPLIER * HASH_MULTIPLIER; v3 *= HASH_MULTIPLIER * HASH_MULTIPLIER * HASH_MULTIPLIER; v1 >>= 32; v2 >>= 32; v3 >>= 32; return v1 ^ v2 ^ v3; } /** * \brief Internal, used by the bloom filter hash functions below. Hashes 16 * bytes beginning at (ptr + offset). */ static really_inline u32 bloomHash_i(const u8 *ptr, u32 offset, u64a multiplier, char nocase) { assert(offset + 16 <= LONG_LIT_HASH_LEN); u64a v = unaligned_load_u64a(ptr + offset); if (nocase) { v &= OCTO_CASE_CLEAR; } v *= multiplier; return v >> 32; } /* * We ensure that we see every byte the first LONG_LIT_HASH_LEN bytes of input * data (using at least one of the following functions). */ static really_inline u32 bloomHash_1(const u8 *ptr, char nocase) { const u64a multiplier = HASH_MULTIPLIER; return bloomHash_i(ptr, 0, multiplier, nocase); } static really_inline u32 bloomHash_2(const u8 *ptr, char nocase) { const u64a multiplier = HASH_MULTIPLIER * HASH_MULTIPLIER; return bloomHash_i(ptr, 4, multiplier, nocase); } static really_inline u32 bloomHash_3(const u8 *ptr, char nocase) { const u64a multiplier = HASH_MULTIPLIER * HASH_MULTIPLIER * HASH_MULTIPLIER; return bloomHash_i(ptr, 8, multiplier, nocase); } #endif // STREAM_LONG_LIT_HASH_H hyperscan-4.4.1/src/rose/rose_build_add.cpp0000644000175000017500000020341513055426554021506 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_add_internal.h" #include "rose_build_impl.h" #include "ue2common.h" #include "grey.h" #include "rose_build_anchored.h" #include "rose_in_util.h" #include "hwlm/hwlm_literal.h" #include "nfa/goughcompile.h" #include "nfa/nfa_api_queue.h" #include "nfagraph/ng_depth.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_mcclellan.h" #include "nfagraph/ng_prefilter.h" #include "nfagraph/ng_prune.h" #include "nfagraph/ng_region.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_reports.h" #include "nfagraph/ng_rose.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_width.h" #include "util/charreach.h" #include "util/charreach_util.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include #include #include #include using namespace std; namespace ue2 { /** * \brief Data used by most of the construction code in this file. */ struct RoseBuildData : boost::noncopyable { RoseBuildData(const RoseInGraph &ig_in, bool som_in) : ig(ig_in), som(som_in) {} /** Input rose graph. */ const RoseInGraph &ig; /** Mapping from engine graph to constructed DFA for pre-build DFAs. */ ue2::unordered_map > early_dfas; /** Edges we've transformed (in \ref transformAnchoredLiteralOverlap) which * require ANCH history to prevent overlap. */ ue2::unordered_set anch_history_edges; /** True if we're tracking Start of Match. */ bool som; }; static ReportID findReportId(const NGHolder &g) { /* prefix/infix always have an edge to accept and only 1 reportid initially */ assert(in_degree(g.accept, g)); const auto &rep = g[*inv_adjacent_vertices(g.accept, g).first].reports; assert(!rep.empty()); return *rep.begin(); } static RoseVertex createVertex(RoseBuildImpl *build, u32 literalId, u32 min_offset, u32 max_offset) { RoseGraph &g = build->g; // add to tree RoseVertex v = add_vertex(g); g[v].min_offset = min_offset; g[v].max_offset = max_offset; DEBUG_PRINTF("insert vertex %zu into literal %u's vertex set\n", g[v].index, literalId); g[v].literals.insert(literalId); build->literal_info[literalId].vertices.insert(v); return v; } RoseVertex createVertex(RoseBuildImpl *build, const RoseVertex parent, u32 minBound, u32 maxBound, u32 literalId, size_t literalLength, const ue2::flat_set &reports) { assert(parent != RoseGraph::null_vertex()); RoseGraph &g = build->g; // add to tree (offsets set latter) RoseVertex v = createVertex(build, literalId, 0U, 0U); /* fill in report information */ g[v].reports.insert(reports.begin(), reports.end()); RoseEdge e = add_edge(parent, v, g); DEBUG_PRINTF("adding edge (%u, %u) to parent\n", minBound, maxBound); g[e].minBound = minBound; g[e].maxBound = maxBound; g[e].rose_top = 0; u32 min_offset = add_rose_depth(g[parent].min_offset, minBound); u32 max_offset = add_rose_depth(g[parent].max_offset, maxBound); /* take literal length into account for offsets */ const u32 lit_len = verify_u32(literalLength); min_offset = add_rose_depth(min_offset, lit_len); max_offset = add_rose_depth(max_offset, lit_len); g[v].min_offset = min_offset; g[v].max_offset = max_offset; return v; } static RoseVertex createAnchoredVertex(RoseBuildImpl *build, u32 literalId, u32 min_offset, u32 max_offset) { RoseGraph &g = build->g; RoseVertex v = createVertex(build, literalId, min_offset, max_offset); DEBUG_PRINTF("created anchored vertex %zu with lit id %u\n", g[v].index, literalId); RoseEdge e = add_edge(build->anchored_root, v, g); g[e].minBound = min_offset; g[e].maxBound = max_offset; return v; } static RoseVertex duplicate(RoseBuildImpl *build, RoseVertex v) { RoseGraph &g = build->g; RoseVertex w = add_vertex(g[v], g); DEBUG_PRINTF("added vertex %zu\n", g[w].index); for (auto lit_id : g[w].literals) { build->literal_info[lit_id].vertices.insert(w); } for (const auto &e : in_edges_range(v, g)) { RoseVertex s = source(e, g); add_edge(s, w, g[e], g); DEBUG_PRINTF("added edge (%zu,%zu)\n", g[s].index, g[w].index); } return w; } namespace { struct created_key { explicit created_key(const RoseInEdgeProps &trep) : prefix(trep.graph.get()), lag(trep.graph_lag) { } bool operator<(const created_key &b) const { const created_key &a = *this; ORDER_CHECK(prefix); ORDER_CHECK(lag); return false; } NGHolder *prefix; u32 lag; }; } static bool isPureAnchored(const NGHolder &h) { return !proper_out_degree(h.startDs, h); } static RoseRoleHistory selectHistory(const RoseBuildImpl &tbi, const RoseBuildData &bd, const RoseInEdge &rose_edge, const RoseEdge &e) { const RoseGraph &g = tbi.g; const RoseVertex u = source(e, g), v = target(e, g); const bool fixed_offset_src = g[u].fixedOffset(); const bool has_bounds = g[e].minBound || (g[e].maxBound != ROSE_BOUND_INF); DEBUG_PRINTF("edge %zu->%zu, bounds=[%u,%u], fixed_u=%d, prefix=%d\n", g[u].index, g[v].index, g[e].minBound, g[e].maxBound, (int)g[u].fixedOffset(), (int)g[v].left); if (g[v].left) { // Roles with prefix engines have their history handled by that prefix. assert(!contains(bd.anch_history_edges, rose_edge)); return ROSE_ROLE_HISTORY_NONE; } if (contains(bd.anch_history_edges, rose_edge)) { DEBUG_PRINTF("needs anch history\n"); return ROSE_ROLE_HISTORY_ANCH; } if (fixed_offset_src && has_bounds) { DEBUG_PRINTF("needs anch history\n"); return ROSE_ROLE_HISTORY_ANCH; } return ROSE_ROLE_HISTORY_NONE; } static bool hasSuccessorLiterals(RoseInVertex iv, const RoseInGraph &ig) { for (auto v : adjacent_vertices_range(iv, ig)) { if (ig[v].type != RIV_ACCEPT) { return true; } } return false; } static void createVertices(RoseBuildImpl *tbi, map > &vertex_map, const vector > &parents, RoseInVertex iv, u32 min_offset, u32 max_offset, u32 literalId, u32 delay, const RoseBuildData &bd) { RoseGraph &g = tbi->g; DEBUG_PRINTF("vertex has %zu parents\n", parents.size()); map created; for (const auto &pv : parents) { RoseVertex w; const RoseInEdgeProps &edge_props = bd.ig[pv.second]; shared_ptr prefix_graph = edge_props.graph; u32 prefix_lag = edge_props.graph_lag; created_key key(edge_props); if (!contains(created, key)) { assert(prefix_graph || !edge_props.haig); w = createVertex(tbi, literalId, min_offset, max_offset); created[key] = w; if (prefix_graph) { g[w].left.graph = prefix_graph; if (contains(bd.early_dfas, prefix_graph.get())) { g[w].left.dfa = bd.early_dfas.at(prefix_graph.get()); } g[w].left.haig = edge_props.haig; g[w].left.lag = prefix_lag; // The graph already has its report id allocated - find it. g[w].left.leftfix_report = findReportId(*prefix_graph); if (g[w].left.dfa || g[w].left.haig) { assert(prefix_graph); g[w].left.dfa_min_width = findMinWidth(*prefix_graph); g[w].left.dfa_max_width = findMaxWidth(*prefix_graph); } } if (bd.som && !g[w].left.haig) { /* no prefix - som based on literal start */ assert(!prefix_graph); g[w].som_adjust = tbi->literals.right.at(literalId).elength(); DEBUG_PRINTF("set som_adjust to %u\n", g[w].som_adjust); } DEBUG_PRINTF(" adding new vertex index=%zu\n", tbi->g[w].index); vertex_map[iv].push_back(w); } else { w = created[key]; } RoseVertex p = pv.first; RoseEdge e = add_edge(p, w, g); DEBUG_PRINTF("adding edge (%u,%u) to parent\n", edge_props.minBound, edge_props.maxBound); g[e].minBound = edge_props.minBound; if (p != tbi->root && g[w].left.graph && (!tbi->isAnyStart(p) || isPureAnchored(*g[w].left.graph))) { depth mw = findMaxWidth(*g[w].left.graph); if (mw.is_infinite()) { g[e].maxBound = ROSE_BOUND_INF; } else { DEBUG_PRINTF("setting max to %s + %u\n", mw.str().c_str(), prefix_lag); g[e].maxBound = prefix_lag + mw; } } else { g[e].maxBound = edge_props.maxBound; } g[e].rose_top = 0; g[e].history = selectHistory(*tbi, bd, pv.second, e); } if (delay && hasSuccessorLiterals(iv, bd.ig)) { // Add an undelayed "ghost" vertex for this literal. u32 ghostId = tbi->literal_info[literalId].undelayed_id; DEBUG_PRINTF("creating delay ghost vertex, id=%u\n", ghostId); assert(ghostId != literalId); assert(tbi->literals.right.at(ghostId).delay == 0); // Adjust offsets, removing delay. u32 ghost_min = min_offset, ghost_max = max_offset; assert(ghost_min < ROSE_BOUND_INF && ghost_min >= delay); ghost_min -= delay; ghost_max -= ghost_max == ROSE_BOUND_INF ? 0 : delay; RoseVertex g_v = createVertex(tbi, ghostId, ghost_min, ghost_max); for (const auto &pv : parents) { const RoseInEdgeProps &edge_props = bd.ig[pv.second]; RoseEdge e = add_edge(pv.first, g_v, tbi->g); g[e].minBound = edge_props.minBound; g[e].maxBound = edge_props.maxBound; g[e].history = selectHistory(*tbi, bd, pv.second, e); DEBUG_PRINTF("parent edge has bounds [%u,%u]\n", edge_props.minBound, edge_props.maxBound); } for (auto &m : created) { tbi->ghost[m.second] = g_v; } } } /* ensure the holder does not accept any paths which do not end with lit */ static void removeFalsePaths(NGHolder &g, const ue2_literal &lit) { DEBUG_PRINTF("strip '%s'\n", dumpString(lit).c_str()); set curr, next; curr.insert(g.accept); curr.insert(g.acceptEod); for (auto it = lit.rbegin(), ite = lit.rend(); it != ite; ++it) { next.clear(); for (auto curr_v : curr) { DEBUG_PRINTF("handling %zu\n", g[curr_v].index); vector next_cand; insert(&next_cand, next_cand.end(), inv_adjacent_vertices(curr_v, g)); clear_in_edges(curr_v, g); if (curr_v == g.acceptEod) { add_edge(g.accept, g.acceptEod, g); } for (auto v : next_cand) { assert(v != g.startDs); if (v == g.start || v == g.startDs || v == g.accept) { continue; } const CharReach &cr = g[v].char_reach; if (!overlaps(*it, cr)) { DEBUG_PRINTF("false edge %zu\n", g[v].index); continue; } NFAVertex v2 = clone_vertex(g, v); clone_in_edges(g, v, v2); add_edge(v2, curr_v, g); g[v2].char_reach &= *it; DEBUG_PRINTF("next <- %zu\n", g[v2].index); next.insert(v2); } } curr.swap(next); } pruneUseless(g); clearReports(g); assert(in_degree(g.accept, g) || in_degree(g.acceptEod, g) > 1); assert(allMatchStatesHaveReports(g)); DEBUG_PRINTF("graph has %zu vertices left\n", num_vertices(g)); } static RoseVertex tryForAnchoredVertex(RoseBuildImpl *tbi, const RoseInVertexProps &iv_info, const RoseInEdgeProps &ep) { if (ep.graph_lag && ep.graph_lag != iv_info.s.length()) { DEBUG_PRINTF("bad lag %u != %zu\n", ep.graph_lag, iv_info.s.length()); return RoseGraph::null_vertex(); /* TODO: better */ } const depth anchored_max_depth(tbi->cc.grey.maxAnchoredRegion); depth min_width(0), max_width(0); if (ep.graph.get()) { const depth graph_lag(ep.graph_lag); max_width = findMaxWidth(*ep.graph) + graph_lag; min_width = findMinWidth(*ep.graph) + graph_lag; if (proper_out_degree(ep.graph->startDs, *ep.graph)) { max_width = depth::infinity(); } } DEBUG_PRINTF("mw = %s; lag = %u\n", max_width.str().c_str(), ep.graph_lag); NGHolder h; if (ep.graph.get() && max_width <= anchored_max_depth) { cloneHolder(h, *ep.graph); /* add literal/dots */ if (ep.graph_lag) { assert(ep.graph_lag == iv_info.s.length()); appendLiteral(h, iv_info.s); } else { removeFalsePaths(h, iv_info.s); } } else if (!ep.graph.get() && ep.maxBound < ROSE_BOUND_INF && iv_info.s.length() + ep.maxBound <= tbi->cc.grey.maxAnchoredRegion) { if (ep.maxBound || ep.minBound) { /* TODO: handle, however these cases are not generated currently by ng_rose */ return RoseGraph::null_vertex(); } max_width = depth(ep.maxBound + iv_info.s.length()); min_width = depth(ep.minBound + iv_info.s.length()); add_edge(h.start, h.accept, h); appendLiteral(h, iv_info.s); } else { return RoseGraph::null_vertex(); } u32 anchored_exit_id = tbi->getNewLiteralId(); u32 remap_id = 0; DEBUG_PRINTF(" trying to add dfa stuff\n"); int rv = addToAnchoredMatcher(*tbi, h, anchored_exit_id, &remap_id); if (rv == ANCHORED_FAIL) { return RoseGraph::null_vertex(); } else if (rv == ANCHORED_REMAP) { anchored_exit_id = remap_id; } else { assert(rv == ANCHORED_SUCCESS); } // Store the literal itself in a side structure so that we can use it for // overlap calculations later. This may be obsolete when the old Rose // construction path (and its history selection code) goes away. rose_literal_id lit(iv_info.s, ROSE_ANCHORED, 0); tbi->anchoredLitSuffix.insert(make_pair(anchored_exit_id, lit)); assert(min_width <= anchored_max_depth); assert(max_width <= anchored_max_depth); assert(min_width <= max_width); /* Note: bounds are end-to-end as anchored lits are considered * to have 0 length. */ RoseVertex v = createAnchoredVertex(tbi, anchored_exit_id, min_width, max_width); return v; } static u32 findRoseAnchorFloatingOverlap(const RoseInEdgeProps &ep, const RoseInVertexProps &succ_vp) { /* we need to ensure there is enough history to find the successor literal * when we enable its group. */ if (!ep.graph.get()) { return 0; /* non overlapping */ } depth graph_min_width = findMinWidth(*ep.graph); u32 min_width = ep.graph_lag + graph_min_width; u32 s_len = succ_vp.s.length(); if (s_len <= min_width) { return 0; /* no overlap */ } u32 overlap = s_len - min_width; DEBUG_PRINTF("found overlap of %u\n", overlap); return overlap; } static void findRoseLiteralMask(const NGHolder &h, const u32 lag, vector &msk, vector &cmp) { if (lag >= HWLM_MASKLEN) { msk.clear(); cmp.clear(); return; } assert(in_degree(h.acceptEod, h) == 1); // no eod reports // Start with the set of reporter vertices for this rose. set curr, next; insert(&curr, inv_adjacent_vertices(h.accept, h)); assert(!curr.empty()); msk.assign(HWLM_MASKLEN, 0); cmp.assign(HWLM_MASKLEN, 0); size_t i = HWLM_MASKLEN - lag - 1; do { if (curr.empty() || contains(curr, h.start) || contains(curr, h.startDs)) { DEBUG_PRINTF("end of the road\n"); break; } next.clear(); CharReach cr; for (auto v : curr) { DEBUG_PRINTF("vertex %zu, reach %s\n", h[v].index, describeClass(h[v].char_reach).c_str()); cr |= h[v].char_reach; insert(&next, inv_adjacent_vertices(v, h)); } make_and_cmp_mask(cr, &msk[i], &cmp[i]); DEBUG_PRINTF("%zu: reach=%s, msk=%u, cmp=%u\n", i, describeClass(cr).c_str(), msk.at(i), cmp.at(i)); curr.swap(next); } while (i-- > 0); } static void doRoseLiteralVertex(RoseBuildImpl *tbi, bool use_eod_table, map > &vertex_map, const vector > &parents, RoseInVertex iv, const RoseBuildData &bd) { const RoseInGraph &ig = bd.ig; const RoseInVertexProps &iv_info = ig[iv]; assert(iv_info.type == RIV_LITERAL); assert(!parents.empty()); /* start vertices should not be here */ // ng_rose should have ensured that mixed-sensitivity literals are no // longer than the benefits max width. assert(iv_info.s.length() <= MAX_MASK2_WIDTH || !mixed_sensitivity(iv_info.s)); // Rose graph construction process should have given us a min_offset. assert(iv_info.min_offset > 0); if (use_eod_table) { goto floating; } DEBUG_PRINTF("rose find vertex\n"); if (parents.size() == 1) { const RoseVertex u = parents.front().first; const RoseInEdgeProps &ep = ig[parents.front().second]; if (!tbi->isAnyStart(u)) { goto floating; } if (!ep.graph && ep.maxBound == ROSE_BOUND_INF) { goto floating; } if (ep.graph && !isAnchored(*ep.graph)) { goto floating; } DEBUG_PRINTF("cand for anchored maxBound %u, %p (%d)\n", ep.maxBound, ep.graph.get(), ep.graph ? (int)isAnchored(*ep.graph) : 3); /* need to check if putting iv into the anchored table would create * any bad_overlap relationships with its successor literals */ for (const auto &e : out_edges_range(iv, ig)) { RoseInVertex t = target(e, ig); u32 overlap = findRoseAnchorFloatingOverlap(ig[e], ig[t]); DEBUG_PRINTF("found overlap of %u\n", overlap); if (overlap > tbi->cc.grey.maxHistoryAvailable + 1) { goto floating; } } RoseVertex v = tryForAnchoredVertex(tbi, iv_info, ep); if (v != RoseGraph::null_vertex()) { DEBUG_PRINTF("add anchored literal vertex\n"); vertex_map[iv].push_back(v); return; } } floating: vector msk, cmp; if (tbi->cc.grey.roseHamsterMasks && in_degree(iv, ig) == 1) { RoseInEdge e = *in_edges(iv, ig).first; if (ig[e].graph) { findRoseLiteralMask(*ig[e].graph, ig[e].graph_lag, msk, cmp); } } u32 delay = iv_info.delay; rose_literal_table table = use_eod_table ? ROSE_EOD_ANCHORED : ROSE_FLOATING; u32 literalId = tbi->getLiteralId(iv_info.s, msk, cmp, delay, table); DEBUG_PRINTF("literal=%u (len=%zu, delay=%u, offsets=[%u,%u] '%s')\n", literalId, iv_info.s.length(), delay, iv_info.min_offset, iv_info.max_offset, dumpString(iv_info.s).c_str()); createVertices(tbi, vertex_map, parents, iv, iv_info.min_offset, iv_info.max_offset, literalId, delay, bd); } static unique_ptr makeRoseEodPrefix(const NGHolder &h, RoseBuildImpl &build, map, ReportID> &remap) { assert(generates_callbacks(h)); assert(!in_degree(h.accept, h)); auto gg = cloneHolder(h); NGHolder &g = *gg; g.kind = is_triggered(h) ? NFA_INFIX : NFA_PREFIX; // Move acceptEod edges over to accept. vector dead; for (const auto &e : in_edges_range(g.acceptEod, g)) { NFAVertex u = source(e, g); if (u == g.accept) { continue; } add_edge_if_not_present(u, g.accept, g); dead.push_back(e); if (!contains(remap, g[u].reports)) { remap[g[u].reports] = build.getNewNfaReport(); } g[u].reports = { remap[g[u].reports] }; } remove_edges(dead, g); return gg; } static u32 getEodEventID(RoseBuildImpl &build) { // Allocate the EOD event if it hasn't been already. if (build.eod_event_literal_id == MO_INVALID_IDX) { build.eod_event_literal_id = build.getLiteralId({}, 0, ROSE_EVENT); } return build.eod_event_literal_id; } static void makeEodEventLeftfix(RoseBuildImpl &build, RoseVertex u, const NGHolder &h) { assert(!build.isInETable(u)); RoseGraph &g = build.g; map, ReportID> report_remap; shared_ptr eod_leftfix = makeRoseEodPrefix(h, build, report_remap); u32 eod_event = getEodEventID(build); for (const auto &report_mapping : report_remap) { RoseVertex v = add_vertex(g); g[v].literals.insert(eod_event); build.literal_info[eod_event].vertices.insert(v); g[v].left.graph = eod_leftfix; g[v].left.leftfix_report = report_mapping.second; g[v].left.lag = 0; RoseEdge e1 = add_edge(u, v, g); g[e1].minBound = 0; g[e1].maxBound = ROSE_BOUND_INF; g[v].min_offset = add_rose_depth(g[u].min_offset, findMinWidth(*g[v].left.graph)); g[v].max_offset = ROSE_BOUND_INF; depth max_width = findMaxWidth(*g[v].left.graph); if (u != build.root && max_width.is_finite() && (!build.isAnyStart(u) || isPureAnchored(*g[v].left.graph))) { g[e1].maxBound = max_width; g[v].max_offset = add_rose_depth(g[u].max_offset, max_width); } g[e1].history = ROSE_ROLE_HISTORY_NONE; // handled by prefix RoseVertex w = add_vertex(g); g[w].eod_accept = true; g[w].reports = report_mapping.first; g[w].min_offset = g[v].min_offset; g[w].max_offset = g[v].max_offset; RoseEdge e = add_edge(v, w, g); g[e].minBound = 0; g[e].maxBound = 0; g[e].history = ROSE_ROLE_HISTORY_LAST_BYTE; DEBUG_PRINTF("accept eod vertex (index=%zu)\n", g[w].index); } } static void doRoseAcceptVertex(RoseBuildImpl *tbi, const vector > &parents, RoseInVertex iv, const RoseBuildData &bd) { const RoseInGraph &ig = bd.ig; assert(ig[iv].type == RIV_ACCEPT || ig[iv].type == RIV_ACCEPT_EOD); RoseGraph &g = tbi->g; for (const auto &pv : parents) { RoseVertex u = pv.first; const RoseInEdgeProps &edge_props = bd.ig[pv.second]; /* We need to duplicate the parent vertices if: * * 1) It already has a suffix, etc as we are going to add the specified * suffix, etc to the parents and we do not want to overwrite the * existing information. * * 2) We are making the an EOD accept and the vertex already has other * out-edges - The LAST_BYTE history used for EOD accepts is * incompatible with normal successors. As accepts are processed last we * do not need to worry about other normal successors being added later. */ if (g[u].suffix || !g[u].reports.empty() || (ig[iv].type == RIV_ACCEPT_EOD && out_degree(u, g) && !edge_props.graph) || (!isLeafNode(u, g) && !tbi->isAnyStart(u))) { DEBUG_PRINTF("duplicating for parent %zu\n", g[u].index); assert(!tbi->isAnyStart(u)); u = duplicate(tbi, u); g[u].suffix.reset(); g[u].eod_accept = false; } assert(!g[u].suffix); if (ig[iv].type == RIV_ACCEPT) { assert(!tbi->isAnyStart(u)); if (contains(bd.early_dfas, edge_props.graph.get())) { DEBUG_PRINTF("adding early dfa suffix to i%zu\n", g[u].index); g[u].suffix.rdfa = bd.early_dfas.at(edge_props.graph.get()); g[u].suffix.dfa_min_width = findMinWidth(*edge_props.graph); g[u].suffix.dfa_max_width = findMaxWidth(*edge_props.graph); } else if (edge_props.graph) { DEBUG_PRINTF("adding suffix to i%zu\n", g[u].index); g[u].suffix.graph = edge_props.graph; assert(g[u].suffix.graph->kind == NFA_SUFFIX); /* TODO: set dfa_(min|max)_width */ } else if (edge_props.haig) { DEBUG_PRINTF("adding suffaig to i%zu\n", g[u].index); g[u].suffix.haig = edge_props.haig; } else { DEBUG_PRINTF("adding boring accept to i%zu\n", g[u].index); assert(!g[u].eod_accept); g[u].reports = ig[iv].reports; } } else { assert(ig[iv].type == RIV_ACCEPT_EOD); assert(!edge_props.haig); if (!edge_props.graph) { RoseVertex w = add_vertex(g); g[w].eod_accept = true; g[w].reports = ig[iv].reports; g[w].min_offset = g[u].min_offset; g[w].max_offset = g[u].max_offset; RoseEdge e = add_edge(u, w, g); g[e].minBound = 0; g[e].maxBound = 0; g[e].history = ROSE_ROLE_HISTORY_LAST_BYTE; DEBUG_PRINTF("accept eod vertex (index=%zu)\n", g[w].index); continue; } const NGHolder &h = *edge_props.graph; assert(!in_degree(h.accept, h)); assert(generates_callbacks(h)); if (tbi->isInETable(u)) { assert(h.kind == NFA_SUFFIX); assert(!tbi->isAnyStart(u)); /* etable can't/shouldn't use eod event */ DEBUG_PRINTF("adding suffix to i%zu\n", g[u].index); g[u].suffix.graph = edge_props.graph; continue; } makeEodEventLeftfix(*tbi, u, h); } } } static bool suitableForEod(const RoseInGraph &ig, vector topo, u32 *max_len, const CompileContext &cc) { map max_depth_from_eod; *max_len = 0; reverse(topo.begin(), topo.end()); /* we want to start at accept end */ for (auto v : topo) { u32 v_depth = 0; if (ig[v].type == RIV_ACCEPT) { DEBUG_PRINTF("[ACCEPT]\n"); for (const auto &e : in_edges_range(v, ig)) { if (!ig[e].graph || !can_only_match_at_eod(*ig[e].graph)) { DEBUG_PRINTF("floating accept\n"); return false; } } } switch (ig[v].type) { case RIV_LITERAL: DEBUG_PRINTF("[LITERAL]\n"); break; case RIV_START: DEBUG_PRINTF("[START]\n"); break; case RIV_ANCHORED_START: DEBUG_PRINTF("[ANCHOR]\n"); break; case RIV_ACCEPT: break; case RIV_ACCEPT_EOD: DEBUG_PRINTF("[EOD]\n"); break; default: assert(0); DEBUG_PRINTF("????\n"); return false; } for (const auto &e : out_edges_range(v, ig)) { RoseInVertex t = target(e, ig); assert(contains(max_depth_from_eod, t)); u64a max_width; if (ig[v].type == RIV_START || ig[v].type == RIV_ANCHORED_START) { /* start itself doesn't need to be in history buffer * just need to make sure all succ literals are ok */ if (ig[t].type == RIV_LITERAL) { max_width = ig[t].s.length(); } else { max_width = 0; } if (ig[e].graph) { depth graph_max_width = findMaxWidth(*ig[e].graph); DEBUG_PRINTF("graph max width %s, lag %u\n", graph_max_width.str().c_str(), ig[e].graph_lag); if (!graph_max_width.is_finite()) { DEBUG_PRINTF("fail due to graph with inf max width\n"); return false; } max_width += graph_max_width; } } else if (ig[e].haig) { DEBUG_PRINTF("fail due to haig\n"); return false; } else if (ig[e].graph) { depth graph_max_width = findMaxWidth(*ig[e].graph); DEBUG_PRINTF("graph max width %s, lag %u\n", graph_max_width.str().c_str(), ig[e].graph_lag); if (!graph_max_width.is_finite()) { DEBUG_PRINTF("fail due to graph with inf max width\n"); return false; } max_width = ig[e].graph_lag + graph_max_width; } else { max_width = ig[e].maxBound; if (ig[t].type == RIV_LITERAL) { max_width += ig[t].s.length(); } } max_width += max_depth_from_eod[t]; if (max_width > ROSE_BOUND_INF) { max_width = ROSE_BOUND_INF; } DEBUG_PRINTF("max_width=%llu\n", max_width); ENSURE_AT_LEAST(&v_depth, (u32)max_width); } if (v_depth == ROSE_BOUND_INF || v_depth > cc.grey.maxHistoryAvailable) { DEBUG_PRINTF("not suitable for eod table %u\n", v_depth); return false; } max_depth_from_eod[v] = v_depth; ENSURE_AT_LEAST(max_len, v_depth); } DEBUG_PRINTF("to the eod table and beyond\n"); return true; } static void shift_accepts_to_end(const RoseInGraph &ig, vector &topo_order) { stable_partition(begin(topo_order), end(topo_order), [&](RoseInVertex v){ return !is_any_accept(v, ig); }); } static void populateRoseGraph(RoseBuildImpl *tbi, RoseBuildData &bd) { const RoseInGraph &ig = bd.ig; /* add the pattern in to the main rose graph */ DEBUG_PRINTF("%srose pop\n", bd.som ? "som " : ""); /* Note: an input vertex may need to create several rose vertices. This is * primarily because a RoseVertex can only have 1 one leftfix */ map > vertex_map; vector v_order = topo_order(ig); shift_accepts_to_end(ig, v_order); u32 eod_space_required; bool use_eod_table = suitableForEod(ig, v_order, &eod_space_required, tbi->cc); if (use_eod_table) { ENSURE_AT_LEAST(&tbi->ematcher_region_size, eod_space_required); } assert(ig[v_order.front()].type == RIV_START || ig[v_order.front()].type == RIV_ANCHORED_START); for (RoseInVertex iv : v_order) { DEBUG_PRINTF("vertex %zu\n", ig[iv].index); if (ig[iv].type == RIV_START) { DEBUG_PRINTF("is root\n"); vertex_map[iv].push_back(tbi->root); continue; } else if (ig[iv].type == RIV_ANCHORED_START) { DEBUG_PRINTF("is anchored root\n"); vertex_map[iv].push_back(tbi->anchored_root); continue; } vector > parents; for (const auto &e : in_edges_range(iv, ig)) { RoseInVertex u = source(e, ig); assert(contains(vertex_map, u)); const vector &images = vertex_map[u]; // We should have no dupes. assert(set(images.begin(), images.end()).size() == images.size()); for (auto v_image : images) { // v_image should NOT already be in our parents list. assert(find_if(parents.begin(), parents.end(), [&v_image](const pair &p) { return p.first == v_image; }) == parents.end()); parents.emplace_back(v_image, e); if (tbi->isAnchored(v_image)) { assert(!use_eod_table); u32 overlap = findRoseAnchorFloatingOverlap(ig[e], ig[iv]); assert(overlap <= tbi->cc.grey.maxHistoryAvailable + 1); ENSURE_AT_LEAST(&tbi->max_rose_anchored_floating_overlap, overlap); } } } if (ig[iv].type == RIV_LITERAL) { DEBUG_PRINTF("LITERAL '%s'\n", dumpString(ig[iv].s).c_str()); assert(!isLeafNode(iv, ig)); doRoseLiteralVertex(tbi, use_eod_table, vertex_map, parents, iv, bd); } else { if (ig[iv].type == RIV_ACCEPT) { DEBUG_PRINTF("ACCEPT\n"); } else { assert(ig[iv].type == RIV_ACCEPT_EOD); DEBUG_PRINTF("ACCEPT_EOD\n"); } assert(isLeafNode(iv, ig)); /* accepts are final */ doRoseAcceptVertex(tbi, parents, iv, bd); } } DEBUG_PRINTF("done\n"); } template static bool empty(const GraphT &g) { typename GraphT::vertex_iterator vi, ve; tie(vi, ve) = vertices(g); return vi == ve; } /* We only try to implement as a dfa if a non-nullptr as_dfa is provided to return * the raw dfa to. */ static bool canImplementGraph(RoseBuildImpl *tbi, const RoseInGraph &in, NGHolder &h, const vector &edges, bool prefilter, const ReportManager &rm, const CompileContext &cc, bool finalChance, unique_ptr *as_dfa) { assert(!edges.empty()); assert(&*in[edges[0]].graph == &h); assert(h.kind == whatRoseIsThis(in, edges[0])); if (isImplementableNFA(h, &rm, cc)) { return true; } if (prefilter && cc.grey.prefilterReductions) { // If we're prefiltering, we can have another go with a reduced graph. UNUSED size_t numBefore = num_vertices(h); prefilterReductions(h, cc); UNUSED size_t numAfter = num_vertices(h); DEBUG_PRINTF("reduced from %zu to %zu vertices\n", numBefore, numAfter); if (isImplementableNFA(h, &rm, cc)) { return true; } } if (as_dfa) { switch (h.kind) { case NFA_OUTFIX: /* 'prefix' of eod */ case NFA_PREFIX: if (!cc.grey.earlyMcClellanPrefix) { return false; } break; case NFA_INFIX: if (!cc.grey.earlyMcClellanInfix) { return false; } break; case NFA_SUFFIX: if (!cc.grey.earlyMcClellanSuffix) { return false; } break; case NFA_EAGER_PREFIX: case NFA_REV_PREFIX: case NFA_OUTFIX_RAW: DEBUG_PRINTF("kind %u\n", (u32)h.kind); assert(0); } assert(!*as_dfa); assert(tbi); vector > triggers; u32 min_offset = ~0U; u32 max_offset = 0; for (const auto &e : edges) { RoseInVertex s = source(e, in); RoseInVertex t = target(e, in); if (in[s].type == RIV_LITERAL) { triggers.push_back(as_cr_seq(in[s].s)); } if (in[t].type == RIV_ACCEPT_EOD) { /* TODO: support eod prefixes */ return false; } ENSURE_AT_LEAST(&max_offset, in[s].max_offset); LIMIT_TO_AT_MOST(&min_offset, in[s].min_offset); } if (!generates_callbacks(h)) { setReportId(h, tbi->getNewNfaReport()); } bool single_trigger = min_offset == max_offset; DEBUG_PRINTF("trying for mcclellan (%u, %u)\n", min_offset, max_offset); *as_dfa = buildMcClellan(h, &rm, single_trigger, triggers, cc.grey, finalChance); if (*as_dfa) { return true; } } DEBUG_PRINTF("unable to build engine\n"); return false; } static bool predsAreDelaySensitive(const RoseInGraph &ig, RoseInVertex v) { assert(in_degree(v, ig)); for (const auto &e : in_edges_range(v, ig)) { if (ig[e].graph || ig[e].haig) { DEBUG_PRINTF("edge graph\n"); return true; } if (ig[e].minBound || ig[e].maxBound != ROSE_BOUND_INF) { DEBUG_PRINTF("edge bounds\n"); return true; } RoseInVertex u = source(e, ig); if (ig[u].type == RIV_START) { continue; } if (ig[u].type != RIV_LITERAL) { DEBUG_PRINTF("unsafe pred vertex\n"); return true; } if (ig[u].delay) { DEBUG_PRINTF("pred has delay\n"); return true; } } return false; } static u32 maxAvailableDelay(const ue2_literal &pred_key, const ue2_literal &lit_key) { /* overly conservative if only part of the string is nocase */ string pred = pred_key.get_string(); string lit = lit_key.get_string(); if (pred_key.any_nocase() || lit_key.any_nocase()) { upperString(pred); upperString(lit); } string::size_type last = pred.rfind(lit); if (last == string::npos) { return MAX_DELAY; } u32 raw = pred.size() - last - 1; return MIN(raw, MAX_DELAY); } static u32 findMaxSafeDelay(const RoseInGraph &ig, RoseInVertex u, RoseInVertex v) { // First, check the overlap constraints on (u,v). size_t max_delay; if (ig[v].type == RIV_LITERAL) { DEBUG_PRINTF("lit->lit edge: '%s' -> '%s'\n", escapeString(ig[u].s).c_str(), escapeString(ig[v].s).c_str()); max_delay = maxAvailableDelay(ig[u].s, ig[v].s); } else if (ig[v].type == RIV_ACCEPT) { DEBUG_PRINTF("lit->accept edge: '%s' -> ACCEPT\n", escapeString(ig[u].s).c_str()); max_delay = MAX_DELAY; } else { assert(0); return 0; } DEBUG_PRINTF("max safe delay for this edge: %zu\n", max_delay); // Now consider the predecessors of u. for (const auto &e : in_edges_range(u, ig)) { RoseInVertex w = source(e, ig); if (ig[w].type == RIV_START) { continue; } assert(ig[w].type == RIV_LITERAL); assert(ig[w].delay == 0); DEBUG_PRINTF("pred lit->lit edge: '%s' -> '%s'\n", escapeString(ig[w].s).c_str(), escapeString(ig[u].s).c_str()); // We cannot delay the literal on u so much that a predecessor literal // could occur in the delayed region. For example, consider // 'barman.*foobar': if we allow 'foobar' to be delayed by 3, then // 'barman' could occur in the input string and race with 'foobar', as // in 'foobarman'. const size_t pred_len = ig[w].s.length(); size_t overlap = maxOverlap(ig[u].s, ig[w].s, 0); DEBUG_PRINTF("pred_len=%zu, overlap=%zu\n", pred_len, overlap); assert(overlap <= pred_len); size_t max_lit_delay = pred_len - min(overlap + 1, pred_len); DEBUG_PRINTF("overlap=%zu -> max_lit_delay=%zu\n", overlap, max_lit_delay); max_delay = min(max_delay, max_lit_delay); } DEBUG_PRINTF("max_delay=%zu\n", max_delay); assert(max_delay <= MAX_DELAY); return max_delay; } static bool transformInfixToDelay(const RoseInGraph &ig, const RoseInEdge &e, const CompileContext &cc, u32 *delay_out) { const u32 max_history = cc.streaming ? cc.grey.maxHistoryAvailable : ROSE_BOUND_INF; const RoseInVertex u = source(e, ig), v = target(e, ig); const u32 graph_lag = ig[e].graph_lag; // Clone a copy of the graph, as we need to be able to roll back this // operation. NGHolder h; cloneHolder(h, *ig[e].graph); DEBUG_PRINTF("target literal: %s\n", dumpString(ig[v].s).c_str()); DEBUG_PRINTF("graph with %zu vertices and graph_lag %u\n", num_vertices(h), graph_lag); assert(graph_lag <= ig[v].s.length()); if (graph_lag < ig[v].s.length()) { size_t len = ig[v].s.length() - graph_lag; ue2_literal lit(ig[v].s.substr(0, len)); DEBUG_PRINTF("lit2=%s\n", dumpString(lit).c_str()); u32 delay2 = removeTrailingLiteralStates(h, lit, max_history); if (delay2 == MO_INVALID_IDX) { DEBUG_PRINTF("couldn't remove trailing literal\n"); return false; } if (delay2 != len) { DEBUG_PRINTF("couldn't remove entire trailing literal\n"); return false; } } PureRepeat repeat; if (!isPureRepeat(h, repeat)) { DEBUG_PRINTF("graph is not repeat\n"); return false; } DEBUG_PRINTF("graph is %s repeat\n", repeat.bounds.str().c_str()); if (!repeat.bounds.max.is_infinite()) { DEBUG_PRINTF("not inf\n"); return false; } if (!repeat.reach.all()) { DEBUG_PRINTF("non-dot reach\n"); return false; } u32 delay = ig[v].s.length() + repeat.bounds.min; if (delay > MAX_DELAY) { DEBUG_PRINTF("delay %u > MAX_DELAY\n", delay); return false; } if (delay + ig[u].s.length() - 1 > max_history) { DEBUG_PRINTF("delay too large for history\n"); return false; } *delay_out = delay; return true; } static void transformLiteralDelay(RoseInGraph &ig, const CompileContext &cc) { if (!cc.grey.roseTransformDelay) { return; } for (auto u : vertices_range(ig)) { if (ig[u].type != RIV_LITERAL) { continue; } if (out_degree(u, ig) != 1) { continue; } RoseInEdge e = *out_edges(u, ig).first; RoseInVertex v = target(e, ig); if (ig[v].type != RIV_LITERAL) { continue; } if (ig[e].haig) { continue; } if (!ig[e].graph) { continue; } if (predsAreDelaySensitive(ig, u)) { DEBUG_PRINTF("preds are delay sensitive\n"); continue; } u32 max_delay = findMaxSafeDelay(ig, u, v); DEBUG_PRINTF("lit->lit edge with graph: '%s' -> '%s'\n", escapeString(ig[u].s).c_str(), escapeString(ig[v].s).c_str()); u32 delay = 0; if (!transformInfixToDelay(ig, e, cc, &delay)) { continue; } if (delay > max_delay) { DEBUG_PRINTF("delay=%u > max_delay=%u\n", delay, max_delay); continue; } DEBUG_PRINTF("setting lit delay to %u and deleting graph\n", delay); ig[u].delay = delay; ig[u].min_offset = add_rose_depth(ig[u].min_offset, delay); ig[u].max_offset = add_rose_depth(ig[u].max_offset, delay); ig[e].graph_lag = 0; ig[e].graph.reset(); ig[e].minBound = 0; ig[e].maxBound = ROSE_BOUND_INF; } } static bool transformInfixToAnchBounds(const RoseInGraph &ig, const RoseInEdge &e, const CompileContext &cc, DepthMinMax *bounds) { const u32 max_history = cc.streaming ? cc.grey.maxHistoryAvailable : ROSE_BOUND_INF; const RoseInVertex v = target(e, ig); const u32 graph_lag = ig[e].graph_lag; // Clone a copy of the graph, as we need to be able to roll back this // operation. NGHolder h; cloneHolder(h, *ig[e].graph); DEBUG_PRINTF("graph with %zu vertices and graph_lag %u\n", num_vertices(h), graph_lag); assert(graph_lag <= ig[v].s.length()); if (graph_lag < ig[v].s.length()) { size_t len = ig[v].s.length() - graph_lag; ue2_literal lit(ig[v].s.substr(0, len)); DEBUG_PRINTF("lit2=%s\n", dumpString(lit).c_str()); u32 delay2 = removeTrailingLiteralStates(h, lit, max_history); if (delay2 == MO_INVALID_IDX) { DEBUG_PRINTF("couldn't remove trailing literal\n"); return false; } if (delay2 != len) { DEBUG_PRINTF("couldn't remove entire trailing literal\n"); return false; } } PureRepeat repeat; if (!isPureRepeat(h, repeat)) { DEBUG_PRINTF("graph is not repeat\n"); return false; } DEBUG_PRINTF("graph is %s repeat\n", repeat.bounds.str().c_str()); if (!repeat.bounds.max.is_infinite()) { DEBUG_PRINTF("not inf\n"); return false; } if (!repeat.reach.all()) { DEBUG_PRINTF("non-dot reach\n"); return false; } *bounds = repeat.bounds; return true; } static void transformAnchoredLiteralOverlap(RoseInGraph &ig, RoseBuildData &bd, const CompileContext &cc) { if (!cc.grey.roseTransformDelay) { return; } for (const auto &e : edges_range(ig)) { const RoseInVertex u = source(e, ig); const RoseInVertex v = target(e, ig); if (ig[u].type != RIV_LITERAL || ig[v].type != RIV_LITERAL) { continue; } if (ig[e].haig || !ig[e].graph) { continue; } if (ig[u].min_offset != ig[u].max_offset) { DEBUG_PRINTF("u not fixed depth\n"); continue; } DEBUG_PRINTF("anch_lit->lit edge with graph: '%s' -> '%s'\n", escapeString(ig[u].s).c_str(), escapeString(ig[v].s).c_str()); DepthMinMax bounds; if (!transformInfixToAnchBounds(ig, e, cc, &bounds)) { continue; } DEBUG_PRINTF("setting bounds to %s and deleting graph\n", bounds.str().c_str()); ig[e].graph_lag = 0; ig[e].graph.reset(); ig[e].minBound = bounds.min; ig[e].maxBound = bounds.max.is_finite() ? (u32)bounds.max : ROSE_BOUND_INF; bd.anch_history_edges.insert(e); } } /** * \brief Transform small trailing dot repeat suffixes into delay on the last * literal. * * For example, the case /hatstand.*teakettle./s can just delay 'teakettle' +1 * rather than having a suffix to handle the dot. * * This transformation looks for literal->accept edges and transforms them if * appropriate. It doesn't handle complex cases where the literal has more than * one successor. */ static void transformSuffixDelay(RoseInGraph &ig, const CompileContext &cc) { if (!cc.grey.roseTransformDelay) { return; } const u32 max_history = cc.streaming ? cc.grey.maxHistoryAvailable : ROSE_BOUND_INF; set modified_accepts; // may be dead after transform for (auto u : vertices_range(ig)) { if (ig[u].type != RIV_LITERAL) { continue; } if (out_degree(u, ig) != 1) { continue; } RoseInEdge e = *out_edges(u, ig).first; RoseInVertex v = target(e, ig); if (ig[v].type != RIV_ACCEPT) { continue; } if (ig[e].haig) { continue; } if (!ig[e].graph) { continue; } if (predsAreDelaySensitive(ig, u)) { DEBUG_PRINTF("preds are delay sensitive\n"); continue; } DEBUG_PRINTF("lit->accept edge with graph: lit='%s'\n", escapeString(ig[u].s).c_str()); const NGHolder &h = *ig[e].graph; const set reports = all_reports(h); if (reports.size() != 1) { DEBUG_PRINTF("too many reports\n"); continue; } PureRepeat repeat; if (!isPureRepeat(h, repeat)) { DEBUG_PRINTF("suffix graph is not repeat\n"); continue; } DEBUG_PRINTF("suffix graph is %s repeat\n", repeat.bounds.str().c_str()); if (!repeat.reach.all()) { DEBUG_PRINTF("non-dot reach\n"); continue; } if (repeat.bounds.min != repeat.bounds.max || repeat.bounds.min > depth(MAX_DELAY)) { DEBUG_PRINTF("repeat is variable or too large\n"); continue; } u32 max_delay = findMaxSafeDelay(ig, u, v); u32 delay = repeat.bounds.min; if (delay > max_delay) { DEBUG_PRINTF("delay=%u > max_delay=%u\n", delay, max_delay); continue; } if (delay + ig[u].s.length() - 1 > max_history) { DEBUG_PRINTF("delay too large for history\n"); continue; } DEBUG_PRINTF("setting lit delay to %u and removing suffix\n", delay); ig[u].delay = delay; ig[u].min_offset = add_rose_depth(ig[u].min_offset, delay); ig[u].max_offset = add_rose_depth(ig[u].max_offset, delay); // Construct a new accept vertex for this report and remove edge e. // (This allows us to cope if v has more than one in-edge). RoseInVertex v2 = add_vertex(RoseInVertexProps::makeAccept(reports), ig); add_edge(u, v2, ig); remove_edge(e, ig); modified_accepts.insert(v); } DEBUG_PRINTF("%zu modified accepts\n", modified_accepts.size()); for (auto v : modified_accepts) { if (in_degree(v, ig) == 0) { DEBUG_PRINTF("removing accept vertex with no preds\n"); remove_vertex(v, ig); } } } #ifndef NDEBUG static bool validateKinds(const RoseInGraph &g) { for (const auto &e : edges_range(g)) { if (g[e].graph && g[e].graph->kind != whatRoseIsThis(g, e)) { return false; } } return true; } #endif bool RoseBuildImpl::addRose(const RoseInGraph &ig, bool prefilter, bool finalChance) { DEBUG_PRINTF("trying to rose\n"); assert(validateKinds(ig)); assert(hasCorrectlyNumberedVertices(ig)); if (::ue2::empty(ig)) { assert(0); return false; } const unique_ptr in_ptr = cloneRoseGraph(ig); RoseInGraph &in = *in_ptr; RoseBuildData bd(in, false); transformLiteralDelay(in, cc); transformAnchoredLiteralOverlap(in, bd, cc); transformSuffixDelay(in, cc); renumber_vertices(in); assert(validateKinds(in)); map > graphs; vector ordered_graphs; // Stored in first-encounter order. for (const auto &e : edges_range(in)) { if (!in[e].graph) { continue; // no graph } if (in[e].haig) { // Haigs are always implementable (we've already built the raw DFA). continue; } NGHolder *h = in[e].graph.get(); assert(isCorrectlyTopped(*h)); if (!contains(graphs, h)) { ordered_graphs.push_back(h); } graphs[h].push_back(e); } assert(ordered_graphs.size() == graphs.size()); vector graph_edges; for (auto h : ordered_graphs) { const vector &h_edges = graphs.at(h); unique_ptr as_dfa; /* allow finalChance as fallback is basically an outfix at this point */ if (!canImplementGraph(this, in, *h, h_edges, prefilter, rm, cc, finalChance, &as_dfa)) { return false; } if (as_dfa) { bd.early_dfas[h] = move(as_dfa); } insert(&graph_edges, graph_edges.end(), h_edges); } /* we are now past the point of no return. We can start making irreversible changes to the rose graph, etc */ for (const auto &e : graph_edges) { assert(in[e].graph); assert(!in[e].haig); NGHolder &h = *in[e].graph; DEBUG_PRINTF("handling %p\n", &h); assert(allMatchStatesHaveReports(h)); if (!generates_callbacks(whatRoseIsThis(in, e)) && !contains(bd.early_dfas, &h) && in[target(e, in)].type != RIV_ACCEPT_EOD) { setReportId(h, getNewNfaReport()); } } populateRoseGraph(this, bd); return true; } bool RoseBuildImpl::addSombeRose(const RoseInGraph &ig) { DEBUG_PRINTF("rose is trying to consume a sombe\n"); assert(validateKinds(ig)); if (::ue2::empty(ig)) { assert(0); return false; } RoseBuildData bd(ig, true); for (const auto &e : edges_range(ig)) { if (!ig[e].graph) { continue; // no graph } DEBUG_PRINTF("handling %p\n", ig[e].graph.get()); assert(allMatchStatesHaveReports(*ig[e].graph)); assert(ig[e].haig); } populateRoseGraph(this, bd); return true; } bool roseCheckRose(const RoseInGraph &ig, bool prefilter, const ReportManager &rm, const CompileContext &cc) { assert(validateKinds(ig)); if (::ue2::empty(ig)) { assert(0); return false; } map> graphs; for (const auto &e : edges_range(ig)) { if (!ig[e].graph) { continue; // no graph } if (ig[e].haig) { // Haigs are always implementable (we've already built the raw DFA). continue; } graphs[ig[e].graph.get()].push_back(e); } for (const auto &m : graphs) { if (!canImplementGraph(nullptr, ig, *m.first, m.second, prefilter, rm, cc, false, nullptr)) { return false; } } return true; } void RoseBuildImpl::add(bool anchored, bool eod, const ue2_literal &lit, const ue2::flat_set &reports) { assert(!reports.empty()); if (cc.grey.floodAsPuffette && !anchored && !eod && is_flood(lit) && lit.length() > 3) { DEBUG_PRINTF("adding as puffette\n"); const CharReach &cr = *lit.begin(); for (const auto &report : reports) { addOutfix(raw_puff(lit.length(), true, report, cr, true)); } return; } RoseInGraph ig; RoseInVertex start = add_vertex(RoseInVertexProps::makeStart(anchored), ig); RoseInVertex accept = add_vertex( eod ? RoseInVertexProps::makeAcceptEod(set()) : RoseInVertexProps::makeAccept(set()), ig); RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); add_edge(start, v, RoseInEdgeProps(0U, anchored ? 0U : ROSE_BOUND_INF), ig); add_edge(v, accept, RoseInEdgeProps(0U, 0U), ig); calcVertexOffsets(ig); ig[accept].reports.insert(reports.begin(), reports.end()); addRose(ig, false); } static u32 findMaxBAWidth(const NGHolder &h) { // Must be bi-anchored: no out-edges from startDs (other than its // self-loop), no in-edges to accept. if (out_degree(h.startDs, h) > 1 || in_degree(h.accept, h)) { return ROSE_BOUND_INF; } depth d = findMaxWidth(h); assert(d.is_reachable()); if (!d.is_finite()) { return ROSE_BOUND_INF; } return d; } static void populateOutfixInfo(OutfixInfo &outfix, const NGHolder &h, const RoseBuildImpl &tbi) { outfix.maxBAWidth = findMaxBAWidth(h); outfix.minWidth = findMinWidth(h); outfix.maxWidth = findMaxWidth(h); outfix.maxOffset = findMaxOffset(h, tbi.rm); populateReverseAccelerationInfo(outfix.rev_info, h); } bool RoseBuildImpl::addOutfix(const NGHolder &h) { DEBUG_PRINTF("%zu vertices, %zu edges\n", num_vertices(h), num_edges(h)); const u32 nfa_states = isImplementableNFA(h, &rm, cc); if (nfa_states) { DEBUG_PRINTF("implementable as an NFA in %u states\n", nfa_states); } else { DEBUG_PRINTF("not implementable as an NFA\n"); } bool dfa_cand = !nfa_states || nfa_states > 128 /* slow model */ || can_exhaust(h, rm); /* can be pruned */ unique_ptr rdfa; if (!nfa_states || cc.grey.roseMcClellanOutfix == 2 || (cc.grey.roseMcClellanOutfix == 1 && dfa_cand)) { rdfa = buildMcClellan(h, &rm, cc.grey); } if (!nfa_states && !rdfa) { DEBUG_PRINTF("could not build as either an NFA or a DFA\n"); return false; } if (rdfa) { outfixes.push_back(OutfixInfo(move(rdfa))); } else { outfixes.push_back(OutfixInfo(cloneHolder(h))); } populateOutfixInfo(outfixes.back(), h, *this); return true; } bool RoseBuildImpl::addOutfix(const NGHolder &h, const raw_som_dfa &haig) { DEBUG_PRINTF("haig with %zu states\n", haig.states.size()); outfixes.push_back(OutfixInfo(ue2::make_unique(haig))); populateOutfixInfo(outfixes.back(), h, *this); return true; /* failure is not yet an option */ } bool RoseBuildImpl::addOutfix(const raw_puff &rp) { if (!mpv_outfix) { mpv_outfix = make_unique(MpvProto()); } auto *mpv = mpv_outfix->mpv(); assert(mpv); mpv->puffettes.push_back(rp); mpv_outfix->maxBAWidth = ROSE_BOUND_INF; /* not ba */ mpv_outfix->minWidth = min(mpv_outfix->minWidth, depth(rp.repeats)); mpv_outfix->maxWidth = rp.unbounded ? depth::infinity() : max(mpv_outfix->maxWidth, depth(rp.repeats)); if (mpv_outfix->maxOffset == ROSE_BOUND_INF || rp.unbounded) { mpv_outfix->maxOffset = ROSE_BOUND_INF; } else { mpv_outfix->maxOffset = MAX(mpv_outfix->maxOffset, rp.repeats); } return true; /* failure is not yet an option */ } bool RoseBuildImpl::addChainTail(const raw_puff &rp, u32 *queue_out, u32 *event_out) { if (!mpv_outfix) { mpv_outfix = make_unique(MpvProto()); } auto *mpv = mpv_outfix->mpv(); assert(mpv); mpv->triggered_puffettes.push_back(rp); mpv_outfix->maxBAWidth = ROSE_BOUND_INF; /* not ba */ mpv_outfix->minWidth = min(mpv_outfix->minWidth, depth(rp.repeats)); mpv_outfix->maxWidth = rp.unbounded ? depth::infinity() : max(mpv_outfix->maxWidth, depth(rp.repeats)); mpv_outfix->maxOffset = ROSE_BOUND_INF; /* TODO: we could get information from * the caller */ *queue_out = mpv_outfix->get_queue(qif); *event_out = MQE_TOP_FIRST + mpv->triggered_puffettes.size() - 1; return true; /* failure is not yet an option */ } static bool prepAcceptForAddAnchoredNFA(RoseBuildImpl &tbi, const NGHolder &w, u32 max_adj, NFAVertex u, const vector &vertexDepths, map &depthMap, map > &reportMap, map &allocated_reports, flat_set &added_lit_ids) { const depth max_anchored_depth(tbi.cc.grey.maxAnchoredRegion); const size_t index = w[u].index; assert(index < vertexDepths.size()); const DepthMinMax &d = vertexDepths.at(index); for (const auto &int_report : w[u].reports) { assert(int_report != MO_INVALID_IDX); u32 lit_id; if (!contains(allocated_reports, int_report)) { lit_id = tbi.getNewLiteralId(); added_lit_ids.insert(lit_id); allocated_reports[int_report] = lit_id; } else { lit_id = allocated_reports[int_report]; } reportMap[u].insert(lit_id); if (!contains(depthMap, lit_id)) { depthMap[lit_id] = d; } else { depthMap[lit_id] = unionDepthMinMax(depthMap[lit_id], d); } if (depthMap[lit_id].max + depth(max_adj) > max_anchored_depth) { DEBUG_PRINTF("depth=%s exceeds maxAnchoredRegion=%u\n", (depthMap[lit_id].max + depth(max_adj)).str().c_str(), tbi.cc.grey.maxAnchoredRegion); return false; } } return true; } // Failure path for addAnchoredAcyclic: removes the literal IDs that have been // added to support anchored NFAs. Assumes that they are a contiguous range at // the end of the RoseBuildImpl::literal_info vector. static void removeAddedLiterals(RoseBuildImpl &tbi, const flat_set &lit_ids) { if (lit_ids.empty()) { return; } // lit_ids should be a contiguous range. assert(lit_ids.size() == *lit_ids.rbegin() - *lit_ids.begin() + 1); for (const u32 &lit_id : lit_ids) { assert(lit_id < tbi.literal_info.size()); assert(tbi.literals.right.at(lit_id).table == ROSE_ANCHORED); assert(tbi.literal_info[lit_id].vertices.empty()); tbi.literals.right.erase(lit_id); } // lit_ids should be at the end of tbi.literal_info. assert(tbi.literal_info.size() == *lit_ids.rbegin() + 1); tbi.literal_info.resize(*lit_ids.begin()); // remove all ids in lit_ids } bool RoseBuildImpl::addAnchoredAcyclic(const NGHolder &h) { vector vertexDepths; calcDepthsFrom(h, h.start, vertexDepths); map > reportMap; /* NFAVertex -> literal ids */ map depthMap; /* literal id -> min/max depth */ map allocated_reports; /* report -> literal id */ flat_set added_lit_ids; /* literal ids added for this NFA */ for (auto v : inv_adjacent_vertices_range(h.accept, h)) { if (!prepAcceptForAddAnchoredNFA(*this, h, 0, v, vertexDepths, depthMap, reportMap, allocated_reports, added_lit_ids)) { removeAddedLiterals(*this, added_lit_ids); return false; } } map allocated_reports_eod; /* report -> literal id */ for (auto v : inv_adjacent_vertices_range(h.acceptEod, h)) { if (v == h.accept) { continue; } if (!prepAcceptForAddAnchoredNFA(*this, h, 0, v, vertexDepths, depthMap, reportMap, allocated_reports_eod, added_lit_ids)) { removeAddedLiterals(*this, added_lit_ids); return false; } } assert(!reportMap.empty()); int rv = addAnchoredNFA(*this, h, reportMap); if (rv != ANCHORED_FAIL) { assert(rv != ANCHORED_REMAP); DEBUG_PRINTF("added anchored nfa\n"); /* add edges to the rose graph to bubble the match up */ for (const auto &m : allocated_reports) { const ReportID &report = m.first; const u32 &lit_id = m.second; assert(depthMap[lit_id].max.is_finite()); u32 minBound = depthMap[lit_id].min; u32 maxBound = depthMap[lit_id].max; RoseVertex v = createAnchoredVertex(this, lit_id, minBound, maxBound); g[v].reports.insert(report); } for (const auto &m : allocated_reports_eod) { const ReportID &report = m.first; const u32 &lit_id = m.second; assert(depthMap[lit_id].max.is_finite()); u32 minBound = depthMap[lit_id].min; u32 maxBound = depthMap[lit_id].max; RoseVertex v = createAnchoredVertex(this, lit_id, minBound, maxBound); RoseVertex eod = add_vertex(g); g[eod].eod_accept = true; g[eod].reports.insert(report); g[eod].min_offset = g[v].min_offset; g[eod].max_offset = g[v].max_offset; add_edge(v, eod, g); } return true; } else { DEBUG_PRINTF("failed to add anchored nfa\n"); removeAddedLiterals(*this, added_lit_ids); return false; } } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_engine_blob.h0000644000175000017500000001076413055426554022671 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 ROSE_BUILD_ENGINE_BLOB_H #define ROSE_BUILD_ENGINE_BLOB_H #include "rose_internal.h" #include "ue2common.h" #include "util/alloc.h" #include "util/container.h" #include "util/multibit_build.h" #include "util/ue2_containers.h" #include "util/verify_types.h" #include #include #include namespace ue2 { class RoseEngineBlob : boost::noncopyable { public: /** \brief Base offset of engine_blob in the Rose engine bytecode. */ static constexpr u32 base_offset = ROUNDUP_CL(sizeof(RoseEngine)); bool empty() const { return blob.empty(); } size_t size() const { return blob.size(); } const char *data() const { return blob.data(); } u32 add(const void *a, const size_t len, const size_t align) { pad(align); size_t rv = base_offset + blob.size(); assert(rv >= base_offset); DEBUG_PRINTF("write %zu bytes at offset %zu\n", len, rv); assert(ISALIGNED_N(blob.size(), align)); blob.resize(blob.size() + len); memcpy(&blob.back() - len + 1, a, len); return verify_u32(rv); } template u32 add(const T &a) { static_assert(std::is_pod::value, "should be pod"); return add(&a, sizeof(a), alignof(T)); } template u32 add(const T &a, const size_t len) { static_assert(std::is_pod::value, "should be pod"); return add(&a, len, alignof(T)); } template u32 add(Iter b, const Iter &e) { using value_type = typename std::iterator_traits::value_type; static_assert(std::is_pod::value, "should be pod"); if (b == e) { return 0; } u32 offset = add(*b); for (++b; b != e; ++b) { add(*b); } return offset; } u32 add_iterator(const std::vector &iter) { auto cache_it = cached_iters.find(iter); if (cache_it != cached_iters.end()) { u32 offset = cache_it->second; DEBUG_PRINTF("cache hit for iter at %u\n", offset); return offset; } u32 offset = add(iter.begin(), iter.end()); cached_iters.emplace(iter, offset); return offset; } void write_bytes(RoseEngine *engine) { copy_bytes((char *)engine + base_offset, blob); } private: void pad(size_t align) { assert(ISALIGNED_N(base_offset, align)); size_t s = blob.size(); if (ISALIGNED_N(s, align)) { return; } blob.resize(s + align - s % align); } /** \brief Cache of previously-written sparse iterators. */ unordered_map, u32> cached_iters; /** * \brief Contents of the Rose bytecode immediately following the * RoseEngine. */ std::vector> blob; }; } // namespace ue2 #endif // ROSE_BUILD_ENGINE_BLOB_H hyperscan-4.4.1/src/rose/rose_build.h0000644000175000017500000001275113055426554020344 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose Build interface. * * Rose Build interface. Everything you ever needed to feed literals in and * get a RoseEngine out. This header should be everything needed by the rest * of UE2. */ #ifndef ROSE_BUILD_H #define ROSE_BUILD_H #include "ue2common.h" #include "rose_common.h" #include "rose_in_graph.h" #include "util/alloc.h" #include "util/charreach.h" #include "util/ue2_containers.h" #include "util/ue2string.h" #include #include #include #include #include struct NFA; struct SmallWriteEngine; struct RoseEngine; namespace ue2 { struct BoundaryReports; struct CompileContext; struct raw_puff; struct raw_som_dfa; class CharReach; class NGHolder; class ReportManager; class SmallWriteBuild; class SomSlotManager; class RoseDedupeAux { public: virtual ~RoseDedupeAux(); /** \brief True if we can not establish that at most a single callback will * be generated at a given offset from this set of reports. */ virtual bool requiresDedupeSupport(const ue2::flat_set &reports) const = 0; }; /** \brief Abstract interface intended for callers from elsewhere in the tree, * real underlying implementation is RoseBuildImpl in rose_build_impl.h. */ class RoseBuild : boost::noncopyable { public: virtual ~RoseBuild(); /** \brief Adds a single literal. */ virtual void add(bool anchored, bool eod, const ue2_literal &lit, const ue2::flat_set &ids) = 0; virtual bool addRose(const RoseInGraph &ig, bool prefilter, bool finalChance = false) = 0; virtual bool addSombeRose(const RoseInGraph &ig) = 0; virtual bool addOutfix(const NGHolder &h) = 0; virtual bool addOutfix(const NGHolder &h, const raw_som_dfa &haig) = 0; virtual bool addOutfix(const raw_puff &rp) = 0; virtual bool addChainTail(const raw_puff &rp, u32 *queue_out, u32 *event_out) = 0; /** \brief Returns true if we were able to add it as a mask. */ virtual bool add(bool anchored, const std::vector &mask, const ue2::flat_set &reports) = 0; /** \brief Attempts to add the graph to the anchored acyclic table. Returns * true on success. */ virtual bool addAnchoredAcyclic(const NGHolder &graph) = 0; virtual bool validateMask(const std::vector &mask, const ue2::flat_set &reports, bool anchored, bool eod) const = 0; virtual void addMask(const std::vector &mask, const ue2::flat_set &reports, bool anchored, bool eod) = 0; /** \brief Construct a runtime implementation. */ virtual ue2::aligned_unique_ptr buildRose(u32 minWidth) = 0; virtual std::unique_ptr generateDedupeAux() const = 0; /** Get a unique report identifier for a prefix|infix engine */ virtual ReportID getNewNfaReport() = 0; /** Note that we have seen a SOM pattern. */ virtual void setSom() = 0; }; // Construct a usable Rose builder. std::unique_ptr makeRoseBuilder(ReportManager &rm, SomSlotManager &ssm, SmallWriteBuild &smwr, const CompileContext &cc, const BoundaryReports &boundary); bool roseCheckRose(const RoseInGraph &ig, bool prefilter, const ReportManager &rm, const CompileContext &cc); size_t roseSize(const RoseEngine *t); /* used by heuristics to determine the small write engine. High numbers are * intended to indicate a lightweight rose. */ u32 roseQuality(const RoseEngine *t); bool roseIsPureLiteral(const RoseEngine *t); size_t maxOverlap(const ue2_literal &a, const ue2_literal &b, u32 b_delay); } // namespace ue2 #endif // ROSE_BUILD_H hyperscan-4.4.1/src/rose/rose_build_scatter.h0000644000175000017500000000471513055426554022072 0ustar sleuthkidsleuthkid/* * 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 ROSE_BUILD_SCATTER_H #define ROSE_BUILD_SCATTER_H #include "rose_internal.h" #include "util/scatter.h" #include namespace ue2 { class RoseBuildImpl; struct scatter_plan_raw { std::vector p_u64a; std::vector p_u32; std::vector p_u16; std::vector p_u8; }; void buildStateScatterPlan(u32 role_state_offset, u32 role_state_count, u32 left_array_count, u32 left_prefix_count, const RoseStateOffsets &stateOffsets, bool streaming, u32 leaf_array_count, u32 outfix_begin, u32 outfix_end, scatter_plan_raw *out); u32 aux_size(const scatter_plan_raw &raw); void write_out(scatter_full_plan *plan_out, void *aux_out, const scatter_plan_raw &raw, u32 aux_base_offset); } // namespace ue2 #endif hyperscan-4.4.1/src/rose/block.c0000644000175000017500000003500013055426554017272 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "catchup.h" #include "init.h" #include "match.h" #include "program_runtime.h" #include "rose.h" #include "rose_common.h" #include "nfa/nfa_api.h" #include "nfa/nfa_internal.h" #include "nfa/nfa_rev_api.h" #include "nfa/mcclellan.h" #include "util/fatbit.h" static rose_inline void runAnchoredTableBlock(const struct RoseEngine *t, const void *atable, struct hs_scratch *scratch) { const u8 *buffer = scratch->core_info.buf; size_t length = scratch->core_info.len; size_t alen = MIN(length, t->anchoredDistance); const struct anchored_matcher_info *curr = atable; DEBUG_PRINTF("BEGIN ANCHORED (over %zu/%zu)\n", alen, length); do { const struct NFA *nfa = (const struct NFA *)((const char *)curr + sizeof(*curr)); assert(t->anchoredDistance > curr->anchoredMinDistance); if (length >= curr->anchoredMinDistance) { size_t local_alen = alen - curr->anchoredMinDistance; const u8 *local_buffer = buffer + curr->anchoredMinDistance; DEBUG_PRINTF("--anchored nfa (+%u)\n", curr->anchoredMinDistance); assert(isMcClellanType(nfa->type)); if (nfa->type == MCCLELLAN_NFA_8) { nfaExecMcClellan8_B(nfa, curr->anchoredMinDistance, local_buffer, local_alen, roseAnchoredCallback, scratch); } else { nfaExecMcClellan16_B(nfa, curr->anchoredMinDistance, local_buffer, local_alen, roseAnchoredCallback, scratch); } } if (!curr->next_offset) { break; } curr = (const void *)((const char *)curr + curr->next_offset); } while (1); } static really_inline void init_state_for_block(const struct RoseEngine *t, char *state) { assert(t); assert(state); DEBUG_PRINTF("init for Rose %p with %u state indices\n", t, t->rolesWithStateCount); // Rose is guaranteed 8-aligned state assert(ISALIGNED_N(state, 8)); init_state(t, state); } static really_inline void init_outfixes_for_block(const struct RoseEngine *t, struct hs_scratch *scratch, char *state, char is_small_block) { /* active leaf array has been cleared by the init scatter */ if (t->initMpvNfa != MO_INVALID_IDX) { assert(t->initMpvNfa == 0); const struct NFA *nfa = getNfaByQueue(t, 0); DEBUG_PRINTF("testing minwidth %u > len %zu\n", nfa->minWidth, scratch->core_info.len); size_t len = nfaRevAccelCheck(nfa, scratch->core_info.buf, scratch->core_info.len); if (len) { u8 *activeArray = getActiveLeafArray(t, state); const u32 activeArraySize = t->activeArrayCount; const u32 qCount = t->queueCount; mmbit_set(activeArray, activeArraySize, 0); fatbit_set(scratch->aqa, qCount, 0); struct mq *q = scratch->queues; initQueue(q, 0, t, scratch); q->length = len; /* adjust for rev_accel */ nfaQueueInitState(nfa, q); pushQueueAt(q, 0, MQE_START, 0); pushQueueAt(q, 1, MQE_TOP, 0); } } if (is_small_block && !t->hasOutfixesInSmallBlock) { DEBUG_PRINTF("all outfixes in small block table\n"); return; } if (t->outfixBeginQueue != t->outfixEndQueue) { blockInitSufPQ(t, state, scratch, is_small_block); } } static really_inline void init_for_block(const struct RoseEngine *t, struct hs_scratch *scratch, char *state, char is_small_block) { init_state_for_block(t, state); struct RoseContext *tctxt = &scratch->tctxt; tctxt->groups = t->initialGroups; tctxt->lit_offset_adjust = 1; // index after last byte tctxt->delayLastEndOffset = 0; tctxt->lastEndOffset = 0; tctxt->filledDelayedSlots = 0; tctxt->lastMatchOffset = 0; tctxt->minMatchOffset = 0; tctxt->minNonMpvMatchOffset = 0; tctxt->next_mpv_offset = 0; scratch->al_log_sum = 0; fatbit_clear(scratch->aqa); scratch->catchup_pq.qm_size = 0; init_outfixes_for_block(t, scratch, state, is_small_block); } static rose_inline void roseBlockEodExec(const struct RoseEngine *t, u64a offset, struct hs_scratch *scratch) { assert(t->requiresEodCheck); assert(t->maxBiAnchoredWidth == ROSE_BOUND_INF || offset <= t->maxBiAnchoredWidth); assert(!can_stop_matching(scratch)); assert(t->eodProgramOffset); // Ensure that history is correct before we look for EOD matches. roseFlushLastByteHistory(t, scratch, offset); scratch->tctxt.lastEndOffset = offset; DEBUG_PRINTF("running eod program at %u\n", t->eodProgramOffset); // There should be no pending delayed literals. assert(!scratch->tctxt.filledDelayedSlots); const u64a som = 0; const size_t match_len = 0; const u8 flags = ROSE_PROG_FLAG_SKIP_MPV_CATCHUP; // Note: we ignore the result, as this is the last thing to ever happen on // a scan. roseRunProgram(t, scratch, t->eodProgramOffset, som, offset, match_len, flags); } /** * \brief Run the anchored matcher, if any. Returns non-zero if matching should * halt. */ static rose_inline int roseBlockAnchored(const struct RoseEngine *t, struct hs_scratch *scratch) { const void *atable = getALiteralMatcher(t); if (!atable) { DEBUG_PRINTF("no anchored table\n"); return 0; } const size_t length = scratch->core_info.len; if (t->amatcherMaxBiAnchoredWidth != ROSE_BOUND_INF && length > t->amatcherMaxBiAnchoredWidth) { return 0; } if (length < t->amatcherMinWidth) { return 0; } runAnchoredTableBlock(t, atable, scratch); return can_stop_matching(scratch); } /** * \brief Run the floating matcher, if any. Returns non-zero if matching should * halt. */ static rose_inline int roseBlockFloating(const struct RoseEngine *t, struct hs_scratch *scratch) { const struct HWLM *ftable = getFLiteralMatcher(t); if (!ftable) { return 0; } const size_t length = scratch->core_info.len; char *state = scratch->core_info.state; struct RoseContext *tctxt = &scratch->tctxt; DEBUG_PRINTF("ftable fd=%u fmd %u\n", t->floatingDistance, t->floatingMinDistance); if (t->noFloatingRoots && !roseHasInFlightMatches(t, state, scratch)) { DEBUG_PRINTF("skip FLOATING: no inflight matches\n"); return 0; } if (t->fmatcherMaxBiAnchoredWidth != ROSE_BOUND_INF && length > t->fmatcherMaxBiAnchoredWidth) { return 0; } if (length < t->fmatcherMinWidth) { return 0; } const u8 *buffer = scratch->core_info.buf; size_t flen = length; if (t->floatingDistance != ROSE_BOUND_INF) { flen = MIN(t->floatingDistance, length); } if (flen <= t->floatingMinDistance) { return 0; } DEBUG_PRINTF("BEGIN FLOATING (over %zu/%zu)\n", flen, length); DEBUG_PRINTF("-- %016llx\n", tctxt->groups); hwlmExec(ftable, buffer, flen, t->floatingMinDistance, roseFloatingCallback, scratch, tctxt->groups & t->floating_group_mask); return can_stop_matching(scratch); } static rose_inline void runEagerPrefixesBlock(const struct RoseEngine *t, struct hs_scratch *scratch) { if (!t->eagerIterOffset) { return; } char *state = scratch->core_info.state; u8 *ara = getActiveLeftArray(t, state); /* indexed by offsets into * left_table */ const u32 arCount = t->activeLeftCount; const u32 qCount = t->queueCount; const struct LeftNfaInfo *left_table = getLeftTable(t); const struct mmbit_sparse_iter *it = getByOffset(t, t->eagerIterOffset); struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES]; u32 idx = 0; u32 ri = mmbit_sparse_iter_begin(ara, arCount, &idx, it, si_state); for (; ri != MMB_INVALID; ri = mmbit_sparse_iter_next(ara, arCount, ri, &idx, it, si_state)) { const struct LeftNfaInfo *left = left_table + ri; u32 qi = ri + t->leftfixBeginQueue; DEBUG_PRINTF("leftfix %u/%u, maxLag=%u\n", ri, arCount, left->maxLag); assert(!fatbit_isset(scratch->aqa, qCount, qi)); assert(left->eager); assert(!left->infix); struct mq *q = scratch->queues + qi; const struct NFA *nfa = getNfaByQueue(t, qi); if (scratch->core_info.len < nfa->minWidth) { /* we know that there is not enough data for this to ever match, so * we can immediately squash/ */ mmbit_unset(ara, arCount, ri); scratch->tctxt.groups &= left->squash_mask; } s64a loc = MIN(scratch->core_info.len, EAGER_STOP_OFFSET); fatbit_set(scratch->aqa, qCount, qi); initRoseQueue(t, qi, left, scratch); pushQueueAt(q, 0, MQE_START, 0); pushQueueAt(q, 1, MQE_TOP, 0); pushQueueAt(q, 2, MQE_END, loc); nfaQueueInitState(nfa, q); char alive = nfaQueueExecToMatch(q->nfa, q, loc); if (!alive) { DEBUG_PRINTF("queue %u dead, squashing\n", qi); mmbit_unset(ara, arCount, ri); fatbit_unset(scratch->aqa, qCount, qi); scratch->tctxt.groups &= left->squash_mask; } else if (q->cur == q->end) { assert(alive != MO_MATCHES_PENDING); if (loc == (s64a)scratch->core_info.len) { /* We know that the prefix does not match in the block so we * can squash the groups anyway even though it did not die */ /* TODO: if we knew the minimum lag the leftfix is checked at we * could make this check tighter */ DEBUG_PRINTF("queue %u has no match in block, squashing\n", qi); mmbit_unset(ara, arCount, ri); fatbit_unset(scratch->aqa, qCount, qi); scratch->tctxt.groups &= left->squash_mask; } else { DEBUG_PRINTF("queue %u finished, nfa lives\n", qi); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } } else { assert(alive == MO_MATCHES_PENDING); DEBUG_PRINTF("queue %u unfinished, nfa lives\n", qi); q->end--; /* remove end item */ } } } void roseBlockExec(const struct RoseEngine *t, struct hs_scratch *scratch) { assert(t); assert(scratch); assert(scratch->core_info.buf); assert(mmbit_sparse_iter_state_size(t->rolesWithStateCount) < MAX_SPARSE_ITER_STATES); // We should not have been called if we've already been told to terminate // matching. assert(!told_to_stop_matching(scratch)); // If this block is shorter than our minimum width, then no pattern in this // RoseEngine could match. /* minWidth checks should have already been performed by the caller */ assert(scratch->core_info.len >= t->minWidth); // Similarly, we may have a maximum width (for engines constructed entirely // of bi-anchored patterns). /* This check is now handled by the interpreter */ assert(t->maxBiAnchoredWidth == ROSE_BOUND_INF || scratch->core_info.len <= t->maxBiAnchoredWidth); const size_t length = scratch->core_info.len; // We have optimizations for small block scans: we run a single coalesced // HWLM scan instead of running the anchored and floating matchers. Some // outfixes are disabled as well (for SEP scans of single-byte literals, // which are also run in the HWLM scan). const char is_small_block = (length < ROSE_SMALL_BLOCK_LEN && t->sbmatcherOffset); char *state = scratch->core_info.state; init_for_block(t, scratch, state, is_small_block); struct RoseContext *tctxt = &scratch->tctxt; if (is_small_block) { const void *sbtable = getSBLiteralMatcher(t); assert(sbtable); size_t sblen = MIN(length, t->smallBlockDistance); DEBUG_PRINTF("BEGIN SMALL BLOCK (over %zu/%zu)\n", sblen, length); DEBUG_PRINTF("-- %016llx\n", tctxt->groups); hwlmExec(sbtable, scratch->core_info.buf, sblen, 0, roseCallback, scratch, tctxt->groups); } else { runEagerPrefixesBlock(t, scratch); if (roseBlockAnchored(t, scratch)) { return; } if (roseBlockFloating(t, scratch)) { return; } } if (cleanUpDelayed(t, scratch, length, 0) == HWLM_TERMINATE_MATCHING) { return; } assert(!can_stop_matching(scratch)); roseCatchUpTo(t, scratch, length); if (!t->requiresEodCheck || !t->eodProgramOffset) { DEBUG_PRINTF("no eod check required\n"); return; } if (can_stop_matching(scratch)) { DEBUG_PRINTF("bailing, already halted\n"); return; } roseBlockEodExec(t, length, scratch); } hyperscan-4.4.1/src/rose/validate_shufti.h0000644000175000017500000001502213055426554021362 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 VALIDATE_SHUFTI_H #define VALIDATE_SHUFTI_H #include "ue2common.h" #include "util/simd_utils.h" #if defined(DEBUG) static void dumpMask(const void *mask, int len) { const u8 *c = (const u8 *)mask; for (int i = 0; i < len; i++) { printf("%02x", c[i]); } printf("\n"); } #endif static really_inline int validateShuftiMask16x16(const m256 data, const m256 hi_mask, const m256 lo_mask, const m256 and_mask, const u32 neg_mask, const u16 valid_data_mask) { m256 low4bits = set32x8(0xf); m256 c_lo = vpshufb(lo_mask, and256(data, low4bits)); m256 c_hi = vpshufb(hi_mask, rshift64_m256(andnot256(low4bits, data), 4)); m256 t = and256(c_lo, c_hi); u32 nresult = movemask256(eq256(and256(t, and_mask), zeroes256())); #ifdef DEBUG DEBUG_PRINTF("data\n"); dumpMask(&data, 32); DEBUG_PRINTF("hi_mask\n"); dumpMask(&hi_mask, 32); DEBUG_PRINTF("lo_mask\n"); dumpMask(&lo_mask, 32); DEBUG_PRINTF("c_lo\n"); dumpMask(&c_lo, 32); DEBUG_PRINTF("c_hi\n"); dumpMask(&c_hi, 32); DEBUG_PRINTF("and_mask\n"); dumpMask(&and_mask, 32); DEBUG_PRINTF("nresult %x\n", nresult); DEBUG_PRINTF("valid_data_mask %x\n", valid_data_mask); #endif u32 cmp_result = (((nresult >> 16) & nresult) ^ neg_mask) & valid_data_mask; return !cmp_result; } static really_inline int validateShuftiMask16x8(const m128 data, const m256 nib_mask, const m128 and_mask, const u32 neg_mask, const u16 valid_data_mask) { m256 data_m256 = combine2x128(rshift64_m128(data, 4), data); m256 low4bits = set32x8(0xf); m256 c_nib = vpshufb(nib_mask, and256(data_m256, low4bits)); m128 t = and128(movdq_hi(c_nib), movdq_lo(c_nib)); m128 nresult = eq128(and128(t, and_mask), zeroes128()); #ifdef DEBUG DEBUG_PRINTF("data\n"); dumpMask(&data_m256, 32); DEBUG_PRINTF("nib_mask\n"); dumpMask(&nib_mask, 32); DEBUG_PRINTF("c_nib\n"); dumpMask(&c_nib, 32); DEBUG_PRINTF("nresult\n"); dumpMask(&nresult, 16); DEBUG_PRINTF("valid_data_mask %x\n", valid_data_mask); #endif u32 cmp_result = (movemask128(nresult) ^ neg_mask) & valid_data_mask; return !cmp_result; } static really_inline int validateShuftiMask32x8(const m256 data, const m256 hi_mask, const m256 lo_mask, const m256 and_mask, const u32 neg_mask, const u32 valid_data_mask) { m256 low4bits = set32x8(0xf); m256 c_lo = vpshufb(lo_mask, and256(data, low4bits)); m256 c_hi = vpshufb(hi_mask, rshift64_m256(andnot256(low4bits, data), 4)); m256 t = and256(c_lo, c_hi); m256 nresult = eq256(and256(t, and_mask), zeroes256()); #ifdef DEBUG DEBUG_PRINTF("data\n"); dumpMask(&data, 32); DEBUG_PRINTF("hi_mask\n"); dumpMask(&hi_mask, 32); DEBUG_PRINTF("lo_mask\n"); dumpMask(&lo_mask, 32); DEBUG_PRINTF("c_lo\n"); dumpMask(&c_lo, 32); DEBUG_PRINTF("c_hi\n"); dumpMask(&c_hi, 32); DEBUG_PRINTF("nresult\n"); dumpMask(&nresult, 32); DEBUG_PRINTF("valid_data_mask %x\n", valid_data_mask); #endif u32 cmp_result = (movemask256(nresult) ^ neg_mask) & valid_data_mask; return !cmp_result; } static really_inline int validateShuftiMask32x16(const m256 data, const m256 hi_mask_1, const m256 hi_mask_2, const m256 lo_mask_1, const m256 lo_mask_2, const m256 bucket_mask_hi, const m256 bucket_mask_lo, const u32 neg_mask, const u32 valid_data_mask) { m256 low4bits = set32x8(0xf); m256 data_lo = and256(data, low4bits); m256 data_hi = and256(rshift64_m256(data, 4), low4bits); m256 c_lo_1 = vpshufb(lo_mask_1, data_lo); m256 c_lo_2 = vpshufb(lo_mask_2, data_lo); m256 c_hi_1 = vpshufb(hi_mask_1, data_hi); m256 c_hi_2 = vpshufb(hi_mask_2, data_hi); m256 t1 = and256(c_lo_1, c_hi_1); m256 t2 = and256(c_lo_2, c_hi_2); m256 result = or256(and256(t1, bucket_mask_lo), and256(t2, bucket_mask_hi)); u32 nresult = movemask256(eq256(result, zeroes256())); #ifdef DEBUG DEBUG_PRINTF("data\n"); dumpMask(&data, 32); DEBUG_PRINTF("data_lo\n"); dumpMask(&data_lo, 32); DEBUG_PRINTF("data_hi\n"); dumpMask(&data_hi, 32); DEBUG_PRINTF("hi_mask_1\n"); dumpMask(&hi_mask_1, 16); DEBUG_PRINTF("hi_mask_2\n"); dumpMask(&hi_mask_2, 16); DEBUG_PRINTF("lo_mask_1\n"); dumpMask(&lo_mask_1, 16); DEBUG_PRINTF("lo_mask_2\n"); dumpMask(&lo_mask_2, 16); DEBUG_PRINTF("c_lo_1\n"); dumpMask(&c_lo_1, 32); DEBUG_PRINTF("c_lo_2\n"); dumpMask(&c_lo_2, 32); DEBUG_PRINTF("c_hi_1\n"); dumpMask(&c_hi_1, 32); DEBUG_PRINTF("c_hi_2\n"); dumpMask(&c_hi_2, 32); DEBUG_PRINTF("result\n"); dumpMask(&result, 32); DEBUG_PRINTF("valid_data_mask %x\n", valid_data_mask); #endif u32 cmp_result = (nresult ^ neg_mask) & valid_data_mask; return !cmp_result; } #endif hyperscan-4.4.1/src/rose/rose_build_convert.cpp0000644000175000017500000010113513055426554022432 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_convert.h" #include "grey.h" #include "rose_build.h" #include "rose_build_impl.h" #include "rose_build_util.h" #include "ue2common.h" #include "hwlm/hwlm_build.h" #include "nfa/castlecompile.h" #include "nfa/limex_limits.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_reports.h" #include "nfagraph/ng_split.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_width.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/charreach_util.h" #include "util/compile_context.h" #include "util/depth.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/ue2string.h" #include #include #include #include #include #include #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { static NFAVertex addHolderVertex(const CharReach &cr, NGHolder &out) { assert(cr.any()); NFAVertex v = add_vertex(out); out[v].char_reach = cr; return v; } // Returns the first and last vertices. static pair addLiteralVertices(const RoseGraph &g, const RoseLiteralMap &literals, const RoseVertex &t_v, NGHolder &out) { // We have limited cases that we support: one literal of arbitrary length, // or a bunch of literals of length one that just become a vertex with // their reach unioned together. // TODO: generalise this and handle more cases. const auto &litids = g[t_v].literals; if (litids.size() > 1) { // Multiple literals of len 1. CharReach v_cr; for (const auto &lit_id : litids) { const rose_literal_id &litv = literals.right.at(lit_id); assert(litv.s.length() == 1); v_cr |= *litv.s.begin(); } NFAVertex v = addHolderVertex(v_cr, out); return make_pair(v, v); } // Otherwise, we have a single literal, could be of arbitrary length. assert(litids.size() == 1); u32 lit_id = *(litids.begin()); const rose_literal_id &litv = literals.right.at(lit_id); assert(!litv.s.empty()); ue2_literal::const_iterator it = litv.s.begin(), ite = litv.s.end(); NFAVertex first = addHolderVertex(*it, out), last = first; for (++it; it != ite; ++it) { NFAVertex v = addHolderVertex(*it, out); add_edge(last, v, out); last = v; } return make_pair(first, last); } static unique_ptr convertLeafToHolder(const RoseGraph &g, const RoseEdge &t_e, const RoseLiteralMap &literals) { RoseVertex t_v = target(t_e, g); // leaf vertex for demolition. u32 minBound = g[t_e].minBound; u32 maxBound = g[t_e].maxBound; const CharReach dot = CharReach::dot(); assert(!g[t_v].left); auto out = ue2::make_unique(NFA_SUFFIX); // Repeats wired to the start of the graph. DEBUG_PRINTF("bounds [%u, %u]\n", minBound, maxBound); u32 i = 1; NFAVertex last = out->start; for (; i <= minBound; i++) { NFAVertex v = addHolderVertex(dot, *out); add_edge(last, v, *out); last = v; } NFAVertex last_mand = last; if (maxBound != ROSE_BOUND_INF) { for (; i <= maxBound; i++) { NFAVertex v = addHolderVertex(dot, *out); add_edge(last_mand, v, *out); if (last != last_mand) { add_edge(last, v, *out); } last = v; } } else { if (minBound) { add_edge(last_mand, last_mand, *out); } else { NFAVertex v = addHolderVertex(dot, *out); add_edge(last_mand, v, *out); add_edge(v, v, *out); last = v; } } setTops(*out); // Literal vertices wired to accept. NFAVertex litfirst, litlast; tie(litfirst, litlast) = addLiteralVertices(g, literals, t_v, *out); add_edge(last, litfirst, *out); if (last != last_mand) { add_edge(last_mand, litfirst, *out); } add_edge(litlast, out->accept, *out); insert(&(*out)[litlast].reports, g[t_v].reports); return out; } static bool areLiteralsConvertible(const RoseLiteralMap &literals, const flat_set &ids) { // Every literal in v must have the same length. // TODO: at the moment, we only handle two cases in construction: (a) one // literal of arbitrary length, and (b) many literals, but all with length // 1. if (ids.empty()) { return false; } auto it = ids.begin(), ite = ids.end(); const size_t len = literals.right.at(*it).elength(); // Note: len may be 0 for cases with special literals, like EOD prefixes. if (len != 1 && ids.size() != 1) { DEBUG_PRINTF("more than one literal of len > 1\n"); return false; } // Check the others all have the same length. while (++it != ite) { if (literals.right.at(*it).elength() != len) { DEBUG_PRINTF("literals have different lengths\n"); return false; } } return true; } // Returns true if the given vertex doesn't qualify as a bad leaf to be eaten // by an NFA. static bool isUnconvertibleLeaf(const RoseBuildImpl &tbi, const RoseVertex v) { const RoseGraph &g = tbi.g; if (in_degree(v, g) != 1) { DEBUG_PRINTF("more than one in-edge\n"); return true; } const RoseEdge &e = *(in_edges(v, g).first); RoseVertex u = source(e, g); if (!g[u].reports.empty()) { DEBUG_PRINTF("pred has accept\n"); return true; } if (g[u].suffix) { // TODO: this could be handled by adding new vertices to the existing // suffix. DEBUG_PRINTF("pred already has suffix\n"); return true; } if (tbi.isAnyStart(u)) { DEBUG_PRINTF("fail start\n"); return true; } if (tbi.isAnchored(u)) { /* TODO need to check for possible anchored queue overflow? maybe? */ DEBUG_PRINTF("fail anchored\n"); return true; } if (g[v].reports.empty() || g[v].eod_accept) { DEBUG_PRINTF("bad accept\n"); return true; } if (g[v].suffix) { DEBUG_PRINTF("suffix\n"); return true; } if (g[v].left) { /* TODO: we really should handle this case as we would be checking * an nfa each time. However it requires completely different graph * fiddling logic */ DEBUG_PRINTF("rose prefix action\n"); return true; } if (!areLiteralsConvertible(tbi.literals, g[v].literals)) { DEBUG_PRINTF("fail length\n"); return true; } u32 max_lit_len = tbi.maxLiteralLen(v); u32 maxbound = max_lit_len == 1 ? 124 : 32; // arbitrary magic numbers if (g[e].maxBound > maxbound && g[e].maxBound != ROSE_BOUND_INF) { DEBUG_PRINTF("fail maxbound (%u)\n", maxbound); return true; } if (g[e].maxBound == ROSE_BOUND_INF) { /* slightly risky as nfa won't die */ DEBUG_PRINTF("fail: .*\n"); return true; } return false; } // Find all of the leaves with literals whose length is <= len. static void findBadLeaves(RoseBuildImpl &tbi, set &bad) { RoseGraph &g = tbi.g; u32 len = tbi.cc.grey.roseMaxBadLeafLength; for (const auto &m : tbi.literals.right) { if (m.second.s.length() > len) { continue; } u32 lid = m.first; DEBUG_PRINTF("%u is a short lit (length %zu)\n", lid, m.second.s.length()); if (tbi.isDelayed(lid)) { DEBUG_PRINTF("delayed, skipping!\n"); continue; } const rose_literal_info &info = tbi.literal_info[lid]; for (auto v : info.vertices) { if (!isLeafNode(v, g)) { continue; } if (isUnconvertibleLeaf(tbi, v)) { continue; // we don't want to touch it } // This leaf may have a predecessor with more than one successor, // in which case we want to clone the pred just to support this // leaf. const RoseEdge &e = *in_edges(v, g).first; RoseVertex u = source(e, g); if (out_degree(u, g) != 1) { DEBUG_PRINTF("re-homing %zu to cloned pred\n", g[v].index); RoseVertex u2 = tbi.cloneVertex(u); for (const auto &e_in : in_edges_range(u, g)) { add_edge(source(e_in, g), u2, g[e_in], g); } add_edge(u2, v, g[e], g); remove_edge(e, g); } DEBUG_PRINTF("%zu is a bad leaf vertex\n", g[v].index); bad.insert(v); } } } void convertBadLeaves(RoseBuildImpl &tbi) { RoseGraph &g = tbi.g; set bad; findBadLeaves(tbi, bad); DEBUG_PRINTF("found %zu bad leaves\n", bad.size()); if (bad.empty()) { return; } vector dead; for (auto v : bad) { assert(in_degree(v, g)); const RoseEdge &e = *(in_edges(v, g).first); shared_ptr h = convertLeafToHolder(g, e, tbi.literals); if (num_vertices(*h) >= NFA_MAX_STATES) { assert(0); // too big! continue; } RoseVertex u = source(e, g); assert(!g[u].suffix); g[u].suffix.graph = h; DEBUG_PRINTF("%zu's nfa holder %p\n", g[u].index, h.get()); dead.push_back(v); } tbi.removeVertices(dead); } static size_t suffixFloodLen(const ue2_literal &s) { if (s.empty()) { return 0; } const ue2_literal::elem &c = s.back(); auto it = find_if(s.rbegin(), s.rend(), bind2nd(not_equal_to(), c)); return distance(s.rbegin(), it); } static unique_ptr makeFloodProneSuffix(const ue2_literal &s, size_t len, const flat_set &reports) { assert(len < s.length()); assert(!reports.empty()); unique_ptr h = ue2::make_unique(NFA_SUFFIX); NFAVertex u = h->start; for (auto it = s.begin() + s.length() - len; it != s.end(); ++it) { NFAVertex v = addHolderVertex(*it, *h); NFAEdge e = add_edge(u, v, *h); if (u == h->start) { (*h)[e].tops.insert(DEFAULT_TOP); } u = v; } (*h)[u].reports.insert(reports.begin(), reports.end()); add_edge(u, h->accept, *h); return h; } static unique_ptr makeRosePrefix(const ue2_literal &s) { unique_ptr h = ue2::make_unique(NFA_PREFIX); NFAVertex u = h->startDs; for (const auto &c : s) { NFAVertex v = addHolderVertex(c, *h); add_edge(u, v, *h); u = v; } add_edge(u, h->accept, *h); return h; } static void replaceWithLitPrefix(RoseBuildImpl &tbi, RoseVertex v, u32 lit_id, const rose_literal_id &lit, size_t suffixlen, size_t delay) { assert(suffixlen < lit.s.length()); DEBUG_PRINTF("replacing '%s' with prefix, length=%zu, delay=%zu\n", dumpString(lit.s).c_str(), lit.s.length() - suffixlen, delay); RoseGraph &g = tbi.g; ue2_literal new_lit = lit.s.substr(0, lit.s.length() - suffixlen); u32 new_id = tbi.getLiteralId(new_lit, delay, ROSE_FLOATING); rose_literal_info &old_info = tbi.literal_info.at(lit_id); old_info.vertices.erase(v); tbi.literal_info.at(new_id).vertices.insert(v); g[v].literals.clear(); g[v].literals.insert(new_id); } static bool delayLiteralWithPrefix(RoseBuildImpl &tbi, RoseVertex v, u32 lit_id, const rose_literal_id &lit, size_t suffixlen) { if (suffixlen > MAX_DELAY) { DEBUG_PRINTF("delay too large\n"); return false; } if (!tbi.isDirectReport(lit_id)) { DEBUG_PRINTF("literal is not direct report\n"); return false; } if (tbi.cc.streaming && lit.s.length() > tbi.cc.grey.maxHistoryAvailable + 1) { DEBUG_PRINTF("insufficient history to delay literal of len %zu\n", lit.s.length()); return false; } shared_ptr h = makeRosePrefix(lit.s); ReportID prefix_report = 0; setReportId(*h, prefix_report); if (!isImplementableNFA(*h, &tbi.rm, tbi.cc)) { DEBUG_PRINTF("prefix not implementable\n"); return false; } RoseGraph &g = tbi.g; assert(!g[v].left); g[v].left.graph = h; g[v].left.lag = 0; g[v].left.leftfix_report = prefix_report; // Swap v's literal for a shorter one, delayed by suffix len. replaceWithLitPrefix(tbi, v, lit_id, lit, suffixlen, suffixlen); return true; } static void convertFloodProneSuffix(RoseBuildImpl &tbi, RoseVertex v, u32 lit_id, const rose_literal_id &lit, size_t suffixlen) { DEBUG_PRINTF("flood-prone leaf '%s'\n", dumpString(lit.s).c_str()); DEBUG_PRINTF("turning last %zu chars into a suffix NFA\n", suffixlen); RoseGraph &g = tbi.g; assert(!g[v].eod_accept); // If we're a direct report literal, we may be able to convert this case // into a delayed literal with a (very boring) transient prefix that // handles our flood-prone suffix. if (delayLiteralWithPrefix(tbi, v, lit_id, lit, suffixlen)) { DEBUG_PRINTF("implemented as delayed literal with a rose prefix\n"); return; } // General case: create a suffix that implements the flood-prone portion. // Create the NFA. auto h = makeFloodProneSuffix(lit.s, suffixlen, g[v].reports); if (!isImplementableNFA(*h, &tbi.rm, tbi.cc)) { DEBUG_PRINTF("not implementable\n"); return; } // Apply the NFA. assert(!g[v].suffix); g[v].suffix.graph = move(h); g[v].reports.clear(); // Swap v's literal for a shorter one. replaceWithLitPrefix(tbi, v, lit_id, lit, suffixlen, 0); // It's possible that min_offset might be an underestimate, so we // subtract min(min_offset, suffixlen) for safety. g[v].min_offset -= min((size_t)g[v].min_offset, suffixlen); if (g[v].max_offset < ROSE_BOUND_INF) { assert(g[v].max_offset >= suffixlen); g[v].max_offset -= suffixlen; } } /** * Collect an estimate of the number of literals in the floating table, and use * this to estimate the flood prone suffix length. */ static size_t findFloodProneSuffixLen(const RoseBuildImpl &tbi) { size_t numLiterals = 0; for (const rose_literal_id &lit : tbi.literals.right | map_values) { if (lit.delay) { continue; // delay ids are virtual-ish } if (lit.table != ROSE_FLOATING) { continue; } numLiterals++; } return hwlmFloodProneSuffixLen(numLiterals, tbi.cc); } /** * \brief Convert flood-prone literal suffixes into suffix NFAs. * * For any trailing string in Rose (string cannot lead to more Rose roles or * NFAs, etc) ending with a continuous run of a single character with more than * 3 copies of that single character, * * If the result of removing all but 2 copies of that character yields a string * that is greater than FLOOD_PRONE_LIT_MIN_LENGTH characters, remove those * final characters from the literal and move them into a suffix NFA. */ void convertFloodProneSuffixes(RoseBuildImpl &tbi) { static const size_t FLOOD_PRONE_LIT_MIN_LENGTH = 5; if (!tbi.cc.grey.roseConvertFloodProneSuffixes) { return; } const size_t floodProneLen = findFloodProneSuffixLen(tbi); DEBUG_PRINTF("flood prone suffix len = %zu\n", floodProneLen); RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { if (!isLeafNode(v, g)) { continue; } if (g[v].reports.empty()) { continue; } // TODO: currently only boring vertices. if (!g[v].isBoring()) { continue; } // Currently only handles vertices with a single literal (should always // be the case this early in Rose construction). if (g[v].literals.size() != 1) { continue; } u32 lit_id = *g[v].literals.begin(); const rose_literal_id &lit = tbi.literals.right.at(lit_id); // anchored or delayed literals need thought. if (lit.table != ROSE_FLOATING || lit.delay) { continue; } // don't do this to literals with msk/cmp. if (!lit.msk.empty()) { continue; } // Can't safely do this operation to vertices with delayed // predecessors. if (tbi.hasDelayPred(v)) { DEBUG_PRINTF("delayed pred\n"); continue; } if (lit.s.length() <= FLOOD_PRONE_LIT_MIN_LENGTH) { DEBUG_PRINTF("literal is short enough already\n"); continue; } size_t floodLen = suffixFloodLen(lit.s); if (floodLen < floodProneLen) { DEBUG_PRINTF("literal not flood-prone\n"); continue; } if (floodLen == lit.s.length()) { DEBUG_PRINTF("whole literal is a flood\n"); // Removing the part of the flood from the end of the literal would // leave us with a shorter, but still flood-prone, prefix. Better // to leave it alone. continue; } size_t suffixLen = floodLen - (floodProneLen - 1); if (lit.s.length() - suffixLen < FLOOD_PRONE_LIT_MIN_LENGTH) { DEBUG_PRINTF("removing flood would leave literal too short\n"); continue; } convertFloodProneSuffix(tbi, v, lit_id, lit, suffixLen); } } static CharReach getReachOfNormalVertex(const NGHolder &g) { for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } return g[v].char_reach; } assert(0); return CharReach(); } /** * \brief Set the edge bounds and appropriate history on the given edge in the * Rose graph. */ static void setEdgeBounds(RoseGraph &g, const RoseEdge &e, u32 min_bound, u32 max_bound) { assert(min_bound <= max_bound); assert(max_bound <= ROSE_BOUND_INF); g[e].minBound = min_bound; g[e].maxBound = max_bound; if (min_bound || max_bound < ROSE_BOUND_INF) { g[e].history = ROSE_ROLE_HISTORY_ANCH; } else { g[e].history = ROSE_ROLE_HISTORY_NONE; } } static bool handleStartPrefixCliche(const NGHolder &h, RoseGraph &g, RoseVertex v, const RoseEdge &e_old, RoseVertex ar, vector *to_delete) { DEBUG_PRINTF("hi\n"); /* check for prefix cliches connected to start (^.{N,M}) */ if (!getReachOfNormalVertex(h).all()) { DEBUG_PRINTF(":(\n"); return false; } PureRepeat repeat; if (!isPureRepeat(h, repeat)) { DEBUG_PRINTF(":(\n"); return false; } assert(repeat.bounds.min.is_finite()); assert(repeat.bounds.max.is_reachable()); assert(repeat.bounds.min <= repeat.bounds.max); DEBUG_PRINTF("prefix is ^.{%s,%s}\n", repeat.bounds.min.str().c_str(), repeat.bounds.max.str().c_str()); /* update bounds on edge */ // Convert to Rose graph bounds, which are not (yet?) depth classes. u32 bound_min = repeat.bounds.min; u32 bound_max = repeat.bounds.max.is_finite() ? (u32)repeat.bounds.max : ROSE_BOUND_INF; if (source(e_old, g) == ar) { assert(g[e_old].minBound <= bound_min); assert(g[e_old].maxBound >= bound_max); setEdgeBounds(g, e_old, bound_min, bound_max); } else { RoseEdge e_new = add_edge(ar, v, g); setEdgeBounds(g, e_new, bound_min, bound_max); to_delete->push_back(e_old); } g[v].left.reset(); /* clear the prefix info */ return true; } static bool handleStartDsPrefixCliche(const NGHolder &h, RoseGraph &g, RoseVertex v, const RoseEdge &e) { DEBUG_PRINTF("hi\n"); /* check for prefix cliches connected to start-ds (.{N}, ^.{N,}) */ u32 repeatCount = 0; NFAVertex hu = h.startDs; auto start_succ = succs>(h.start, h); auto startds_succ = succs>(h.startDs, h); if (!is_subset_of(start_succ, startds_succ)) { DEBUG_PRINTF("not a simple chain\n"); return false; } set seen; do { if (!h[hu].char_reach.all()) { return false; } NFAVertex hv = getSoleDestVertex(h, hu); if (!hv) { return false; } if (contains(seen, hv)) { assert(0); return false; } hu = hv; repeatCount++; if (hu == h.accept) { break; } } while(1); assert(hu == h.accept); repeatCount--; /* do not count accept as part of the chain */ DEBUG_PRINTF("prefix is ^.{%u,}\n", repeatCount); /* update bounds on edge */ assert(g[e].minBound <= repeatCount); setEdgeBounds(g, e, repeatCount, ROSE_BOUND_INF); g[v].left.reset(); /* clear the prefix info */ return true; } static bool handleMixedPrefixCliche(const NGHolder &h, RoseGraph &g, RoseVertex v, const RoseEdge &e_old, RoseVertex ar, vector *to_delete, const CompileContext &cc) { assert(in_degree(h.acceptEod, h) == 1); bool anchored = !proper_out_degree(h.startDs, h); NFAVertex key = NGHolder::null_vertex(); NFAVertex base = anchored ? h.start : h.startDs; if (!anchored) { auto start_succ = succs>(h.start, h); auto startds_succ = succs>(h.startDs, h); if (!is_subset_of(start_succ, startds_succ)) { DEBUG_PRINTF("not a simple chain\n"); return false; } } for (auto w : adjacent_vertices_range(base, h)) { DEBUG_PRINTF("checking %zu\n", h[w].index); if (!h[w].char_reach.all()) { continue; } if (!is_special(w, h)) { key = w; break; } } if (!key) { return false; } vector repeats; findRepeats(h, 2, &repeats); vector::const_iterator it; for (it = repeats.begin(); it != repeats.end(); ++it) { DEBUG_PRINTF("checking.. %zu verts\n", it->vertices.size()); if (find(it->vertices.begin(), it->vertices.end(), key) != it->vertices.end()) { break; } } if (it == repeats.end()) { DEBUG_PRINTF("no repeat found\n"); return false; } GraphRepeatInfo ri = *it; set exits_and_repeat_verts; for (auto repeat_v : ri.vertices) { DEBUG_PRINTF("repeat vertex %zu\n", h[repeat_v].index); succ(h, repeat_v, &exits_and_repeat_verts); exits_and_repeat_verts.insert(repeat_v); } DEBUG_PRINTF("repeat {%s,%s}\n", ri.repeatMin.str().c_str(), ri.repeatMax.str().c_str()); set rep_verts; insert(&rep_verts, ri.vertices); set exits; exits = exits_and_repeat_verts; erase_all(&exits, rep_verts); auto base_succ = succs>(base, h); base_succ.erase(h.startDs); if (is_subset_of(base_succ, rep_verts)) { /* all good: repeat dominates the rest of the pattern */ } else if (ri.repeatMin == depth(1) && is_subset_of(exits, base_succ) && is_subset_of(base_succ, exits_and_repeat_verts)) { /* we have a jump edge */ ri.repeatMin = 0; } else { return false; } DEBUG_PRINTF("repeat {%s,%s}\n", ri.repeatMin.str().c_str(), ri.repeatMax.str().c_str()); DEBUG_PRINTF("woot?\n"); shared_ptr h_new = make_shared(); ue2::unordered_map rhs_map; vector exits_vec; insert(&exits_vec, exits_vec.end(), exits); splitRHS(h, exits_vec, h_new.get(), &rhs_map); h_new->kind = NFA_PREFIX; if (num_vertices(*h_new) <= N_SPECIALS) { DEBUG_PRINTF("not a hybrid??\n"); /* TODO: pick up these cases, unify code */ return false; } for (auto w : adjacent_vertices_range(h_new->start, *h_new)) { if (w != h_new->startDs) { add_edge(h_new->startDs, w, *h_new); } } clear_out_edges(h_new->start, *h_new); add_edge(h_new->start, h_new->startDs, *h_new); depth width = findMinWidth(*h_new); if (width != findMaxWidth(*h_new)) { return false; } if (g[v].left.dfa) { /* we were unable to implement initial graph as an nfa; * we need to to check if we still need a dfa and, if so, rebuild. */ if (!isImplementableNFA(*h_new, nullptr, cc)) { return false; /* TODO: handle rebuilding dfa */ } } if (anchored) { if (ri.repeatMax.is_infinite()) { return false; /* TODO */ } if (source(e_old, g) == ar) { setEdgeBounds(g, e_old, ri.repeatMin + width, ri.repeatMax + width); } else { RoseEdge e_new = add_edge(ar, v, g); setEdgeBounds(g, e_new, ri.repeatMin + width, ri.repeatMax + width); to_delete->push_back(e_old); } } else { assert(g[e_old].minBound <= ri.repeatMin + width); setEdgeBounds(g, e_old, ri.repeatMin + width, ROSE_BOUND_INF); } g[v].left.dfa.reset(); g[v].left.graph = h_new; return true; } /* turns simple prefixes like /^.{30,} into bounds on the root roles */ void convertPrefixToBounds(RoseBuildImpl &tbi) { RoseGraph &g = tbi.g; vector to_delete; RoseVertex ar = tbi.anchored_root; /* graphs with prefixes produced by rose are wired to tbi.root */ for (const auto &e : out_edges_range(tbi.root, g)) { RoseVertex v = target(e, g); if (in_degree(v, g) != 1) { continue; } if (!g[v].left.graph) { continue; } if (g[v].left.tracksSom()) { continue; } const NGHolder &h = *g[v].left.graph; if (g[v].left.lag != tbi.minLiteralLen(v) || g[v].left.lag != tbi.maxLiteralLen(v)) { continue; } if (all_reports(h).size() != 1) { assert(0); continue; } DEBUG_PRINTF("inspecting prefix of %zu\n", g[v].index); if (!proper_out_degree(h.startDs, h)) { if (handleStartPrefixCliche(h, g, v, e, ar, &to_delete)) { continue; } } else { if (handleStartDsPrefixCliche(h, g, v, e)) { continue; } } /* prefix is not just a simple dot repeat. However, it is still * possible that it consists of dot repeat and fixed width mask that we * can handle. */ handleMixedPrefixCliche(h, g, v, e, ar, &to_delete, tbi.cc); } for (const auto &e : out_edges_range(ar, g)) { RoseVertex v = target(e, g); /* note: vertices that we have rehomed will currently have an in-degree * of 2 */ if (in_degree(v, g) != 1) { continue; } if (!g[v].left.graph) { continue; } if (g[v].left.tracksSom()) { continue; } if (g[v].left.lag != tbi.minLiteralLen(v) || g[v].left.lag != tbi.maxLiteralLen(v)) { continue; } const NGHolder &h = *g[v].left.graph; if (all_reports(h).size() != 1) { assert(0); continue; } DEBUG_PRINTF("inspecting prefix of %zu\n", g[v].index); if (!proper_out_degree(h.startDs, h)) { if (handleStartPrefixCliche(h, g, v, e, ar, &to_delete)) { continue; } } else { if (handleStartDsPrefixCliche(h, g, v, e)) { continue; } } /* prefix is not just a simple dot repeat. However, it is still * possible that it consists of dot repeat and fixed width mask that we * can handle. */ handleMixedPrefixCliche(h, g, v, e, ar, &to_delete, tbi.cc); } for (const auto &e : to_delete) { remove_edge(e, g); } } /** * Identify dot-repeat infixes after fixed-depth literals and convert them to * edges with ROSE_ROLE_HISTORY_ANCH history and equivalent bounds. */ void convertAnchPrefixToBounds(RoseBuildImpl &tbi) { RoseGraph &g = tbi.g; for (const auto v : vertices_range(g)) { if (!g[v].left) { continue; } DEBUG_PRINTF("vertex %zu\n", g[v].index); // This pass runs after makeCastles, so we use the fact that bounded // repeat detection has already been done for us. if (!g[v].left.castle) { DEBUG_PRINTF("not a castle\n"); continue; } const CastleProto &castle = *g[v].left.castle; if (castle.repeats.size() != 1) { DEBUG_PRINTF("too many repeats\n"); assert(0); // Castles should not have been merged yet. continue; } if (!castle.reach().all()) { DEBUG_PRINTF("not dot\n"); continue; } if (in_degree(v, g) != 1) { DEBUG_PRINTF("too many in-edges\n"); continue; } RoseEdge e = *in_edges(v, g).first; RoseVertex u = source(e, g); if (g[e].history != ROSE_ROLE_HISTORY_NONE) { DEBUG_PRINTF("history already set to something other than NONE?\n"); assert(0); continue; } if (g[u].min_offset != g[u].max_offset) { DEBUG_PRINTF("pred not fixed offset\n"); continue; } DEBUG_PRINTF("pred is fixed offset, at %u\n", g[u].min_offset); assert(g[u].min_offset < ROSE_BOUND_INF); size_t lit_length = tbi.minLiteralLen(v); if (lit_length != tbi.maxLiteralLen(v)) { assert(0); DEBUG_PRINTF("variable literal lengths\n"); continue; } u32 lag = g[v].left.lag; DEBUG_PRINTF("lit_length=%zu, lag=%u\n", lit_length, lag); assert(lag <= lit_length); depth delay_adj(lit_length - lag); const PureRepeat &pr = castle.repeats.begin()->second; DEBUG_PRINTF("castle has repeat %s\n", pr.bounds.str().c_str()); DEBUG_PRINTF("delay adj %u\n", (u32)delay_adj); if (delay_adj >= pr.bounds.max) { DEBUG_PRINTF("delay adj too large\n"); continue; } DepthMinMax bounds(pr.bounds); // copy if (delay_adj > bounds.min) { bounds.min = 0; } else { bounds.min -= delay_adj; } bounds.max -= delay_adj; setEdgeBounds(g, e, bounds.min, bounds.max.is_finite() ? (u32)bounds.max : ROSE_BOUND_INF); g[v].left.reset(); } } } // namespace ue2 hyperscan-4.4.1/src/rose/program_runtime.c0000644000175000017500000000427213055426554021421 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** * \file * \brief Rose runtime: program interpreter. */ #include "program_runtime.h" int roseNfaEarliestSom(u64a start, UNUSED u64a end, UNUSED ReportID id, void *context) { assert(context); u64a *som = context; *som = MIN(*som, start); return MO_CONTINUE_MATCHING; } hwlmcb_rv_t roseRunProgram(const struct RoseEngine *t, struct hs_scratch *scratch, u32 programOffset, u64a som, u64a end, size_t match_len, u8 prog_flags) { return roseRunProgram_i(t, scratch, programOffset, som, end, match_len, prog_flags); } hyperscan-4.4.1/src/rose/rose_build_exclusive.h0000644000175000017500000001255213055426554022432 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief exclusive analysis for infix and suffix engines. * Two engines are considered as exclusive if they can never be alive * at the same time. This analysis takes advantage of the property of * triggering literal + engine graph. If the triggering literals of * two engines can make all the states dead in each other's graph, * then they are exclusive. */ #ifndef ROSE_BUILD_EXCLUSIVE_H #define ROSE_BUILD_EXCLUSIVE_H #include "ue2common.h" #include "rose_build_impl.h" #include "util/alloc.h" #include "util/charreach.h" #include #include #include namespace ue2 { /** brief subengine info including built engine and * corresponding triggering rose vertices */ struct ExclusiveSubengine { aligned_unique_ptr nfa; std::vector vertices; }; /** \brief exclusive info to build tamarama */ struct ExclusiveInfo { // subengine info std::vector subengines; // all the report in tamarama std::set reports; // assigned queue id u32 queue; }; /** \brief role info structure for exclusive analysis */ template struct RoleInfo { RoleInfo(role_id role_in, u32 id_in) : role(role_in), id(id_in) {} bool operator==(const RoleInfo &b) const { return id == b.id; } bool operator!=(const RoleInfo &b) const { return !(*this == b); } bool operator<(const RoleInfo &b) const { const RoleInfo &a = *this; if (a.score != b.score) { return a.score > b.score; } ORDER_CHECK(id); return false; } std::vector> literals; // prefix literals CharReach prefix_cr; // reach of prefix literals CharReach last_cr; // reach of the last character of literals CharReach cr; // reach of engine graph const role_id role; // infix or suffix info const u32 id; // infix or suffix id u32 score = ~0U; // score for exclusive analysis }; /** * \brief add triggering literals to infix info. */ bool setTriggerLiteralsInfix(RoleInfo &roleInfo, const std::map>> &triggers); /** * \brief add triggering literals to suffix info. */ bool setTriggerLiteralsSuffix(RoleInfo &roleInfo, const std::map>> &triggers); /** * Exclusive analysis for infix engines. * * @param build rose build info mainly used to set exclusive chunk size here * @param vertex_map mapping between engine id and rose vertices * related to this engine * @param roleInfoSet structure contains role properties including infix info, * triggering literals and literal reachabilities. * Used for exclusive analysis. * @param exclusive_roles output mapping between engine id and its exclusive * group id */ void exclusiveAnalysisInfix(const RoseBuildImpl &build, const std::map> &vertex_map, std::set> &roleInfoSet, std::vector> &exclusive_roles); /** * Exclusive analysis for suffix engines. * * @param build rose build info mainly used to set exclusive chunk size here * @param vertex_map mapping between engine id and rose vertices * related to this engine * @param roleInfoSet structure contains role properties including suffix info, * triggering literals and literal reachabilities. * Used for exclusive analysis. * @param exclusive_roles output mapping between engine id and its exclusive * group id */ void exclusiveAnalysisSuffix(const RoseBuildImpl &build, const std::map> &vertex_map, std::set> &roleInfoSet, std::vector> &exclusive_roles); } // namespace ue2 #endif //ROSE_BUILD_EXCLUSIVE_H hyperscan-4.4.1/src/rose/rose_build_matchers.h0000644000175000017500000000560113055426554022226 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** * \file * \brief Rose build: code for constructing literal tables. */ #ifndef ROSE_BUILD_MATCHERS_H #define ROSE_BUILD_MATCHERS_H #include "rose_build_impl.h" #include struct HWLM; namespace ue2 { struct hwlmLiteral; /** * \brief Build up a vector of literals for the given table. * * If max_offset is specified (and not ROSE_BOUND_INF), then literals that can * only lead to a pattern match after max_offset may be excluded. */ std::vector fillHamsterLiteralList(const RoseBuildImpl &build, rose_literal_table table, size_t max_len, u32 max_offset = ROSE_BOUND_INF); aligned_unique_ptr buildFloatingMatcher(const RoseBuildImpl &build, size_t longLitLengthThreshold, rose_group *fgroups, size_t *fsize, size_t *historyRequired); aligned_unique_ptr buildSmallBlockMatcher(const RoseBuildImpl &build, size_t *sbsize); aligned_unique_ptr buildEodAnchoredMatcher(const RoseBuildImpl &build, size_t *esize); void findMoreLiteralMasks(RoseBuildImpl &build); } // namespace ue2 #endif // ROSE_BUILD_MATCHERS_H hyperscan-4.4.1/src/rose/rose_in_graph.h0000644000175000017500000001551513055426554021035 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose Input Graph: Used for ng_rose -> rose_build_add communication. * * The input graph MUST be a DAG. * There MUST be exactly 1 START or ANCHORED_START vertex. * The edges MUST be of the form START->LITERAL, LITERAL->LITERAL, * LITERAL->ACCEPT or LITERAL->ACCEPT_EOD. * Every non START/ANCHORED_START vertex MUST have an in-edge. * Every non ACCEPT/ACCEPT_EOD vertex MUST have an out-edge. * * Edges are either a graph or have bounds associated with them. * Graphs on edges to accepts use their internal report ids. */ #ifndef ROSE_IN_GRAPH_H #define ROSE_IN_GRAPH_H #include "ue2common.h" #include "rose/rose_common.h" #include "util/ue2_containers.h" #include "util/ue2_graph.h" #include "util/ue2string.h" #include namespace ue2 { class NGHolder; struct raw_som_dfa; enum RoseInVertexType { RIV_LITERAL, RIV_START, RIV_ANCHORED_START, RIV_ACCEPT, RIV_ACCEPT_EOD }; struct RoseInVertexProps { RoseInVertexProps() : type(RIV_LITERAL), delay(0), min_offset(0), max_offset(ROSE_BOUND_INF) {} private: template RoseInVertexProps(RoseInVertexType type_in, const ue2_literal &s_in, const ReportContainer &reports_in, u32 min_offset_in, u32 max_offset_in) : type(type_in), s(s_in), delay(0), reports(begin(reports_in), end(reports_in)), min_offset(min_offset_in), max_offset(max_offset_in) {} // Constructor for a vertex with no reports. RoseInVertexProps(RoseInVertexType type_in, const ue2_literal &s_in, u32 min_offset_in, u32 max_offset_in) : type(type_in), s(s_in), delay(0), min_offset(min_offset_in), max_offset(max_offset_in) {} public: static RoseInVertexProps makeLiteral(const ue2_literal &lit) { DEBUG_PRINTF("making literal %s\n", dumpString(lit).c_str()); return RoseInVertexProps(RIV_LITERAL, lit, 0, ROSE_BOUND_INF); } template static RoseInVertexProps makeAccept(const ReportContainer &rep) { DEBUG_PRINTF("making accept for %zu reports\n", rep.size()); return RoseInVertexProps(RIV_ACCEPT, ue2_literal(), rep, 0, ROSE_BOUND_INF); } template static RoseInVertexProps makeAcceptEod(const ReportContainer &rep) { DEBUG_PRINTF("making accept-eod for %zu reports\n", rep.size()); return RoseInVertexProps(RIV_ACCEPT_EOD, ue2_literal(), rep, 0, ROSE_BOUND_INF); } /* for when there is a suffix graph which handles the reports */ static RoseInVertexProps makeAcceptEod() { return RoseInVertexProps(RIV_ACCEPT_EOD, ue2_literal(), 0, ROSE_BOUND_INF); } static RoseInVertexProps makeStart(bool anchored) { DEBUG_PRINTF("making %s\n", anchored ? "anchored start" : "start"); if (anchored) { return RoseInVertexProps(RIV_ANCHORED_START, ue2_literal(), 0, 0); } else { return RoseInVertexProps(RIV_START, ue2_literal(), 0, ROSE_BOUND_INF); } } RoseInVertexType type; /* polymorphic vertices are probably a bad idea */ ue2_literal s; /**< for RIV_LITERAL */ u32 delay; /**< for RIV_LITERAL, delay applied to literal. */ flat_set reports; /**< for RIV_ACCEPT/RIV_ACCEPT_EOD */ u32 min_offset; /**< Minimum offset at which this vertex can match. */ u32 max_offset; /**< Maximum offset at which this vertex can match. */ size_t index = 0; }; struct RoseInEdgeProps { RoseInEdgeProps() : minBound(0), maxBound(0), graph(), haig(), graph_lag(0) {} RoseInEdgeProps(u32 min_in, u32 max_in) : minBound(min_in), maxBound(max_in), graph(), graph_lag(0) { assert(minBound <= maxBound); assert(minBound != ROSE_BOUND_INF); } /* haig rosefixes (prefix/infix) require their corresponding holders */ RoseInEdgeProps(std::shared_ptr g, std::shared_ptr h, u32 lag) : minBound(0), maxBound(ROSE_BOUND_INF), graph(g), haig(h), graph_lag(lag) { assert(graph); assert(haig); } /* haig suffixes do not require their corresponding holders */ explicit RoseInEdgeProps(std::shared_ptr h) : minBound(0), maxBound(ROSE_BOUND_INF), haig(h), graph_lag(0) { assert(haig); } RoseInEdgeProps(std::shared_ptr g, u32 lag) : minBound(0), maxBound(ROSE_BOUND_INF), graph(g), graph_lag(lag) { assert(graph); } /** \brief Minimum bound on 'dot' repeat between literals. ie pred end -> * succ begin. */ u32 minBound; /** \brief Maximum bound on 'dot' repeat between literals. */ u32 maxBound; /** \brief Prefix graph. Graph is end to (end - lag). */ std::shared_ptr graph; /** \brief Haig version of graph, if required. */ std::shared_ptr haig; u32 graph_lag; size_t index = 0; }; struct RoseInGraph : public ue2_graph { }; typedef RoseInGraph::vertex_descriptor RoseInVertex; typedef RoseInGraph::edge_descriptor RoseInEdge; } // namespace ue2 #endif hyperscan-4.4.1/src/rose/rose_in_dump.h0000644000175000017500000000363113055426554020675 0ustar sleuthkidsleuthkid/* * 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 ROSE_IN_DUMP_H #define ROSE_IN_DUMP_H #include "rose_in_graph.h" namespace ue2 { struct Grey; #ifdef DUMP_SUPPORT void dumpPreRoseGraph(const RoseInGraph &ig, const Grey &grey, const char *filename = nullptr); #else static UNUSED void dumpPreRoseGraph(const RoseInGraph &, const Grey &, const char * = nullptr) { } #endif } #endif hyperscan-4.4.1/src/rose/rose_build_groups.cpp0000644000175000017500000005050613055426554022276 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** * \file * \brief Rose build: code for analysing literal groups. */ #include "rose_build_groups.h" #include #include #include #include #include using namespace std; using boost::adaptors::map_keys; namespace ue2 { #define ROSE_LONG_LITERAL_LEN 8 static bool superStrong(const rose_literal_id &lit) { if (lit.s.length() < ROSE_LONG_LITERAL_LEN) { return false; } const u32 EXPECTED_FDR_BUCKET_LENGTH = 8; assert(lit.s.length() >= EXPECTED_FDR_BUCKET_LENGTH); size_t len = lit.s.length(); const string &s = lit.s.get_string(); for (size_t i = 1; i < EXPECTED_FDR_BUCKET_LENGTH; i++) { if (s[len - 1 - i] != s[len - 1]) { return true; /* we have at least some variation in the tail */ } } DEBUG_PRINTF("lit '%s' is not superstrong due to tail\n", escapeString(s).c_str()); return false; } static bool eligibleForAlwaysOnGroup(const RoseBuildImpl &build, u32 id) { /* returns true if it or any of its delay versions have root role */ for (auto v : build.literal_info[id].vertices) { if (build.isRootSuccessor(v)) { NGHolder *h = build.g[v].left.graph.get(); if (!h || proper_out_degree(h->startDs, *h)) { return true; } } } for (u32 delayed_id : build.literal_info[id].delayed_ids) { for (auto v : build.literal_info[delayed_id].vertices) { if (build.isRootSuccessor(v)) { NGHolder *h = build.g[v].left.graph.get(); if (!h || proper_out_degree(h->startDs, *h)) { return true; } } } } return false; } static bool requires_group_assignment(const rose_literal_id &lit, const rose_literal_info &info) { if (lit.delay) { /* we will check the shadow's master */ return false; } if (lit.table == ROSE_ANCHORED || lit.table == ROSE_EVENT) { return false; } // If we already have a group applied, skip. if (info.group_mask) { return false; } if (info.vertices.empty() && info.delayed_ids.empty()) { DEBUG_PRINTF("literal is good for nothing\n"); return false; } return true; } static rose_group calcLocalGroup(const RoseVertex v, const RoseGraph &g, const deque &literal_info, const bool small_literal_count) { rose_group local_group = 0; for (auto u : inv_adjacent_vertices_range(v, g)) { /* In small cases, ensure that siblings have the same rose parentage to * allow rose squashing. In larger cases, don't do this as groups are * probably too scarce. */ for (auto w : adjacent_vertices_range(u, g)) { if (!small_literal_count || g[v].left == g[w].left) { for (u32 lit_id : g[w].literals) { local_group |= literal_info[lit_id].group_mask; } } else { DEBUG_PRINTF("not sibling different mother %zu %zu\n", g[v].index, g[w].index); } } } return local_group; } /* group constants */ #define MAX_LIGHT_LITERAL_CASE 200 /* allow rose to affect group decisions below * this */ static flat_set getAssociatedVertices(const RoseBuildImpl &build, u32 id) { flat_set out; const auto &info = build.literal_info[id]; insert(&out, info.vertices); for (const auto &delayed : info.delayed_ids) { insert(&out, build.literal_info[delayed].vertices); } return out; } static u32 next_available_group(u32 counter, u32 min_start_group) { counter++; if (counter == ROSE_GROUPS_MAX) { DEBUG_PRINTF("resetting groups\n"); counter = min_start_group; } return counter; } void assignGroupsToLiterals(RoseBuildImpl &build) { auto &literals = build.literals; auto &literal_info = build.literal_info; bool small_literal_count = literal_info.size() <= MAX_LIGHT_LITERAL_CASE; map groupCount; /* group index to number of members */ u32 counter = 0; u32 group_always_on = 0; // First pass: handle always on literals. for (const auto &e : literals.right) { u32 id = e.first; const rose_literal_id &lit = e.second; rose_literal_info &info = literal_info[id]; if (!requires_group_assignment(lit, info)) { continue; } // If this literal has a root role, we always have to search for it // anyway, so it goes in the always-on group. /* We could end up squashing it if it is followed by a .* */ if (eligibleForAlwaysOnGroup(build, id)) { info.group_mask = 1ULL << group_always_on; groupCount[group_always_on]++; continue; } } u32 group_long_lit; if (groupCount[group_always_on]) { DEBUG_PRINTF("%u always on literals\n", groupCount[group_always_on]); group_long_lit = group_always_on; counter++; } else { group_long_lit = counter; counter++; } u32 min_start_group = counter; priority_queue> pq; // Second pass: the other literals. for (const auto &e : literals.right) { u32 id = e.first; const rose_literal_id &lit = e.second; rose_literal_info &info = literal_info[id]; if (!requires_group_assignment(lit, info)) { continue; } assert(!eligibleForAlwaysOnGroup(build, id)); pq.emplace(-(s32)info.vertices.size(), -(s32)lit.s.length(), id); } vector long_lits; while (!pq.empty()) { u32 id = get<2>(pq.top()); pq.pop(); UNUSED const rose_literal_id &lit = literals.right.at(id); DEBUG_PRINTF("assigning groups to lit %u (v %zu l %zu)\n", id, literal_info[id].vertices.size(), lit.s.length()); u8 group_id = 0; rose_group group = ~0ULL; for (auto v : getAssociatedVertices(build, id)) { rose_group local_group = calcLocalGroup(v, build.g, literal_info, small_literal_count); group &= local_group; if (!group) { break; } } if (group == ~0ULL) { goto boring; } group &= ~((1ULL << min_start_group) - 1); /* ensure the purity of the * always_on groups */ if (!group) { goto boring; } group_id = ctz64(group); /* TODO: fairness */ DEBUG_PRINTF("picking sibling group %hhd\n", group_id); literal_info[id].group_mask = 1ULL << group_id; groupCount[group_id]++; continue; boring: /* long literals will either be stuck in a mega group or spread around * depending on availability */ if (superStrong(lit)) { long_lits.push_back(id); continue; } // Other literals are assigned to our remaining groups round-robin. group_id = counter; DEBUG_PRINTF("picking boring group %hhd\n", group_id); literal_info[id].group_mask = 1ULL << group_id; groupCount[group_id]++; counter = next_available_group(counter, min_start_group); } /* spread long literals out amongst unused groups if any, otherwise stick * them in the always on the group */ if (groupCount[counter]) { DEBUG_PRINTF("sticking long literals in the image of the always on\n"); for (u32 lit_id : long_lits) { literal_info[lit_id].group_mask = 1ULL << group_long_lit; groupCount[group_long_lit]++; } } else { u32 min_long_counter = counter; DEBUG_PRINTF("base long lit group = %u\n", min_long_counter); for (u32 lit_id : long_lits) { u8 group_id = counter; literal_info[lit_id].group_mask = 1ULL << group_id; groupCount[group_id]++; counter = next_available_group(counter, min_long_counter); } } /* assign delayed literals to the same group as their parent */ for (const auto &e : literals.right) { u32 id = e.first; const rose_literal_id &lit = e.second; if (!lit.delay) { continue; } u32 parent = literal_info[id].undelayed_id; DEBUG_PRINTF("%u is shadow picking up groups from %u\n", id, parent); assert(literal_info[parent].undelayed_id == parent); assert(literal_info[parent].group_mask); literal_info[id].group_mask = literal_info[parent].group_mask; /* don't increment the group count - these don't really exist */ } DEBUG_PRINTF("populate group to literal mapping\n"); for (const u32 id : literals.right | map_keys) { rose_group groups = literal_info[id].group_mask; while (groups) { u32 group_id = findAndClearLSB_64(&groups); build.group_to_literal[group_id].insert(id); } } /* find how many groups we allocated */ for (u32 i = 0; i < ROSE_GROUPS_MAX; i++) { if (groupCount[i]) { build.group_end = max(build.group_end, i + 1); } } } rose_group RoseBuildImpl::getGroups(RoseVertex v) const { rose_group groups = 0; for (u32 id : g[v].literals) { u32 lit_id = literal_info.at(id).undelayed_id; rose_group mygroups = literal_info[lit_id].group_mask; groups |= mygroups; } return groups; } /** \brief Get the groups of the successor literals of a given vertex. */ rose_group RoseBuildImpl::getSuccGroups(RoseVertex start) const { rose_group initialGroups = 0; for (auto v : adjacent_vertices_range(start, g)) { initialGroups |= getGroups(v); } return initialGroups; } /** * The groups that a role sets are determined by the union of its successor * literals. Requires the literals already have had groups assigned. */ void assignGroupsToRoles(RoseBuildImpl &build) { auto &g = build.g; /* Note: if there is a succ literal in the sidematcher, its successors * literals must be added instead */ for (auto v : vertices_range(g)) { if (build.isAnyStart(v)) { continue; } const rose_group succ_groups = build.getSuccGroups(v); g[v].groups |= succ_groups; auto ghost_it = build.ghost.find(v); if (ghost_it != end(build.ghost)) { /* delayed roles need to supply their groups to the ghost role */ g[ghost_it->second].groups |= succ_groups; } DEBUG_PRINTF("vertex %zu: groups=%llx\n", g[v].index, g[v].groups); } } /** * \brief Returns a mapping from each graph vertex v to the intersection of the * groups switched on by all of the paths leading up to (and including) v from * the start vertexes. */ unordered_map getVertexGroupMap(const RoseBuildImpl &build) { const RoseGraph &g = build.g; vector v_order; v_order.reserve(num_vertices(g)); boost::topological_sort(g, back_inserter(v_order)); unordered_map vertex_group_map; vertex_group_map.reserve(num_vertices(g)); const rose_group initial_groups = build.getInitialGroups(); for (const auto &v : boost::adaptors::reverse(v_order)) { DEBUG_PRINTF("vertex %zu\n", g[v].index); if (build.isAnyStart(v)) { DEBUG_PRINTF("start vertex, groups=0x%llx\n", initial_groups); vertex_group_map.emplace(v, initial_groups); continue; } // To get to this vertex, we must have come through a predecessor, and // everyone who isn't a start vertex has one. assert(in_degree(v, g) > 0); rose_group pred_groups = ~rose_group{0}; for (auto u : inv_adjacent_vertices_range(v, g)) { DEBUG_PRINTF("pred %zu\n", g[u].index); assert(contains(vertex_group_map, u)); pred_groups &= vertex_group_map.at(u); } DEBUG_PRINTF("pred_groups=0x%llx\n", pred_groups); DEBUG_PRINTF("g[v].groups=0x%llx\n", g[v].groups); rose_group v_groups = pred_groups | g[v].groups; DEBUG_PRINTF("v_groups=0x%llx\n", v_groups); vertex_group_map.emplace(v, v_groups); } return vertex_group_map; } /** * \brief Find the set of groups that can be squashed anywhere in the graph, * either by a literal or by a leftfix. */ rose_group getSquashableGroups(const RoseBuildImpl &build) { rose_group squashable_groups = 0; for (const auto &info : build.literal_info) { if (info.squash_group) { DEBUG_PRINTF("lit squash mask 0x%llx\n", info.group_mask); squashable_groups |= info.group_mask; } } for (const auto &m : build.rose_squash_masks) { DEBUG_PRINTF("left squash mask 0x%llx\n", ~m.second); squashable_groups |= ~m.second; } DEBUG_PRINTF("squashable groups=0x%llx\n", squashable_groups); return squashable_groups; } /** * \brief True if every vertex associated with a group also belongs to * lit_info. */ static bool coversGroup(const RoseBuildImpl &build, const rose_literal_info &lit_info) { if (lit_info.vertices.empty()) { DEBUG_PRINTF("no vertices - does not cover\n"); return false; } if (!lit_info.group_mask) { DEBUG_PRINTF("no group - does not cover\n"); return false; /* no group (not a floating lit?) */ } assert(popcount64(lit_info.group_mask) == 1); /* for each lit in group, ensure that vertices are a subset of lit_info's */ rose_group groups = lit_info.group_mask; while (groups) { u32 group_id = findAndClearLSB_64(&groups); for (u32 id : build.group_to_literal.at(group_id)) { DEBUG_PRINTF(" checking against friend %u\n", id); if (!is_subset_of(build.literal_info[id].vertices, lit_info.vertices)) { DEBUG_PRINTF("fail\n"); return false; } } } DEBUG_PRINTF("ok\n"); return true; } static bool isGroupSquasher(const RoseBuildImpl &build, const u32 id /* literal id */, rose_group forbidden_squash_group) { const RoseGraph &g = build.g; const rose_literal_info &lit_info = build.literal_info.at(id); DEBUG_PRINTF("checking if %u '%s' is a group squasher %016llx\n", id, dumpString(build.literals.right.at(id).s).c_str(), lit_info.group_mask); if (build.literals.right.at(id).table == ROSE_EVENT) { DEBUG_PRINTF("event literal, has no groups to squash\n"); return false; } if (!coversGroup(build, lit_info)) { DEBUG_PRINTF("does not cover group\n"); return false; } if (lit_info.group_mask & forbidden_squash_group) { /* probably a delayed lit */ DEBUG_PRINTF("skipping as involves a forbidden group\n"); return false; } // Single-vertex, less constrained case than the multiple-vertex one below. if (lit_info.vertices.size() == 1) { const RoseVertex &v = *lit_info.vertices.begin(); if (build.hasDelayPred(v)) { /* due to rebuild issues */ return false; } /* there are two ways to be a group squasher: * 1) only care about the first accepted match * 2) can only match once after a pred match * * (2) requires analysis of the infix before v and is not implemented, * TODO */ /* Case 1 */ // Can't squash cases with accepts if (!g[v].reports.empty()) { return false; } /* Can't squash cases with a suffix without analysis of the suffix. * TODO: look at suffixes */ if (g[v].suffix) { return false; } // Out-edges must have inf max bound, + no other shenanigans */ for (const auto &e : out_edges_range(v, g)) { if (g[e].maxBound != ROSE_BOUND_INF) { return false; } if (g[target(e, g)].left) { return false; /* is an infix rose trigger, TODO: analysis */ } } DEBUG_PRINTF("%u is a path 1 group squasher\n", id); return true; /* note: we could also squash the groups of its preds (if nobody else is * using them. TODO. */ } // Multiple-vertex case for (auto v : lit_info.vertices) { assert(!build.isAnyStart(v)); // Can't squash cases with accepts if (!g[v].reports.empty()) { return false; } // Suffixes and leftfixes are out too as first literal may not match // for everyone. if (!g[v].isBoring()) { return false; } /* TODO: checks are solid but we should explain */ if (build.hasDelayPred(v) || build.hasAnchoredTablePred(v)) { return false; } // Out-edges must have inf max bound and not directly lead to another // vertex with this group, e.g. 'foobar.*foobar'. for (const auto &e : out_edges_range(v, g)) { if (g[e].maxBound != ROSE_BOUND_INF) { return false; } RoseVertex t = target(e, g); if (g[t].left) { return false; /* is an infix rose trigger */ } for (u32 lit_id : g[t].literals) { if (build.literal_info[lit_id].group_mask & lit_info.group_mask) { return false; } } } // In-edges must all be dot-stars with no overlap at all, as overlap // also causes history to be used. /* Different tables are already forbidden by previous checks */ for (const auto &e : in_edges_range(v, g)) { if (!(g[e].minBound == 0 && g[e].maxBound == ROSE_BOUND_INF)) { return false; } // Check overlap, if source was a literal. RoseVertex u = source(e, g); if (build.maxLiteralOverlap(u, v)) { return false; } } } DEBUG_PRINTF("literal %u is a multi-vertex group squasher\n", id); return true; } void findGroupSquashers(RoseBuildImpl &build) { rose_group forbidden_squash_group = 0; for (const auto &e : build.literals.right) { if (e.second.delay) { forbidden_squash_group |= build.literal_info[e.first].group_mask; } } for (u32 id = 0; id < build.literal_info.size(); id++) { if (isGroupSquasher(build, id, forbidden_squash_group)) { build.literal_info[id].squash_group = true; } } } } // namespace ue2 hyperscan-4.4.1/src/rose/init.c0000644000175000017500000000662113055426554017152 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "init.h" #include "match.h" #include "runtime.h" #include "scratch.h" #include "rose.h" #include "rose_common.h" #include "rose_internal.h" #include "ue2common.h" #include "nfa/mcclellan.h" #include "nfa/nfa_api_util.h" #include "nfa/nfa_internal.h" #include "util/multibit.h" #include static really_inline void init_rstate(const struct RoseEngine *t, char *state) { // Set runtime state: we take our initial groups from the RoseEngine. DEBUG_PRINTF("setting initial groups to 0x%016llx\n", t->initialGroups); storeGroups(t, state, t->initialGroups); } static really_inline void init_outfixes(const struct RoseEngine *t, char *state) { /* The active leaf array has been init'ed by the scatter with outfix * bits set on */ // Init the NFA state for each outfix. for (u32 qi = t->outfixBeginQueue; qi < t->outfixEndQueue; qi++) { const struct NfaInfo *info = getNfaInfoByQueue(t, qi); const struct NFA *nfa = getNfaByInfo(t, info); nfaInitCompressedState(nfa, 0, state + info->stateOffset, 0 /* assume NUL at start */); } if (t->initMpvNfa != MO_INVALID_IDX) { const struct NfaInfo *info = getNfaInfoByQueue(t, t->initMpvNfa); const struct NFA *nfa = getNfaByInfo(t, info); nfaInitCompressedState(nfa, 0, state + info->stateOffset, 0 /* assume NUL at start */); mmbit_set(getActiveLeafArray(t, state), t->activeArrayCount, t->initMpvNfa); } } void roseInitState(const struct RoseEngine *t, char *state) { assert(t); assert(state); DEBUG_PRINTF("init for Rose %p with %u state indices)\n", t, t->rolesWithStateCount); // Rose is guaranteed 8-aligned state assert(ISALIGNED_N(state, 8)); init_rstate(t, state); init_state(t, state); init_outfixes(t, state); } hyperscan-4.4.1/src/rose/catchup.c0000644000175000017500000007611313055426554017641 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** * \file * \brief Rose runtime: code for catching up output-exposed engines. */ #include "catchup.h" #include "match.h" #include "program_runtime.h" #include "rose.h" #include "nfa/nfa_rev_api.h" #include "nfa/mpv.h" #include "som/som_runtime.h" #include "util/fatbit.h" #include "report.h" typedef struct queue_match PQ_T; #define PQ_COMP(pqc_items, a, b) ((pqc_items)[a].loc < (pqc_items)[b].loc) #define PQ_COMP_B(pqc_items, a, b_fixed) ((pqc_items)[a].loc < (b_fixed).loc) #include "util/pqueue.h" static really_inline int roseNfaRunProgram(const struct RoseEngine *rose, struct hs_scratch *scratch, u64a som, u64a offset, ReportID id, const char from_mpv) { const u32 program = id; const size_t match_len = 0; // Unused in this path. u8 flags = ROSE_PROG_FLAG_IN_CATCHUP; if (from_mpv) { flags |= ROSE_PROG_FLAG_FROM_MPV; } roseRunProgram(rose, scratch, program, som, offset, match_len, flags); return can_stop_matching(scratch) ? MO_HALT_MATCHING : MO_CONTINUE_MATCHING; } static rose_inline char roseSuffixInfoIsExhausted(const struct RoseEngine *rose, const struct NfaInfo *info, const char *exhausted) { if (!info->ekeyListOffset) { return 0; } DEBUG_PRINTF("check exhaustion -> start at %u\n", info->ekeyListOffset); /* INVALID_EKEY terminated list */ const u32 *ekeys = getByOffset(rose, info->ekeyListOffset); while (*ekeys != INVALID_EKEY) { DEBUG_PRINTF("check %u\n", *ekeys); if (!isExhausted(rose, exhausted, *ekeys)) { DEBUG_PRINTF("not exhausted -> alive\n"); return 0; } ++ekeys; } DEBUG_PRINTF("all ekeys exhausted -> dead\n"); return 1; } static really_inline char roseSuffixIsExhausted(const struct RoseEngine *rose, u32 qi, const char *exhausted) { DEBUG_PRINTF("check queue %u\n", qi); const struct NfaInfo *info = getNfaInfoByQueue(rose, qi); return roseSuffixInfoIsExhausted(rose, info, exhausted); } static really_inline void deactivateQueue(const struct RoseEngine *t, u8 *aa, u32 qi, struct hs_scratch *scratch) { u32 aaCount = t->activeArrayCount; u32 qCount = t->queueCount; /* this is sailing close to the wind with regards to invalidating an * iteration. We are saved by the fact that unsetting does not clear the * summary bits -> the block under the gun remains valid */ DEBUG_PRINTF("killing off zombie queue %u\n", qi); mmbit_unset(aa, aaCount, qi); fatbit_unset(scratch->aqa, qCount, qi); } static really_inline void ensureQueueActive(const struct RoseEngine *t, u32 qi, u32 qCount, struct mq *q, struct hs_scratch *scratch) { if (!fatbit_set(scratch->aqa, qCount, qi)) { DEBUG_PRINTF("initing %u\n", qi); initQueue(q, qi, t, scratch); loadStreamState(q->nfa, q, 0); pushQueueAt(q, 0, MQE_START, 0); } } static really_inline void pq_replace_top_with(struct catchup_pq *pq, UNUSED struct hs_scratch *scratch, u32 queue, s64a loc) { DEBUG_PRINTF("inserting q%u in pq at %lld\n", queue, loc); struct queue_match temp = { .queue = queue, .loc = (size_t)loc }; assert(loc > 0); assert(pq->qm_size); assert(loc <= (s64a)scratch->core_info.len); pq_replace_top(pq->qm, pq->qm_size, temp); } static really_inline void pq_insert_with(struct catchup_pq *pq, UNUSED struct hs_scratch *scratch, u32 queue, s64a loc) { DEBUG_PRINTF("inserting q%u in pq at %lld\n", queue, loc); struct queue_match temp = { .queue = queue, .loc = (size_t)loc }; assert(loc > 0); assert(loc <= (s64a)scratch->core_info.len); pq_insert(pq->qm, pq->qm_size, temp); ++pq->qm_size; } static really_inline void pq_pop_nice(struct catchup_pq *pq) { pq_pop(pq->qm, pq->qm_size); pq->qm_size--; } static really_inline s64a pq_top_loc(struct catchup_pq *pq) { assert(pq->qm_size); return (s64a)pq_top(pq->qm)->loc; } /* requires that we are the top item on the pq */ static really_inline hwlmcb_rv_t runExistingNfaToNextMatch(const struct RoseEngine *t, u32 qi, struct mq *q, s64a loc, struct hs_scratch *scratch, u8 *aa, char report_curr) { assert(pq_top(scratch->catchup_pq.qm)->queue == qi); assert(scratch->catchup_pq.qm_size); assert(!q->report_current); if (report_curr) { DEBUG_PRINTF("need to report matches\n"); q->report_current = 1; } DEBUG_PRINTF("running queue from %u:%lld to %lld\n", q->cur, q_cur_loc(q), loc); assert(q_cur_loc(q) <= loc); char alive = nfaQueueExecToMatch(q->nfa, q, loc); /* exit via gift shop */ if (alive == MO_MATCHES_PENDING) { /* we have pending matches */ assert(q_cur_loc(q) + scratch->core_info.buf_offset >= scratch->tctxt.minMatchOffset); pq_replace_top_with(&scratch->catchup_pq, scratch, qi, q_cur_loc(q)); return HWLM_CONTINUE_MATCHING; } else if (!alive) { if (report_curr && can_stop_matching(scratch)) { DEBUG_PRINTF("bailing\n"); return HWLM_TERMINATE_MATCHING; } deactivateQueue(t, aa, qi, scratch); } else if (q->cur == q->end) { DEBUG_PRINTF("queue %u finished, nfa lives\n", qi); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } else { DEBUG_PRINTF("queue %u unfinished, nfa lives\n", qi); u32 i = 0; while (q->cur < q->end) { q->items[i] = q->items[q->cur++]; DEBUG_PRINTF("q[%u] = %u:%lld\n", i, q->items[i].type, q->items[i].location); assert(q->items[i].type != MQE_END); i++; } q->cur = 0; q->end = i; } pq_pop_nice(&scratch->catchup_pq); return HWLM_CONTINUE_MATCHING; } static really_inline hwlmcb_rv_t runNewNfaToNextMatch(const struct RoseEngine *t, u32 qi, struct mq *q, s64a loc, struct hs_scratch *scratch, u8 *aa, s64a report_ok_loc) { assert(!q->report_current); DEBUG_PRINTF("running queue from %u:%lld to %lld\n", q->cur, q_cur_loc(q), loc); DEBUG_PRINTF("min match offset %llu\n", scratch->tctxt.minMatchOffset); char alive = 1; restart: alive = nfaQueueExecToMatch(q->nfa, q, loc); if (alive == MO_MATCHES_PENDING) { DEBUG_PRINTF("we have pending matches at %lld\n", q_cur_loc(q)); s64a qcl = q_cur_loc(q); if (qcl == report_ok_loc) { assert(q->cur != q->end); /* the queue shouldn't be empty if there * are pending matches. */ q->report_current = 1; DEBUG_PRINTF("restarting...\n"); goto restart; } assert(qcl + scratch->core_info.buf_offset >= scratch->tctxt.minMatchOffset); pq_insert_with(&scratch->catchup_pq, scratch, qi, qcl); } else if (!alive) { if (can_stop_matching(scratch)) { DEBUG_PRINTF("bailing\n"); return HWLM_TERMINATE_MATCHING; } deactivateQueue(t, aa, qi, scratch); } else if (q->cur == q->end) { DEBUG_PRINTF("queue %u finished, nfa lives\n", qi); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } else { DEBUG_PRINTF("queue %u unfinished, nfa lives\n", qi); u32 i = 0; while (q->cur < q->end) { q->items[i] = q->items[q->cur++]; DEBUG_PRINTF("q[%u] = %u:%lld\n", i, q->items[i].type, q->items[i].location); assert(q->items[i].type != MQE_END); i++; } q->cur = 0; q->end = i; } return HWLM_CONTINUE_MATCHING; } /* for use by mpv (chained) only */ static int roseNfaFinalBlastAdaptor(u64a start, u64a end, ReportID id, void *context) { struct hs_scratch *scratch = context; assert(scratch && scratch->magic == SCRATCH_MAGIC); const struct RoseEngine *t = scratch->core_info.rose; DEBUG_PRINTF("id=%u matched at [%llu,%llu]\n", id, start, end); int cb_rv = roseNfaRunProgram(t, scratch, start, end, id, 1); if (cb_rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) { return MO_CONTINUE_MATCHING; } else { assert(cb_rv == MO_CONTINUE_MATCHING); return !roseSuffixIsExhausted(t, 0, scratch->core_info.exhaustionVector); } } static really_inline void ensureEnd(struct mq *q, UNUSED u32 qi, s64a final_loc) { DEBUG_PRINTF("ensure MQE_END %lld for queue %u\n", final_loc, qi); if (final_loc >= q_last_loc(q)) { /* TODO: ensure situation does not arise */ assert(q_last_type(q) != MQE_END); pushQueueNoMerge(q, MQE_END, final_loc); } } static really_inline hwlmcb_rv_t add_to_queue(const struct RoseEngine *t, struct mq *queues, u32 qCount, u8 *aa, struct hs_scratch *scratch, s64a loc, u32 qi, s64a report_ok_loc) { struct mq *q = queues + qi; const struct NfaInfo *info = getNfaInfoByQueue(t, qi); if (roseSuffixInfoIsExhausted(t, info, scratch->core_info.exhaustionVector)) { deactivateQueue(t, aa, qi, scratch); return HWLM_CONTINUE_MATCHING; } ensureQueueActive(t, qi, qCount, q, scratch); if (unlikely(loc < q_cur_loc(q))) { DEBUG_PRINTF("err loc %lld < location %lld\n", loc, q_cur_loc(q)); return HWLM_CONTINUE_MATCHING; } ensureEnd(q, qi, loc); return runNewNfaToNextMatch(t, qi, q, loc, scratch, aa, report_ok_loc); } static really_inline s64a findSecondPlace(struct catchup_pq *pq, s64a loc_limit) { assert(pq->qm_size); /* we are still on the pq and we are first place */ /* we know (*cough* encapsulation) that second place will either be in * pq->qm[1] or pq->qm[2] (we are pq->qm[0]) */ switch (pq->qm_size) { case 0: case 1: return (s64a)loc_limit; case 2: return MIN((s64a)pq->qm[1].loc, loc_limit); default:; size_t best = MIN(pq->qm[1].loc, pq->qm[2].loc); return MIN((s64a)best, loc_limit); } } hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, s64a loc, struct hs_scratch *scratch) { char *state = scratch->core_info.state; struct mq *queues = scratch->queues; u8 *aa = getActiveLeafArray(t, state); UNUSED u32 aaCount = t->activeArrayCount; u32 qCount = t->queueCount; /* find first match of each pending nfa */ DEBUG_PRINTF("aa=%p, aaCount=%u\n", aa, aaCount); assert(t->outfixBeginQueue == 1); u32 qi = 0; assert(mmbit_isset(aa, aaCount, 0)); /* caller should have already bailed */ DEBUG_PRINTF("catching up qi=%u to loc %lld\n", qi, loc); struct mq *q = queues + qi; const struct NfaInfo *info = getNfaInfoByQueue(t, qi); u64a mpv_exec_end = scratch->core_info.buf_offset + loc; u64a next_pos_match_loc = 0; if (roseSuffixInfoIsExhausted(t, info, scratch->core_info.exhaustionVector)) { deactivateQueue(t, aa, qi, scratch); goto done; } ensureQueueActive(t, qi, qCount, q, scratch); if (unlikely(loc < q_cur_loc(q))) { DEBUG_PRINTF("err loc %lld < location %lld\n", loc, q_cur_loc(q)); goto done; } ensureEnd(q, qi, loc); assert(!q->report_current); q->cb = roseNfaFinalBlastAdaptor; DEBUG_PRINTF("queue %u blasting, %u/%u [%lld/%lld]\n", qi, q->cur, q->end, q->items[q->cur].location, loc); scratch->tctxt.mpv_inactive = 0; /* we know it is going to be an mpv, skip the indirection */ next_pos_match_loc = nfaExecMpv_QueueExecRaw(q->nfa, q, loc); assert(!q->report_current); if (!next_pos_match_loc) { /* 0 means dead */ DEBUG_PRINTF("mpv is pining for the fjords\n"); if (can_stop_matching(scratch)) { deactivateQueue(t, aa, qi, scratch); return HWLM_TERMINATE_MATCHING; } next_pos_match_loc = scratch->core_info.len; scratch->tctxt.mpv_inactive = 1; } if (q->cur == q->end) { DEBUG_PRINTF("queue %u finished, nfa lives [%lld]\n", qi, loc); q->cur = 0; q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } else { DEBUG_PRINTF("queue %u not finished, nfa lives [%lld]\n", qi, loc); } done: updateMinMatchOffsetFromMpv(&scratch->tctxt, mpv_exec_end); scratch->tctxt.next_mpv_offset = MAX(next_pos_match_loc + scratch->core_info.buf_offset, mpv_exec_end + 1); DEBUG_PRINTF("next match loc %lld (off %llu)\n", next_pos_match_loc, scratch->tctxt.next_mpv_offset); return can_stop_matching(scratch) ? HWLM_TERMINATE_MATCHING : HWLM_CONTINUE_MATCHING; } static really_inline char in_mpv(const struct RoseEngine *rose, const struct hs_scratch *scratch) { const struct RoseContext *tctxt = &scratch->tctxt; assert(tctxt->curr_qi < rose->queueCount); if (tctxt->curr_qi < rose->outfixBeginQueue) { assert(getNfaByQueue(rose, tctxt->curr_qi)->type == MPV_NFA); return 1; } return 0; } static int roseNfaBlastAdaptor(u64a start, u64a end, ReportID id, void *context) { struct hs_scratch *scratch = context; assert(scratch && scratch->magic == SCRATCH_MAGIC); const struct RoseEngine *t = scratch->core_info.rose; DEBUG_PRINTF("id=%u matched at [%llu,%llu]\n", id, start, end); const char from_mpv = in_mpv(t, scratch); int cb_rv = roseNfaRunProgram(t, scratch, start, end, id, from_mpv); if (cb_rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } else if (cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) { return MO_CONTINUE_MATCHING; } else { assert(cb_rv == MO_CONTINUE_MATCHING); return !roseSuffixIsExhausted(t, scratch->tctxt.curr_qi, scratch->core_info.exhaustionVector); } } int roseNfaAdaptor(u64a start, u64a end, ReportID id, void *context) { struct hs_scratch *scratch = context; assert(scratch && scratch->magic == SCRATCH_MAGIC); DEBUG_PRINTF("id=%u matched at [%llu,%llu]\n", id, start, end); /* must be a external report as haig cannot directly participate in chain */ return roseNfaRunProgram(scratch->core_info.rose, scratch, start, end, id, 0); } static really_inline char blast_queue(struct hs_scratch *scratch, struct mq *q, u32 qi, s64a to_loc, char report_current) { scratch->tctxt.curr_qi = qi; q->cb = roseNfaBlastAdaptor; q->report_current = report_current; DEBUG_PRINTF("queue %u blasting, %u/%u [%lld/%lld]\n", qi, q->cur, q->end, q_cur_loc(q), to_loc); char alive = nfaQueueExec(q->nfa, q, to_loc); q->cb = roseNfaAdaptor; assert(!q->report_current); return alive; } static really_inline hwlmcb_rv_t buildSufPQ_final(const struct RoseEngine *t, s64a report_ok_loc, s64a second_place_loc, s64a final_loc, struct hs_scratch *scratch, u8 *aa, u32 a_qi) { struct mq *q = scratch->queues + a_qi; const struct NfaInfo *info = getNfaInfoByQueue(t, a_qi); DEBUG_PRINTF("blasting qi=%u to %lld [final %lld]\n", a_qi, second_place_loc, final_loc); if (roseSuffixInfoIsExhausted(t, info, scratch->core_info.exhaustionVector)) { deactivateQueue(t, aa, a_qi, scratch); return HWLM_CONTINUE_MATCHING; } ensureQueueActive(t, a_qi, t->queueCount, q, scratch); if (unlikely(final_loc < q_cur_loc(q))) { DEBUG_PRINTF("err loc %lld < location %lld\n", final_loc, q_cur_loc(q)); return HWLM_CONTINUE_MATCHING; } ensureEnd(q, a_qi, final_loc); char alive = blast_queue(scratch, q, a_qi, second_place_loc, 0); /* We have three possible outcomes: * (1) the nfa died * (2) we completed the queue (implies that second_place_loc == final_loc) * (3) the queue ran to second_place_loc and stopped. In this case we need * to find the next match location. */ if (!alive) { if (can_stop_matching(scratch)) { DEBUG_PRINTF("roseCatchUpNfas done as bailing\n"); return HWLM_TERMINATE_MATCHING; } deactivateQueue(t, aa, a_qi, scratch); } else if (q->cur == q->end) { DEBUG_PRINTF("queue %u finished, nfa lives [%lld]\n", a_qi, final_loc); assert(second_place_loc == final_loc); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, final_loc); } else { DEBUG_PRINTF("queue %u not finished, %u/%u [%lld/%lld]\n", a_qi, q->cur, q->end, q_cur_loc(q), final_loc); DEBUG_PRINTF("finding next match location\n"); assert(second_place_loc < final_loc); assert(q_cur_loc(q) >= second_place_loc); if (runNewNfaToNextMatch(t, a_qi, q, final_loc, scratch, aa, report_ok_loc) == HWLM_TERMINATE_MATCHING) { DEBUG_PRINTF("roseCatchUpNfas done\n"); return HWLM_TERMINATE_MATCHING; } } return HWLM_CONTINUE_MATCHING; } void streamInitSufPQ(const struct RoseEngine *t, char *state, struct hs_scratch *scratch) { assert(scratch->catchup_pq.qm_size == 0); assert(t->outfixBeginQueue != t->outfixEndQueue); DEBUG_PRINTF("initSufPQ: outfixes [%u,%u)\n", t->outfixBeginQueue, t->outfixEndQueue); u32 qCount = t->queueCount; u8 *aa = getActiveLeafArray(t, state); u32 aaCount = t->activeArrayCount; struct mq *queues = scratch->queues; size_t length = scratch->core_info.len; u32 qi = mmbit_iterate_bounded(aa, aaCount, t->outfixBeginQueue, t->outfixEndQueue); for (; qi < t->outfixEndQueue;) { DEBUG_PRINTF("adding qi=%u\n", qi); struct mq *q = queues + qi; ensureQueueActive(t, qi, qCount, q, scratch); ensureEnd(q, qi, length); char alive = nfaQueueExecToMatch(q->nfa, q, length); if (alive == MO_MATCHES_PENDING) { DEBUG_PRINTF("we have pending matches at %lld\n", q_cur_loc(q)); s64a qcl = q_cur_loc(q); pq_insert_with(&scratch->catchup_pq, scratch, qi, qcl); } else if (!alive) { deactivateQueue(t, aa, qi, scratch); } else { assert(q->cur == q->end); /* TODO: can this be simplified? the nfa will never produce any * matches for this block. */ DEBUG_PRINTF("queue %u finished, nfa lives\n", qi); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, length); } qi = mmbit_iterate_bounded(aa, aaCount, qi + 1, t->outfixEndQueue); } } void blockInitSufPQ(const struct RoseEngine *t, char *state, struct hs_scratch *scratch, char is_small_block) { DEBUG_PRINTF("initSufPQ: outfixes [%u,%u)\n", t->outfixBeginQueue, t->outfixEndQueue); assert(scratch->catchup_pq.qm_size == 0); assert(t->outfixBeginQueue != t->outfixEndQueue); struct mq *queues = scratch->queues; u8 *aa = getActiveLeafArray(t, state); struct fatbit *aqa = scratch->aqa; u32 aaCount = t->activeArrayCount; u32 qCount = t->queueCount; size_t length = scratch->core_info.len; for (u32 qi = t->outfixBeginQueue; qi < t->outfixEndQueue; qi++) { const struct NfaInfo *info = getNfaInfoByQueue(t, qi); if (is_small_block && info->in_sbmatcher) { DEBUG_PRINTF("skip outfix %u as it's in the SB matcher\n", qi); continue; } const struct NFA *nfa = getNfaByInfo(t, info); DEBUG_PRINTF("testing minwidth %u > len %zu\n", nfa->minWidth, length); size_t len = nfaRevAccelCheck(nfa, scratch->core_info.buf, length); if (!len) { continue; } mmbit_set(aa, aaCount, qi); fatbit_set(aqa, qCount, qi); struct mq *q = queues + qi; initQueue(q, qi, t, scratch); q->length = len; /* adjust for rev_accel */ nfaQueueInitState(nfa, q); pushQueueAt(q, 0, MQE_START, 0); pushQueueAt(q, 1, MQE_TOP, 0); pushQueueAt(q, 2, MQE_END, length); DEBUG_PRINTF("adding qi=%u to pq\n", qi); char alive = nfaQueueExecToMatch(q->nfa, q, length); if (alive == MO_MATCHES_PENDING) { DEBUG_PRINTF("we have pending matches at %lld\n", q_cur_loc(q)); s64a qcl = q_cur_loc(q); pq_insert_with(&scratch->catchup_pq, scratch, qi, qcl); } else if (!alive) { deactivateQueue(t, aa, qi, scratch); } else { assert(q->cur == q->end); /* TODO: can this be simplified? the nfa will never produce any * matches for this block. */ DEBUG_PRINTF("queue %u finished, nfa lives\n", qi); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, length); } } } /** * safe_loc is ??? */ static rose_inline hwlmcb_rv_t buildSufPQ(const struct RoseEngine *t, char *state, s64a safe_loc, s64a final_loc, struct hs_scratch *scratch) { assert(scratch->catchup_pq.qm_size <= t->outfixEndQueue); struct RoseContext *tctxt = &scratch->tctxt; assert(t->activeArrayCount); assert(scratch->core_info.buf_offset + final_loc > tctxt->minNonMpvMatchOffset); DEBUG_PRINTF("buildSufPQ final loc %lld (safe %lld)\n", final_loc, safe_loc); assert(safe_loc <= final_loc); u8 *aa = getActiveLeafArray(t, state); u32 aaCount = t->activeArrayCount; /* find first match of each pending nfa */ DEBUG_PRINTF("aa=%p, aaCount=%u\n", aa, aaCount); /* Note: mpv MUST not participate in the main priority queue as * they may have events pushed on during this process which may be before * the catch up point. Outfixes are remain in the pq between catchup events * as they never have any incoming events to worry about. */ if (aaCount == t->outfixEndQueue) { return HWLM_CONTINUE_MATCHING; } DEBUG_PRINTF("mib %u/%u\n", t->outfixBeginQueue, aaCount); u32 a_qi = mmbit_iterate_bounded(aa, aaCount, t->outfixEndQueue, aaCount); if (a_qi == MMB_INVALID) { return HWLM_CONTINUE_MATCHING; } s64a report_ok_loc = tctxt->minNonMpvMatchOffset + 1 - scratch->core_info.buf_offset; hwlmcb_rv_t rv = roseCatchUpMPV(t, report_ok_loc, scratch); if (rv != HWLM_CONTINUE_MATCHING) { DEBUG_PRINTF("terminating...\n"); return rv; } while (a_qi != MMB_INVALID) { DEBUG_PRINTF("catching up qi=%u to %lld\n", a_qi, final_loc); u32 n_qi = mmbit_iterate(aa, aaCount, a_qi); s64a second_place_loc = scratch->catchup_pq.qm_size ? pq_top_loc(&scratch->catchup_pq) : safe_loc; second_place_loc = MIN(second_place_loc, safe_loc); if (n_qi == MMB_INVALID && report_ok_loc <= second_place_loc) { if (buildSufPQ_final(t, report_ok_loc, second_place_loc, final_loc, scratch, aa, a_qi) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } break; } if (add_to_queue(t, scratch->queues, t->queueCount, aa, scratch, final_loc, a_qi, report_ok_loc) == HWLM_TERMINATE_MATCHING) { DEBUG_PRINTF("roseCatchUpNfas done\n"); return HWLM_TERMINATE_MATCHING; } a_qi = n_qi; } DEBUG_PRINTF("PQ BUILD %u items\n", scratch->catchup_pq.qm_size); return HWLM_CONTINUE_MATCHING; } static never_inline hwlmcb_rv_t roseCatchUpNfas(const struct RoseEngine *t, s64a loc, s64a final_loc, struct hs_scratch *scratch) { assert(t->activeArrayCount); DEBUG_PRINTF("roseCatchUpNfas offset=%llu + %lld/%lld\n", scratch->core_info.buf_offset, loc, final_loc); DEBUG_PRINTF("min non mpv match offset %llu\n", scratch->tctxt.minNonMpvMatchOffset); struct RoseContext *tctxt = &scratch->tctxt; assert(scratch->core_info.buf_offset + loc >= tctxt->minNonMpvMatchOffset); char *state = scratch->core_info.state; struct mq *queues = scratch->queues; u8 *aa = getActiveLeafArray(t, state); /* fire off earliest nfa match and catchup anchored matches to that point */ while (scratch->catchup_pq.qm_size) { s64a match_loc = pq_top_loc(&scratch->catchup_pq); u32 qi = pq_top(scratch->catchup_pq.qm)->queue; DEBUG_PRINTF("winrar q%u@%lld loc %lld\n", qi, match_loc, loc); assert(match_loc + scratch->core_info.buf_offset >= scratch->tctxt.minNonMpvMatchOffset); if (match_loc > loc) { /* we have processed all the matches at or before rose's current * location; only things remaining on the pq should be outfixes. */ DEBUG_PRINTF("saving for later\n"); goto exit; } /* catch up char matches to this point */ if (roseCatchUpMPV(t, match_loc, scratch) == HWLM_TERMINATE_MATCHING) { DEBUG_PRINTF("roseCatchUpNfas done\n"); return HWLM_TERMINATE_MATCHING; } assert(match_loc + scratch->core_info.buf_offset >= scratch->tctxt.minNonMpvMatchOffset); struct mq *q = queues + qi; /* outfixes must be advanced all the way as they persist in the pq * between catchup events */ s64a q_final_loc = qi >= t->outfixEndQueue ? final_loc : (s64a)scratch->core_info.len; /* fire nfa matches, and find next place this nfa match */ DEBUG_PRINTF("reporting matches %u@%llu [q->cur %u/%u]\n", qi, match_loc, q->cur, q->end); /* we then need to catch this nfa up to next earliest nfa match. These * matches can be fired directly from the callback. The callback needs * to ensure that the anchored matches remain in sync though */ s64a second_place_loc = findSecondPlace(&scratch->catchup_pq, loc); DEBUG_PRINTF("second place %lld loc %lld\n", second_place_loc, loc); if (second_place_loc == q_cur_loc(q)) { if (runExistingNfaToNextMatch(t, qi, q, q_final_loc, scratch, aa, 1) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } continue; } char alive = blast_queue(scratch, q, qi, second_place_loc, 1); if (!alive) { if (can_stop_matching(scratch)) { DEBUG_PRINTF("roseCatchUpNfas done as bailing\n"); return HWLM_TERMINATE_MATCHING; } deactivateQueue(t, aa, qi, scratch); pq_pop_nice(&scratch->catchup_pq); } else if (q->cur == q->end) { DEBUG_PRINTF("queue %u finished, nfa lives [%lld]\n", qi, loc); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); pq_pop_nice(&scratch->catchup_pq); } else if (second_place_loc == q_final_loc) { DEBUG_PRINTF("queue %u on hold\n", qi); pq_pop_nice(&scratch->catchup_pq); break; } else { DEBUG_PRINTF("queue %u not finished, %u/%u [%lld/%lld]\n", qi, q->cur, q->end, q->items[q->cur].location, loc); runExistingNfaToNextMatch(t, qi, q, q_final_loc, scratch, aa, 0); } } exit:; tctxt->minNonMpvMatchOffset = scratch->core_info.buf_offset + loc; DEBUG_PRINTF("roseCatchUpNfas done\n"); return HWLM_CONTINUE_MATCHING; } hwlmcb_rv_t roseCatchUpAll(s64a loc, struct hs_scratch *scratch) { /* just need suf/outfixes and mpv */ DEBUG_PRINTF("loc %lld mnmmo %llu mmo %llu\n", loc, scratch->tctxt.minNonMpvMatchOffset, scratch->tctxt.minMatchOffset); assert(scratch->core_info.buf_offset + loc > scratch->tctxt.minNonMpvMatchOffset); const struct RoseEngine *t = scratch->core_info.rose; char *state = scratch->core_info.state; hwlmcb_rv_t rv = buildSufPQ(t, state, loc, loc, scratch); if (rv != HWLM_CONTINUE_MATCHING) { return rv; } rv = roseCatchUpNfas(t, loc, loc, scratch); if (rv != HWLM_CONTINUE_MATCHING) { return rv; } rv = roseCatchUpMPV(t, loc, scratch); assert(rv != HWLM_CONTINUE_MATCHING || scratch->catchup_pq.qm_size <= t->outfixEndQueue); assert(!can_stop_matching(scratch) || rv == HWLM_TERMINATE_MATCHING); return rv; } hwlmcb_rv_t roseCatchUpSuf(s64a loc, struct hs_scratch *scratch) { /* just need suf/outfixes. mpv will be caught up only to last reported * external match */ assert(scratch->core_info.buf_offset + loc > scratch->tctxt.minNonMpvMatchOffset); const struct RoseEngine *t = scratch->core_info.rose; char *state = scratch->core_info.state; hwlmcb_rv_t rv = buildSufPQ(t, state, loc, loc, scratch); if (rv != HWLM_CONTINUE_MATCHING) { return rv; } rv = roseCatchUpNfas(t, loc, loc, scratch); assert(rv != HWLM_CONTINUE_MATCHING || scratch->catchup_pq.qm_size <= t->outfixEndQueue); return rv; } hyperscan-4.4.1/src/rose/rose_build_dump.h0000644000175000017500000000417313055426554021370 0ustar sleuthkidsleuthkid/* * 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 ROSE_BUILD_DUMP_H #define ROSE_BUILD_DUMP_H struct RoseEngine; namespace ue2 { class RoseBuild; struct Grey; #ifdef DUMP_SUPPORT // Dump the Rose graph in graphviz representation. void dumpRoseGraph(const RoseBuild &build, const RoseEngine *t, const char *filename); void dumpRose(const RoseBuild &build_base, const RoseEngine *t, const Grey &grey); #else static UNUSED void dumpRoseGraph(const RoseBuild &, const RoseEngine *, const char *) { } static UNUSED void dumpRose(const RoseBuild &, const RoseEngine *, const Grey &) { } #endif } // namespace ue2 #endif hyperscan-4.4.1/src/rose/rose_in_util.h0000644000175000017500000000437413055426554020712 0ustar sleuthkidsleuthkid/* * 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 ROSE_IN_UTIL_H #define ROSE_IN_UTIL_H #include "rose_in_graph.h" #include "nfa/nfa_kind.h" #include namespace ue2 { /* Returns a topological ordering of the vertices in g. That is the starts are * at the front and all the predecessors of a vertex occur earlier in the list * than the vertex. */ std::vector topo_order(const RoseInGraph &g); std::unique_ptr cloneRoseGraph(const RoseInGraph &ig); void calcVertexOffsets(RoseInGraph &ig); enum nfa_kind whatRoseIsThis(const RoseInGraph &in, const RoseInEdge &e); void pruneUseless(RoseInGraph &g); inline bool is_any_accept(RoseInVertex v, const RoseInGraph &g) { return g[v].type == RIV_ACCEPT || g[v].type == RIV_ACCEPT_EOD; } } #endif hyperscan-4.4.1/src/rose/rose_in_dump.cpp0000644000175000017500000001041713055426554021230 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "rose_in_dump.h" #include "grey.h" #include "ue2common.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng_util.h" #include "util/container.h" #include "util/graph_range.h" #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { void dumpPreRoseGraph(const RoseInGraph &ig, const Grey &grey, const char *filename) { if (!(grey.dumpFlags & Grey::DUMP_INT_GRAPH)) { return; } if (!filename) { filename = "pre_rose.dot"; } DEBUG_PRINTF("dumping rose graphs\n"); FILE *f = fopen((grey.dumpPath + filename).c_str(), "w"); fprintf(f, "digraph NFA {\n"); fprintf(f, "rankdir=LR;\n"); fprintf(f, "size=\"11.5,8\"\n"); fprintf(f, "node [ shape = circle ];\n"); u32 next_id = 0; map i_map; for (auto v : vertices_range(ig)) { u32 id = next_id++; i_map[v] = id; const RoseInVertexProps &vp = ig[v]; fprintf(f, "%u [ width = 1, fontsize = 12, label = \"%u:", id, id); switch(vp.type) { case RIV_LITERAL: fprintf(f, "%s", dotEscapeString(dumpString(vp.s)).c_str()); break; case RIV_START: fprintf(f, "[START]"); break; case RIV_ANCHORED_START: fprintf(f, "[ANCHOR]"); break; case RIV_ACCEPT: if (!vp.reports.empty()) { fprintf(f, "[ACCEPT %s]", as_string_list(vp.reports).c_str()); } else { fprintf(f, "[ACCEPT]"); } break; case RIV_ACCEPT_EOD: fprintf(f, "[EOD %s]", as_string_list(vp.reports).c_str()); break; } fprintf(f, "\" ]; \n"); } map graph_ids; for (const auto &e : edges_range(ig)) { u32 u = i_map[source(e, ig)]; u32 v = i_map[target(e, ig)]; fprintf(f, "%u -> %u [label=\"", u, v); if (ig[e].graph) { if (!contains(graph_ids, &*ig[e].graph)) { size_t id = graph_ids.size(); graph_ids[&*ig[e].graph] = id; } fprintf(f, "graph %zu\n%s", graph_ids[&*ig[e].graph], to_string(ig[e].graph->kind).c_str()); } if (ig[e].haig) { fprintf(f, "haig "); } fprintf(f, "\"]\n"); } for (const auto &e : graph_ids) { NGHolder *h = e.first; size_t id = e.second; ostringstream name; name << grey.dumpPath << "pre_rose_" << id << ".dot"; dumpGraph(name.str().c_str(), *h); assert(allMatchStatesHaveReports(*h)); } fprintf(f, "}\n"); fclose(f); } } hyperscan-4.4.1/src/rose/rose_build_merge.cpp0000644000175000017500000027111213055426554022054 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose Build: functions for reducing the size of the Rose graph * through merging. */ #include "rose_build_merge.h" #include "grey.h" #include "rose_build.h" #include "rose_build_impl.h" #include "rose_build_util.h" #include "ue2common.h" #include "nfa/castlecompile.h" #include "nfa/goughcompile.h" #include "nfa/limex_limits.h" #include "nfa/mcclellancompile.h" #include "nfa/nfa_build_util.h" #include "nfa/rdfa_merge.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_haig.h" #include "nfagraph/ng_is_equal.h" #include "nfagraph/ng_lbr.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_mcclellan.h" #include "nfagraph/ng_puff.h" #include "nfagraph/ng_redundancy.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_reports.h" #include "nfagraph/ng_stop.h" #include "nfagraph/ng_uncalc_components.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_width.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/ue2string.h" #include #include #include #include #include #include #include #include #include #include #include using namespace std; using boost::adaptors::map_values; using boost::hash_combine; namespace ue2 { static const size_t NARROW_START_MAX = 10; static const size_t SMALL_MERGE_MAX_VERTICES_STREAM = 128; static const size_t SMALL_MERGE_MAX_VERTICES_BLOCK = 64; static const size_t SMALL_ROSE_THRESHOLD_STREAM = 32; static const size_t SMALL_ROSE_THRESHOLD_BLOCK = 10; static const size_t MERGE_GROUP_SIZE_MAX = 200; static const size_t MERGE_CASTLE_GROUP_SIZE_MAX = 1000; /** \brief Max number of DFAs (McClellan, Haig) to pairwise merge together. */ static const size_t DFA_CHUNK_SIZE_MAX = 200; /** \brief Max DFA states in a merged DFA. */ static const size_t DFA_MERGE_MAX_STATES = 8000; /** \brief An LBR must have at least this many vertices to be protected from * merging with other graphs. */ static const size_t LARGE_LBR_MIN_VERTICES = 32; /** \brief In block mode, merge two prefixes even if they don't have identical * literal sets if they have fewer than this many states and the merged graph * is also small. */ static constexpr size_t MAX_BLOCK_PREFIX_MERGE_VERTICES = 32; static size_t small_merge_max_vertices(const CompileContext &cc) { return cc.streaming ? SMALL_MERGE_MAX_VERTICES_STREAM : SMALL_MERGE_MAX_VERTICES_BLOCK; } static size_t small_rose_threshold(const CompileContext &cc) { return cc.streaming ? SMALL_ROSE_THRESHOLD_STREAM : SMALL_ROSE_THRESHOLD_BLOCK; } static bool isLargeLBR(const NGHolder &g, const Grey &grey) { if (num_vertices(g) < LARGE_LBR_MIN_VERTICES) { return false; } return isLBR(g, grey); } namespace { struct DupeLeafKey { explicit DupeLeafKey(const RoseVertexProps &litv) : literals(litv.literals), reports(litv.reports), eod_accept(litv.eod_accept), suffix(litv.suffix), left(litv.left), som_adjust(litv.som_adjust) { DEBUG_PRINTF("eod_accept %d\n", (int)eod_accept); DEBUG_PRINTF("report %u\n", left.leftfix_report); DEBUG_PRINTF("lag %u\n", left.lag); } bool operator<(const DupeLeafKey &b) const { const DupeLeafKey &a = *this; ORDER_CHECK(literals); ORDER_CHECK(eod_accept); ORDER_CHECK(suffix); ORDER_CHECK(reports); ORDER_CHECK(som_adjust); ORDER_CHECK(left.leftfix_report); ORDER_CHECK(left.lag); return false; } flat_set literals; flat_set reports; bool eod_accept; suffix_id suffix; LeftEngInfo left; u32 som_adjust; }; struct UncalcLeafKey { UncalcLeafKey(const RoseGraph &g, RoseVertex v) : literals(g[v].literals), rose(g[v].left) { for (const auto &e : in_edges_range(v, g)) { RoseVertex u = source(e, g); preds.insert(make_pair(u, g[e])); } } bool operator<(const UncalcLeafKey &b) const { const UncalcLeafKey &a = *this; ORDER_CHECK(literals); ORDER_CHECK(preds); ORDER_CHECK(rose); return false; } flat_set literals; flat_set> preds; LeftEngInfo rose; }; } // namespace /** * This function merges leaf vertices with the same literals and report * id/suffix. The leaf vertices of the graph are inspected and a mapping of * leaf vertex properties to vertices is built. If the same set of leaf * properties has already been seen when we inspect a vertex, we attempt to * merge the vertex in with the previously seen vertex. This process can fail * if the vertices share a common predecessor vertex but have a differing, * incompatible relationship (different bounds or infix) with the predecessor. * * This takes place after \ref dedupeSuffixes to increase effectiveness as the * same suffix is required for a merge to occur. */ void mergeDupeLeaves(RoseBuildImpl &tbi) { map leaves; vector changed; RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { if (in_degree(v, g) == 0) { assert(tbi.isAnyStart(v)); continue; } DEBUG_PRINTF("inspecting vertex index=%zu in_degree %zu " "out_degree %zu\n", g[v].index, in_degree(v, g), out_degree(v, g)); // Vertex must be a reporting leaf node if (g[v].reports.empty() || !isLeafNode(v, g)) { continue; } // At the moment, we ignore all successors of root or anchored_root, // since many parts of our runtime assume that these have in-degree 1. if (tbi.isRootSuccessor(v)) { continue; } DupeLeafKey dupe(g[v]); if (leaves.find(dupe) == leaves.end()) { leaves.insert(make_pair(dupe, v)); continue; } RoseVertex t = leaves.find(dupe)->second; DEBUG_PRINTF("found two leaf dupe roles, index=%zu,%zu\n", g[v].index, g[t].index); vector deadEdges; for (const auto &e : in_edges_range(v, g)) { RoseVertex u = source(e, g); DEBUG_PRINTF("u index=%zu\n", g[u].index); if (RoseEdge et = edge(u, t, g)) { if (g[et].minBound <= g[e].minBound && g[et].maxBound >= g[e].maxBound) { DEBUG_PRINTF("remove more constrained edge\n"); deadEdges.push_back(e); } } else { DEBUG_PRINTF("rehome edge: add %zu->%zu\n", g[u].index, g[t].index); add_edge(u, t, g[e], g); deadEdges.push_back(e); } } if (!deadEdges.empty()) { for (auto &e : deadEdges) { remove_edge(e, g); } changed.push_back(v); g[t].min_offset = min(g[t].min_offset, g[v].min_offset); g[t].max_offset = max(g[t].max_offset, g[v].max_offset); } } DEBUG_PRINTF("find loop done\n"); // Remove any vertices that now have no in-edges. size_t countRemovals = 0; for (size_t i = 0; i < changed.size(); i++) { RoseVertex v = changed[i]; if (in_degree(v, g) == 0) { DEBUG_PRINTF("remove vertex\n"); if (!tbi.isVirtualVertex(v)) { for (u32 lit_id : g[v].literals) { tbi.literal_info[lit_id].vertices.erase(v); } } remove_vertex(v, g); countRemovals++; } } // if we've removed anything, we need to renumber vertices if (countRemovals) { renumber_vertices(g); DEBUG_PRINTF("removed %zu vertices.\n", countRemovals); } } /** Merges the suffixes on the (identical) vertices in \a vcluster, used by * \ref uncalcLeaves. */ static void mergeCluster(RoseGraph &g, const ReportManager &rm, const vector &vcluster, vector &dead, const CompileContext &cc) { if (vcluster.size() <= 1) { return; // No merge to perform. } // Note that we batch merges up fairly crudely for performance reasons. vector::const_iterator it = vcluster.begin(), it2; while (it != vcluster.end()) { vector cluster; map rev; for (it2 = it; it2 != vcluster.end() && cluster.size() < MERGE_GROUP_SIZE_MAX; ++it2) { RoseVertex v = *it2; NGHolder *h = g[v].suffix.graph.get(); assert(!g[v].suffix.haig); /* should not be here if haig */ rev[h] = v; cluster.push_back(h); } it = it2; DEBUG_PRINTF("merging cluster %zu\n", cluster.size()); auto merged = mergeNfaCluster(cluster, &rm, cc); DEBUG_PRINTF("done\n"); for (const auto &m : merged) { NGHolder *h_victim = m.first; // mergee NGHolder *h_winner = m.second; RoseVertex victim = rev[h_victim]; RoseVertex winner = rev[h_winner]; LIMIT_TO_AT_MOST(&g[winner].min_offset, g[victim].min_offset); ENSURE_AT_LEAST(&g[winner].max_offset, g[victim].max_offset); insert(&g[winner].reports, g[victim].reports); dead.push_back(victim); } } } static void findUncalcLeavesCandidates(RoseBuildImpl &tbi, map > &clusters, deque &ordered) { const RoseGraph &g = tbi.g; vector suffix_vertices; // vertices with suffix graphs ue2::unordered_map fcount; // ref count per graph for (auto v : vertices_range(g)) { if (g[v].suffix) { if (!g[v].suffix.graph) { continue; /* cannot uncalc (haig/mcclellan); TODO */ } assert(g[v].suffix.graph->kind == NFA_SUFFIX); // Ref count all suffixes, as we don't want to merge a suffix // that happens to be shared with a non-leaf vertex somewhere. DEBUG_PRINTF("vertex %zu has suffix %p\n", g[v].index, g[v].suffix.graph.get()); fcount[g[v].suffix.graph.get()]++; // Vertex must be a reporting pseudo accept if (!isLeafNode(v, g)) { continue; } suffix_vertices.push_back(v); } } for (auto v : suffix_vertices) { if (in_degree(v, g) == 0) { assert(tbi.isAnyStart(v)); continue; } const NGHolder *h = g[v].suffix.graph.get(); assert(h); DEBUG_PRINTF("suffix %p\n", h); // We can't easily merge suffixes shared with other vertices, and // creating a unique copy to do so may just mean we end up tracking // more NFAs. Better to leave shared suffixes alone. if (fcount[h] != 1) { DEBUG_PRINTF("skipping shared suffix\n"); continue; } UncalcLeafKey key(g, v); vector &vec = clusters[key]; if (vec.empty()) { ordered.push_back(key); } vec.push_back(v); } DEBUG_PRINTF("find loop done\n"); } /** * This function attempts to combine identical roles (same literals, same * predecessors, etc) with different suffixes into a single role which * activates a larger suffix. The leaf vertices of the graph with a suffix are * grouped into clusters which have members triggered by identical roles. The * \ref mergeNfaCluster function (from ng_uncalc_components) is then utilised * to build a set of larger (and still implementable) suffixes. The graph is * then updated to point to the new suffixes and any unneeded roles are * removed. * * Note: suffixes which are shared amongst multiple roles are not considered * for this pass as the individual suffixes would have to continue to exist for * the other roles to trigger resulting in the transformation not producing any * savings. * * Note: as \ref mergeNfaCluster is slow when the cluster sizes are large, * clusters of more than \ref MERGE_GROUP_SIZE_MAX roles are split into smaller * chunks for processing. */ void uncalcLeaves(RoseBuildImpl &tbi) { DEBUG_PRINTF("uncalcing\n"); map > clusters; deque ordered; findUncalcLeavesCandidates(tbi, clusters, ordered); vector dead; for (const auto &key : ordered) { DEBUG_PRINTF("cluster of size %zu\n", clusters[key].size()); mergeCluster(tbi.g, tbi.rm, clusters[key], dead, tbi.cc); } tbi.removeVertices(dead); } /** * Returns a loose hash of a leftfix for use in dedupeLeftfixes. Note that * reports should not contribute to the hash. */ static size_t hashLeftfix(const LeftEngInfo &left) { size_t val = 0; if (left.castle) { hash_combine(val, left.castle->reach()); for (const auto &pr : left.castle->repeats) { hash_combine(val, pr.first); // top hash_combine(val, pr.second.bounds); } } else if (left.graph) { hash_combine(val, hash_holder(*left.graph)); } return val; } namespace { /** Key used to group sets of leftfixes by the dedupeLeftfixes path. */ struct RoseGroup { RoseGroup(const RoseBuildImpl &build, RoseVertex v) : left_hash(hashLeftfix(build.g[v].left)), lag(build.g[v].left.lag), eod_table(build.isInETable(v)) { const RoseGraph &g = build.g; assert(in_degree(v, g) == 1); RoseVertex u = *inv_adjacent_vertices(v, g).first; parent = g[u].index; } bool operator<(const RoseGroup &b) const { const RoseGroup &a = *this; ORDER_CHECK(parent); ORDER_CHECK(left_hash); ORDER_CHECK(lag); ORDER_CHECK(eod_table); return false; } private: /** Parent vertex index. We must use the index, rather than the descriptor, * for compile determinism. */ size_t parent; /** Quick hash of the leftfix itself. Must be identical for a given pair of * graphs if is_equal would return true. */ size_t left_hash; /** Leftfix lag value. */ u32 lag; /** True if associated vertex (successor) is in the EOD table. We don't * allow sharing of leftfix engines between "normal" and EOD operation. */ bool eod_table; }; /** * Trivial Rose comparator intended to find graphs that are identical except * for their report IDs. Relies on vertex and edge indices to pick up graphs * that have been messily put together in different orderings... */ struct RoseComparator { explicit RoseComparator(const RoseGraph &g_in) : g(g_in) {} bool operator()(const RoseVertex u, const RoseVertex v) const { const LeftEngInfo &u_left = g[u].left; const LeftEngInfo &v_left = g[v].left; if (u_left.castle && v_left.castle) { return is_equal(*u_left.castle, u_left.leftfix_report, *v_left.castle, v_left.leftfix_report); } if (!u_left.graph || !v_left.graph) { return false; } return is_equal(*u_left.graph, u_left.leftfix_report, *v_left.graph, v_left.leftfix_report); } private: const RoseGraph &g; }; } // namespace /** * This pass performs work similar to \ref dedupeSuffixes - it removes * duplicate prefix/infixes (that is, leftfixes) which are identical graphs and * share the same trigger vertex and lag. Leftfixes are first grouped by * parent role and lag to reduce the number of candidates to be inspected * for each leftfix. The graphs in each cluster are then compared with each * other and the graph is updated to only refer to a canonical version of each * graph. * * Note: only roles with a single predecessor vertex are considered for this * transform - it should probably be generalised to work for roles which share * the same set of predecessor roles as for \ref dedupeLeftfixesVariableLag or it * should be retired entirely. */ bool dedupeLeftfixes(RoseBuildImpl &tbi) { DEBUG_PRINTF("deduping leftfixes\n"); map> roses; bool work_done = false; /* Note: a leftfix's transientness will not be altered by deduping */ // Collect leftfixes into groups. RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { if (!g[v].left) { continue; } const left_id left(g[v].left); if (left.haig()) { /* TODO: allow merging of identical haigs */ continue; } if (in_degree(v, g) != 1) { continue; } roses[RoseGroup(tbi, v)].push_back(v); } DEBUG_PRINTF("collected %zu rose groups\n", roses.size()); const RoseComparator rosecmp(g); // Walk groups and dedupe the roses therein. for (deque &verts : roses | map_values) { DEBUG_PRINTF("group has %zu vertices\n", verts.size()); ue2::unordered_set seen; for (auto jt = verts.begin(), jte = verts.end(); jt != jte; ++jt) { RoseVertex v = *jt; left_id left(g[v].left); // Skip cases we've already handled, and mark as seen otherwise. if (!seen.insert(left).second) { continue; } // Scan the rest of the list for dupes. for (auto kt = std::next(jt); kt != jte; ++kt) { if (g[v].left == g[*kt].left || !rosecmp(v, *kt)) { continue; } // Dupe found. DEBUG_PRINTF("rose at vertex %zu is a dupe of %zu\n", g[*kt].index, g[v].index); assert(g[v].left.lag == g[*kt].left.lag); g[*kt].left = g[v].left; work_done = true; } } } return work_done; } /** * \brief Returns a numeric key that can be used to group this suffix with * others that may be its duplicate. */ static size_t suffix_size_key(const suffix_id &s) { if (s.graph()) { return num_vertices(*s.graph()); } if (s.castle()) { return s.castle()->repeats.size(); } return 0; } static bool is_equal(const suffix_id &s1, const suffix_id &s2) { if (s1.graph() && s2.graph()) { return is_equal(*s1.graph(), *s2.graph()); } else if (s1.castle() && s2.castle()) { return is_equal(*s1.castle(), *s2.castle()); } return false; } /** * This function simply looks for suffix NGHolder graphs which are identical * and updates the roles in the RoseGraph to refer to only a single copy. This * obviously has benefits in terms of both performance (as we don't run * multiple engines doing the same work) and stream state. This function first * groups all suffixes by number of vertices and report set to restrict the set * of possible candidates. Each group is then walked to find duplicates using * the \ref is_equal comparator for NGHolders and updating the RoseGraph as it * goes. * * Note: does not dedupe suffixes of vertices in the EOD table. */ void dedupeSuffixes(RoseBuildImpl &tbi) { DEBUG_PRINTF("deduping suffixes\n"); ue2::unordered_map> suffix_map; map>, vector> part; // Collect suffixes into groups. RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { if (!g[v].suffix || tbi.isInETable(v)) { continue; } const suffix_id s(g[v].suffix); if (!(s.graph() || s.castle())) { continue; // e.g. Haig } set &verts = suffix_map[s]; if (verts.empty()) { part[make_pair(suffix_size_key(s), all_reports(s))].push_back(s); } verts.insert(v); } DEBUG_PRINTF("collected %zu groups\n", part.size()); for (const auto &cand : part | map_values) { if (cand.size() <= 1) { continue; } DEBUG_PRINTF("deduping cand set of size %zu\n", cand.size()); for (auto jt = cand.begin(); jt != cand.end(); ++jt) { if (suffix_map[*jt].empty()) { continue; } for (auto kt = next(jt); kt != cand.end(); ++kt) { if (suffix_map[*kt].empty() || !is_equal(*jt, *kt)) { continue; } DEBUG_PRINTF("found dupe\n"); for (auto v : suffix_map[*kt]) { RoseVertex dupe = *suffix_map[*jt].begin(); assert(dupe != v); g[v].suffix.graph = g[dupe].suffix.graph; g[v].suffix.castle = g[dupe].suffix.castle; assert(suffix_id(g[v].suffix) == suffix_id(g[dupe].suffix)); suffix_map[*jt].insert(v); } suffix_map[*kt].clear(); } } } } namespace { /** * This class stores a mapping from an engine reference (left_id, suffix_id, * etc) to a list of vertices, and also allows us to iterate over the set of * engine references in insertion order -- we add to the mapping in vertex * iteration order, so this allows us to provide a consistent ordering. */ template class Bouquet { private: list ordering; // Unique list in insert order. typedef ue2::unordered_map > BouquetMap; BouquetMap bouquet; public: void insert(const EngineRef &h, RoseVertex v) { typename BouquetMap::iterator f = bouquet.find(h); if (f == bouquet.end()) { ordering.push_back(h); bouquet[h].push_back(v); } else { f->second.push_back(v); } } void insert(const EngineRef &h, const deque &verts) { typename BouquetMap::iterator f = bouquet.find(h); if (f == bouquet.end()) { ordering.push_back(h); bouquet.insert(make_pair(h, verts)); } else { f->second.insert(f->second.end(), verts.begin(), verts.end()); } } const deque &vertices(const EngineRef &h) const { typename BouquetMap::const_iterator it = bouquet.find(h); assert(it != bouquet.end()); // must be present return it->second; } void erase(const EngineRef &h) { assert(bouquet.find(h) != bouquet.end()); bouquet.erase(h); ordering.remove(h); } /** Remove all the elements in the given iterator range. */ template void erase_all(Iter erase_begin, Iter erase_end) { for (Iter it = erase_begin; it != erase_end; ++it) { bouquet.erase(*it); } // Use a quick-lookup container so that we only have to traverse the // 'ordering' list once. const set dead(erase_begin, erase_end); for (iterator it = begin(); it != end(); /* incremented inside */) { if (contains(dead, *it)) { ordering.erase(it++); } else { ++it; } } } void clear() { ordering.clear(); bouquet.clear(); } size_t size() const { return bouquet.size(); } // iterate over holders in insert order typedef typename list::iterator iterator; iterator begin() { return ordering.begin(); } iterator end() { return ordering.end(); } // const iterate over holders in insert order typedef typename list::const_iterator const_iterator; const_iterator begin() const { return ordering.begin(); } const_iterator end() const { return ordering.end(); } }; typedef Bouquet RoseBouquet; typedef Bouquet SuffixBouquet; } // namespace /** * Split a \ref Bouquet of some type into several smaller ones. */ template static void chunkBouquets(const Bouquet &in, deque> &out, const size_t chunk_size) { if (in.size() <= chunk_size) { out.push_back(in); return; } out.push_back(Bouquet()); for (const auto &engine : in) { if (out.back().size() >= chunk_size) { out.push_back(Bouquet()); } out.back().insert(engine, in.vertices(engine)); } } static bool stringsCanFinishAtSameSpot(const ue2_literal &u, ue2_literal::const_iterator v_b, ue2_literal::const_iterator v_e) { ue2_literal::const_iterator u_e = u.end(); ue2_literal::const_iterator u_b = u.begin(); while (u_e != u_b && v_e != v_b) { --u_e; --v_e; if (!overlaps(*u_e, *v_e)) { return false; } } return true; } /** * Check that if after u has been seen, that it is impossible for the arrival of * v to require the inspection of an engine earlier than u did. * * Let delta be the earliest that v can be seen after u (may be zero) * * ie, we require u_loc - ulag <= v_loc - vlag (v_loc = u_loc + delta) * ==> - ulag <= delta - vlag * ==> vlag - ulag <= delta */ static bool checkPrefix(const rose_literal_id &ul, const u32 ulag, const rose_literal_id &vl, const u32 vlag) { DEBUG_PRINTF("'%s'-%u '%s'-%u\n", escapeString(ul.s).c_str(), ulag, escapeString(vl.s).c_str(), vlag); if (vl.delay || ul.delay) { /* engine related literals should not be delayed anyway */ return false; } if (ulag >= vlag) { assert(maxOverlap(ul, vl) <= vl.elength() - vlag + ulag); return true; } size_t min_allowed_delta = vlag - ulag; DEBUG_PRINTF("min allow distace %zu\n", min_allowed_delta); for (size_t i = 0; i < min_allowed_delta; i++) { if (stringsCanFinishAtSameSpot(ul.s, vl.s.begin(), vl.s.end() - i)) { DEBUG_PRINTF("v can follow u at a (too close) distance of %zu\n", i); return false; } } DEBUG_PRINTF("OK\n"); return true; } static bool hasSameEngineType(const RoseVertexProps &u_prop, const RoseVertexProps &v_prop) { const left_id u_left(u_prop.left), v_left(v_prop.left); if (u_left.haig() || v_left.haig()) { if (u_left.graph() != v_left.graph()) { return false; } } if (u_left.dfa() || v_left.dfa()) { if (u_left.graph() != v_left.graph()) { return false; } } if (u_left.castle() || v_left.castle()) { if (!u_left.castle() || !v_left.castle()) { return false; // Must both be castles. } } return true; } static bool compatibleLiteralsForMerge( const vector> &ulits, const vector> &vlits) { assert(!ulits.empty()); assert(!vlits.empty()); // We cannot merge engines that prefix literals in different tables. if (ulits[0].first->table != vlits[0].first->table) { DEBUG_PRINTF("literals in different tables\n"); return false; } /* An engine requires that all accesses to it are ordered by offsets. (ie, we can not check an engine's state at offset Y, if we have already checked its status at offset X and X > Y). If we can not establish that the literals used for triggering will statisfy this property, then it is not safe to merge the engine. */ for (const auto &ue : ulits) { const rose_literal_id &ul = *ue.first; u32 ulag = ue.second; if (ul.delay) { return false; // We don't handle delayed cases yet. } for (const auto &ve : vlits) { const rose_literal_id &vl = *ve.first; u32 vlag = ve.second; if (vl.delay) { return false; // We don't handle delayed cases yet. } if (!checkPrefix(ul, ulag, vl, vlag) || !checkPrefix(vl, vlag, ul, ulag)) { DEBUG_PRINTF("prefix check failed\n"); return false; } } } return true; } /** * True if this graph has few enough accel states to be implemented as an NFA * with all of those states actually becoming accel schemes. */ static bool isAccelerableLeftfix(const RoseBuildImpl &build, const NGHolder &g) { u32 num = countAccelStates(g, &build.rm, build.cc); DEBUG_PRINTF("graph with %zu vertices has %u accel states\n", num_vertices(g), num); return num <= NFA_MAX_ACCEL_STATES; } /** * In block mode, we want to be a little more selective, We will only merge * prefix engines when the literal sets are the same, or if the merged graph * has only grown by a small amount. */ static bool safeBlockModeMerge(const RoseBuildImpl &build, RoseVertex u, RoseVertex v) { assert(!build.cc.streaming); assert(build.isRootSuccessor(u) == build.isRootSuccessor(v)); // Always merge infixes if we can (subject to the other criteria in // mergeableRoseVertices). if (!build.isRootSuccessor(u)) { return true; } const RoseGraph &g = build.g; // Merge prefixes with identical literal sets (as we'd have to run them // both when we see those literals anyway). if (g[u].literals == g[v].literals) { return true; } // The rest of this function only deals with the case when both vertices // have graph leftfixes. if (!g[u].left.graph || !g[v].left.graph) { return false; } const size_t u_count = num_vertices(*g[u].left.graph); const size_t v_count = num_vertices(*g[v].left.graph); DEBUG_PRINTF("u prefix has %zu vertices, v prefix has %zu vertices\n", u_count, v_count); if (u_count > MAX_BLOCK_PREFIX_MERGE_VERTICES || v_count > MAX_BLOCK_PREFIX_MERGE_VERTICES) { DEBUG_PRINTF("prefixes too big already\n"); return false; } DEBUG_PRINTF("trying merge\n"); NGHolder h; cloneHolder(h, *g[v].left.graph); if (!mergeNfaPair(*g[u].left.graph, h, nullptr, build.cc)) { DEBUG_PRINTF("couldn't merge\n"); return false; } const size_t merged_count = num_vertices(h); DEBUG_PRINTF("merged result has %zu vertices\n", merged_count); if (merged_count > MAX_BLOCK_PREFIX_MERGE_VERTICES) { DEBUG_PRINTF("exceeded limit\n"); return false; } // We want to only perform merges that take advantage of some // commonality in the two input graphs, so we check that the number of // vertices has only grown a small amount: somewhere between the sum // (no commonality) and the max (no growth at all) of the vertex counts // of the input graphs. const size_t max_size = u_count + v_count; const size_t min_size = max(u_count, v_count); const size_t max_growth = ((max_size - min_size) * 25) / 100; if (merged_count > min_size + max_growth) { DEBUG_PRINTF("grew too much\n"); return false; } // We don't want to squander any chances at accelerating. if (!isAccelerableLeftfix(build, h) && (isAccelerableLeftfix(build, *g[u].left.graph) || isAccelerableLeftfix(build, *g[v].left.graph))) { DEBUG_PRINTF("would lose accel property\n"); return false; } DEBUG_PRINTF("safe to merge\n"); return true; } bool mergeableRoseVertices(const RoseBuildImpl &tbi, RoseVertex u, RoseVertex v) { assert(u != v); if (!hasSameEngineType(tbi.g[u], tbi.g[v])) { return false; } if (!tbi.cc.streaming && !safeBlockModeMerge(tbi, u, v)) { return false; } /* We cannot merge prefixes/vertices if they are successors of different * root vertices */ if (tbi.isRootSuccessor(u)) { assert(tbi.isRootSuccessor(v)); set u_preds; set v_preds; insert(&u_preds, inv_adjacent_vertices(u, tbi.g)); insert(&v_preds, inv_adjacent_vertices(v, tbi.g)); if (u_preds != v_preds) { return false; } } u32 ulag = tbi.g[u].left.lag; vector> ulits; ulits.reserve(tbi.g[u].literals.size()); for (u32 id : tbi.g[u].literals) { ulits.push_back(make_pair(&tbi.literals.right.at(id), ulag)); } u32 vlag = tbi.g[v].left.lag; vector> vlits; vlits.reserve(tbi.g[v].literals.size()); for (u32 id : tbi.g[v].literals) { vlits.push_back(make_pair(&tbi.literals.right.at(id), vlag)); } if (!compatibleLiteralsForMerge(ulits, vlits)) { return false; } DEBUG_PRINTF("roses on %zu and %zu are mergeable\n", tbi.g[u].index, tbi.g[v].index); return true; } /* We cannot merge an engine, if a trigger literal and a post literal overlap * in such a way that engine status needs to be check at a point before the * engine's current location. * * i.e., for a trigger literal u and a pos literal v, * where delta is the earliest v can appear after t, * we require that v_loc - v_lag >= u_loc * ==> u_loc + delta - v_lag >= u_loc * ==> delta >= v_lag * */ static bool checkPredDelay(const rose_literal_id &ul, const rose_literal_id &vl, u32 vlag) { DEBUG_PRINTF("%s %s (lag %u)\n", escapeString(ul.s).c_str(), escapeString(vl.s).c_str(), vlag); for (size_t i = 0; i < vlag; i++) { if (stringsCanFinishAtSameSpot(ul.s, vl.s.begin(), vl.s.end() - i)) { DEBUG_PRINTF("v can follow u at a (too close) distance of %zu\n", i); return false; } } DEBUG_PRINTF("OK\n"); return true; } static never_inline bool checkPredDelays(const RoseBuildImpl &tbi, const deque &v1, const deque &v2) { flat_set preds; for (auto v : v1) { insert(&preds, inv_adjacent_vertices(v, tbi.g)); } flat_set pred_lits; /* No need to examine delays of a common pred - as it must already have * survived the delay checks. * * This is important when the pred is in the anchored table as * the literal is no longer available. */ flat_set known_good_preds; for (auto v : v2) { insert(&known_good_preds, inv_adjacent_vertices(v, tbi.g)); } for (auto u : preds) { if (!contains(known_good_preds, u)) { insert(&pred_lits, tbi.g[u].literals); } } vector pred_rose_lits; pred_rose_lits.reserve(pred_lits.size()); for (const auto &p : pred_lits) { pred_rose_lits.push_back(&tbi.literals.right.at(p)); } for (auto v : v2) { u32 vlag = tbi.g[v].left.lag; if (!vlag) { continue; } for (const u32 vlit : tbi.g[v].literals) { const rose_literal_id &vl = tbi.literals.right.at(vlit); assert(!vl.delay); // this should never have got this far? for (const auto &ul : pred_rose_lits) { assert(!ul->delay); // this should never have got this far? if (!checkPredDelay(*ul, vl, vlag)) { return false; } } } } return true; } static bool mergeableRoseVertices(const RoseBuildImpl &tbi, const deque &verts1, const deque &verts2) { assert(!verts1.empty()); assert(!verts2.empty()); RoseVertex u_front = verts1.front(); RoseVertex v_front = verts2.front(); /* all vertices must have the same engine type: assume all verts in each * group are already of the same type */ if (!hasSameEngineType(tbi.g[u_front], tbi.g[v_front])) { return false; } bool is_prefix = tbi.isRootSuccessor(u_front); /* We cannot merge prefixes/vertices if they are successors of different * root vertices: similarly, assume the grouped vertices are compatible */ if (is_prefix) { assert(tbi.isRootSuccessor(v_front)); set u_preds; set v_preds; insert(&u_preds, inv_adjacent_vertices(u_front, tbi.g)); insert(&v_preds, inv_adjacent_vertices(v_front, tbi.g)); if (u_preds != v_preds) { return false; } } vector> ulits; /* lit + lag pairs */ for (auto a : verts1) { if (!tbi.cc.streaming && !safeBlockModeMerge(tbi, u_front, a)) { return false; } u32 ulag = tbi.g[a].left.lag; for (u32 id : tbi.g[a].literals) { ulits.push_back(make_pair(&tbi.literals.right.at(id), ulag)); } } vector> vlits; for (auto a : verts2) { if (!tbi.cc.streaming && !safeBlockModeMerge(tbi, u_front, a)) { return false; } u32 vlag = tbi.g[a].left.lag; for (u32 id : tbi.g[a].literals) { vlits.push_back(make_pair(&tbi.literals.right.at(id), vlag)); } } if (!compatibleLiteralsForMerge(ulits, vlits)) { return false; } // Check preds are compatible as well. if (!checkPredDelays(tbi, verts1, verts2) || !checkPredDelays(tbi, verts2, verts1)) { return false; } DEBUG_PRINTF("vertex sets are mergeable\n"); return true; } bool mergeableRoseVertices(const RoseBuildImpl &tbi, const set &v1, const set &v2) { const deque vv1(v1.begin(), v1.end()); const deque vv2(v2.begin(), v2.end()); return mergeableRoseVertices(tbi, vv1, vv2); } /** \brief Priority queue element for Rose merges. */ namespace { struct RoseMergeCandidate { RoseMergeCandidate(const left_id &r1_in, const left_id &r2_in, u32 cpl_in, u32 tb) : r1(r1_in), r2(r2_in), stopxor(0), cpl(cpl_in), states(0), tie_breaker(tb) { if (r1.graph() && r2.graph()) { const NGHolder &h1 = *r1.graph(), &h2 = *r2.graph(); /* som_none as haigs don't merge and just a guiding heuristic */ CharReach stop1 = findStopAlphabet(h1, SOM_NONE); CharReach stop2 = findStopAlphabet(h2, SOM_NONE); stopxor = (stop1 ^ stop2).count(); // We use the number of vertices as an approximation of the state // count here, as this is just feeding a comparison. u32 vertex_count = num_vertices(h1) + num_vertices(h2); states = vertex_count - min(vertex_count, cpl); } else if (r1.castle() && r2.castle()) { // FIXME } } bool operator<(const RoseMergeCandidate &a) const { if (stopxor != a.stopxor) { return stopxor > a.stopxor; } if (cpl != a.cpl) { return cpl < a.cpl; } if (states != a.states) { return states > a.states; } return tie_breaker < a.tie_breaker; } left_id r1; left_id r2; u32 stopxor; u32 cpl; //!< common prefix length u32 states; u32 tie_breaker; //!< determinism }; } static bool mergeRosePair(RoseBuildImpl &tbi, left_id &r1, left_id &r2, const deque &verts1, const deque &verts2) { assert(!verts1.empty() && !verts2.empty()); RoseGraph &g = tbi.g; if (r1.graph()) { assert(r2.graph()); assert(r1.graph()->kind == r2.graph()->kind); if (!mergeNfaPair(*r1.graph(), *r2.graph(), nullptr, tbi.cc)) { DEBUG_PRINTF("nfa merge failed\n"); return false; } // The graph in r1 has been merged into the graph in r2. Update r1's // vertices with the new graph ptr. Since the parent vertices are the // same, we know that tops will already have been distinct. shared_ptr &h = g[verts2.front()].left.graph; for (RoseVertex v : verts1) { g[v].left.graph = h; } return true; } else if (r1.castle()) { assert(r2.castle()); assert(tbi.cc.grey.allowCastle); map top_map; if (!mergeCastle(*r2.castle(), *r1.castle(), top_map)) { DEBUG_PRINTF("castle merge failed\n"); return false; } // The castle in r1 has been merged into the castle in r2, with tops // remapped as per top_map. const shared_ptr &c = g[verts2.front()].left.castle; for (RoseVertex v : verts1) { g[v].left.castle = c; for (const auto &e : in_edges_range(v, g)) { g[e].rose_top = top_map.at(g[e].rose_top); } } return true; } assert(0); return false; } static void processMergeQueue(RoseBuildImpl &tbi, RoseBouquet &roses, priority_queue &pq) { ue2::unordered_set dead; DEBUG_PRINTF("merge queue has %zu entries\n", pq.size()); while (!pq.empty()) { DEBUG_PRINTF("pq pop h1=%p, h2=%p, cpl=%u, states=%u\n", pq.top().r1.graph(), pq.top().r2.graph(), pq.top().cpl, pq.top().states); left_id r1 = pq.top().r1, r2 = pq.top().r2; pq.pop(); if (contains(dead, r1) || contains(dead, r2)) { continue; } if (r1.graph() && r2.graph()) { NGHolder *h1 = r1.graph(), *h2 = r2.graph(); CharReach stop1 = findStopAlphabet(*h1, SOM_NONE); CharReach stop2 = findStopAlphabet(*h2, SOM_NONE); CharReach stopboth(stop1 & stop2); DEBUG_PRINTF("stop1=%zu, stop2=%zu, stopboth=%zu\n", stop1.count(), stop2.count(), stopboth.count()); if (stopboth.count() < 10 && (stop1.count() > 10 || stop2.count() > 10)) { DEBUG_PRINTF("skip merge, would kill stop alphabet\n"); continue; } size_t maxstop = max(stop1.count(), stop2.count()); if (maxstop > 200 && stopboth.count() < 200) { DEBUG_PRINTF("skip merge, would reduce stop alphabet\n"); continue; } } const deque &verts1 = roses.vertices(r1); const deque &verts2 = roses.vertices(r2); if (!mergeableRoseVertices(tbi, verts1, verts2)) { continue; } if (!mergeRosePair(tbi, r1, r2, verts1, verts2)) { continue; } roses.insert(r2, verts1); roses.erase(r1); dead.insert(r1); } } static bool nfaHasNarrowStart(const NGHolder &g) { if (out_degree(g.startDs, g) > 1) { return false; // unanchored } CharReach cr; for (auto v : adjacent_vertices_range(g.start, g)) { if (v == g.startDs) { continue; } cr |= g[v].char_reach; } return cr.count() <= NARROW_START_MAX; } static bool nfaHasFiniteMaxWidth(const NGHolder &g) { return findMaxWidth(g).is_finite(); } namespace { struct RoseMergeKey { RoseMergeKey(const set &parents_in, bool narrowStart_in, bool hasMaxWidth_in) : narrowStart(narrowStart_in), hasMaxWidth(hasMaxWidth_in), parents(parents_in) {} bool operator<(const RoseMergeKey &b) const { const RoseMergeKey &a = *this; ORDER_CHECK(narrowStart); ORDER_CHECK(hasMaxWidth); ORDER_CHECK(parents); return false; } // NOTE: these two bool discriminators are only used for prefixes, not // infixes. bool narrowStart; bool hasMaxWidth; set parents; }; } static bool hasReformedStartDotStar(const NGHolder &h, const Grey &grey) { if (!proper_out_degree(h.startDs, h)) { return false; } assert(!is_triggered(h)); NGHolder h_temp; cloneHolder(h_temp, h); vector repeats; bool suitable_for_sds_reforming = false; const map fixed_depth_tops; /* not relevant for cfa check */ const map>> triggers; /* not for cfa check */ const bool simple_model_selection = true; // FIRST is considered simple analyseRepeats(h_temp, nullptr, fixed_depth_tops, triggers, &repeats, true, simple_model_selection, grey, &suitable_for_sds_reforming); return suitable_for_sds_reforming; } static u32 commonPrefixLength(left_id &r1, left_id &r2) { if (r1.graph() && r2.graph()) { return commonPrefixLength(*r1.graph(), *r2.graph()); } else if (r1.castle() && r2.castle()) { return min(findMinWidth(*r1.castle()), findMinWidth(*r2.castle())); } return 0; } /** * This pass attempts to merge prefix/infix engines which share a common set of * parent vertices. * * Engines are greedily merged pairwise by this process based on a priority * queue keyed off the common prefix length. * * Engines are not merged if the lags are not compatible or if it would damage * the stop alphabet. * * Infixes: * - LBR candidates are not considered. * * Prefixes: * - transient prefixes are not considered. * - with a max width or a narrow start are kept segregated by * this phase and can only be merged with similar infixes. * - in block mode, merges are only performed if literal sets are the same. * - merges are not considered in cases where dot star start state will be * reformed to optimise a leading repeat. */ void mergeLeftfixesVariableLag(RoseBuildImpl &tbi) { if (!tbi.cc.grey.mergeRose) { return; } map rosesByParent; RoseGraph &g = tbi.g; set parents; DEBUG_PRINTF("-----\n"); DEBUG_PRINTF("entry\n"); DEBUG_PRINTF("-----\n"); for (auto v : vertices_range(g)) { if (!g[v].left) { continue; } const bool is_prefix = tbi.isRootSuccessor(v); // Only non-transient for the moment. if (contains(tbi.transient, g[v].left)) { continue; } // No forced McClellan or Haig infix merges. if (g[v].left.dfa || (!is_prefix && g[v].left.haig)) { continue; } if (g[v].left.graph) { NGHolder &h = *g[v].left.graph; /* Ensure that kind on the graph is correct */ assert(h.kind == (is_prefix ? NFA_PREFIX : NFA_INFIX)); if (hasReformedStartDotStar(h, tbi.cc.grey)) { continue; // preserve the optimisation of the leading repeat } if (!is_prefix && isLargeLBR(h, tbi.cc.grey)) { continue; } } if (g[v].left.castle && !tbi.cc.grey.allowCastle) { DEBUG_PRINTF("castle merging disallowed by greybox\n"); continue; } // We collapse the anchored root into the root vertex when calculating // parents, so that we can merge differently-anchored prefix roses // together. (Prompted by UE-2100) parents.clear(); for (auto u : inv_adjacent_vertices_range(v, g)) { if (tbi.isAnyStart(u)) { parents.insert(tbi.root); } else { parents.insert(u); } } if (parents.empty()) { assert(0); continue; } // We want to distinguish prefixes (but not infixes) on whether they // have a narrow start or max width. bool narrowStart = false, hasMaxWidth = false; if (is_prefix && g[v].left.graph) { const NGHolder &h = *g[v].left.graph; narrowStart = nfaHasNarrowStart(h); hasMaxWidth = nfaHasFiniteMaxWidth(h); } RoseMergeKey key(parents, narrowStart, hasMaxWidth); rosesByParent[key].insert(g[v].left, v); } for (auto &m : rosesByParent) { if (m.second.size() < 2) { continue; } deque rose_groups; chunkBouquets(m.second, rose_groups, MERGE_GROUP_SIZE_MAX); m.second.clear(); DEBUG_PRINTF("chunked roses into %zu groups\n", rose_groups.size()); for (auto &roses : rose_groups) { // All pairs on the prio queue. u32 tie_breaker = 0; priority_queue pq; for (auto it = roses.begin(), ite = roses.end(); it != ite; ++it) { left_id r1 = *it; const deque &verts1 = roses.vertices(r1); for (auto jt = next(it); jt != ite; ++jt) { left_id r2 = *jt; // Roses must be of the same engine type to be mergeable. if ((!r1.graph() != !r2.graph()) || (!r1.castle() != !r2.castle())) { continue; } // Castles must have the same reach to be mergeable. if (r1.castle()) { if (r1.castle()->reach() != r2.castle()->reach()) { continue; } } const deque &verts2 = roses.vertices(r2); if (!mergeableRoseVertices(tbi, verts1, verts2)) { continue; // No point queueing unmergeable cases. } u32 cpl = commonPrefixLength(r1, r2); pq.push(RoseMergeCandidate(r1, r2, cpl, tie_breaker++)); } } processMergeQueue(tbi, roses, pq); } } DEBUG_PRINTF("-----\n"); DEBUG_PRINTF("exit\n"); DEBUG_PRINTF("-----\n"); } namespace { /** * Key used to group sets of leftfixes for the dedupeLeftfixesVariableLag path. */ struct DedupeLeftKey { DedupeLeftKey(const RoseBuildImpl &build, RoseVertex v) : left_hash(hashLeftfix(build.g[v].left)) { const auto &g = build.g; for (const auto &e : in_edges_range(v, g)) { preds.emplace(g[source(e, g)].index, g[e].rose_top); } } bool operator<(const DedupeLeftKey &b) const { return tie(left_hash, preds) < tie(b.left_hash, b.preds); } private: /** Quick hash of the leftfix itself. Must be identical for a given pair of * graphs if is_equal would return true. */ size_t left_hash; /** For each in-edge, the pair of (parent index, edge top). */ set> preds; }; } // namespace /** * This is a generalisation of \ref dedupeLeftfixes which relaxes two * restrictions: multiple predecessor roles are allowed and the delay used by * each vertex may not be the same for each vertex. Like \ref dedupeLeftfixes, * the leftfixes' successor vertices are first grouped to reduce the number of * potential candidates - the grouping in this case is by the set of * predecessor roles with their associated top events. For the dedupe to be * possible, it is required that: * * 1. the nfa graphs with respect to the relevant reports are identical * 2. the nfa graphs are triggered by the same roles with same events (ensured * by the initial grouping pass) * 3. all the successor roles of either graph can inspect the combined leftfix * without advancing the state of the leftfix past the point that another * successor may want to inspect it; the overlap relationships between the * involved literals are examined to ensure that this property holds. * * Note: in block mode we restrict the dedupe of prefixes further as some of * logic checks are shared with the mergeLeftfix functions. */ void dedupeLeftfixesVariableLag(RoseBuildImpl &tbi) { map roseGrouping; DEBUG_PRINTF("entry\n"); RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { if (!g[v].left) { continue; } const left_id leftfix(g[v].left); // Only non-transient for the moment. if (contains(tbi.transient, leftfix)) { continue; } if (leftfix.haig()) { /* TODO: allow merging of identical haigs */ continue; } roseGrouping[DedupeLeftKey(tbi, v)].insert(leftfix, v); } for (RoseBouquet &roses : roseGrouping | map_values) { DEBUG_PRINTF("group of %zu roses\n", roses.size()); if (roses.size() < 2) { continue; } const RoseComparator rosecmp(g); for (auto it = roses.begin(); it != roses.end(); ++it) { left_id r1 = *it; const deque &verts1 = roses.vertices(r1); for (auto jt = next(it); jt != roses.end(); ++jt) { left_id r2 = *jt; const deque &verts2 = roses.vertices(r2); if (!rosecmp(verts1.front(), verts2.front())) { continue; } if (!mergeableRoseVertices(tbi, verts1, verts2)) { continue; } DEBUG_PRINTF("%p and %p are dupes\n", r1.graph(), r2.graph()); // Replace h1 with h2. const LeftEngInfo &v2_left = g[verts2.front()].left; assert(v2_left.graph.get() == r2.graph()); for (auto v : verts1) { DEBUG_PRINTF("replacing report %u with %u on %zu\n", g[v].left.leftfix_report, v2_left.leftfix_report, g[v].index); u32 orig_lag = g[v].left.lag; g[v].left = v2_left; g[v].left.lag = orig_lag; } roses.insert(r2, verts1); // no need to erase h1 from roses, that would invalidate `it'. break; } } } } static u32 findUnusedTop(const ue2::flat_set &tops) { u32 i = 0; while (contains(tops, i)) { i++; } return i; } // Replace top 't' on edges with new top 'u'. static void replaceTops(NGHolder &h, const map &top_mapping) { for (const auto &e : out_edges_range(h.start, h)) { NFAVertex v = target(e, h); if (v == h.startDs) { continue; } flat_set new_tops; for (u32 t : h[e].tops) { DEBUG_PRINTF("vertex %zu has top %u\n", h[v].index, t); new_tops.insert(top_mapping.at(t)); } h[e].tops = move(new_tops); } } static bool setDistinctTops(NGHolder &h1, const NGHolder &h2, map &top_mapping) { ue2::flat_set tops1 = getTops(h1), tops2 = getTops(h2); DEBUG_PRINTF("before: h1 has %zu tops, h2 has %zu tops\n", tops1.size(), tops2.size()); // If our tops don't intersect, we're OK to merge with no changes. if (!has_intersection(tops1, tops2)) { DEBUG_PRINTF("tops don't intersect\n"); return true; } // Otherwise, we have to renumber the tops in h1 so that they don't overlap // with the tops in h2. top_mapping.clear(); for (u32 t : tops1) { u32 u = findUnusedTop(tops2); DEBUG_PRINTF("replacing top %u with %u in h1\n", t, u); top_mapping.insert(make_pair(t, u)); assert(!contains(tops2, u)); tops2.insert(u); } replaceTops(h1, top_mapping); return true; } bool setDistinctRoseTops(RoseGraph &g, NGHolder &h1, const NGHolder &h2, const deque &verts1) { map top_mapping; if (!setDistinctTops(h1, h2, top_mapping)) { return false; } if (top_mapping.empty()) { return true; // No remapping necessary. } for (auto v : verts1) { DEBUG_PRINTF("vertex %zu\n", g[v].index); assert(!g[v].left.haig); assert(!g[v].left.dfa); for (const auto &e : in_edges_range(v, g)) { u32 t = g[e].rose_top; DEBUG_PRINTF("t=%u\n", t); assert(contains(top_mapping, t)); g[e].rose_top = top_mapping[t]; DEBUG_PRINTF("edge (%zu,%zu) went from top %u to %u\n", g[source(e, g)].index, g[target(e, g)].index, t, top_mapping[t]); } } return true; } static bool setDistinctSuffixTops(RoseGraph &g, NGHolder &h1, const NGHolder &h2, const deque &verts1) { map top_mapping; if (!setDistinctTops(h1, h2, top_mapping)) { return false; } if (top_mapping.empty()) { return true; // No remapping necessary. } for (auto v : verts1) { DEBUG_PRINTF("vertex %zu\n", g[v].index); u32 t = g[v].suffix.top; assert(contains(top_mapping, t)); g[v].suffix.top = top_mapping[t]; } return true; } /** \brief Estimate the number of accel states in the given graph when built as * an NFA. * * (The easiest way to estimate something like this is to actually build it: * the criteria for NFA acceleration are quite complicated and buried in * limex_compile.) */ static u32 estimatedAccelStates(const RoseBuildImpl &tbi, const NGHolder &h) { return countAccelStates(h, &tbi.rm, tbi.cc); } static void mergeNfaLeftfixes(RoseBuildImpl &tbi, RoseBouquet &roses) { RoseGraph &g = tbi.g; DEBUG_PRINTF("%zu nfa rose merge candidates\n", roses.size()); // We track the number of accelerable states for each graph in a map and // only recompute them when the graph is modified. ue2::unordered_map accel_count; for (const auto &rose : roses) { assert(rose.graph()->kind == NFA_INFIX); accel_count[rose] = estimatedAccelStates(tbi, *rose.graph()); } for (auto it = roses.begin(); it != roses.end(); ++it) { left_id r1 = *it; const deque &verts1 = roses.vertices(r1); deque merged; for (auto jt = next(it); jt != roses.end(); ++jt) { left_id r2 = *jt; const deque &verts2 = roses.vertices(r2); DEBUG_PRINTF("consider merging rose %p (%zu verts) " "with %p (%zu verts)\n", r1.graph(), verts1.size(), r2.graph(), verts2.size()); u32 accel1 = accel_count[r1]; if (accel1 >= NFA_MAX_ACCEL_STATES) { DEBUG_PRINTF("h1 has hit max accel\n"); break; // next h1 } u32 accel2 = accel_count[r2]; if (accel1 + accel2 > NFA_MAX_ACCEL_STATES) { DEBUG_PRINTF("not merging, might make unaccel (accel1=%u, " "accel2=%u)\n", accel1, accel2); continue; // next h2 } if (!mergeableRoseVertices(tbi, verts1, verts2)) { DEBUG_PRINTF("not mergeable\n"); continue; // next h2 } // Attempt to merge h2 into h1. NGHolder victim; cloneHolder(victim, *r2.graph()); // Store a copy of the in-edge properties in case we have to roll // back. map edge_props; for (auto v : verts2) { for (const auto &e : in_edges_range(v, g)) { edge_props[e] = g[e]; } } if (!setDistinctRoseTops(g, victim, *r1.graph(), verts2)) { DEBUG_PRINTF("can't set distinct tops\n"); continue; // next h2 } assert(victim.kind == r1.graph()->kind); assert(!generates_callbacks(*r1.graph())); if (!mergeNfaPair(victim, *r1.graph(), nullptr, tbi.cc)) { DEBUG_PRINTF("merge failed\n"); // Roll back in-edge properties. for (const auto &m : edge_props) { g[m.first] = m.second; } continue; // next h2 } // Update h2's roses to point to h1 now shared_ptr winner = g[verts1.front()].left.graph; for (auto v : verts2) { g[v].left.graph = winner; } roses.insert(r1, verts2); merged.push_back(r2); if (num_vertices(*winner) >= small_merge_max_vertices(tbi.cc)) { DEBUG_PRINTF("h1 now has %zu vertices, proceeding to next\n", num_vertices(*winner)); break; // next h1 } // Update h1's accel count estimate. accel_count[r1] = estimatedAccelStates(tbi, *winner); } DEBUG_PRINTF("%zu roses merged\n", merged.size()); roses.erase_all(merged.begin(), merged.end()); } } static void mergeCastleChunk(RoseBuildImpl &tbi, RoseBouquet &cands) { /* caller must have already ensured that candidates have the same reach */ RoseGraph &g = tbi.g; DEBUG_PRINTF("%zu castle rose merge candidates\n", cands.size()); deque merged; for (auto it = cands.begin(); it != cands.end(); ++it) { left_id r1 = *it; CastleProto &castle1 = *r1.castle(); const deque &verts1 = cands.vertices(r1); merged.clear(); for (auto jt = next(it); jt != cands.end(); ++jt) { left_id r2 = *jt; CastleProto &castle2 = *r2.castle(); const deque &verts2 = cands.vertices(r2); if (castle1.repeats.size() == castle1.max_occupancy) { DEBUG_PRINTF("castle1 has hit max occupancy\n"); break; // next castle1 } assert(castle1.reach() == castle2.reach()); if (!mergeableRoseVertices(tbi, verts1, verts2)) { DEBUG_PRINTF("not mergeable\n"); continue; // next castle2 } DEBUG_PRINTF("castle1=%p (size %zu), castle2=%p (size %zu)\n", &castle1, castle1.repeats.size(), &castle2, castle2.repeats.size()); map top_map; if (!mergeCastle(castle1, castle2, top_map)) { DEBUG_PRINTF("couldn't merge\n"); continue; // next castle2 } // Update castle2's roses to point to castle1 now. shared_ptr winner = g[verts1.front()].left.castle; for (auto v : verts2) { g[v].left.castle = winner; for (const auto &e : in_edges_range(v, g)) { g[e].rose_top = top_map.at(g[e].rose_top); } } cands.insert(r1, verts2); merged.push_back(r2); } DEBUG_PRINTF("%zu roses merged\n", merged.size()); cands.erase_all(merged.begin(), merged.end()); } } /** * This pass attempts to merge prefix/infix engines with a small number of * vertices together into larger engines. The engines must not be have a * reformed start dot star (due to a leading repeat) nor an infix LBR. Engines * that have compatible lag are greedily grouped such that they remain * accelerable and only have a small number of states. Note: if a role has an * infix with multiple trigger vertices, the role will be left unchanged by this * pass and will remain using an unmerged graph. */ void mergeSmallLeftfixes(RoseBuildImpl &tbi) { DEBUG_PRINTF("entry\n"); if (!tbi.cc.grey.mergeRose || !tbi.cc.grey.roseMultiTopRoses) { return; } RoseGraph &g = tbi.g; RoseBouquet nfa_roses; for (auto v : vertices_range(g)) { if (!g[v].left) { continue; } // Handle single-parent infixes only. if (tbi.isRootSuccessor(v)) { continue; } left_id left(g[v].left); // Only non-transient for the moment. if (contains(tbi.transient, left)) { continue; } // No DFAs or Haigs right now. if (left.dfa() || left.haig()) { continue; } // Castles are handled by a different pass. if (left.castle()) { continue; } assert(left.graph()); NGHolder &h = *left.graph(); /* Ensure that kind on the graph is correct */ assert(h.kind == (tbi.isRootSuccessor(v) ? NFA_PREFIX : NFA_INFIX)); if (hasReformedStartDotStar(h, tbi.cc.grey)) { /* We would lose optimisations of the leading repeat by merging. */ continue; } // Don't merge cases that will become LBRs or haigs. if (isLargeLBR(h, tbi.cc.grey)) { continue; } // Small roses only. if (num_vertices(h) > small_rose_threshold(tbi.cc)) { continue; } nfa_roses.insert(left, v); } deque rose_groups; chunkBouquets(nfa_roses, rose_groups, MERGE_GROUP_SIZE_MAX); nfa_roses.clear(); DEBUG_PRINTF("chunked nfa roses into %zu groups\n", rose_groups.size()); for (auto &group : rose_groups) { mergeNfaLeftfixes(tbi, group); } } void mergeCastleLeftfixes(RoseBuildImpl &tbi) { DEBUG_PRINTF("entry\n"); if (!tbi.cc.grey.mergeRose || !tbi.cc.grey.roseMultiTopRoses || !tbi.cc.grey.allowCastle) { return; } RoseGraph &g = tbi.g; map by_reach; for (auto v : vertices_range(g)) { if (!g[v].left) { continue; } // Handle single-parent infixes only. if (tbi.isRootSuccessor(v)) { continue; } const left_id left(g[v].left); // Only non-transient for the moment. if (contains(tbi.transient, left)) { continue; } if (!left.castle()) { continue; } const CastleProto &castle = *left.castle(); const CharReach &cr = castle.reach(); by_reach[cr].insert(left, v); } for (auto &m : by_reach) { DEBUG_PRINTF("%zu castles for reach: %s\n", m.second.size(), describeClass(m.first).c_str()); RoseBouquet &candidates = m.second; deque cand_groups; chunkBouquets(candidates, cand_groups, MERGE_CASTLE_GROUP_SIZE_MAX); candidates.clear(); for (auto &group : cand_groups) { mergeCastleChunk(tbi, group); } } } static void mergeSuffixes(RoseBuildImpl &tbi, SuffixBouquet &suffixes, const bool acyclic) { RoseGraph &g = tbi.g; DEBUG_PRINTF("group has %zu suffixes\n", suffixes.size()); // If this isn't an acyclic case, we track the number of accelerable states // for each graph in a map and only recompute them when the graph is // modified. ue2::unordered_map accel_count; if (!acyclic) { for (const auto &suffix : suffixes) { assert(suffix.graph() && suffix.graph()->kind == NFA_SUFFIX); accel_count[suffix] = estimatedAccelStates(tbi, *suffix.graph()); } } for (auto it = suffixes.begin(); it != suffixes.end(); ++it) { suffix_id s1 = *it; const deque &verts1 = suffixes.vertices(s1); assert(s1.graph() && s1.graph()->kind == NFA_SUFFIX); // Caller should ensure that we don't propose merges of graphs that are // already too big. assert(num_vertices(*s1.graph()) < small_merge_max_vertices(tbi.cc)); deque merged; for (auto jt = next(it); jt != suffixes.end(); ++jt) { suffix_id s2 = *jt; const deque &verts2 = suffixes.vertices(s2); assert(s2.graph() && s2.graph()->kind == NFA_SUFFIX); if (!acyclic) { u32 accel1 = accel_count[s1]; if (accel1 >= NFA_MAX_ACCEL_STATES) { DEBUG_PRINTF("h1 has hit max accel\n"); break; // next h1 } u32 accel2 = accel_count[s2]; if (accel1 + accel2 > NFA_MAX_ACCEL_STATES) { DEBUG_PRINTF("not merging, might make unaccel (accel1=%u, " "accel2=%u)\n", accel1, accel2); continue; // next h2 } } // Attempt to merge h2 into h1. NGHolder victim; cloneHolder(victim, *s2.graph()); // Store a copy of the suffix tops in case we have to roll back. map old_tops; for (auto v : verts2) { old_tops[v] = g[v].suffix.top; } if (!setDistinctSuffixTops(g, victim, *s1.graph(), verts2)) { DEBUG_PRINTF("can't set distinct tops\n"); continue; // next h2 } if (!mergeNfaPair(victim, *s1.graph(), &tbi.rm, tbi.cc)) { DEBUG_PRINTF("merge failed\n"); // Roll back in-edge properties. for (const auto &m : old_tops) { g[m.first].suffix.top = m.second; } continue; // next h2 } // Update h2's roses to point to h1 now shared_ptr winner = g[verts1.front()].suffix.graph; for (auto v : verts2) { g[v].suffix.graph = winner; } suffixes.insert(s1, verts2); merged.push_back(s2); if (num_vertices(*s1.graph()) >= small_merge_max_vertices(tbi.cc)) { DEBUG_PRINTF("h1 now has %zu vertices, proceeding to next\n", num_vertices(*s1.graph())); break; // next h1 } if (!acyclic) { // Update h1's accel count estimate. accel_count[s1] = estimatedAccelStates(tbi, *s1.graph()); } } DEBUG_PRINTF("%zu suffixes merged\n", merged.size()); suffixes.erase_all(merged.begin(), merged.end()); } } /** * This merge pass combines suffixes from unrelated roles into a single * suffix with multiple top events in order to distinguish the triggers * from differing roles. mergeAcyclicSuffixes only considers acyclic suffixes * while mergeSmallSuffixes only considers small suffixes. The merges will * group roles with suffixes in the graph into clusters of at most * \ref MERGE_GROUP_SIZE_MAX. Each cluster is processed by iterating over the * suffixes and attempting to pairwise merge it with another member. Merges * will fail if the result is not implementable, requires too many distinct top * events, or if it losses the ability to be accelerated. The merge will modify * the existing suffix graph of the one member (g1), the other member updates * it graph to refer to g1 instead of its previous graph (g2) and use the new * tops created. Other roles may have been sharing g1 - these are unaffected by * the change as the existing top events are left untouched. Other roles using * g2 are also unaffected as g2 will continue to exist until while it has any * roles triggering it. * * Note: suffixes destined for the LBR are not considered for these merges as * the LBR can only handle a single repeat and this type of repeat is ideally * handled outside of an NFA or DFA. */ void mergeAcyclicSuffixes(RoseBuildImpl &tbi) { DEBUG_PRINTF("entry\n"); if (!tbi.cc.grey.mergeSuffixes) { return; } SuffixBouquet suffixes; RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { shared_ptr h = g[v].suffix.graph; if (!h || tbi.isInETable(v)) { continue; } assert(!g[v].suffix.haig); if (num_vertices(*h) >= small_merge_max_vertices(tbi.cc)) { continue; } if (!isAcyclic(*h)) { continue; } if (isLargeLBR(*h, tbi.cc.grey)) { DEBUG_PRINTF("not considering LBR suffix for merge\n"); continue; } suffixes.insert(g[v].suffix, v); } deque suff_groups; chunkBouquets(suffixes, suff_groups, MERGE_GROUP_SIZE_MAX); DEBUG_PRINTF("chunked %zu suffixes into %zu groups\n", suffixes.size(), suff_groups.size()); suffixes.clear(); for (auto &group : suff_groups) { mergeSuffixes(tbi, group, true); } } /** * This merge pass combines suffixes from unrelated roles into a single * suffix with multiple top events in order to distinguish the triggers * from differing roles. mergeAcyclicSuffixes only considers acyclic suffixes * while mergeSmallSuffixes only considers small suffixes. The merges will * group roles with suffixes in the graph into clusters of at most * \ref MERGE_GROUP_SIZE_MAX. Each cluster is processed by iterating over the * suffixes and attempting to pairwise merge it with another member. Merges * will fail if the result is not implementable, requires too many distinct top * events, or if it losses the ability to be accelerated. The merge will modify * the existing suffix graph of the one member (g1), the other member updates * it graph to refer to g1 instead of its previous graph (g2) and use the new * tops created. Other roles may have been sharing g1 - these are unaffected by * the change as the existing top events are left untouched. Other roles using * g2 are also unaffected as g2 will continue to exist until while it has any * roles triggering it. * * Note: suffixes destined for the LBR are not considered for these merges as * the LBR can only handle a single repeat and this type of repeat is ideally * handled outside of an NFA or DFA. */ void mergeSmallSuffixes(RoseBuildImpl &tbi) { DEBUG_PRINTF("entry\n"); if (!tbi.cc.grey.mergeSuffixes) { return; } RoseGraph &g = tbi.g; SuffixBouquet suffixes; for (auto v : vertices_range(g)) { shared_ptr h = g[v].suffix.graph; if (!h || tbi.isInETable(v)) { continue; } assert(!g[v].suffix.haig); // Leave acyclics out for the moment. if (isAcyclic(*h)) { continue; } // Small-ish suffixes only. if (num_vertices(*h) > 32) { continue; } if (isLargeLBR(*h, tbi.cc.grey)) { DEBUG_PRINTF("not considering LBR suffix for merge\n"); continue; } suffixes.insert(g[v].suffix, v); } deque suff_groups; chunkBouquets(suffixes, suff_groups, MERGE_GROUP_SIZE_MAX); DEBUG_PRINTF("chunked %zu suffixes into %zu groups\n", suffixes.size(), suff_groups.size()); suffixes.clear(); for (auto &group : suff_groups) { mergeSuffixes(tbi, group, false); } } static void removeDeadOutfixes(vector &outfixes) { auto is_dead = [](const OutfixInfo &outfix) { return outfix.is_dead(); }; outfixes.erase(remove_if(begin(outfixes), end(outfixes), is_dead), end(outfixes)); } static void mergeOutfixInfo(OutfixInfo &winner, const OutfixInfo &victim) { assert(!winner.is_dead()); winner.maxBAWidth = max(winner.maxBAWidth, victim.maxBAWidth); winner.minWidth = min(winner.minWidth, victim.minWidth); winner.maxWidth = max(winner.maxWidth, victim.maxWidth); winner.maxOffset = max(winner.maxOffset, victim.maxOffset); mergeReverseAccelerationInfo(winner.rev_info, victim.rev_info); // This outfix can be ignored in small block mode if both were. The dedupe // layer at runtime will protect us from extra matches if only one was in // the small block matcher. winner.in_sbmatcher &= victim.in_sbmatcher; } static map chunkedNfaMerge(RoseBuildImpl &build, const vector &nfas) { map merged; vector batch; for (auto it = begin(nfas), ite = end(nfas); it != ite; ++it) { batch.push_back(*it); assert((*it)->kind == NFA_OUTFIX); if (batch.size() == MERGE_GROUP_SIZE_MAX || next(it) == ite) { auto batch_merged = mergeNfaCluster(batch, &build.rm, build.cc); insert(&merged, batch_merged); batch.clear(); } } return merged; } static void mergeOutfixNfas(RoseBuildImpl &tbi, vector &nfas) { DEBUG_PRINTF("merging %zu nfas\n", nfas.size()); if (nfas.size() < 2) { return; } vector &outfixes = tbi.outfixes; map nfa_mapping; for (size_t i = 0; i < outfixes.size(); i++) { auto *holder = outfixes[i].holder(); if (holder) { nfa_mapping[holder] = i; } } map merged = chunkedNfaMerge(tbi, nfas); if (merged.empty()) { return; } DEBUG_PRINTF("%zu nfas merged\n", merged.size()); // Update the outfix info for merged holders. for (const auto &m : merged) { OutfixInfo &victim = outfixes.at(nfa_mapping[m.first]); OutfixInfo &winner = outfixes.at(nfa_mapping[m.second]); mergeOutfixInfo(winner, victim); victim.clear(); } removeDeadOutfixes(outfixes); } namespace { struct MergeMcClellan { MergeMcClellan(const ReportManager &rm_in, const Grey &grey_in) : rm(rm_in), grey(grey_in) {} unique_ptr operator()(const raw_dfa *d1, const raw_dfa *d2) const { assert(d1 && d2); return mergeTwoDfas(d1, d2, DFA_MERGE_MAX_STATES, &rm, grey); } private: const ReportManager &rm; const Grey &grey; }; struct MergeHaig { explicit MergeHaig(u32 limit_in) : limit(limit_in) {} unique_ptr operator()(const raw_som_dfa *d1, const raw_som_dfa *d2) const { assert(d1 && d2); return attemptToMergeHaig({d1, d2}, limit); } private: const u32 limit; //!< state limit for merged result. }; } /** * Generic pairwise merge algorithm that can be used for either McClellan * (RawDfa=raw_dfa) or Haig (RawDfa=raw_som_dfa). Delegates the actual merge * operation to a merge functor, which allows the caller to set some policy * (state limits, etc). * * This is currently astonishingly simple and just considers every pair of * DFAs, slow and steady. We may wish to actually apply a merge ordering * strategy in the future. */ template static void pairwiseDfaMerge(vector &dfas, ue2::unordered_map &dfa_mapping, vector &outfixes, MergeFunctor merge_func) { DEBUG_PRINTF("merging group of size %zu\n", dfas.size()); for (auto it = dfas.begin(), ite = dfas.end(); it != ite; ++it) { if (!*it) { continue; } for (auto jt = next(it); jt != ite; ++jt) { if (!*jt) { continue; } DEBUG_PRINTF("try merge %p and %p\n", *it, *jt); unique_ptr rdfa = merge_func(*it, *jt); if (!rdfa) { continue; // Merge failed. } DEBUG_PRINTF("merge succeeded, built %p\n", rdfa.get()); OutfixInfo &winner = outfixes.at(dfa_mapping[*it]); OutfixInfo &victim = outfixes.at(dfa_mapping[*jt]); assert(!winner.is_dead() && !victim.is_dead()); RawDfa *dfa_ptr = rdfa.get(); dfa_mapping[dfa_ptr] = dfa_mapping[*it]; dfa_mapping.erase(*it); winner.proto = move(rdfa); mergeOutfixInfo(winner, victim); victim.clear(); *jt = nullptr; // to be deleted. *it = dfa_ptr; } } } template static void chunkedDfaMerge(vector &dfas, ue2::unordered_map &dfa_mapping, vector &outfixes, MergeFunctor merge_func) { DEBUG_PRINTF("begin merge of %zu dfas\n", dfas.size()); vector out_dfas; vector chunk; for (auto it = begin(dfas), ite = end(dfas); it != ite; ++it) { chunk.push_back(*it); if (chunk.size() >= DFA_CHUNK_SIZE_MAX || next(it) == ite) { pairwiseDfaMerge(chunk, dfa_mapping, outfixes, merge_func); out_dfas.insert(end(out_dfas), begin(chunk), end(chunk)); chunk.clear(); } } // Remove null (merged) DFAs and update vector for subsequent use. out_dfas.erase(remove(out_dfas.begin(), out_dfas.end(), nullptr), out_dfas.end()); dfas.swap(out_dfas); DEBUG_PRINTF("after merge there are %zu dfas\n", dfas.size()); } static void mergeOutfixDfas(RoseBuildImpl &tbi, vector &dfas) { DEBUG_PRINTF("merging %zu nfas\n", dfas.size()); if (dfas.size() < 2) { return; } vector &outfixes = tbi.outfixes; /* key is index into outfix array as iterators, etc may be invalidated by * element addition. */ ue2::unordered_map dfa_mapping; for (size_t i = 0; i < outfixes.size(); i++) { auto *rdfa = outfixes[i].rdfa(); if (rdfa) { dfa_mapping[rdfa] = i; } } chunkedDfaMerge(dfas, dfa_mapping, outfixes, MergeMcClellan(tbi.rm, tbi.cc.grey)); removeDeadOutfixes(outfixes); } static void mergeOutfixCombo(RoseBuildImpl &tbi, const ReportManager &rm, const Grey &grey) { if (!grey.roseMcClellanOutfix) { return; } DEBUG_PRINTF("merge combo\n"); bool seen_dfa = false; u32 nfa_count = 0; for (const auto &outfix : tbi.outfixes) { if (outfix.holder()) { DEBUG_PRINTF("nfa\n"); nfa_count++; } else if (outfix.rdfa()) { DEBUG_PRINTF("dfa\n"); seen_dfa = true; } } DEBUG_PRINTF("nfa %u dfas present %d\n", nfa_count, (int)seen_dfa); if (!nfa_count || (nfa_count == 1 && !seen_dfa)) { DEBUG_PRINTF("no combo merges possible\n"); return; } /* key is index into outfix array as iterators, etc may be invalidated by * element addition. */ size_t new_dfas = 0; ue2::unordered_map dfa_mapping; vector dfas; for (auto it = tbi.outfixes.begin(); it != tbi.outfixes.end(); ++it) { auto &outfix = *it; assert(!outfix.is_dead()); if (outfix.rdfa()) { auto *rdfa = outfix.rdfa(); dfas.push_back(rdfa); dfa_mapping[rdfa] = it - tbi.outfixes.begin(); continue; } if (!outfix.holder()) { continue; } NGHolder *h = outfix.holder(); assert(h->kind == NFA_OUTFIX); auto rdfa = buildMcClellan(*h, &rm, grey); if (rdfa) { // Transform this outfix into a DFA and add it to the merge set. dfa_mapping[rdfa.get()] = it - tbi.outfixes.begin(); dfas.push_back(rdfa.get()); outfix.proto = move(rdfa); new_dfas++; } } DEBUG_PRINTF("constructed %zu new dfas\n", new_dfas); if (!new_dfas) { /* assumes normal dfas have already been fully merged */ return; } chunkedDfaMerge(dfas, dfa_mapping, tbi.outfixes, MergeMcClellan(tbi.rm, tbi.cc.grey)); removeDeadOutfixes(tbi.outfixes); } static void mergeOutfixHaigs(RoseBuildImpl &tbi, vector &dfas, u32 limit) { if (dfas.size() < 2) { return; } vector &outfixes = tbi.outfixes; ue2::unordered_map dfa_mapping; for (size_t i = 0; i < outfixes.size(); i++) { auto *haig = outfixes[i].haig(); if (haig) { dfa_mapping[haig] = i; } } chunkedDfaMerge(dfas, dfa_mapping, outfixes, MergeHaig(limit)); removeDeadOutfixes(outfixes); } /** * This pass attempts to merge outfix engines together. At this point in time, * the engine type (NFA, DFA, Haig) has already been decided for each outfix * and outfixes can only merged with others of their same type. NFAs are merged * in a priority order based on common prefix length. The other types are * merged blindly. Engines are merged to the extent that they can still be * implemented efficiently. */ void mergeOutfixes(RoseBuildImpl &tbi) { if (!tbi.cc.grey.mergeOutfixes) { return; } vector nfas; vector dfas; vector som_dfas; for (auto &outfix : tbi.outfixes) { if (outfix.rdfa()) { dfas.push_back(outfix.rdfa()); } else if (outfix.holder()) { nfas.push_back(outfix.holder()); } else if (outfix.haig()) { som_dfas.push_back(outfix.haig()); } } DEBUG_PRINTF("merging %zu dfas, %zu nfas\n", dfas.size(), nfas.size()); mergeOutfixNfas(tbi, nfas); mergeOutfixDfas(tbi, dfas); mergeOutfixHaigs(tbi, som_dfas, 255); mergeOutfixHaigs(tbi, som_dfas, 8192); mergeOutfixCombo(tbi, tbi.rm, tbi.cc.grey); } static u32 allowedSquashDistance(const CharReach &cr, u32 min_width, const RoseBuildImpl &tbi, RoseVertex tv) { CharReach accept_cr; DEBUG_PRINTF("hello |cr|=%zu\n", cr.count()); const RoseGraph &g = tbi.g; /* TODO: inspect further back in the pattern */ for (u32 lit_id : g[tv].literals) { const rose_literal_id &lit = tbi.literals.right.at(lit_id); if (lit.delay) { return 0; /* TODO: better */ } if (lit.table != ROSE_FLOATING && lit.table != ROSE_EOD_ANCHORED) { return 0; } assert(!lit.s.empty()); accept_cr |= *lit.s.rbegin(); } DEBUG_PRINTF("|accept_cr|=%zu\n", accept_cr.count()); if ((accept_cr & cr).any()) { DEBUG_PRINTF("no squash\n"); return 0; /* the accept byte doesn't always kill the puffette. TODO: * maybe if we look further back we could find something that * would kill the puffette... */ } DEBUG_PRINTF("allowed to squash %u\n", min_width); return min_width; } void mergePuffixes(RoseBuildImpl &tbi) { DEBUG_PRINTF("entry\n"); if (!tbi.cc.grey.mergeSuffixes) { return; } RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { shared_ptr h = g[v].suffix.graph; if (!h) { continue; } assert(!g[v].suffix.haig); assert(!g[v].eod_accept); assert(onlyOneTop(*h)); /* we should not have merged yet */ bool fixed_depth = g[v].min_offset == g[v].max_offset; if (!isPuffable(*h, fixed_depth, tbi.rm, tbi.cc.grey)) { continue; } PureRepeat repeat; if (!isPureRepeat(*h, repeat)) { assert(0); continue; } if (repeat.bounds.min == depth(0)) { assert(0); // No vacuous puffs allowed. continue; } assert(repeat.bounds.min.is_finite() && repeat.bounds.max.is_reachable()); assert(repeat.bounds.max == repeat.bounds.min || repeat.bounds.max.is_infinite()); const bool unbounded = repeat.bounds.max.is_infinite(); const set reports = all_reports(*h); assert(reports.size() == 1); ReportID report = *reports.begin(); DEBUG_PRINTF("got puffette candidate %u:%s\n", report, repeat.bounds.str().c_str()); raw_puff rp(repeat.bounds.min, unbounded, report, repeat.reach); u32 queue; u32 event; tbi.addChainTail(rp, &queue, &event); u32 squashDistance = allowedSquashDistance(repeat.reach, repeat.bounds.min, tbi, v); Report ir = makeMpvTrigger(event, squashDistance); ReportID id = tbi.rm.getInternalId(ir); DEBUG_PRINTF("puffette event q%u t%u\n", queue, event); g[v].suffix.reset(); g[v].reports.insert(id); } } static void updateCastleSuffix(RoseGraph &g, const shared_ptr &m, u32 top, const vector &verts) { DEBUG_PRINTF("merged in as top %u, updating %zu vertices\n", top, verts.size()); for (auto v : verts) { assert(g[v].suffix.castle); g[v].suffix.castle = m; g[v].suffix.top = top; } } static void mergeCastleSuffixes(RoseBuildImpl &tbi, vector > &castles, map, vector > &castle_map) { if (castles.size() <= 1) { return; } RoseGraph &g = tbi.g; const size_t max_size = CastleProto::max_occupancy; shared_ptr m = castles.front(); assert(m->repeats.size() == 1); // Not yet merged. // Cache repeats we've already merged, mapped to (prototype, top). That // way, we can ensure that we don't construct more than one completely // identical repeat. typedef map, u32> > RepeatCache; RepeatCache cache; { // Initial entry in cache. const u32 top = m->repeats.begin()->first; const PureRepeat &pr = m->repeats.begin()->second; cache[pr] = make_pair(m, top); } for (size_t i = 1; i < castles.size(); i++) { shared_ptr c = castles[i]; assert(c->repeats.size() == 1); // Not yet merged. const PureRepeat &pr = c->repeats.begin()->second; RepeatCache::const_iterator it = cache.find(pr); if (it != cache.end()) { DEBUG_PRINTF("reusing cached merge, top=%u, proto=%p\n", it->second.second, it->second.first.get()); updateCastleSuffix(g, it->second.first, it->second.second, castle_map[c]); continue; } if (m->repeats.size() == max_size) { // No room left to merge into 'm'. This one becomes the new 'm'. DEBUG_PRINTF("next mergee\n"); m = c; u32 top = m->repeats.begin()->first; cache[pr] = make_pair(m, top); } else { u32 top = m->add(pr); updateCastleSuffix(g, m, top, castle_map[c]); DEBUG_PRINTF("added to %p, top %u\n", m.get(), top); cache[pr] = make_pair(m, top); } } } void mergeCastleSuffixes(RoseBuildImpl &tbi) { DEBUG_PRINTF("entry\n"); if (!(tbi.cc.grey.allowCastle && tbi.cc.grey.mergeSuffixes)) { return; } map, vector> castles; map>> by_reach; RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { if (!g[v].suffix.castle) { continue; } shared_ptr c = g[v].suffix.castle; if (c->repeats.size() != 1) { // This code assumes it's the only place merging is being done. assert(0); continue; } if (!contains(castles, c)) { by_reach[c->reach()].push_back(c); } castles[c].push_back(v); } for (auto &m : by_reach) { DEBUG_PRINTF("reach %s, %zu elements\n", describeClass(m.first).c_str(), m.second.size()); mergeCastleSuffixes(tbi, m.second, castles); } } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_types.h0000644000175000017500000000525613055426554020413 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose runtime types (callbacks, etc). */ #ifndef ROSE_TYPES_H #define ROSE_TYPES_H #include "ue2common.h" struct hs_scratch; /** * \brief Continue without checking for exhaustion. * * \ref RoseCallback return value indicating that execution should continue and * that it is not necessary to check if all reports have been exhausted. */ #define ROSE_CONTINUE_MATCHING_NO_EXHAUST 2 /** * \brief The type for a Rose callback. * * \return * - \ref MO_HALT_MATCHING if matching should terminate; * - \ref MO_CONTINUE_MATCHING if matching should continue; * - \ref ROSE_CONTINUE_MATCHING_NO_EXHAUST if matching should continue and no * exhaustion is possible. */ typedef int (*RoseCallback)(u64a offset, ReportID id, struct hs_scratch *scratch); /** * \brief The type for a Rose callback which also tracks start of match. * * Behaves just like \ref RoseCallback except that it is provided with both a * start and an end offset. * * \see RoseCallback */ typedef int (*RoseCallbackSom)(u64a from_offset, u64a to_offset, ReportID id, struct hs_scratch *scratch); #endif hyperscan-4.4.1/src/rose/rose_dump.cpp0000644000175000017500000013407213055426554020546 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "hwlm/hwlm_build.h" #include "hwlm/hwlm_dump.h" #include "rose_build.h" #include "rose_dump.h" #include "rose_common.h" #include "rose_internal.h" #include "rose_program.h" #include "hs_compile.h" #include "ue2common.h" #include "nfa/nfa_build_util.h" #include "nfa/nfa_dump_api.h" #include "nfa/nfa_internal.h" #include "nfa/nfa_kind.h" #include "util/dump_charclass.h" #include "util/multibit_build.h" #include "util/multibit.h" #include #include #include #include #include #include #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { namespace /* anonymous */ { struct rose_off { explicit rose_off(u32 j) : i(j) {} string str(void) const; u32 i; }; ostream &operator<< (ostream &o, const rose_off &to) { if (to.i == ROSE_BOUND_INF) { o << "inf"; } else { o << to.i; } return o; } string rose_off::str(void) const { ostringstream out; out << *this; return out.str(); } } static const void *loadFromByteCodeOffset(const RoseEngine *t, u32 offset) { if (!offset) { return nullptr; } const char *lt = (const char *)t + offset; return lt; } static const void *getAnchoredMatcher(const RoseEngine *t) { return loadFromByteCodeOffset(t, t->amatcherOffset); } static const HWLM *getFloatingMatcher(const RoseEngine *t) { return (const HWLM *)loadFromByteCodeOffset(t, t->fmatcherOffset); } static const HWLM *getEodMatcher(const RoseEngine *t) { return (const HWLM *)loadFromByteCodeOffset(t, t->ematcherOffset); } static const HWLM *getSmallBlockMatcher(const RoseEngine *t) { return (const HWLM *)loadFromByteCodeOffset(t, t->sbmatcherOffset); } static CharReach bitvectorToReach(const u8 *reach) { CharReach cr; for (size_t i = 0; i < 256; i++) { if (reach[i / 8] & (1U << (i % 8))) { cr.set(i); } } return cr; } static void dumpLookaround(ofstream &os, const RoseEngine *t, const ROSE_STRUCT_CHECK_LOOKAROUND *ri) { assert(ri); const u8 *base = (const u8 *)t; const s8 *look_base = (const s8 *)(base + t->lookaroundTableOffset); const u8 *reach_base = base + t->lookaroundReachOffset; const s8 *look = look_base + ri->index; const s8 *look_end = look + ri->count; const u8 *reach = reach_base + ri->index * REACH_BITVECTOR_LEN; os << " contents:" << endl; for (; look < look_end; look++, reach += REACH_BITVECTOR_LEN) { os << " " << std::setw(4) << std::setfill(' ') << int{*look} << ": "; describeClass(os, bitvectorToReach(reach), 1000, CC_OUT_TEXT); os << endl; } } static vector sparseIterValues(const mmbit_sparse_iter *it, u32 num_bits) { vector keys; if (num_bits == 0) { return keys; } vector bits(mmbit_size(num_bits), u8{0xff}); // All bits on. vector state(MAX_SPARSE_ITER_STATES); const u8 *b = bits.data(); mmbit_sparse_state *s = state.data(); u32 idx = 0; u32 i = mmbit_sparse_iter_begin(b, num_bits, &idx, it, s); while (i != MMB_INVALID) { keys.push_back(i); i = mmbit_sparse_iter_next(b, num_bits, i, &idx, it, s); } return keys; } static void dumpJumpTable(ofstream &os, const RoseEngine *t, const ROSE_STRUCT_SPARSE_ITER_BEGIN *ri) { auto *it = (const mmbit_sparse_iter *)loadFromByteCodeOffset(t, ri->iter_offset); auto *jumps = (const u32 *)loadFromByteCodeOffset(t, ri->jump_table); for (const auto &key : sparseIterValues(it, t->rolesWithStateCount)) { os << " " << std::setw(4) << std::setfill(' ') << key << " : +" << *jumps << endl; ++jumps; } } static void dumpSomOperation(ofstream &os, const som_operation &op) { os << " som (type=" << u32{op.type} << ", onmatch=" << op.onmatch; switch (op.type) { case SOM_EXTERNAL_CALLBACK_REV_NFA: case SOM_INTERNAL_LOC_SET_REV_NFA: case SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET: case SOM_INTERNAL_LOC_SET_REV_NFA_IF_WRITABLE: os << ", revNfaIndex=" << op.aux.revNfaIndex; break; default: os << ", somDistance=" << op.aux.somDistance; break; } os << ")" << endl; } static string dumpStrMask(const u8 *mask, size_t len) { ostringstream oss; for (size_t i = 0; i < len; i++) { oss << std::hex << std::setw(2) << std::setfill('0') << u32{mask[i]} << " "; } return oss.str(); } #define PROGRAM_CASE(name) \ case ROSE_INSTR_##name: { \ os << " " << std::setw(4) << std::setfill('0') << (pc - pc_base) \ << ": " #name " (" << (int)ROSE_INSTR_##name << ")" << endl; \ const auto *ri = (const struct ROSE_STRUCT_##name *)pc; #define PROGRAM_NEXT_INSTRUCTION \ pc += ROUNDUP_N(sizeof(*ri), ROSE_INSTR_MIN_ALIGN); \ break; \ } static void dumpProgram(ofstream &os, const RoseEngine *t, const char *pc) { const char *pc_base = pc; for (;;) { u8 code = *(const u8 *)pc; assert(code <= LAST_ROSE_INSTRUCTION); const size_t offset = pc - pc_base; switch (code) { PROGRAM_CASE(END) { return; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(ANCHORED_DELAY) { os << " groups 0x" << std::hex << ri->groups << std::dec << endl; os << " done_jump " << offset + ri->done_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_LIT_EARLY) { os << " min_offset " << ri->min_offset << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_GROUPS) { os << " groups 0x" << std::hex << ri->groups << std::dec << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_ONLY_EOD) { os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_BOUNDS) { os << " min_bound " << ri->min_bound << endl; os << " max_bound " << ri->max_bound << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_NOT_HANDLED) { os << " key " << ri->key << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SINGLE_LOOKAROUND) { os << " offset " << int{ri->offset} << endl; os << " reach_index " << ri->reach_index << endl; os << " fail_jump " << offset + ri->fail_jump << endl; const u8 *base = (const u8 *)t; const u8 *reach_base = base + t->lookaroundReachOffset; const u8 *reach = reach_base + ri->reach_index * REACH_BITVECTOR_LEN; os << " contents "; describeClass(os, bitvectorToReach(reach), 1000, CC_OUT_TEXT); os << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_LOOKAROUND) { os << " index " << ri->index << endl; os << " count " << ri->count << endl; os << " fail_jump " << offset + ri->fail_jump << endl; dumpLookaround(os, t, ri); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_MASK) { os << " and_mask 0x" << std::hex << std::setw(16) << std::setfill('0') << ri->and_mask << std::dec << endl; os << " cmp_mask 0x" << std::hex << std::setw(16) << std::setfill('0') << ri->cmp_mask << std::dec << endl; os << " neg_mask 0x" << std::hex << std::setw(16) << std::setfill('0') << ri->neg_mask << std::dec << endl; os << " offset " << ri->offset << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_MASK_32) { os << " and_mask " << dumpStrMask(ri->and_mask, sizeof(ri->and_mask)) << endl; os << " cmp_mask " << dumpStrMask(ri->cmp_mask, sizeof(ri->cmp_mask)) << endl; os << " neg_mask 0x" << std::hex << std::setw(8) << std::setfill('0') << ri->neg_mask << std::dec << endl; os << " offset " << ri->offset << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_BYTE) { os << " and_mask 0x" << std::hex << std::setw(2) << std::setfill('0') << u32{ri->and_mask} << std::dec << endl; os << " cmp_mask 0x" << std::hex << std::setw(2) << std::setfill('0') << u32{ri->cmp_mask} << std::dec << endl; os << " negation " << u32{ri->negation} << endl; os << " offset " << ri->offset << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SHUFTI_16x8) { os << " nib_mask " << dumpStrMask(ri->nib_mask, sizeof(ri->nib_mask)) << endl; os << " bucket_select_mask " << dumpStrMask(ri->bucket_select_mask, sizeof(ri->bucket_select_mask)) << endl; os << " offset " << ri->offset << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SHUFTI_32x8) { os << " hi_mask " << dumpStrMask(ri->hi_mask, sizeof(ri->hi_mask)) << endl; os << " lo_mask " << dumpStrMask(ri->lo_mask, sizeof(ri->lo_mask)) << endl; os << " bucket_select_mask " << dumpStrMask(ri->bucket_select_mask, sizeof(ri->bucket_select_mask)) << endl; os << " offset " << ri->offset << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SHUFTI_16x16) { os << " hi_mask " << dumpStrMask(ri->hi_mask, sizeof(ri->hi_mask)) << endl; os << " lo_mask " << dumpStrMask(ri->lo_mask, sizeof(ri->lo_mask)) << endl; os << " bucket_select_mask " << dumpStrMask(ri->bucket_select_mask, sizeof(ri->bucket_select_mask)) << endl; os << " offset " << ri->offset << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SHUFTI_32x16) { os << " hi_mask " << dumpStrMask(ri->hi_mask, sizeof(ri->hi_mask)) << endl; os << " lo_mask " << dumpStrMask(ri->lo_mask, sizeof(ri->lo_mask)) << endl; os << " bucket_select_mask_hi " << dumpStrMask(ri->bucket_select_mask_hi, sizeof(ri->bucket_select_mask_hi)) << endl; os << " bucket_select_mask_lo " << dumpStrMask(ri->bucket_select_mask_lo, sizeof(ri->bucket_select_mask_lo)) << endl; os << " offset " << ri->offset << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_INFIX) { os << " queue " << ri->queue << endl; os << " lag " << ri->lag << endl; os << " report " << ri->report << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_PREFIX) { os << " queue " << ri->queue << endl; os << " lag " << ri->lag << endl; os << " report " << ri->report << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(PUSH_DELAYED) { os << " delay " << u32{ri->delay} << endl; os << " index " << ri->index << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(RECORD_ANCHORED) { os << " id " << ri->id << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CATCH_UP) {} PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CATCH_UP_MPV) {} PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SOM_ADJUST) { os << " distance " << ri->distance << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SOM_LEFTFIX) { os << " queue " << ri->queue << endl; os << " lag " << ri->lag << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SOM_FROM_REPORT) { dumpSomOperation(os, ri->som); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SOM_ZERO) {} PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(TRIGGER_INFIX) { os << " queue " << ri->queue << endl; os << " event " << ri->event << endl; os << " cancel " << u32{ri->cancel} << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(TRIGGER_SUFFIX) { os << " queue " << ri->queue << endl; os << " event " << ri->event << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(DEDUPE) { os << " quash_som " << u32{ri->quash_som} << endl; os << " dkey " << ri->dkey << endl; os << " offset_adjust " << ri->offset_adjust << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(DEDUPE_SOM) { os << " quash_som " << u32{ri->quash_som} << endl; os << " dkey " << ri->dkey << endl; os << " offset_adjust " << ri->offset_adjust << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_CHAIN) { os << " event " << ri->event << endl; os << " top_squash_distance " << ri->top_squash_distance << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_SOM_INT) { dumpSomOperation(os, ri->som); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_SOM_AWARE) { dumpSomOperation(os, ri->som); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT) { os << " onmatch " << ri->onmatch << endl; os << " offset_adjust " << ri->offset_adjust << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_EXHAUST) { os << " onmatch " << ri->onmatch << endl; os << " offset_adjust " << ri->offset_adjust << endl; os << " ekey " << ri->ekey << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_SOM) { os << " onmatch " << ri->onmatch << endl; os << " offset_adjust " << ri->offset_adjust << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_SOM_EXHAUST) { os << " onmatch " << ri->onmatch << endl; os << " offset_adjust " << ri->offset_adjust << endl; os << " ekey " << ri->ekey << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(DEDUPE_AND_REPORT) { os << " quash_som " << u32{ri->quash_som} << endl; os << " dkey " << ri->dkey << endl; os << " onmatch " << ri->onmatch << endl; os << " offset_adjust " << ri->offset_adjust << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(FINAL_REPORT) { os << " onmatch " << ri->onmatch << endl; os << " offset_adjust " << ri->offset_adjust << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_EXHAUSTED) { os << " ekey " << ri->ekey << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_MIN_LENGTH) { os << " end_adj " << ri->end_adj << endl; os << " min_length " << ri->min_length << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SET_STATE) { os << " index " << ri->index << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SET_GROUPS) { os << " groups 0x" << std::hex << ri->groups << std::dec << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SQUASH_GROUPS) { os << " groups 0x" << std::hex << ri->groups << std::dec << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_STATE) { os << " index " << ri->index << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SPARSE_ITER_BEGIN) { os << " iter_offset " << ri->iter_offset << endl; os << " jump_table " << ri->jump_table << endl; dumpJumpTable(os, t, ri); os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SPARSE_ITER_NEXT) { os << " iter_offset " << ri->iter_offset << endl; os << " jump_table " << ri->jump_table << endl; os << " state " << ri->state << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SPARSE_ITER_ANY) { os << " iter_offset " << ri->iter_offset << endl; os << " fail_jump " << offset + ri->fail_jump << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(ENGINES_EOD) { os << " iter_offset " << ri->iter_offset << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SUFFIXES_EOD) {} PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(MATCHER_EOD) {} PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_LONG_LIT) { os << " lit_offset " << ri->lit_offset << endl; os << " lit_length " << ri->lit_length << endl; const char *lit = (const char *)t + ri->lit_offset; os << " literal: \"" << escapeString(string(lit, ri->lit_length)) << "\"" << endl; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_LONG_LIT_NOCASE) { os << " lit_offset " << ri->lit_offset << endl; os << " lit_length " << ri->lit_length << endl; const char *lit = (const char *)t + ri->lit_offset; os << " literal: \"" << escapeString(string(lit, ri->lit_length)) << "\"" << endl; } PROGRAM_NEXT_INSTRUCTION default: os << " UNKNOWN (code " << int{code} << ")" << endl; os << " " << endl; return; } } } #undef PROGRAM_CASE #undef PROGRAM_NEXT_INSTRUCTION static void dumpRoseLitPrograms(const RoseEngine *t, const string &filename) { ofstream os(filename); const u32 *litPrograms = (const u32 *)loadFromByteCodeOffset(t, t->litProgramOffset); const u32 *delayRebuildPrograms = (const u32 *)loadFromByteCodeOffset(t, t->litDelayRebuildProgramOffset); for (u32 i = 0; i < t->literalCount; i++) { os << "Literal " << i << endl; os << "---------------" << endl; if (litPrograms[i]) { os << "Program @ " << litPrograms[i] << ":" << endl; const char *prog = (const char *)loadFromByteCodeOffset(t, litPrograms[i]); dumpProgram(os, t, prog); } else { os << "" << endl; } if (delayRebuildPrograms[i]) { os << "Delay Rebuild Program @ " << delayRebuildPrograms[i] << ":" << endl; const char *prog = (const char *)loadFromByteCodeOffset( t, delayRebuildPrograms[i]); dumpProgram(os, t, prog); } os << endl; } os.close(); } static void dumpRoseEodPrograms(const RoseEngine *t, const string &filename) { ofstream os(filename); const char *base = (const char *)t; if (t->eodProgramOffset) { os << "EOD Program @ " << t->eodProgramOffset << ":" << endl; dumpProgram(os, t, base + t->eodProgramOffset); os << endl; } else { os << "" << endl; } os.close(); } static void dumpRoseReportPrograms(const RoseEngine *t, const string &filename) { ofstream os(filename); const u32 *programs = (const u32 *)loadFromByteCodeOffset(t, t->reportProgramOffset); for (u32 i = 0; i < t->reportProgramCount; i++) { os << "Report " << i << endl; os << "---------------" << endl; if (programs[i]) { os << "Program @ " << programs[i] << ":" << endl; const char *prog = (const char *)loadFromByteCodeOffset(t, programs[i]); dumpProgram(os, t, prog); } else { os << "" << endl; } } os.close(); } static void dumpNfaNotes(ofstream &fout, const RoseEngine *t, const NFA *n) { const u32 qindex = n->queueIndex; if (qindex < t->outfixBeginQueue) { fout << "chained"; return; } if (qindex < t->outfixEndQueue) { fout << "outfix"; return; } const NfaInfo *nfa_info = getNfaInfoByQueue(t, qindex); const NFA *nfa = getNfaByInfo(t, nfa_info); if (nfa_info->eod) { fout << "eod "; } if (qindex < t->leftfixBeginQueue) { fout << "suffix"; return; } const LeftNfaInfo *left = getLeftInfoByQueue(t, qindex); if (left->eager) { fout << "eager "; } if (left->transient) { fout << "transient " << (u32)left->transient << " "; } if (left->infix) { fout << "infix"; u32 maxQueueLen = left->maxQueueLen; if (maxQueueLen != (u32)(-1)) { fout << " maxqlen=" << maxQueueLen; } } else { fout << "prefix"; } fout << " maxlag=" << left->maxLag; if (left->stopTable) { fout << " miracles"; } if (left->countingMiracleOffset) { const RoseCountingMiracle *cm = (const RoseCountingMiracle *)((const char *)t + left->countingMiracleOffset); fout << " counting_miracle:" << (int)cm->count << (cm->shufti ? "s" : "v"); } if (nfaSupportsZombie(nfa)) { fout << " zombie"; } if (left->eod_check) { fout << " eod"; } } static void dumpComponentInfo(const RoseEngine *t, const string &base) { stringstream ss; ss << base << "rose_components.txt"; ofstream fout(ss.str().c_str()); fout << "Index Offset\tEngine \tStates S.State Bytes Notes\n"; for (u32 i = 0; i < t->queueCount; i++) { const NfaInfo *nfa_info = getNfaInfoByQueue(t, i); const NFA *n = getNfaByInfo(t, nfa_info); fout << left << setw(6) << i << " "; fout << left << ((const char *)n - (const char *)t) << "\t"; /* offset */ fout << left << setw(16) << describe(*n) << "\t"; fout << left << setw(6) << n->nPositions << " "; fout << left << setw(7) << n->streamStateSize << " "; fout << left << setw(7) << n->length << " "; dumpNfaNotes(fout, t, n); fout << endl; } } static void dumpComponentInfoCsv(const RoseEngine *t, const string &base) { FILE *f = fopen((base +"rose_components.csv").c_str(), "w"); fprintf(f, "Index, Offset,Engine Type,States,Stream State,Bytecode Size," "Kind,Notes\n"); for (u32 i = 0; i < t->queueCount; i++) { const NfaInfo *nfa_info = getNfaInfoByQueue(t, i); const NFA *n = getNfaByInfo(t, nfa_info); nfa_kind kind; stringstream notes; if (i < t->outfixBeginQueue) { notes << "chained;"; } if (nfa_info->eod) { notes << "eod;"; } if (i < t->outfixEndQueue) { kind = NFA_OUTFIX; } else if (i < t->leftfixBeginQueue) { kind = NFA_SUFFIX; } else { const LeftNfaInfo *left = getLeftInfoByQueue(t, i); if (left->eager) { notes << "eager;"; } if (left->transient) { notes << "transient " << (u32)left->transient << ";"; } if (left->infix) { kind = NFA_INFIX; u32 maxQueueLen = left->maxQueueLen; if (maxQueueLen != (u32)(-1)) { notes << "maxqlen=" << maxQueueLen << ";"; } } else { kind = NFA_PREFIX; } notes << "maxlag=" << left->maxLag << ";"; if (left->stopTable) { notes << "miracles;"; } if (left->countingMiracleOffset) { auto cm = (const RoseCountingMiracle *) ((const char *)t + left->countingMiracleOffset); notes << "counting_miracle:" << (int)cm->count << (cm->shufti ? "s" : "v") << ";"; } if (nfaSupportsZombie(n)) { notes << " zombie;"; } if (left->eod_check) { notes << "left_eod;"; } } fprintf(f, "%u,%zd,\"%s\",%u,%u,%u,%s,%s\n", i, (const char *)n - (const char *)t, describe(*n).c_str(), n->nPositions, n->streamStateSize, n->length, to_string(kind).c_str(), notes.str().c_str()); } fclose(f); } static void dumpExhaust(const RoseEngine *t, const string &base) { stringstream sstxt; sstxt << base << "rose_exhaust.txt"; FILE *f = fopen(sstxt.str().c_str(), "w"); const NfaInfo *infos = (const NfaInfo *)((const char *)t + t->nfaInfoOffset); u32 queue_count = t->activeArrayCount; for (u32 i = 0; i < queue_count; ++i) { u32 ekey_offset = infos[i].ekeyListOffset; fprintf(f, "%u (%u):", i, ekey_offset); if (ekey_offset) { const u32 *ekeys = (const u32 *)((const char *)t + ekey_offset); while (1) { u32 e = *ekeys; ++ekeys; if (e == ~0U) { break; } fprintf(f, " %u", e); } } fprintf(f, "\n"); } fclose(f); } static void dumpNfas(const RoseEngine *t, bool dump_raw, const string &base) { dumpExhaust(t, base); for (u32 i = 0; i < t->queueCount; i++) { const NfaInfo *nfa_info = getNfaInfoByQueue(t, i); const NFA *n = getNfaByInfo(t, nfa_info); stringstream ssbase; ssbase << base << "rose_nfa_" << i; nfaGenerateDumpFiles(n, ssbase.str()); if (dump_raw) { stringstream ssraw; ssraw << base << "rose_nfa_" << i << ".raw"; FILE *f = fopen(ssraw.str().c_str(), "w"); fwrite(n, 1, n->length, f); fclose(f); } } } static void dumpRevComponentInfo(const RoseEngine *t, const string &base) { stringstream ss; ss << base << "som_rev_components.txt"; ofstream fout(ss.str().c_str()); fout << "Index Offset\tEngine \tStates S.State Bytes\n"; const char *tp = (const char *)t; const u32 *rev_offsets = (const u32 *)(tp + t->somRevOffsetOffset); for (u32 i = 0; i < t->somRevCount; i++) { u32 offset = rev_offsets[i]; const NFA *n = (const NFA *)(tp + offset); fout << left << setw(6) << i << " "; fout << left << offset << "\t"; /* offset */ fout << left << setw(16) << describe(*n) << "\t"; fout << left << setw(6) << n->nPositions << " "; fout << left << setw(7) << n->streamStateSize << " "; fout << left << setw(7) << n->length; fout << endl; } } static void dumpRevNfas(const RoseEngine *t, bool dump_raw, const string &base) { const char *tp = (const char *)t; const u32 *rev_offsets = (const u32 *)(tp + t->somRevOffsetOffset); for (u32 i = 0; i < t->somRevCount; i++) { const NFA *n = (const NFA *)(tp + rev_offsets[i]); stringstream ssbase; ssbase << base << "som_rev_nfa_" << i; nfaGenerateDumpFiles(n, ssbase.str()); if (dump_raw) { stringstream ssraw; ssraw << base << "som_rev_nfa_" << i << ".raw"; FILE *f = fopen(ssraw.str().c_str(), "w"); fwrite(n, 1, n->length, f); fclose(f); } } } static void dumpAnchored(const RoseEngine *t, const string &base) { u32 i = 0; const anchored_matcher_info *curr = (const anchored_matcher_info *)getALiteralMatcher(t); while (curr) { const NFA *n = (const NFA *)((const char *)curr + sizeof(*curr)); stringstream ssbase; ssbase << base << "anchored_" << i; nfaGenerateDumpFiles(n, ssbase.str()); curr = curr->next_offset ? (const anchored_matcher_info *) ((const char *)curr + curr->next_offset) : nullptr; i++; }; } static void dumpAnchoredStats(const void *atable, FILE *f) { assert(atable); u32 i = 0; const anchored_matcher_info *curr = (const anchored_matcher_info *)atable; while (curr) { const NFA *n = (const NFA *)((const char *)curr + sizeof(*curr)); fprintf(f, " NFA %u: %s, %u states (%u bytes)\n", i, describe(*n).c_str(), n->nPositions, n->length); curr = curr->next_offset ? (const anchored_matcher_info *) ((const char *)curr + curr->next_offset) : nullptr; i++; }; } static void dumpLongLiteralSubtable(const RoseLongLitTable *ll_table, const RoseLongLitSubtable *ll_sub, FILE *f) { if (!ll_sub->hashBits) { fprintf(f, " \n"); return; } const char *base = (const char *)ll_table; u32 nbits = ll_sub->hashBits; u32 num_entries = 1U << nbits; const auto *tab = (const RoseLongLitHashEntry *)(base + ll_sub->hashOffset); u32 hash_occ = count_if(tab, tab + num_entries, [](const RoseLongLitHashEntry &ent) { return ent.str_offset != 0; }); float hash_occ_percent = ((float)hash_occ / (float)num_entries) * 100; fprintf(f, " hash table : %u bits, occupancy %u/%u (%0.1f%%)\n", nbits, hash_occ, num_entries, hash_occ_percent); u32 bloom_bits = ll_sub->bloomBits; u32 bloom_size = 1U << bloom_bits; const u8 *bloom = (const u8 *)base + ll_sub->bloomOffset; u32 bloom_occ = accumulate(bloom, bloom + bloom_size / 8, 0, [](const u32 &sum, const u8 &elem) { return sum + popcount32(elem); }); float bloom_occ_percent = ((float)bloom_occ / (float)(bloom_size)) * 100; fprintf(f, " bloom filter : %u bits, occupancy %u/%u (%0.1f%%)\n", bloom_bits, bloom_occ, bloom_size, bloom_occ_percent); } static void dumpLongLiteralTable(const RoseEngine *t, FILE *f) { if (!t->longLitTableOffset) { return; } fprintf(f, "\n"); fprintf(f, "Long literal table (streaming):\n"); const auto *ll_table = (const struct RoseLongLitTable *)loadFromByteCodeOffset( t, t->longLitTableOffset); fprintf(f, " total size : %u bytes\n", ll_table->size); fprintf(f, " longest len : %u\n", ll_table->maxLen); fprintf(f, " stream state : %u bytes\n", ll_table->streamStateBytes); fprintf(f, " caseful:\n"); dumpLongLiteralSubtable(ll_table, &ll_table->caseful, f); fprintf(f, " nocase:\n"); dumpLongLiteralSubtable(ll_table, &ll_table->nocase, f); } // Externally accessible functions void roseDumpText(const RoseEngine *t, FILE *f) { if (!t) { fprintf(f, "<< no rose >>\n"); return; } const void *atable = getAnchoredMatcher(t); const HWLM *ftable = getFloatingMatcher(t); const HWLM *etable = getEodMatcher(t); const HWLM *sbtable = getSmallBlockMatcher(t); fprintf(f, "Rose:\n\n"); fprintf(f, "mode: : "); switch(t->mode) { case HS_MODE_BLOCK: fprintf(f, "block"); break; case HS_MODE_STREAM: fprintf(f, "streaming"); break; case HS_MODE_VECTORED: fprintf(f, "vectored"); break; } fprintf(f, "\n"); fprintf(f, "properties :"); if (t->canExhaust) { fprintf(f, " canExhaust"); } if (t->hasSom) { fprintf(f, " hasSom"); } fprintf(f, "\n"); fprintf(f, "dkey count : %u\n", t->dkeyCount); fprintf(f, "som slot count : %u\n", t->somLocationCount); fprintf(f, "som width : %u bytes\n", t->somHorizon); fprintf(f, "rose count : %u\n", t->roseCount); fprintf(f, "\n"); fprintf(f, "total engine size : %u bytes\n", t->size); fprintf(f, " - anchored matcher : %u bytes over %u bytes\n", t->asize, t->anchoredDistance); fprintf(f, " - floating matcher : %zu bytes%s", ftable ? hwlmSize(ftable) : 0, t->noFloatingRoots ? " (cond)":""); if (t->floatingMinDistance) { fprintf(f, " from %s bytes\n", rose_off(t->floatingMinDistance).str().c_str()); } if (t->floatingDistance != ROSE_BOUND_INF && ftable) { fprintf(f, " over %u bytes\n", t->floatingDistance); } else { fprintf(f, "\n"); } fprintf(f, " - eod-anch matcher : %zu bytes over last %u bytes\n", etable ? hwlmSize(etable) : 0, t->ematcherRegionSize); fprintf(f, " - small-blk matcher : %zu bytes over %u bytes\n", sbtable ? hwlmSize(sbtable) : 0, t->smallBlockDistance); fprintf(f, " - role state table : %zu bytes\n", t->rolesWithStateCount * sizeof(u32)); fprintf(f, " - nfa info table : %zu bytes\n", t->queueCount * sizeof(NfaInfo)); fprintf(f, " - lookaround table : %u bytes\n", t->nfaInfoOffset - t->lookaroundTableOffset); fprintf(f, " - lookaround reach : %u bytes\n", t->lookaroundTableOffset - t->lookaroundReachOffset); fprintf(f, "state space required : %u bytes\n", t->stateOffsets.end); fprintf(f, " - history buffer : %u bytes\n", t->historyRequired); fprintf(f, " - exhaustion vector : %u bytes\n", (t->ekeyCount + 7) / 8); fprintf(f, " - role state mmbit : %u bytes\n", t->stateSize); fprintf(f, " - long lit matcher : %u bytes\n", t->longLitStreamState); fprintf(f, " - active array : %u bytes\n", mmbit_size(t->activeArrayCount)); fprintf(f, " - active rose : %u bytes\n", mmbit_size(t->activeLeftCount)); fprintf(f, " - anchored state : %u bytes\n", t->anchorStateSize); fprintf(f, " - nfa state : %u bytes\n", t->nfaStateSize); fprintf(f, " - (trans. nfa state): %u bytes\n", t->tStateSize); fprintf(f, " - one whole bytes : %u bytes\n", t->stateOffsets.anchorState - t->stateOffsets.leftfixLagTable); fprintf(f, " - groups : %u bytes\n", t->stateOffsets.groups_size); fprintf(f, "\n"); fprintf(f, "initial groups : 0x%016llx\n", t->initialGroups); fprintf(f, "floating groups : 0x%016llx\n", t->floating_group_mask); fprintf(f, "handled key count : %u\n", t->handledKeyCount); fprintf(f, "\n"); fprintf(f, "total literal count : %u\n", t->totalNumLiterals); fprintf(f, " prog table size : %u\n", t->literalCount); fprintf(f, " delayed literals : %u\n", t->delay_count); fprintf(f, "\n"); fprintf(f, " minWidth : %u\n", t->minWidth); fprintf(f, " minWidthExcludingBoundaries : %u\n", t->minWidthExcludingBoundaries); fprintf(f, " maxBiAnchoredWidth : %s\n", rose_off(t->maxBiAnchoredWidth).str().c_str()); fprintf(f, " minFloatLitMatchOffset : %s\n", rose_off(t->floatingMinLiteralMatchOffset).str().c_str()); fprintf(f, " delay_base_id : %u\n", t->delay_base_id); fprintf(f, " maxFloatingDelayedMatch : %s\n", rose_off(t->maxFloatingDelayedMatch).str().c_str()); if (atable) { fprintf(f, "\nAnchored literal matcher stats:\n\n"); dumpAnchoredStats(atable, f); } if (ftable) { fprintf(f, "\nFloating literal matcher stats:\n\n"); hwlmPrintStats(ftable, f); } if (etable) { fprintf(f, "\nEOD-anchored literal matcher stats:\n\n"); hwlmPrintStats(etable, f); } if (sbtable) { fprintf(f, "\nSmall-block literal matcher stats:\n\n"); hwlmPrintStats(sbtable, f); } dumpLongLiteralTable(t, f); } #define DUMP_U8(o, member) \ fprintf(f, " %-32s: %hhu/%hhx\n", #member, o->member, o->member) #define DUMP_U32(o, member) \ fprintf(f, " %-32s: %u/%08x\n", #member, o->member, o->member) #define DUMP_U64(o, member) \ fprintf(f, " %-32s: %llu/%016llx\n", #member, o->member, o->member) void roseDumpStructRaw(const RoseEngine *t, FILE *f) { fprintf(f, "struct RoseEngine {\n"); DUMP_U8(t, noFloatingRoots); DUMP_U8(t, requiresEodCheck); DUMP_U8(t, hasOutfixesInSmallBlock); DUMP_U8(t, runtimeImpl); DUMP_U8(t, mpvTriggeredByLeaf); DUMP_U8(t, canExhaust); DUMP_U8(t, hasSom); DUMP_U8(t, somHorizon); DUMP_U8(t, needsCatchup); DUMP_U32(t, mode); DUMP_U32(t, historyRequired); DUMP_U32(t, ekeyCount); DUMP_U32(t, dkeyCount); DUMP_U32(t, dkeyLogSize); DUMP_U32(t, invDkeyOffset); DUMP_U32(t, somLocationCount); DUMP_U32(t, somLocationFatbitSize); DUMP_U32(t, rolesWithStateCount); DUMP_U32(t, stateSize); DUMP_U32(t, anchorStateSize); DUMP_U32(t, nfaStateSize); DUMP_U32(t, tStateSize); DUMP_U32(t, smallWriteOffset); DUMP_U32(t, amatcherOffset); DUMP_U32(t, ematcherOffset); DUMP_U32(t, fmatcherOffset); DUMP_U32(t, sbmatcherOffset); DUMP_U32(t, longLitTableOffset); DUMP_U32(t, amatcherMinWidth); DUMP_U32(t, fmatcherMinWidth); DUMP_U32(t, eodmatcherMinWidth); DUMP_U32(t, amatcherMaxBiAnchoredWidth); DUMP_U32(t, fmatcherMaxBiAnchoredWidth); DUMP_U32(t, litProgramOffset); DUMP_U32(t, litDelayRebuildProgramOffset); DUMP_U32(t, reportProgramOffset); DUMP_U32(t, reportProgramCount); DUMP_U32(t, literalCount); DUMP_U32(t, activeArrayCount); DUMP_U32(t, activeLeftCount); DUMP_U32(t, queueCount); DUMP_U32(t, activeQueueArraySize); DUMP_U32(t, eagerIterOffset); DUMP_U32(t, handledKeyCount); DUMP_U32(t, handledKeyFatbitSize); DUMP_U32(t, leftOffset); DUMP_U32(t, roseCount); DUMP_U32(t, lookaroundTableOffset); DUMP_U32(t, lookaroundReachOffset); DUMP_U32(t, eodProgramOffset); DUMP_U32(t, lastByteHistoryIterOffset); DUMP_U32(t, minWidth); DUMP_U32(t, minWidthExcludingBoundaries); DUMP_U32(t, maxBiAnchoredWidth); DUMP_U32(t, anchoredDistance); DUMP_U32(t, anchoredMinDistance); DUMP_U32(t, floatingDistance); DUMP_U32(t, floatingMinDistance); DUMP_U32(t, smallBlockDistance); DUMP_U32(t, floatingMinLiteralMatchOffset); DUMP_U32(t, nfaInfoOffset); DUMP_U64(t, initialGroups); DUMP_U64(t, floating_group_mask); DUMP_U32(t, size); DUMP_U32(t, delay_count); DUMP_U32(t, delay_fatbit_size); DUMP_U32(t, delay_base_id); DUMP_U32(t, anchored_count); DUMP_U32(t, anchored_fatbit_size); DUMP_U32(t, anchored_base_id); DUMP_U32(t, maxFloatingDelayedMatch); DUMP_U32(t, delayRebuildLength); DUMP_U32(t, stateOffsets.history); DUMP_U32(t, stateOffsets.exhausted); DUMP_U32(t, stateOffsets.activeLeafArray); DUMP_U32(t, stateOffsets.activeLeftArray); DUMP_U32(t, stateOffsets.activeLeftArray_size); DUMP_U32(t, stateOffsets.leftfixLagTable); DUMP_U32(t, stateOffsets.anchorState); DUMP_U32(t, stateOffsets.groups); DUMP_U32(t, stateOffsets.groups_size); DUMP_U32(t, stateOffsets.longLitState); DUMP_U32(t, stateOffsets.somLocation); DUMP_U32(t, stateOffsets.somValid); DUMP_U32(t, stateOffsets.somWritable); DUMP_U32(t, stateOffsets.end); DUMP_U32(t, boundary.reportEodOffset); DUMP_U32(t, boundary.reportZeroOffset); DUMP_U32(t, boundary.reportZeroEodOffset); DUMP_U32(t, totalNumLiterals); DUMP_U32(t, asize); DUMP_U32(t, outfixBeginQueue); DUMP_U32(t, outfixEndQueue); DUMP_U32(t, leftfixBeginQueue); DUMP_U32(t, initMpvNfa); DUMP_U32(t, rosePrefixCount); DUMP_U32(t, activeLeftIterOffset); DUMP_U32(t, ematcherRegionSize); DUMP_U32(t, somRevCount); DUMP_U32(t, somRevOffsetOffset); DUMP_U32(t, longLitStreamState); fprintf(f, "}\n"); fprintf(f, "sizeof(RoseEngine) = %zu\n", sizeof(RoseEngine)); } void roseDumpComponents(const RoseEngine *t, bool dump_raw, const string &base) { dumpComponentInfo(t, base); dumpComponentInfoCsv(t, base); dumpNfas(t, dump_raw, base); dumpAnchored(t, base); dumpRevComponentInfo(t, base); dumpRevNfas(t, dump_raw, base); dumpRoseLitPrograms(t, base + "/rose_lit_programs.txt"); dumpRoseEodPrograms(t, base + "/rose_eod_programs.txt"); dumpRoseReportPrograms(t, base + "/rose_report_programs.txt"); } void roseDumpInternals(const RoseEngine *t, const string &base) { if (!t) { DEBUG_PRINTF("no rose\n"); return; } const void *atable = getAnchoredMatcher(t); const HWLM *ftable = getFloatingMatcher(t); const HWLM *etable = getEodMatcher(t); if (atable) { FILE *f = fopen((base + "/anchored.raw").c_str(), "w"); if (f) { fwrite(atable, 1, t->asize, f); fclose(f); } } if (ftable) { FILE *f = fopen((base + "/floating.raw").c_str(), "w"); if (f) { fwrite(ftable, 1, hwlmSize(ftable), f); fclose(f); } } if (etable) { FILE *f = fopen((base + "/eod.raw").c_str(), "w"); if (f) { fwrite(etable, 1, hwlmSize(etable), f); fclose(f); } } FILE *f = fopen((base + "/rose.raw").c_str(), "w"); assert(f); fwrite(t, 1, roseSize(t), f); fclose(f); f = fopen((base + "/rose_struct.txt").c_str(), "w"); roseDumpStructRaw(t, f); fclose(f); roseDumpComponents(t, true, base); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_add_mask.cpp0000644000175000017500000006134513055426554022525 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_impl.h" #include "ue2common.h" #include "grey.h" #include "rose_build_add_internal.h" #include "rose_build_anchored.h" #include "rose_in_util.h" #include "hwlm/hwlm_literal.h" #include "nfagraph/ng_depth.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_reports.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_width.h" #include "util/charreach.h" #include "util/charreach_util.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph.h" #include "util/make_unique.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include #include #include using namespace std; namespace ue2 { #define MIN_MASK_LIT_LEN 2 #define MAX_MASK_SIZE 255 #define MAX_MASK_LITS 30 static void findMaskLiteral(const vector &mask, bool streaming, ue2_literal *lit, u32 *offset, const Grey &grey) { bool case_fixed = false; bool nocase = false; size_t best_begin = 0; size_t best_end = 0; size_t best_len = 0; size_t begin = 0; size_t end = 0; for (size_t i = 0; i < mask.size(); i++) { bool fail = false; if (mask[i].count() != 1 && !mask[i].isCaselessChar()) { DEBUG_PRINTF("hit non-literal char, resetting at %zu\n", i); fail = true; } if (!fail && streaming && (end >= grey.maxHistoryAvailable + 1)) { DEBUG_PRINTF("hit literal limit, resetting at %zu\n", i); fail = true; } if (!fail && case_fixed && mask[i].isAlpha()) { if (nocase && mask[i].count() != 2) { fail = true; } if (!nocase && mask[i].count() != 1) { fail = true; } } if (fail) { case_fixed = false; nocase = false; size_t len = end - begin; bool better = len > best_len; if (better) { best_begin = begin; best_end = end; best_len = len; } begin = i + 1; end = i + 1; } else { assert(end == i); end = i + 1; if (mask[i].isAlpha()) { case_fixed = true; nocase = mask[i].count() == 2; } } } size_t len = end - begin; /* Everybody would rather be trigger towards the end */ bool better = len >= best_len && mask.size() - end <= MAX_DELAY; if (better) { best_begin = begin; best_end = end; best_len = len; } for (size_t i = best_begin; i < best_end; i++) { assert(mask[i].count() == 1 || mask[i].count() == 2); lit->push_back(mask[i].find_first(), mask[i].count() > 1); } *offset = verify_u32(best_begin); } static bool initFmlCandidates(const CharReach &cr, vector *cand) { for (size_t i = cr.find_first(); i != cr.npos; i = cr.find_next(i)) { char c = (char)i; bool nocase = myisupper(c) && cr.test(mytolower(c)); if (myislower(c) && cr.test(mytoupper(c))) { continue; } if (cand->size() >= MAX_MASK_LITS) { DEBUG_PRINTF("hit lit limit of %u\n", MAX_MASK_LITS); return false; } cand->emplace_back(c, nocase); } assert(cand->size() <= MAX_MASK_LITS); return !cand->empty(); } static bool expandFmlCandidates(const CharReach &cr, vector *cand) { DEBUG_PRINTF("expanding string with cr of %zu\n", cr.count()); DEBUG_PRINTF(" current cand list size %zu\n", cand->size()); vector curr; for (size_t i = cr.find_first(); i != cr.npos; i = cr.find_next(i)) { char c = (char)i; bool nocase = myisupper(c) && cr.test(mytolower(c)); if (myislower(c) && cr.test(mytoupper(c))) { continue; } for (const auto &lit : *cand) { if (curr.size() >= MAX_MASK_LITS) { DEBUG_PRINTF("hit lit limit of %u\n", MAX_MASK_LITS); return false; } curr.emplace_back(c, nocase); curr.back() += lit; } } if (curr.back().length() > MAX_MASK2_WIDTH && any_of(begin(curr), end(curr), mixed_sensitivity)) { DEBUG_PRINTF("mixed-sensitivity lit is too long, stopping\n"); return false; } assert(curr.size() <= MAX_MASK_LITS); cand->swap(curr); return true; } static u32 scoreFmlCandidates(const vector &cand) { if (cand.empty()) { DEBUG_PRINTF("no candidates\n"); return 0; } const u32 len = cand.back().length(); DEBUG_PRINTF("length = %u count %zu\n", len, cand.size()); u32 min_period = len; for (const auto &lit : cand) { u32 period = lit.length() - maxStringSelfOverlap(lit); min_period = min(min_period, period); } DEBUG_PRINTF("min_period %u\n", min_period); u32 length_score = (5 * min_period + len) * (cand.back().any_nocase() ? 90 : 100); u32 count_penalty; if (len > 4) { count_penalty = 9 * len * cand.size(); } else { count_penalty = 5 * cand.size(); } if (length_score <= count_penalty) { return 1; } return length_score - count_penalty; } /* favours later literals */ static bool findMaskLiterals(const vector &mask, vector *lit, u32 *minBound, u32 *length) { *minBound = 0; *length = 0; vector candidates, best_candidates; u32 best_score = 0; u32 best_minOffset = 0; vector::const_iterator it, itb, ite; for (it = itb = mask.begin(), ite = mask.end(); it != ite; ++it) { candidates.clear(); if (!initFmlCandidates(*it, &candidates)) { DEBUG_PRINTF("failed to init\n"); continue; } DEBUG_PRINTF("++\n"); vector::const_iterator jt = it; while (jt != itb) { --jt; DEBUG_PRINTF("--\n"); if (!expandFmlCandidates(*jt, &candidates)) { DEBUG_PRINTF("expansion stopped\n"); break; } } u32 score = scoreFmlCandidates(candidates); DEBUG_PRINTF("scored %u for literal set of size %zu\n", score, candidates.size()); if (!candidates.empty() && score >= best_score) { best_minOffset = it - itb - candidates.back().length() + 1; best_candidates.swap(candidates); best_score = score; } } if (!best_score) { DEBUG_PRINTF("no lits\n"); return false; } *minBound = best_minOffset; *length = best_candidates.back().length(); DEBUG_PRINTF("best minbound %u length %u\n", *minBound, *length); for (const auto &cand : best_candidates) { assert(cand.length() == *length); lit->push_back(cand); } return true; } static unique_ptr buildMaskLhs(bool anchored, u32 prefix_len, const vector &mask) { DEBUG_PRINTF("build %slhs len %u/%zu\n", anchored ? "anc " : "", prefix_len, mask.size()); unique_ptr lhs = ue2::make_unique(NFA_PREFIX); assert(prefix_len); assert(mask.size() >= prefix_len); NFAVertex pred = anchored ? lhs->start : lhs->startDs; u32 m_idx = 0; while (prefix_len--) { NFAVertex v = add_vertex(*lhs); (*lhs)[v].char_reach = mask[m_idx++]; add_edge(pred, v, *lhs); pred = v; } add_edge(pred, lhs->accept, *lhs); (*lhs)[pred].reports.insert(0); return lhs; } static void buildLiteralMask(const vector &mask, vector &msk, vector &cmp, u32 delay) { msk.clear(); cmp.clear(); if (mask.size() <= delay) { return; } // Construct an and/cmp mask from our mask ending at delay positions before // the end of the literal, with max length HWLM_MASKLEN. auto ite = mask.end() - delay; auto it = ite - min(size_t{HWLM_MASKLEN}, mask.size() - delay); for (; it != ite; ++it) { msk.push_back(0); cmp.push_back(0); make_and_cmp_mask(*it, &msk.back(), &cmp.back()); } assert(msk.size() == cmp.size()); assert(msk.size() <= HWLM_MASKLEN); } static bool validateTransientMask(const vector &mask, bool anchored, bool eod, const Grey &grey) { assert(!mask.empty()); // An EOD anchored mask requires that everything fit into history, while an // ordinary floating case can handle one byte more (i.e., max history size // and one byte in the buffer). const size_t max_width = grey.maxHistoryAvailable + (eod ? 0 : 1); if (mask.size() > max_width) { DEBUG_PRINTF("mask too long for max available history\n"); return false; } /* although anchored masks cannot be transient, short masks may be placed * into the atable. */ if (anchored && mask.size() > grey.maxAnchoredRegion) { return false; } vector lits; u32 lit_minBound; /* minBound of each literal in lit */ u32 lit_length; /* length of each literal in lit */ if (!findMaskLiterals(mask, &lits, &lit_minBound, &lit_length)) { DEBUG_PRINTF("failed to find any lits\n"); return false; } if (lits.empty()) { return false; } const u32 delay = mask.size() - lit_length - lit_minBound; if (delay > MAX_DELAY) { DEBUG_PRINTF("delay %u is too much\n", delay); return false; } if (lit_length == 1 && lits.size() > 3) { DEBUG_PRINTF("no decent trigger\n"); return false; } // Mixed-sensitivity literals require benefits masks to implement, and thus // have a maximum length. This has been taken into account in // findMaskLiterals. assert(lit_length <= MAX_MASK2_WIDTH || none_of(begin(lits), end(lits), mixed_sensitivity)); // Build the HWLM literal mask. vector msk, cmp; if (grey.roseHamsterMasks) { buildLiteralMask(mask, msk, cmp, delay); } // We consider the HWLM mask length to run from the first non-zero byte to // the end, and let max(mask length, literal length) be the effective // literal length. // // A one-byte literal with no mask is too short, but a one-byte literal // with a few bytes of mask information is OK. u32 msk_length = distance(find_if(begin(msk), end(msk), [](u8 v) { return v != 0; }), end(msk)); u32 eff_lit_length = max(lit_length, msk_length); DEBUG_PRINTF("msk_length=%u, eff_lit_length = %u\n", msk_length, eff_lit_length); if (eff_lit_length < MIN_MASK_LIT_LEN) { DEBUG_PRINTF("literals too short\n"); return false; } DEBUG_PRINTF("mask is ok\n"); return true; } static bool maskIsNeeded(const ue2_literal &lit, const NGHolder &g) { ue2::flat_set curr = {g.accept}; ue2::flat_set next; for (auto it = lit.rbegin(), ite = lit.rend(); it != ite; ++it) { const CharReach &cr = *it; DEBUG_PRINTF("check %s\n", describeClass(*it).c_str()); next.clear(); for (auto v : curr) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (isSubsetOf(cr, g[u].char_reach)) { next.insert(u); } } } if (next.empty()) { DEBUG_PRINTF("no path to start\n"); return true; } curr.swap(next); } for (auto v : curr) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == g.start || u == g.startDs) { DEBUG_PRINTF("literal spans graph from start to accept\n"); return false; } } } DEBUG_PRINTF("literal doesn't reach start\n"); return true; } static void addTransientMask(RoseBuildImpl &build, const vector &mask, const ue2::flat_set &reports, bool anchored, bool eod) { vector lits; u32 lit_minBound; /* minBound of each literal in lit */ u32 lit_length; /* length of each literal in lit */ if (!findMaskLiterals(mask, &lits, &lit_minBound, &lit_length)) { DEBUG_PRINTF("failed to find any lits\n"); assert(0); return; } DEBUG_PRINTF("%zu literals, minBound=%u, length=%u\n", lits.size(), lit_minBound, lit_length); if (lits.empty()) { assert(0); return; } u32 delay = mask.size() - lit_length - lit_minBound; assert(delay <= MAX_DELAY); DEBUG_PRINTF("delay=%u\n", delay); shared_ptr mask_graph = buildMaskLhs(anchored, mask.size(), mask); u32 mask_lag = 0; /* TODO */ // Everyone gets the same report ID. ReportID mask_report = build.getNewNfaReport(); setReportId(*mask_graph, mask_report); // Build the HWLM literal mask. vector msk, cmp; if (build.cc.grey.roseHamsterMasks) { buildLiteralMask(mask, msk, cmp, delay); } /* adjust bounds to be relative to trigger rather than mask */ const u32 v_min_offset = add_rose_depth(0, mask.size()); const u32 v_max_offset = add_rose_depth(anchored ? 0 : ROSE_BOUND_INF, mask.size()); RoseGraph &g = build.g; // By default, masked literals go into the floating table (except for eod // cases). enum rose_literal_table table = ROSE_FLOATING; RoseVertex eod_v = RoseGraph::null_vertex(); if (eod) { eod_v = add_vertex(g); g[eod_v].eod_accept = true; insert(&g[eod_v].reports, reports); g[eod_v].min_offset = v_min_offset; g[eod_v].max_offset = v_max_offset; // Note: because this is a transient mask, we know that we can match it // completely inside the history buffer. So, using the EOD literal // table is always safe. table = ROSE_EOD_ANCHORED; // Widen the EOD table window to cover the mask. ENSURE_AT_LEAST(&build.ematcher_region_size, mask.size()); } const ue2::flat_set no_reports; for (const auto &lit : lits) { u32 lit_id = build.getLiteralId(lit, msk, cmp, delay, table); const RoseVertex parent = anchored ? build.anchored_root : build.root; bool use_mask = delay || maskIsNeeded(lit, *mask_graph); auto v = createVertex(&build, parent, 0, ROSE_BOUND_INF, lit_id, lit.length(), eod ? no_reports : reports); if (use_mask) { g[v].left.graph = mask_graph; g[v].left.lag = mask_lag; g[v].left.leftfix_report = mask_report; } else { // Make sure our edge bounds are correct. RoseEdge e = edge(parent, v, g); g[e].minBound = 0; g[e].maxBound = anchored ? 0 : ROSE_BOUND_INF; g[e].history = anchored ? ROSE_ROLE_HISTORY_ANCH : ROSE_ROLE_HISTORY_NONE; } // Set offsets correctly. g[v].min_offset = v_min_offset; g[v].max_offset = v_max_offset; if (eod) { RoseEdge e = add_edge(v, eod_v, g); g[e].minBound = 0; g[e].maxBound = 0; g[e].history = ROSE_ROLE_HISTORY_LAST_BYTE; } } } static unique_ptr buildMaskRhs(const ue2::flat_set &reports, const vector &mask, u32 suffix_len) { assert(suffix_len); assert(mask.size() > suffix_len); unique_ptr rhs = ue2::make_unique(NFA_SUFFIX); NGHolder &h = *rhs; NFAVertex succ = h.accept; u32 m_idx = mask.size() - 1; while (suffix_len--) { NFAVertex u = add_vertex(h); if (succ == h.accept) { h[u].reports.insert(reports.begin(), reports.end()); } h[u].char_reach = mask[m_idx--]; add_edge(u, succ, h); succ = u; } NFAEdge e = add_edge(h.start, succ, h); h[e].tops.insert(DEFAULT_TOP); return rhs; } static void doAddMask(RoseBuildImpl &tbi, bool anchored, const vector &mask, const ue2_literal &lit, u32 prefix_len, u32 suffix_len, const ue2::flat_set &reports) { /* Note: bounds are relative to literal start */ RoseInGraph ig; RoseInVertex s = add_vertex(RoseInVertexProps::makeStart(anchored), ig); RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); DEBUG_PRINTF("pref + lit = %u\n", prefix_len); assert(prefix_len >= lit.length()); // prefix len is relative to end of literal. u32 minBound = prefix_len - lit.length(); if (minBound) { if (anchored && prefix_len > tbi.cc.grey.maxAnchoredRegion) { DEBUG_PRINTF("too deep\n"); /* see if there is an anchored literal we can also hang off */ ue2_literal lit2; u32 lit2_offset; vector mask2 = mask; assert(mask2.size() > tbi.cc.grey.maxAnchoredRegion); mask2.resize(MIN(tbi.cc.grey.maxAnchoredRegion, minBound)); findMaskLiteral(mask2, tbi.cc.streaming, &lit2, &lit2_offset, tbi.cc.grey); if (lit2.length() >= MIN_MASK_LIT_LEN) { u32 prefix2_len = lit2_offset + lit2.length(); assert(prefix2_len < minBound); RoseInVertex u = add_vertex(RoseInVertexProps::makeLiteral(lit2), ig); if (lit2_offset){ DEBUG_PRINTF("building lhs (off %u)\n", lit2_offset); shared_ptr lhs2 = buildMaskLhs(true, lit2_offset, mask); add_edge(s, u, RoseInEdgeProps(lhs2, lit2.length()), ig); } else { add_edge(s, u, RoseInEdgeProps(0, 0), ig); } /* midfix */ DEBUG_PRINTF("building mhs\n"); vector mask3(mask.begin() + prefix2_len, mask.end()); u32 overlap = maxOverlap(lit2, lit, 0); u32 delay = lit.length() - overlap; shared_ptr mhs = buildMaskLhs(true, minBound - prefix2_len + overlap, mask3); mhs->kind = NFA_INFIX; setTops(*mhs); add_edge(u, v, RoseInEdgeProps(mhs, delay), ig); DEBUG_PRINTF("add anch literal too!\n"); goto do_rhs; } } shared_ptr lhs = buildMaskLhs(anchored, minBound, mask); add_edge(s, v, RoseInEdgeProps(lhs, lit.length()), ig); } else { u32 maxBound = anchored ? minBound : ROSE_BOUND_INF; add_edge(s, v, RoseInEdgeProps(minBound, maxBound), ig); } do_rhs: if (suffix_len) { shared_ptr rhs = buildMaskRhs(reports, mask, suffix_len); RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(set()), ig); add_edge(v, a, RoseInEdgeProps(rhs, 0), ig); } else { /* Note: masks have no eod connections */ RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(reports), ig); add_edge(v, a, RoseInEdgeProps(0U, 0U), ig); } calcVertexOffsets(ig); bool rv = tbi.addRose(ig, false); assert(rv); /* checkAllowMask should have prevented this */ if (!rv) { throw std::exception(); } } static bool checkAllowMask(const vector &mask, ue2_literal *lit, u32 *prefix_len, u32 *suffix_len, const CompileContext &cc) { assert(!mask.empty()); u32 lit_offset; findMaskLiteral(mask, cc.streaming, lit, &lit_offset, cc.grey); if (lit->length() < MIN_MASK_LIT_LEN && lit->length() != mask.size()) { DEBUG_PRINTF("need more literal - bad mask\n"); return false; } DEBUG_PRINTF("mask lit '%s', len=%zu at offset=%u\n", dumpString(*lit).c_str(), lit->length(), lit_offset); assert(!cc.streaming || lit->length() <= cc.grey.maxHistoryAvailable + 1); /* literal is included in the prefix nfa so that matches from the prefix * can't occur in the history buffer - probably should tweak the NFA API * to allow such matches not to be suppressed */ *prefix_len = lit_offset + lit->length(); *suffix_len = mask.size() - *prefix_len; DEBUG_PRINTF("prefix_len=%u, suffix_len=%u\n", *prefix_len, *suffix_len); /* check if we can backtrack sufficiently */ if (cc.streaming && *prefix_len > cc.grey.maxHistoryAvailable + 1) { DEBUG_PRINTF("too much lag\n"); return false; } if (*suffix_len > MAX_MASK_SIZE || *prefix_len > MAX_MASK_SIZE) { DEBUG_PRINTF("too big\n"); return false; } return true; } bool RoseBuildImpl::add(bool anchored, const vector &mask, const ue2::flat_set &reports) { if (validateTransientMask(mask, anchored, false, cc.grey)) { bool eod = false; addTransientMask(*this, mask, reports, anchored, eod); return true; } ue2_literal lit; u32 prefix_len = 0; u32 suffix_len = 0; if (!checkAllowMask(mask, &lit, &prefix_len, &suffix_len, cc)) { return false; } /* we know that the mask can be handled now, start playing with the rose * graph */ doAddMask(*this, anchored, mask, lit, prefix_len, suffix_len, reports); return true; } bool RoseBuildImpl::validateMask(const vector &mask, UNUSED const ue2::flat_set &reports, bool anchored, bool eod) const { return validateTransientMask(mask, anchored, eod, cc.grey); } static unique_ptr makeAnchoredGraph(const vector &mask, const ue2::flat_set &reports, bool eod) { auto gp = ue2::make_unique(); NGHolder &g = *gp; NFAVertex u = g.start; for (const auto &cr : mask) { NFAVertex v = add_vertex(g); g[v].char_reach = cr; add_edge(u, v, g); u = v; } g[u].reports = reports; add_edge(u, eod ? g.acceptEod : g.accept, g); return gp; } static bool addAnchoredMask(RoseBuildImpl &build, const vector &mask, const ue2::flat_set &reports, bool eod) { if (!build.cc.grey.allowAnchoredAcyclic) { return false; } auto g = makeAnchoredGraph(mask, reports, eod); assert(g); return build.addAnchoredAcyclic(*g); } void RoseBuildImpl::addMask(const vector &mask, const ue2::flat_set &reports, bool anchored, bool eod) { if (anchored && addAnchoredMask(*this, mask, reports, eod)) { DEBUG_PRINTF("added mask as anchored acyclic graph\n"); return; } addTransientMask(*this, mask, reports, anchored, eod); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_misc.cpp0000644000175000017500000011734613055426554021720 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_impl.h" #include "hwlm/hwlm_build.h" #include "nfa/castlecompile.h" #include "nfa/goughcompile.h" #include "nfa/mcclellancompile_util.h" #include "nfa/nfa_api.h" #include "nfa/rdfa.h" #include "nfa/tamaramacompile.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_reports.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_width.h" #include "smallwrite/smallwrite_build.h" #include "util/alloc.h" #include "util/boundary_reports.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/ue2string.h" #include "util/verify_types.h" #include "ue2common.h" #include "grey.h" #include #include using namespace std; using boost::hash_combine; namespace ue2 { // just to get it out of the header RoseBuild::~RoseBuild() { } RoseBuildImpl::RoseBuildImpl(ReportManager &rm_in, SomSlotManager &ssm_in, SmallWriteBuild &smwr_in, const CompileContext &cc_in, const BoundaryReports &boundary_in) : cc(cc_in), root(add_vertex(g)), anchored_root(add_vertex(g)), delay_base_id(MO_INVALID_IDX), hasSom(false), group_end(0), anchored_base_id(MO_INVALID_IDX), ematcher_region_size(0), eod_event_literal_id(MO_INVALID_IDX), max_rose_anchored_floating_overlap(0), rm(rm_in), ssm(ssm_in), smwr(smwr_in), boundary(boundary_in), next_nfa_report(0) { // add root vertices to graph g[root].min_offset = 0; g[root].max_offset = 0; g[anchored_root].min_offset = 0; g[anchored_root].max_offset = 0; } RoseBuildImpl::~RoseBuildImpl() { // empty } bool RoseVertexProps::isBoring(void) const { return !suffix && !left; } bool RoseVertexProps::fixedOffset(void) const { assert(min_offset <= max_offset); /* ensure offsets calculated */ return max_offset == min_offset && max_offset != ROSE_BOUND_INF; } bool RoseBuildImpl::isRootSuccessor(const RoseVertex &v) const { for (auto u : inv_adjacent_vertices_range(v, g)) { if (isAnyStart(u)) { return true; } } return false; } bool RoseBuildImpl::isNonRootSuccessor(const RoseVertex &v) const { for (auto u : inv_adjacent_vertices_range(v, g)) { if (!isAnyStart(u)) { return true; } } return false; } bool hasAnchHistorySucc(const RoseGraph &g, RoseVertex v) { for (const auto &e : out_edges_range(v, g)) { if (g[e].history == ROSE_ROLE_HISTORY_ANCH) { return true; } } return false; } bool hasLastByteHistorySucc(const RoseGraph &g, RoseVertex v) { for (const auto &e : out_edges_range(v, g)) { if (g[e].history == ROSE_ROLE_HISTORY_LAST_BYTE) { return true; } } return false; } static bool isInTable(const RoseBuildImpl &tbi, RoseVertex v, rose_literal_table table) { const auto &lit_ids = tbi.g[v].literals; if (lit_ids.empty()) { return false; // special role with no literals } // All literals for a given vertex will be in the same table, so we need // only inspect the first one. const auto lit_table = tbi.literals.right.at(*lit_ids.begin()).table; #ifndef NDEBUG // Verify that all literals for this vertex are in the same table. for (auto lit_id : lit_ids) { assert(tbi.literals.right.at(lit_id).table == lit_table); } #endif return lit_table == table; } bool RoseBuildImpl::isAnchored(RoseVertex v) const { return isInTable(*this, v, ROSE_ANCHORED); } bool RoseBuildImpl::isFloating(RoseVertex v) const { return isInTable(*this, v, ROSE_FLOATING); } bool RoseBuildImpl::isInETable(RoseVertex v) const { return isInTable(*this, v, ROSE_EOD_ANCHORED); } bool RoseBuildImpl::hasLiteralInTable(RoseVertex v, enum rose_literal_table t) const { return isInTable(*this, v, t); } /* Indicates that the floating table (if it exists) will be only run conditionally based on matches from the anchored table. */ bool RoseBuildImpl::hasNoFloatingRoots() const { for (auto v : adjacent_vertices_range(root, g)) { if (isFloating(v)) { DEBUG_PRINTF("direct floating root %zu\n", g[v].index); return false; } } /* need to check if the anchored_root has any literals which are too deep */ for (auto v : adjacent_vertices_range(anchored_root, g)) { if (isFloating(v)) { DEBUG_PRINTF("indirect floating root %zu\n", g[v].index); return false; } } return true; } size_t RoseBuildImpl::maxLiteralLen(RoseVertex v) const { const auto &lit_ids = g[v].literals; assert(!lit_ids.empty()); size_t maxlen = 0; for (const auto &lit_id : lit_ids) { maxlen = max(maxlen, literals.right.at(lit_id).elength()); } return maxlen; } size_t RoseBuildImpl::minLiteralLen(RoseVertex v) const { const auto &lit_ids = g[v].literals; assert(!lit_ids.empty()); size_t minlen = ROSE_BOUND_INF; for (const auto &lit_id : lit_ids) { minlen = min(minlen, literals.right.at(lit_id).elength()); } return minlen; } // RoseBuild factory unique_ptr makeRoseBuilder(ReportManager &rm, SomSlotManager &ssm, SmallWriteBuild &smwr, const CompileContext &cc, const BoundaryReports &boundary) { return ue2::make_unique(rm, ssm, smwr, cc, boundary); } size_t roseSize(const RoseEngine *t) { assert(t); return t->size; } bool roseIsPureLiteral(const RoseEngine *t) { return t->runtimeImpl == ROSE_RUNTIME_PURE_LITERAL; } // Returns non-zero max overlap len if a suffix of the literal 'a' overlaps // with a prefix of the literal 'b' or 'a' can be contained in 'b'. size_t maxOverlap(const ue2_literal &a, const ue2_literal &b, u32 b_delay) { /* overly conservative if only part of the string is nocase */ bool nocase = a.any_nocase() || b.any_nocase(); DEBUG_PRINTF("max overlap %s %s+%u %d\n", dumpString(a).c_str(), dumpString(b).c_str(), b_delay, (int)nocase); size_t a_len = a.length(); size_t b_len = b.length(); const char *a_end = a.c_str() + a_len; const char *b_end = b.c_str() + b_len; if (b_delay >= a_len) { return b_len + b_delay; } else if (b_delay) { /* a can be a substring of b which overlaps some of the end dots * OR b can be a substring near the end of a */ /* ignore overlap due to the final trailing dot as delayed literals * are delivered before undelayed */ for (u32 j = b_delay - 1; j > 0; j--) { if (b_len + j >= a_len) { if (!cmp(a.c_str(), b_end + j - a_len, a_len - j, nocase)) { return b_len + j; } } else { if (!cmp(a_end - j - b_len, b.c_str(), b_len, nocase)) { return b_len + j; } } } } return maxStringOverlap(a.get_string(), b.get_string(), nocase); } // Returns non-zero max overlap len if a suffix of the literal ID 'a' overlaps // with a prefix of the literal ID 'b' or 'a' can be contained in 'b'. size_t maxOverlap(const rose_literal_id &a, const rose_literal_id &b) { assert(!a.delay); return maxOverlap(a.s, b.s, b.delay); } static const rose_literal_id &getOverlapLiteral(const RoseBuildImpl &tbi, u32 literal_id) { map::const_iterator it = tbi.anchoredLitSuffix.find(literal_id); if (it != tbi.anchoredLitSuffix.end()) { return it->second; } return tbi.literals.right.at(literal_id); } ue2_literal findNonOverlappingTail(const set &lits, const ue2_literal &s) { size_t max_overlap = 0; for (const auto &lit : lits) { size_t overlap = lit != s ? maxStringOverlap(lit, s) : maxStringSelfOverlap(s); max_overlap = max(max_overlap, overlap); } /* find the tail that doesn't overlap */ ue2_literal tail = s.substr(max_overlap); DEBUG_PRINTF("%zu overlap, tail: '%s'\n", max_overlap, dumpString(tail).c_str()); return tail; } size_t RoseBuildImpl::maxLiteralOverlap(RoseVertex u, RoseVertex v) const { size_t overlap = 0; for (auto u_lit_id : g[u].literals) { const rose_literal_id &ul = getOverlapLiteral(*this, u_lit_id); for (auto v_lit_id : g[v].literals) { const rose_literal_id &vl = getOverlapLiteral(*this, v_lit_id); overlap = max(overlap, maxOverlap(ul, vl)); } } return overlap; } void RoseBuildImpl::removeVertices(const vector &dead) { for (auto v : dead) { assert(!isAnyStart(v)); DEBUG_PRINTF("removing vertex %zu\n", g[v].index); for (auto lit_id : g[v].literals) { literal_info[lit_id].vertices.erase(v); } clear_vertex(v, g); remove_vertex(v, g); } renumber_vertices(g); } // Find the maximum bound on the edges to this vertex's successors ignoring // those via infixes. u32 RoseBuildImpl::calcSuccMaxBound(RoseVertex u) const { u32 maxBound = 0; for (const auto &e : out_edges_range(u, g)) { RoseVertex v = target(e, g); if (g[v].left) { continue; } u32 thisBound = g[e].maxBound; if (thisBound == ROSE_BOUND_INF) { return ROSE_BOUND_INF; } if (!g[v].eod_accept) { // Add the length of the longest of our literals. thisBound += maxLiteralLen(v); } maxBound = max(maxBound, thisBound); } assert(maxBound <= ROSE_BOUND_INF); return maxBound; } u32 RoseBuildImpl::getLiteralId(const ue2_literal &s, u32 delay, rose_literal_table table) { DEBUG_PRINTF("getting id for %s\n", dumpString(s).c_str()); assert(table != ROSE_ANCHORED); rose_literal_id key(s, table, delay); u32 numLiterals = verify_u32(literals.left.size()); RoseLiteralMap::iterator it; bool inserted; tie(it, inserted) = literals.insert(RoseLiteralMap::value_type(key, numLiterals)); u32 id = it->right; if (inserted) { literal_info.push_back(rose_literal_info()); assert(literal_info.size() == id + 1); if (delay) { u32 undelayed_id = getLiteralId(s, 0, table); literal_info[id].undelayed_id = undelayed_id; literal_info[undelayed_id].delayed_ids.insert(id); } else { literal_info[id].undelayed_id = id; } } return id; } // Function that operates on a msk/cmp pair and a literal, as used in // hwlmLiteral, and zeroes msk elements that don't add any power to the // literal. void normaliseLiteralMask(const ue2_literal &s_in, vector &msk, vector &cmp) { assert(msk.size() == cmp.size()); assert(msk.size() <= HWLM_MASKLEN); if (msk.empty()) { return; } // Work over a caseless copy if the string contains nocase chars. This will // ensure that we treat masks designed to handle mixed-sensitivity literals // correctly: these will be matched by the literal matcher in caseless // mode, with the mask used to narrow the matches. ue2_literal s(s_in); if (s.any_nocase()) { make_nocase(&s); } ue2_literal::const_reverse_iterator it = s.rbegin(), ite = s.rend(); size_t i = msk.size(); while (i-- != 0 && it != ite) { const CharReach &cr = *it; for (size_t c = cr.find_first(); c != CharReach::npos; c = cr.find_next(c)) { if (((u8)c & msk[i]) != cmp[i]) { goto skip; } } // If we didn't jump out of the loop to skip, then this mask position // doesn't further narrow the set of acceptable literals from those // accepted by s. So we can zero this element. msk[i] = 0; cmp[i] = 0; skip: ++it; } // Wipe out prefix zeroes. while (!msk.empty() && msk[0] == 0) { msk.erase(msk.begin()); cmp.erase(cmp.begin()); } } rose_literal_id::rose_literal_id(const ue2_literal &s_in, const vector &msk_in, const vector &cmp_in, rose_literal_table table_in, u32 delay_in) : s(s_in), msk(msk_in), cmp(cmp_in), table(table_in), delay(delay_in), distinctiveness(0) { assert(msk.size() == cmp.size()); assert(msk.size() <= HWLM_MASKLEN); assert(delay <= MAX_DELAY); normaliseLiteralMask(s, msk, cmp); } u32 RoseBuildImpl::getLiteralId(const ue2_literal &s, const vector &msk, const vector &cmp, u32 delay, rose_literal_table table) { DEBUG_PRINTF("getting id for %s\n", dumpString(s).c_str()); assert(table != ROSE_ANCHORED); rose_literal_id key(s, msk, cmp, table, delay); u32 numLiterals = verify_u32(literals.left.size()); /* ue2_literals are always uppercased if nocase and must have an * alpha char */ RoseLiteralMap::iterator it; bool inserted; tie(it, inserted) = literals.insert( RoseLiteralMap::value_type(key, numLiterals)); u32 id = it->right; if (inserted) { literal_info.push_back(rose_literal_info()); assert(literal_info.size() == id + 1); if (delay) { u32 undelayed_id = getLiteralId(s, msk, cmp, 0, table); literal_info[id].undelayed_id = undelayed_id; literal_info[undelayed_id].delayed_ids.insert(id); } else { literal_info[id].undelayed_id = id; } } return id; } bool RoseBuildImpl::hasLiteral(const ue2_literal &s, rose_literal_table table) const { DEBUG_PRINTF("looking if %s exists\n", dumpString(s).c_str()); assert(table != ROSE_ANCHORED); for (RoseLiteralMap::left_map::const_iterator it = literals.left.lower_bound(rose_literal_id(s, table, 0)); it != literals.left.end(); ++it) { if (it->first.table != table || it->first.s != s) { break; } const rose_literal_info &info = literal_info[it->second]; if (!info.vertices.empty()) { return true; } } DEBUG_PRINTF("(used) literal not found\n"); return false; } u32 RoseBuildImpl::getNewLiteralId() { rose_literal_id key(ue2_literal(), ROSE_ANCHORED, 0); u32 numLiterals = verify_u32(literals.left.size()); key.distinctiveness = numLiterals; RoseLiteralMap::iterator it; bool inserted; tie(it, inserted) = literals.insert(RoseLiteralMap::value_type(key, numLiterals)); u32 id = it->right; assert(inserted); literal_info.push_back(rose_literal_info()); assert(literal_info.size() == id + 1); literal_info[id].undelayed_id = id; return id; } static bool requiresDedupe(const NGHolder &h, const ue2::flat_set &reports, const Grey &grey) { /* TODO: tighten */ NFAVertex seen_vert = NGHolder::null_vertex(); for (auto v : inv_adjacent_vertices_range(h.accept, h)) { if (has_intersection(h[v].reports, reports)) { if (seen_vert != NGHolder::null_vertex()) { return true; } seen_vert = v; } } for (auto v : inv_adjacent_vertices_range(h.acceptEod, h)) { if (has_intersection(h[v].reports, reports)) { if (seen_vert != NGHolder::null_vertex()) { return true; } seen_vert = v; } } if (seen_vert) { /* if the reporting vertex is part of of a terminal repeat, the * construction process may reform the graph splitting it into two * vertices (pos, cyclic) and hence require dedupe */ vector repeats; findRepeats(h, grey.minExtBoundedRepeatSize, &repeats); for (const auto &repeat : repeats) { if (find(repeat.vertices.begin(), repeat.vertices.end(), seen_vert) != repeat.vertices.end()) { return true; } } } return false; } class RoseDedupeAuxImpl : public RoseDedupeAux { public: explicit RoseDedupeAuxImpl(const RoseBuildImpl &tbi_in); bool requiresDedupeSupport( const ue2::flat_set &reports) const override; private: bool hasSafeMultiReports(const ue2::flat_set &reports) const; const RoseBuildImpl &tbi; map> vert_map; //!< ordinary literals map> sb_vert_map; //!< small block literals map> suffix_map; map> outfix_map; map> puff_map; }; unique_ptr RoseBuildImpl::generateDedupeAux() const { return ue2::make_unique(*this); } RoseDedupeAux::~RoseDedupeAux() { } RoseDedupeAuxImpl::RoseDedupeAuxImpl(const RoseBuildImpl &tbi_in) : tbi(tbi_in) { const RoseGraph &g = tbi.g; set suffixes; for (auto v : vertices_range(g)) { // Literals in the small block table are "shadow" copies of literals in // the other tables that do not run in the same runtime invocation. // Dedupe key assignment will be taken care of by the real literals. if (tbi.hasLiteralInTable(v, ROSE_ANCHORED_SMALL_BLOCK)) { for (const auto &report_id : g[v].reports) { sb_vert_map[report_id].insert(v); } } else { for (const auto &report_id : g[v].reports) { vert_map[report_id].insert(v); } } // Several vertices may share a suffix, so we collect the set of // suffixes first to avoid repeating work. if (g[v].suffix) { suffixes.insert(g[v].suffix); } } for (const auto &suffix : suffixes) { for (const auto &report_id : all_reports(suffix)) { suffix_map[report_id].insert(suffix); } } for (const auto &outfix : tbi.outfixes) { for (const auto &report_id : all_reports(outfix)) { outfix_map[report_id].insert(&outfix); } } if (tbi.mpv_outfix) { auto *mpv = tbi.mpv_outfix->mpv(); for (const auto &puff : mpv->puffettes) { puff_map[puff.report].insert(&puff); } for (const auto &puff : mpv->triggered_puffettes) { puff_map[puff.report].insert(&puff); } } } static vector makePath(const rose_literal_id &lit) { vector path(begin(lit.s), end(lit.s)); for (u32 i = 0; i < lit.delay; i++) { path.push_back(CharReach::dot()); } return path; } /** * \brief True if one of the given literals overlaps with the suffix of * another, meaning that they could arrive at the same offset. */ static bool literalsCouldRace(const rose_literal_id &lit1, const rose_literal_id &lit2) { DEBUG_PRINTF("compare %s (delay %u) and %s (delay %u)\n", dumpString(lit1.s).c_str(), lit1.delay, dumpString(lit2.s).c_str(), lit2.delay); // Add dots on the end of each literal for delay. const auto v1 = makePath(lit1); const auto v2 = makePath(lit2); // See if the smaller path is a suffix of the larger path. const auto *smaller = v1.size() < v2.size() ? &v1 : &v2; const auto *bigger = v1.size() < v2.size() ? &v2 : &v1; auto r = mismatch(smaller->rbegin(), smaller->rend(), bigger->rbegin(), overlaps); return r.first == smaller->rend(); } bool RoseDedupeAuxImpl::hasSafeMultiReports( const flat_set &reports) const { if (reports.size() <= 1) { return true; } /* We have more than one ReportID corresponding to the external ID that is * presented to the user. These may differ in offset adjustment, bounds * checks, etc. */ /* TODO: work out if these differences will actually cause problems */ /* One common case where we know we don't have a problem is if there are * precisely two reports, one for the main Rose path and one for the * "small block matcher" path. */ if (reports.size() == 2) { ReportID id1 = *reports.begin(); ReportID id2 = *reports.rbegin(); bool has_verts_1 = contains(vert_map, id1); bool has_verts_2 = contains(vert_map, id2); bool has_sb_verts_1 = contains(sb_vert_map, id1); bool has_sb_verts_2 = contains(sb_vert_map, id2); if (has_verts_1 != has_verts_2 && has_sb_verts_1 != has_sb_verts_2) { DEBUG_PRINTF("two reports, one full and one small block: ok\n"); return true; } } DEBUG_PRINTF("more than one report\n"); return false; } bool RoseDedupeAuxImpl::requiresDedupeSupport( const ue2::flat_set &reports) const { /* TODO: this could be expanded to check for offset or character constraints */ DEBUG_PRINTF("reports: %s\n", as_string_list(reports).c_str()); const RoseGraph &g = tbi.g; bool has_suffix = false; bool has_outfix = false; if (!hasSafeMultiReports(reports)) { DEBUG_PRINTF("multiple reports not safe\n"); return true; } set roles; set suffixes; set outfixes; set puffettes; for (ReportID r : reports) { if (contains(vert_map, r)) { insert(&roles, vert_map.at(r)); } if (contains(suffix_map, r)) { insert(&suffixes, suffix_map.at(r)); } if (contains(outfix_map, r)) { insert(&outfixes, outfix_map.at(r)); } if (contains(puff_map, r)) { insert(&puffettes, puff_map.at(r)); } } /* roles */ map lits; // Literal ID -> count of occurrences. const bool has_role = !roles.empty(); for (auto v : roles) { for (const auto &lit : g[v].literals) { lits[lit]++; } if (g[v].eod_accept) { // Literals plugged into this EOD accept must be taken into account // as well. for (auto u : inv_adjacent_vertices_range(v, g)) { for (const auto &lit : g[u].literals) { lits[lit]++; } } } } /* literals */ for (const auto &m : lits) { if (m.second > 1) { DEBUG_PRINTF("lit %u used by >1 reporting roles\n", m.first); return true; } } for (auto it = begin(lits); it != end(lits); ++it) { const auto &lit1 = tbi.literals.right.at(it->first); for (auto jt = next(it); jt != end(lits); ++jt) { const auto &lit2 = tbi.literals.right.at(jt->first); if (literalsCouldRace(lit1, lit2)) { DEBUG_PRINTF("literals could race\n"); return true; } } } /* suffixes */ for (const auto &suffix : suffixes) { if (has_suffix || has_role) { return true; /* scope for badness */ } has_suffix = true; /* some lesser suffix engines (nfas, haig, castle) can raise multiple * matches for a report id at the same offset if there are multiple * report states live. */ if (suffix.haig()) { return true; } if (suffix.graph() && requiresDedupe(*suffix.graph(), reports, tbi.cc.grey)) { return true; } if (suffix.castle() && requiresDedupe(*suffix.castle(), reports)) { return true; } } /* outfixes */ for (const auto &outfix_ptr : outfixes) { assert(outfix_ptr); const OutfixInfo &out = *outfix_ptr; if (has_outfix || has_role || has_suffix) { return true; } has_outfix = true; if (out.haig()) { return true; /* haig may report matches with different SOM at the same offset */ } if (out.holder() && requiresDedupe(*out.holder(), reports, tbi.cc.grey)) { return true; } } /* mpv */ for (UNUSED const auto &puff : puffettes) { if (has_outfix || has_role || has_suffix) { return true; } has_outfix = true; } /* boundary */ if (has_intersection(tbi.boundary.report_at_eod, reports)) { if (has_outfix || has_role || has_suffix) { return true; } } return false; } // Sets the report ID for all vertices connected to an accept to `id`. void setReportId(NGHolder &g, ReportID id) { // First, wipe the report IDs on all vertices. for (auto v : vertices_range(g)) { g[v].reports.clear(); } // Any predecessors of accept get our id. for (auto v : inv_adjacent_vertices_range(g.accept, g)) { g[v].reports.insert(id); } // Same for preds of acceptEod, except accept itself. for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (v == g.accept) { continue; } g[v].reports.insert(id); } } bool operator<(const RoseEdgeProps &a, const RoseEdgeProps &b) { ORDER_CHECK(minBound); ORDER_CHECK(maxBound); ORDER_CHECK(history); return false; } // Note: only clones the vertex, you'll have to wire up your own edges. RoseVertex RoseBuildImpl::cloneVertex(RoseVertex v) { RoseVertex v2 = add_vertex(g[v], g); for (const auto &lit_id : g[v2].literals) { literal_info[lit_id].vertices.insert(v2); } return v2; } #ifndef NDEBUG bool roseHasTops(const RoseBuildImpl &build, RoseVertex v) { const RoseGraph &g = build.g; assert(g[v].left); set graph_tops; if (!build.isRootSuccessor(v)) { for (const auto &e : in_edges_range(v, g)) { graph_tops.insert(g[e].rose_top); } } return is_subset_of(graph_tops, all_tops(g[v].left)); } #endif u32 OutfixInfo::get_queue(QueueIndexFactory &qif) { if (queue == ~0U) { queue = qif.get_queue(); } return queue; } namespace { class OutfixAllReports : public boost::static_visitor> { public: set operator()(const boost::blank &) const { return set(); } template set operator()(const unique_ptr &x) const { return all_reports(*x); } set operator()(const MpvProto &mpv) const { set reports; for (const auto &puff : mpv.puffettes) { reports.insert(puff.report); } for (const auto &puff : mpv.triggered_puffettes) { reports.insert(puff.report); } return reports; } }; } set all_reports(const OutfixInfo &outfix) { auto reports = boost::apply_visitor(OutfixAllReports(), outfix.proto); assert(!reports.empty()); return reports; } bool RoseSuffixInfo::operator==(const RoseSuffixInfo &b) const { return top == b.top && graph == b.graph && castle == b.castle && rdfa == b.rdfa && haig == b.haig && tamarama == b.tamarama; } bool RoseSuffixInfo::operator<(const RoseSuffixInfo &b) const { const RoseSuffixInfo &a = *this; ORDER_CHECK(top); ORDER_CHECK(graph); ORDER_CHECK(castle); ORDER_CHECK(haig); ORDER_CHECK(rdfa); ORDER_CHECK(tamarama); assert(a.dfa_min_width == b.dfa_min_width); assert(a.dfa_max_width == b.dfa_max_width); return false; } void RoseSuffixInfo::reset(void) { top = 0; graph.reset(); castle.reset(); rdfa.reset(); haig.reset(); tamarama.reset(); dfa_min_width = 0; dfa_max_width = depth::infinity(); } std::set all_reports(const suffix_id &s) { assert(s.graph() || s.castle() || s.haig() || s.dfa()); if (s.tamarama()) { return all_reports(*s.tamarama()); } else if (s.graph()) { return all_reports(*s.graph()); } else if (s.castle()) { return all_reports(*s.castle()); } else if (s.dfa()) { return all_reports(*s.dfa()); } else { return all_reports(*s.haig()); } } depth findMinWidth(const suffix_id &s) { assert(s.graph() || s.castle() || s.haig() || s.dfa()); if (s.graph()) { return findMinWidth(*s.graph()); } else if (s.castle()) { return findMinWidth(*s.castle()); } else { return s.dfa_min_width; } } depth findMinWidth(const suffix_id &s, u32 top) { assert(s.graph() || s.castle() || s.haig() || s.dfa()); if (s.graph()) { return findMinWidth(*s.graph(), top); } else if (s.castle()) { return findMinWidth(*s.castle(), top); } else { return s.dfa_min_width; } } depth findMaxWidth(const suffix_id &s) { assert(s.graph() || s.castle() || s.haig() || s.dfa()); if (s.graph()) { return findMaxWidth(*s.graph()); } else if (s.castle()) { return findMaxWidth(*s.castle()); } else { return s.dfa_max_width; } } depth findMaxWidth(const suffix_id &s, u32 top) { assert(s.graph() || s.castle() || s.haig() || s.dfa()); if (s.graph()) { return findMaxWidth(*s.graph(), top); } else if (s.castle()) { return findMaxWidth(*s.castle(), top); } else { return s.dfa_max_width; } } bool has_eod_accepts(const suffix_id &s) { assert(s.graph() || s.castle() || s.haig() || s.dfa()); if (s.graph()) { /* ignore accept -> eod edge */ return in_degree(s.graph()->acceptEod, *s.graph()) > 1; } else if (s.castle()) { return false; } else if (s.dfa()) { return has_eod_accepts(*s.dfa()); } else { return has_eod_accepts(*s.haig()); } } bool has_non_eod_accepts(const suffix_id &s) { assert(s.graph() || s.castle() || s.haig() || s.dfa()); if (s.graph()) { return in_degree(s.graph()->accept, *s.graph()); } else if (s.castle()) { return true; } else if (s.dfa()) { return has_non_eod_accepts(*s.dfa()); } else { return has_non_eod_accepts(*s.haig()); } } set all_tops(const suffix_id &s) { assert(s.graph() || s.castle() || s.haig() || s.dfa()); if (s.graph()) { flat_set tops = getTops(*s.graph()); assert(!tops.empty()); return {tops.begin(), tops.end()}; } if (s.castle()) { return assoc_keys(s.castle()->repeats); } // Other types of suffix are not multi-top. return {0}; } size_t suffix_id::hash() const { size_t val = 0; hash_combine(val, g); hash_combine(val, c); hash_combine(val, d); hash_combine(val, h); return val; } size_t hash_value(const suffix_id &s) { return s.hash(); } bool isAnchored(const left_id &r) { assert(r.graph() || r.castle() || r.haig() || r.dfa()); if (r.graph()) { return isAnchored(*r.graph()); } // All other types are explicitly anchored. return true; } depth findMinWidth(const left_id &r) { assert(r.graph() || r.castle() || r.haig() || r.dfa()); if (r.graph()) { return findMinWidth(*r.graph()); } else if (r.castle()) { return findMinWidth(*r.castle()); } else { return r.dfa_min_width; } } depth findMaxWidth(const left_id &r) { assert(r.graph() || r.castle() || r.haig() || r.dfa()); if (r.graph()) { return findMaxWidth(*r.graph()); } else if (r.castle()) { return findMaxWidth(*r.castle()); } else { return r.dfa_max_width; } } set all_tops(const left_id &r) { assert(r.graph() || r.castle() || r.haig() || r.dfa()); if (r.graph()) { flat_set tops = getTops(*r.graph()); return {tops.begin(), tops.end()}; } if (r.castle()) { return assoc_keys(r.castle()->repeats); } // Other types of rose are not multi-top. return {0}; } u32 num_tops(const left_id &r) { return all_tops(r).size(); } size_t left_id::hash() const { size_t val = 0; hash_combine(val, g); hash_combine(val, c); hash_combine(val, d); hash_combine(val, h); return val; } size_t hash_value(const left_id &r) { return r.hash(); } u64a findMaxOffset(const set &reports, const ReportManager &rm) { assert(!reports.empty()); u64a maxOffset = 0; for (const auto &report_id : reports) { const Report &ir = rm.getReport(report_id); if (ir.hasBounds()) { maxOffset = max(maxOffset, ir.maxOffset); } else { return MAX_OFFSET; } } return maxOffset; } void LeftEngInfo::reset(void) { graph.reset(); castle.reset(); dfa.reset(); haig.reset(); tamarama.reset(); lag = 0; leftfix_report = MO_INVALID_IDX; dfa_min_width = 0; dfa_max_width = depth::infinity(); } LeftEngInfo::operator bool() const { assert((int)!!castle + (int)!!dfa + (int)!!haig <= 1); assert(!castle || !graph); assert(!dfa || graph); /* dfas always have the graph as well */ assert(!haig || graph); return graph || castle || dfa || haig; } u32 roseQuality(const RoseEngine *t) { /* Rose is low quality if the atable is a Mcclellan 16 or has multiple DFAs */ const anchored_matcher_info *atable = getALiteralMatcher(t); if (atable) { if (atable->next_offset) { DEBUG_PRINTF("multiple atable engines\n"); return 0; } const NFA *nfa = (const NFA *)((const char *)atable + sizeof(*atable)); if (!isSmallDfaType(nfa->type)) { DEBUG_PRINTF("m16 atable engine\n"); return 0; } } /* if we always run multiple engines then we are slow */ u32 always_run = 0; if (atable) { always_run++; } if (t->eagerIterOffset) { /* eager prefixes are always run */ always_run++; } const HWLM *ftable = getFLiteralMatcher(t); if (ftable) { /* TODO: ignore conditional ftables, or ftables beyond smwr region */ always_run++; } if (t->ematcherOffset) { always_run++; } /* ignore mpv outfixes as they are v good, mpv outfixes are before begin */ if (t->outfixBeginQueue != t->outfixEndQueue) { /* TODO: ignore outfixes > smwr region */ always_run++; } bool eod_prefix = false; const LeftNfaInfo *left = getLeftTable(t); for (u32 i = 0; i < t->activeLeftCount; i++) { if (left->eod_check) { eod_prefix = true; break; } } if (eod_prefix) { always_run++; DEBUG_PRINTF("eod prefixes are slow"); return 0; } if (always_run > 1) { DEBUG_PRINTF("we always run %u engines\n", always_run); return 0; } return 1; } #ifndef NDEBUG /** \brief Returns true if all the graphs (NFA, DFA, Haig, etc) in this Rose * graph are implementable. */ bool canImplementGraphs(const RoseBuildImpl &tbi) { const RoseGraph &g = tbi.g; // First, check the Rose leftfixes. for (auto v : vertices_range(g)) { DEBUG_PRINTF("leftfix: check vertex %zu\n", g[v].index); if (g[v].left.castle) { DEBUG_PRINTF("castle ok\n"); continue; } if (g[v].left.dfa) { DEBUG_PRINTF("dfa ok\n"); continue; } if (g[v].left.haig) { DEBUG_PRINTF("haig ok\n"); continue; } if (g[v].left.graph) { assert(g[v].left.graph->kind == (tbi.isRootSuccessor(v) ? NFA_PREFIX : NFA_INFIX)); if (!isImplementableNFA(*g[v].left.graph, nullptr, tbi.cc)) { DEBUG_PRINTF("nfa prefix %zu failed (%zu vertices)\n", g[v].index, num_vertices(*g[v].left.graph)); return false; } } } // Suffix graphs. for (auto v : vertices_range(g)) { DEBUG_PRINTF("suffix: check vertex %zu\n", g[v].index); const RoseSuffixInfo &suffix = g[v].suffix; if (suffix.castle) { DEBUG_PRINTF("castle suffix ok\n"); continue; } if (suffix.rdfa) { DEBUG_PRINTF("dfa suffix ok\n"); continue; } if (suffix.haig) { DEBUG_PRINTF("haig suffix ok\n"); continue; } if (suffix.graph) { assert(suffix.graph->kind == NFA_SUFFIX); if (!isImplementableNFA(*suffix.graph, &tbi.rm, tbi.cc)) { DEBUG_PRINTF("nfa suffix %zu failed (%zu vertices)\n", g[v].index, num_vertices(*suffix.graph)); return false; } } } return true; } bool hasOrphanedTops(const RoseBuildImpl &build) { const RoseGraph &g = build.g; ue2::unordered_map > roses; ue2::unordered_map > suffixes; for (auto v : vertices_range(g)) { if (g[v].left) { set &tops = roses[g[v].left]; if (!build.isRootSuccessor(v)) { // Tops for infixes come from the in-edges. for (const auto &e : in_edges_range(v, g)) { tops.insert(g[e].rose_top); } } } if (g[v].suffix) { suffixes[g[v].suffix].insert(g[v].suffix.top); } } for (const auto &e : roses) { if (all_tops(e.first) != e.second) { DEBUG_PRINTF("rose tops (%s) don't match rose graph (%s)\n", as_string_list(all_tops(e.first)).c_str(), as_string_list(e.second).c_str()); return true; } } for (const auto &e : suffixes) { if (all_tops(e.first) != e.second) { DEBUG_PRINTF("suffix tops (%s) don't match rose graph (%s)\n", as_string_list(all_tops(e.first)).c_str(), as_string_list(e.second).c_str()); return true; } } return false; } #endif // NDEBUG } // namespace ue2 hyperscan-4.4.1/src/rose/catchup.h0000644000175000017500000001623313055426554017643 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** * \file * \brief Rose runtime: code for catching up output-exposed engines. * * Rose has several components which run behind the main (floating table) clock * and need to be caught up before we report matches. * * Currently we have to deal with: * 1. Suffix/Outfix NFAs * 2. A single MPV NFA (chained), which may also be triggered by (1). * * The approach is to: * - (A) build a priority queue of the suffix/outfixes based on their first * match location; * - (B) process the matches from the priority queue in order; * - (C) As we report matches from (B) we interleave matches from the MPV if it * exists. */ #ifndef ROSE_CATCHUP_H #define ROSE_CATCHUP_H #include "hwlm/hwlm.h" #include "runtime.h" #include "scratch.h" #include "rose_common.h" #include "rose_internal.h" #include "ue2common.h" #include "util/multibit.h" hwlmcb_rv_t roseCatchUpAll(s64a loc, struct hs_scratch *scratch); /* will only catch mpv up to last reported external match */ hwlmcb_rv_t roseCatchUpSuf(s64a loc, struct hs_scratch *scratch); hwlmcb_rv_t roseCatchUpMPV_i(const struct RoseEngine *t, s64a loc, struct hs_scratch *scratch); void blockInitSufPQ(const struct RoseEngine *t, char *state, struct hs_scratch *scratch, char is_small_block); void streamInitSufPQ(const struct RoseEngine *t, char *state, struct hs_scratch *scratch); static really_inline int canSkipCatchUpMPV(const struct RoseEngine *t, struct hs_scratch *scratch, u64a cur_offset) { if (!has_chained_nfas(t)) { return 1; } /* note: we may have to run at less than tctxt.minMatchOffset as we may * have a full queue of postponed events that we need to flush */ if (cur_offset < scratch->tctxt.next_mpv_offset) { DEBUG_PRINTF("skipping cur_offset %llu min %llu, mpv %llu\n", cur_offset, scratch->tctxt.minMatchOffset, scratch->tctxt.next_mpv_offset); return 1; } assert(t->activeArrayCount); DEBUG_PRINTF("cur offset offset: %llu\n", cur_offset); DEBUG_PRINTF("min match offset %llu\n", scratch->tctxt.minMatchOffset); assert(t->outfixBeginQueue == 1); /* if it exists mpv is queue 0 */ const u8 *aa = getActiveLeafArray(t, scratch->core_info.state); return !mmbit_isset(aa, t->activeArrayCount, 0); } /** \brief Catches up the MPV. */ static really_inline hwlmcb_rv_t roseCatchUpMPV(const struct RoseEngine *t, s64a loc, struct hs_scratch *scratch) { u64a cur_offset = loc + scratch->core_info.buf_offset; assert(cur_offset >= scratch->tctxt.minMatchOffset); assert(!can_stop_matching(scratch)); if (canSkipCatchUpMPV(t, scratch, cur_offset)) { updateMinMatchOffsetFromMpv(&scratch->tctxt, cur_offset); return HWLM_CONTINUE_MATCHING; } /* Note: chained tails MUST not participate in the priority queue as * they may have events pushed on during this process which may be before * the catch up point */ return roseCatchUpMPV_i(t, loc, scratch); } /** \brief Catches up NFAs and the MPV. */ static rose_inline hwlmcb_rv_t roseCatchUpTo(const struct RoseEngine *t, struct hs_scratch *scratch, u64a end) { /* no need to catch up if we are at the same offset as last time */ if (end <= scratch->tctxt.minMatchOffset) { /* we must already be up to date */ DEBUG_PRINTF("skip\n"); return HWLM_CONTINUE_MATCHING; } char *state = scratch->core_info.state; s64a loc = end - scratch->core_info.buf_offset; if (end <= scratch->tctxt.minNonMpvMatchOffset) { /* only need to catch up the mpv */ return roseCatchUpMPV(t, loc, scratch); } assert(scratch->tctxt.minMatchOffset >= scratch->core_info.buf_offset); hwlmcb_rv_t rv; if (!t->activeArrayCount || !mmbit_any(getActiveLeafArray(t, state), t->activeArrayCount)) { updateMinMatchOffset(&scratch->tctxt, end); rv = HWLM_CONTINUE_MATCHING; } else { rv = roseCatchUpAll(loc, scratch); } assert(rv != HWLM_CONTINUE_MATCHING || scratch->tctxt.minMatchOffset == end); assert(rv != HWLM_CONTINUE_MATCHING || scratch->tctxt.minNonMpvMatchOffset == end); assert(!can_stop_matching(scratch) || rv == HWLM_TERMINATE_MATCHING); return rv; } /** * \brief Catches up anything which may add triggers on the MPV (suffixes and * outfixes). * * The MPV will be run only to intersperse matches in the output match stream * if external matches are raised. */ static rose_inline hwlmcb_rv_t roseCatchUpMpvFeeders(const struct RoseEngine *t, struct hs_scratch *scratch, u64a end) { /* no need to catch up if we are at the same offset as last time */ if (end <= scratch->tctxt.minNonMpvMatchOffset) { /* we must already be up to date */ DEBUG_PRINTF("skip\n"); return HWLM_CONTINUE_MATCHING; } s64a loc = end - scratch->core_info.buf_offset; assert(t->activeArrayCount); /* mpv is in active array */ assert(scratch->tctxt.minMatchOffset >= scratch->core_info.buf_offset); if (!t->mpvTriggeredByLeaf) { /* no need to check as they never put triggers onto the mpv */ return HWLM_CONTINUE_MATCHING; } /* sadly, this branch rarely gets taken as the mpv itself is usually * alive. */ char *state = scratch->core_info.state; if (!mmbit_any(getActiveLeafArray(t, state), t->activeArrayCount)) { scratch->tctxt.minNonMpvMatchOffset = end; return HWLM_CONTINUE_MATCHING; } return roseCatchUpSuf(loc, scratch); } #endif hyperscan-4.4.1/src/rose/rose_build_program.h0000644000175000017500000020547313055426554022100 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 ROSE_BUILD_PROGRAM_H #define ROSE_BUILD_PROGRAM_H #include "rose_build_impl.h" #include "rose_program.h" #include "som/som_operation.h" #include "util/alloc.h" #include "util/container.h" #include "util/hash.h" #include "util/make_unique.h" #include "util/ue2_containers.h" #include "util/ue2string.h" #include #include #include #include #include namespace ue2 { class RoseEngineBlob; /** * \brief Abstract base class representing a single Rose instruction. */ class RoseInstruction { public: virtual ~RoseInstruction(); /** \brief Opcode used for the instruction in the bytecode. */ virtual RoseInstructionCode code() const = 0; /** * \brief Simple hash used for program equivalence. * * Note that pointers (jumps, for example) should not be used when * calculating the hash: they will be converted to instruction offsets when * compared later. */ virtual size_t hash() const = 0; /** \brief Length of the bytecode instruction in bytes. */ virtual size_t byte_length() const = 0; using OffsetMap = unordered_map; /** * \brief Writes a concrete implementation of this instruction. * * Other data that this instruction depends on is written directly into the * blob, while the instruction structure itself (of size given by * the byte_length() function) is written to dest. */ virtual void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const = 0; /** * \brief Update a target pointer. * * If this instruction contains any reference to the old target, replace it * with the new one. */ virtual void update_target(const RoseInstruction *old_target, const RoseInstruction *new_target) = 0; /** * \brief True if these instructions are equivalent within their own * programs. * * Checks that any pointers to other instructions point to the same * offsets. */ bool equiv(const RoseInstruction &other, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return equiv_impl(other, offsets, other_offsets); } private: virtual bool equiv_impl(const RoseInstruction &other, const OffsetMap &offsets, const OffsetMap &other_offsets) const = 0; }; /** * \brief Templated implementation class to handle boring boilerplate code. */ template class RoseInstrBase : public RoseInstruction { protected: static constexpr RoseInstructionCode opcode = Opcode; using impl_type = ImplType; public: RoseInstructionCode code() const override { return opcode; } size_t byte_length() const override { return sizeof(impl_type); } /** * Note: this implementation simply zeroes the destination region and * writes in the correct opcode. This is sufficient for trivial * instructions, but instructions with data members will want to override * it. */ void write(void *dest, RoseEngineBlob &, const RoseInstruction::OffsetMap &) const override { assert(dest != nullptr); assert(ISALIGNED_N(dest, ROSE_INSTR_MIN_ALIGN)); impl_type *inst = static_cast(dest); memset(inst, 0, sizeof(impl_type)); inst->code = verify_u8(opcode); } private: bool equiv_impl(const RoseInstruction &other, const OffsetMap &offsets, const OffsetMap &other_offsets) const override { const auto *ri_that = dynamic_cast(&other); if (!ri_that) { return false; } const auto *ri_this = dynamic_cast(this); assert(ri_this); return ri_this->equiv_to(*ri_that, offsets, other_offsets); } }; /** * \brief Refinement of RoseInstrBase to use for instructions that have * just a single target member, called "target". */ template class RoseInstrBaseOneTarget : public RoseInstrBase { public: void update_target(const RoseInstruction *old_target, const RoseInstruction *new_target) override { RoseInstrType *ri = dynamic_cast(this); assert(ri); if (ri->target == old_target) { ri->target = new_target; } } }; /** * \brief Refinement of RoseInstrBase to use for instructions that have no * targets. */ template class RoseInstrBaseNoTargets : public RoseInstrBase { public: void update_target(const RoseInstruction *, const RoseInstruction *) override {} }; /** * \brief Refinement of RoseInstrBaseNoTargets to use for instructions that * have no members at all, just an opcode. */ template class RoseInstrBaseTrivial : public RoseInstrBaseNoTargets { public: virtual bool operator==(const RoseInstrType &) const { return true; } size_t hash() const override { return boost::hash_value(static_cast(Opcode)); } bool equiv_to(const RoseInstrType &, const RoseInstruction::OffsetMap &, const RoseInstruction::OffsetMap &) const { return true; } }; //// //// Concrete implementation classes start here. //// class RoseInstrAnchoredDelay : public RoseInstrBaseOneTarget { public: rose_group groups; const RoseInstruction *target; RoseInstrAnchoredDelay(rose_group groups_in, const RoseInstruction *target_in) : groups(groups_in), target(target_in) {} bool operator==(const RoseInstrAnchoredDelay &ri) const { return groups == ri.groups && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), groups); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrAnchoredDelay &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return groups == ri.groups && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckLitEarly : public RoseInstrBaseNoTargets { public: u32 min_offset; explicit RoseInstrCheckLitEarly(u32 min) : min_offset(min) {} bool operator==(const RoseInstrCheckLitEarly &ri) const { return min_offset == ri.min_offset; } size_t hash() const override { return hash_all(static_cast(opcode), min_offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckLitEarly &ri, const OffsetMap &, const OffsetMap &) const { return min_offset == ri.min_offset; } }; class RoseInstrCheckGroups : public RoseInstrBaseNoTargets { public: rose_group groups; explicit RoseInstrCheckGroups(rose_group groups_in) : groups(groups_in) {} bool operator==(const RoseInstrCheckGroups &ri) const { return groups == ri.groups; } size_t hash() const override { return hash_all(static_cast(opcode), groups); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckGroups &ri, const OffsetMap &, const OffsetMap &) const { return groups == ri.groups; } }; class RoseInstrCheckOnlyEod : public RoseInstrBaseOneTarget { public: const RoseInstruction *target; explicit RoseInstrCheckOnlyEod(const RoseInstruction *target_in) : target(target_in) {} bool operator==(const RoseInstrCheckOnlyEod &ri) const { return target == ri.target; } size_t hash() const override { return boost::hash_value(static_cast(opcode)); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckOnlyEod &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckBounds : public RoseInstrBaseOneTarget { public: u64a min_bound; u64a max_bound; const RoseInstruction *target; RoseInstrCheckBounds(u64a min, u64a max, const RoseInstruction *target_in) : min_bound(min), max_bound(max), target(target_in) {} bool operator==(const RoseInstrCheckBounds &ri) const { return min_bound == ri.min_bound && max_bound == ri.max_bound && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), min_bound, max_bound); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckBounds &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return min_bound == ri.min_bound && max_bound == ri.max_bound && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckNotHandled : public RoseInstrBaseOneTarget { public: u32 key; const RoseInstruction *target; RoseInstrCheckNotHandled(u32 key_in, const RoseInstruction *target_in) : key(key_in), target(target_in) {} bool operator==(const RoseInstrCheckNotHandled &ri) const { return key == ri.key && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), key); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckNotHandled &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return key == ri.key && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckSingleLookaround : public RoseInstrBaseOneTarget { public: s8 offset; u32 reach_index; const RoseInstruction *target; RoseInstrCheckSingleLookaround(s8 offset_in, u32 reach_index_in, const RoseInstruction *target_in) : offset(offset_in), reach_index(reach_index_in), target(target_in) {} bool operator==(const RoseInstrCheckSingleLookaround &ri) const { return offset == ri.offset && reach_index == ri.reach_index && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), offset, reach_index); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckSingleLookaround &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return offset == ri.offset && reach_index == ri.reach_index && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckLookaround : public RoseInstrBaseOneTarget { public: u32 index; u32 count; const RoseInstruction *target; RoseInstrCheckLookaround(u32 index_in, u32 count_in, const RoseInstruction *target_in) : index(index_in), count(count_in), target(target_in) {} bool operator==(const RoseInstrCheckLookaround &ri) const { return index == ri.index && count == ri.count && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), index, count); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckLookaround &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return index == ri.index && count == ri.count && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckMask : public RoseInstrBaseOneTarget { public: u64a and_mask; u64a cmp_mask; u64a neg_mask; s32 offset; const RoseInstruction *target; RoseInstrCheckMask(u64a and_mask_in, u64a cmp_mask_in, u64a neg_mask_in, s32 offset_in, const RoseInstruction *target_in) : and_mask(and_mask_in), cmp_mask(cmp_mask_in), neg_mask(neg_mask_in), offset(offset_in), target(target_in) {} bool operator==(const RoseInstrCheckMask &ri) const { return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask && neg_mask == ri.neg_mask && offset == ri.offset && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), and_mask, cmp_mask, neg_mask, offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckMask &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask && neg_mask == ri.neg_mask && offset == ri.offset && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckMask32 : public RoseInstrBaseOneTarget { public: std::array and_mask; std::array cmp_mask; u32 neg_mask; s32 offset; const RoseInstruction *target; RoseInstrCheckMask32(std::array and_mask_in, std::array cmp_mask_in, u32 neg_mask_in, s32 offset_in, const RoseInstruction *target_in) : and_mask(move(and_mask_in)), cmp_mask(move(cmp_mask_in)), neg_mask(neg_mask_in), offset(offset_in), target(target_in) {} bool operator==(const RoseInstrCheckMask32 &ri) const { return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask && neg_mask == ri.neg_mask && offset == ri.offset && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), and_mask, cmp_mask, neg_mask, offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckMask32 &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask && neg_mask == ri.neg_mask && offset == ri.offset && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckByte : public RoseInstrBaseOneTarget { public: u8 and_mask; u8 cmp_mask; u8 negation; s32 offset; const RoseInstruction *target; RoseInstrCheckByte(u8 and_mask_in, u8 cmp_mask_in, u8 negation_in, s32 offset_in, const RoseInstruction *target_in) : and_mask(and_mask_in), cmp_mask(cmp_mask_in), negation(negation_in), offset(offset_in), target(target_in) {} bool operator==(const RoseInstrCheckByte &ri) const { return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask && negation == ri.negation && offset == ri.offset && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), and_mask, cmp_mask, negation, offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckByte &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return and_mask == ri.and_mask && cmp_mask == ri.cmp_mask && negation == ri.negation && offset == ri.offset && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckShufti16x8 : public RoseInstrBaseOneTarget { public: std::array nib_mask; std::array bucket_select_mask; u32 neg_mask; s32 offset; const RoseInstruction *target; RoseInstrCheckShufti16x8(std::array nib_mask_in, std::array bucket_select_mask_in, u32 neg_mask_in, s32 offset_in, const RoseInstruction *target_in) : nib_mask(move(nib_mask_in)), bucket_select_mask(move(bucket_select_mask_in)), neg_mask(neg_mask_in), offset(offset_in), target(target_in) {} bool operator==(const RoseInstrCheckShufti16x8 &ri) const { return nib_mask == ri.nib_mask && bucket_select_mask == ri.bucket_select_mask && neg_mask == ri.neg_mask && offset == ri.offset && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), nib_mask, bucket_select_mask, neg_mask, offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckShufti16x8 &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return nib_mask == ri.nib_mask && bucket_select_mask == ri.bucket_select_mask && neg_mask == ri.neg_mask && offset == ri.offset && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckShufti32x8 : public RoseInstrBaseOneTarget { public: std::array hi_mask; std::array lo_mask; std::array bucket_select_mask; u32 neg_mask; s32 offset; const RoseInstruction *target; RoseInstrCheckShufti32x8(std::array hi_mask_in, std::array lo_mask_in, std::array bucket_select_mask_in, u32 neg_mask_in, s32 offset_in, const RoseInstruction *target_in) : hi_mask(move(hi_mask_in)), lo_mask(move(lo_mask_in)), bucket_select_mask(move(bucket_select_mask_in)), neg_mask(neg_mask_in), offset(offset_in), target(target_in) {} bool operator==(const RoseInstrCheckShufti32x8 &ri) const { return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask && bucket_select_mask == ri.bucket_select_mask && neg_mask == ri.neg_mask && offset == ri.offset && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), hi_mask, lo_mask, bucket_select_mask, neg_mask, offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckShufti32x8 &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask && bucket_select_mask == ri.bucket_select_mask && neg_mask == ri.neg_mask && offset == ri.offset && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckShufti16x16 : public RoseInstrBaseOneTarget { public: std::array hi_mask; std::array lo_mask; std::array bucket_select_mask; u32 neg_mask; s32 offset; const RoseInstruction *target; RoseInstrCheckShufti16x16(std::array hi_mask_in, std::array lo_mask_in, std::array bucket_select_mask_in, u32 neg_mask_in, s32 offset_in, const RoseInstruction *target_in) : hi_mask(move(hi_mask_in)), lo_mask(move(lo_mask_in)), bucket_select_mask(move(bucket_select_mask_in)), neg_mask(neg_mask_in), offset(offset_in), target(target_in) {} bool operator==(const RoseInstrCheckShufti16x16 &ri) const { return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask && bucket_select_mask == ri.bucket_select_mask && neg_mask == ri.neg_mask && offset == ri.offset && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), hi_mask, lo_mask, bucket_select_mask, neg_mask, offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckShufti16x16 &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask && bucket_select_mask == ri.bucket_select_mask && neg_mask == ri.neg_mask && offset == ri.offset && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckShufti32x16 : public RoseInstrBaseOneTarget { public: std::array hi_mask; std::array lo_mask; std::array bucket_select_mask_hi; std::array bucket_select_mask_lo; u32 neg_mask; s32 offset; const RoseInstruction *target; RoseInstrCheckShufti32x16(std::array hi_mask_in, std::array lo_mask_in, std::array bucket_select_mask_hi_in, std::array bucket_select_mask_lo_in, u32 neg_mask_in, s32 offset_in, const RoseInstruction *target_in) : hi_mask(move(hi_mask_in)), lo_mask(move(lo_mask_in)), bucket_select_mask_hi(move(bucket_select_mask_hi_in)), bucket_select_mask_lo(move(bucket_select_mask_lo_in)), neg_mask(neg_mask_in), offset(offset_in), target(target_in) {} bool operator==(const RoseInstrCheckShufti32x16 &ri) const { return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask && bucket_select_mask_hi == ri.bucket_select_mask_hi && bucket_select_mask_lo == ri.bucket_select_mask_lo && neg_mask == ri.neg_mask && offset == ri.offset && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), hi_mask, lo_mask, bucket_select_mask_hi, bucket_select_mask_lo, neg_mask, offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckShufti32x16 &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return hi_mask == ri.hi_mask && lo_mask == ri.lo_mask && bucket_select_mask_hi == ri.bucket_select_mask_hi && bucket_select_mask_lo == ri.bucket_select_mask_lo && neg_mask == ri.neg_mask && offset == ri.offset && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckInfix : public RoseInstrBaseOneTarget { public: u32 queue; u32 lag; ReportID report; const RoseInstruction *target; RoseInstrCheckInfix(u32 queue_in, u32 lag_in, ReportID report_in, const RoseInstruction *target_in) : queue(queue_in), lag(lag_in), report(report_in), target(target_in) {} bool operator==(const RoseInstrCheckInfix &ri) const { return queue == ri.queue && lag == ri.lag && report == ri.report && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), queue, lag, report); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckInfix &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return queue == ri.queue && lag == ri.lag && report == ri.report && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckPrefix : public RoseInstrBaseOneTarget { public: u32 queue; u32 lag; ReportID report; const RoseInstruction *target; RoseInstrCheckPrefix(u32 queue_in, u32 lag_in, ReportID report_in, const RoseInstruction *target_in) : queue(queue_in), lag(lag_in), report(report_in), target(target_in) {} bool operator==(const RoseInstrCheckPrefix &ri) const { return queue == ri.queue && lag == ri.lag && report == ri.report && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), queue, lag, report); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckPrefix &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return queue == ri.queue && lag == ri.lag && report == ri.report && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrPushDelayed : public RoseInstrBaseNoTargets { public: u8 delay; u32 index; RoseInstrPushDelayed(u8 delay_in, u32 index_in) : delay(delay_in), index(index_in) {} bool operator==(const RoseInstrPushDelayed &ri) const { return delay == ri.delay && index == ri.index; } size_t hash() const override { return hash_all(static_cast(opcode), delay, index); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrPushDelayed &ri, const OffsetMap &, const OffsetMap &) const { return delay == ri.delay && index == ri.index; } }; class RoseInstrRecordAnchored : public RoseInstrBaseNoTargets { public: u32 id; explicit RoseInstrRecordAnchored(u32 id_in) : id(id_in) {} bool operator==(const RoseInstrRecordAnchored &ri) const { return id == ri.id; } size_t hash() const override { return hash_all(static_cast(opcode), id); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrRecordAnchored &ri, const OffsetMap &, const OffsetMap &) const { return id == ri.id; } }; class RoseInstrCatchUp : public RoseInstrBaseTrivial { public: ~RoseInstrCatchUp() override; }; class RoseInstrCatchUpMpv : public RoseInstrBaseTrivial { public: ~RoseInstrCatchUpMpv() override; }; class RoseInstrSomAdjust : public RoseInstrBaseNoTargets { public: u32 distance; explicit RoseInstrSomAdjust(u32 distance_in) : distance(distance_in) {} bool operator==(const RoseInstrSomAdjust &ri) const { return distance == ri.distance; } size_t hash() const override { return hash_all(static_cast(opcode), distance); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrSomAdjust &ri, const OffsetMap &, const OffsetMap &) const { return distance == ri.distance; } }; class RoseInstrSomLeftfix : public RoseInstrBaseNoTargets { public: u32 queue; u32 lag; RoseInstrSomLeftfix(u32 queue_in, u32 lag_in) : queue(queue_in), lag(lag_in) {} bool operator==(const RoseInstrSomLeftfix &ri) const { return queue == ri.queue && lag == ri.lag; } size_t hash() const override { return hash_all(static_cast(opcode), queue, lag); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrSomLeftfix &ri, const OffsetMap &, const OffsetMap &) const { return queue == ri.queue && lag == ri.lag; } }; class RoseInstrSomFromReport : public RoseInstrBaseNoTargets { public: som_operation som; RoseInstrSomFromReport() { std::memset(&som, 0, sizeof(som)); } bool operator==(const RoseInstrSomFromReport &ri) const { return std::memcmp(&som, &ri.som, sizeof(som)) == 0; } size_t hash() const override { return hash_all(static_cast(opcode), som.type, som.onmatch); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrSomFromReport &ri, const OffsetMap &, const OffsetMap &) const { return std::memcmp(&som, &ri.som, sizeof(som)) == 0; } }; class RoseInstrSomZero : public RoseInstrBaseTrivial { public: ~RoseInstrSomZero() override; }; class RoseInstrTriggerInfix : public RoseInstrBaseNoTargets { public: u8 cancel; u32 queue; u32 event; RoseInstrTriggerInfix(u8 cancel_in, u32 queue_in, u32 event_in) : cancel(cancel_in), queue(queue_in), event(event_in) {} bool operator==(const RoseInstrTriggerInfix &ri) const { return cancel == ri.cancel && queue == ri.queue && event == ri.event; } size_t hash() const override { return hash_all(static_cast(opcode), cancel, queue, event); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrTriggerInfix &ri, const OffsetMap &, const OffsetMap &) const { return cancel == ri.cancel && queue == ri.queue && event == ri.event; } }; class RoseInstrTriggerSuffix : public RoseInstrBaseNoTargets { public: u32 queue; u32 event; RoseInstrTriggerSuffix(u32 queue_in, u32 event_in) : queue(queue_in), event(event_in) {} bool operator==(const RoseInstrTriggerSuffix &ri) const { return queue == ri.queue && event == ri.event; } size_t hash() const override { return hash_all(static_cast(opcode), queue, event); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrTriggerSuffix &ri, const OffsetMap &, const OffsetMap &) const { return queue == ri.queue && event == ri.event; } }; class RoseInstrDedupe : public RoseInstrBaseOneTarget { public: u8 quash_som; u32 dkey; s32 offset_adjust; const RoseInstruction *target; RoseInstrDedupe(u8 quash_som_in, u32 dkey_in, s32 offset_adjust_in, const RoseInstruction *target_in) : quash_som(quash_som_in), dkey(dkey_in), offset_adjust(offset_adjust_in), target(target_in) {} bool operator==(const RoseInstrDedupe &ri) const { return quash_som == ri.quash_som && dkey == ri.dkey && offset_adjust == ri.offset_adjust && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), quash_som, dkey, offset_adjust); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrDedupe &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return quash_som == ri.quash_som && dkey == ri.dkey && offset_adjust == ri.offset_adjust && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrDedupeSom : public RoseInstrBaseOneTarget { public: u8 quash_som; u32 dkey; s32 offset_adjust; const RoseInstruction *target; RoseInstrDedupeSom(u8 quash_som_in, u32 dkey_in, s32 offset_adjust_in, const RoseInstruction *target_in) : quash_som(quash_som_in), dkey(dkey_in), offset_adjust(offset_adjust_in), target(target_in) {} bool operator==(const RoseInstrDedupeSom &ri) const { return quash_som == ri.quash_som && dkey == ri.dkey && offset_adjust == ri.offset_adjust && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), quash_som, dkey, offset_adjust); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrDedupeSom &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return quash_som == ri.quash_som && dkey == ri.dkey && offset_adjust == ri.offset_adjust && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrReportChain : public RoseInstrBaseNoTargets { public: u32 event; u64a top_squash_distance; RoseInstrReportChain(u32 event_in, u32 top_squash_distance_in) : event(event_in), top_squash_distance(top_squash_distance_in) {} bool operator==(const RoseInstrReportChain &ri) const { return event == ri.event && top_squash_distance == ri.top_squash_distance; } size_t hash() const override { return hash_all(static_cast(opcode), event, top_squash_distance); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrReportChain &ri, const OffsetMap &, const OffsetMap &) const { return event == ri.event && top_squash_distance == ri.top_squash_distance; } }; class RoseInstrReportSomInt : public RoseInstrBaseNoTargets { public: som_operation som; RoseInstrReportSomInt() { std::memset(&som, 0, sizeof(som)); } bool operator==(const RoseInstrReportSomInt &ri) const { return std::memcmp(&som, &ri.som, sizeof(som)) == 0; } size_t hash() const override { return hash_all(static_cast(opcode), som.type, som.onmatch); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrReportSomInt &ri, const OffsetMap &, const OffsetMap &) const { return std::memcmp(&som, &ri.som, sizeof(som)) == 0; } }; class RoseInstrReportSomAware : public RoseInstrBaseNoTargets { public: som_operation som; RoseInstrReportSomAware() { std::memset(&som, 0, sizeof(som)); } bool operator==(const RoseInstrReportSomAware &ri) const { return std::memcmp(&som, &ri.som, sizeof(som)) == 0; } size_t hash() const override { return hash_all(static_cast(opcode), som.type, som.onmatch); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrReportSomAware &ri, const OffsetMap &, const OffsetMap &) const { return std::memcmp(&som, &ri.som, sizeof(som)) == 0; } }; class RoseInstrReport : public RoseInstrBaseNoTargets { public: ReportID onmatch; s32 offset_adjust; RoseInstrReport(ReportID onmatch_in, s32 offset_adjust_in) : onmatch(onmatch_in), offset_adjust(offset_adjust_in) {} bool operator==(const RoseInstrReport &ri) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust; } size_t hash() const override { return hash_all(static_cast(opcode), onmatch, offset_adjust); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrReport &ri, const OffsetMap &, const OffsetMap &) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust; } }; class RoseInstrReportExhaust : public RoseInstrBaseNoTargets { public: ReportID onmatch; s32 offset_adjust; u32 ekey; RoseInstrReportExhaust(ReportID onmatch_in, s32 offset_adjust_in, u32 ekey_in) : onmatch(onmatch_in), offset_adjust(offset_adjust_in), ekey(ekey_in) {} bool operator==(const RoseInstrReportExhaust &ri) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust && ekey == ri.ekey; } size_t hash() const override { return hash_all(static_cast(opcode), onmatch, offset_adjust, ekey); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrReportExhaust &ri, const OffsetMap &, const OffsetMap &) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust && ekey == ri.ekey; } }; class RoseInstrReportSom : public RoseInstrBaseNoTargets { public: ReportID onmatch; s32 offset_adjust; RoseInstrReportSom(ReportID onmatch_in, s32 offset_adjust_in) : onmatch(onmatch_in), offset_adjust(offset_adjust_in) {} bool operator==(const RoseInstrReportSom &ri) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust; } size_t hash() const override { return hash_all(static_cast(opcode), onmatch, offset_adjust); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrReportSom &ri, const OffsetMap &, const OffsetMap &) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust; } }; class RoseInstrReportSomExhaust : public RoseInstrBaseNoTargets { public: ReportID onmatch; s32 offset_adjust; u32 ekey; RoseInstrReportSomExhaust(ReportID onmatch_in, s32 offset_adjust_in, u32 ekey_in) : onmatch(onmatch_in), offset_adjust(offset_adjust_in), ekey(ekey_in) {} bool operator==(const RoseInstrReportSomExhaust &ri) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust && ekey == ri.ekey; } size_t hash() const override { return hash_all(static_cast(opcode), onmatch, offset_adjust, ekey); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrReportSomExhaust &ri, const OffsetMap &, const OffsetMap &) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust && ekey == ri.ekey; } }; class RoseInstrDedupeAndReport : public RoseInstrBaseOneTarget { public: u8 quash_som; u32 dkey; ReportID onmatch; s32 offset_adjust; const RoseInstruction *target; RoseInstrDedupeAndReport(u8 quash_som_in, u32 dkey_in, ReportID onmatch_in, s32 offset_adjust_in, const RoseInstruction *target_in) : quash_som(quash_som_in), dkey(dkey_in), onmatch(onmatch_in), offset_adjust(offset_adjust_in), target(target_in) {} bool operator==(const RoseInstrDedupeAndReport &ri) const { return quash_som == ri.quash_som && dkey == ri.dkey && onmatch == ri.onmatch && offset_adjust == ri.offset_adjust && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), quash_som, dkey, onmatch, offset_adjust); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrDedupeAndReport &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return quash_som == ri.quash_som && dkey == ri.dkey && onmatch == ri.onmatch && offset_adjust == ri.offset_adjust && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrFinalReport : public RoseInstrBaseNoTargets { public: ReportID onmatch; s32 offset_adjust; RoseInstrFinalReport(ReportID onmatch_in, s32 offset_adjust_in) : onmatch(onmatch_in), offset_adjust(offset_adjust_in) {} bool operator==(const RoseInstrFinalReport &ri) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust; } size_t hash() const override { return hash_all(static_cast(opcode), onmatch, offset_adjust); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrFinalReport &ri, const OffsetMap &, const OffsetMap &) const { return onmatch == ri.onmatch && offset_adjust == ri.offset_adjust; } }; class RoseInstrCheckExhausted : public RoseInstrBaseOneTarget { public: u32 ekey; const RoseInstruction *target; RoseInstrCheckExhausted(u32 ekey_in, const RoseInstruction *target_in) : ekey(ekey_in), target(target_in) {} bool operator==(const RoseInstrCheckExhausted &ri) const { return ekey == ri.ekey && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), ekey); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckExhausted &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return ekey == ri.ekey && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrCheckMinLength : public RoseInstrBaseOneTarget { public: s32 end_adj; u64a min_length; const RoseInstruction *target; RoseInstrCheckMinLength(s32 end_adj_in, u64a min_length_in, const RoseInstruction *target_in) : end_adj(end_adj_in), min_length(min_length_in), target(target_in) {} bool operator==(const RoseInstrCheckMinLength &ri) const { return end_adj == ri.end_adj && min_length == ri.min_length && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), end_adj, min_length); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckMinLength &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return end_adj == ri.end_adj && min_length == ri.min_length && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrSetState : public RoseInstrBaseNoTargets { public: u32 index; explicit RoseInstrSetState(u32 index_in) : index(index_in) {} bool operator==(const RoseInstrSetState &ri) const { return index == ri.index; } size_t hash() const override { return hash_all(static_cast(opcode), index); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrSetState &ri, const OffsetMap &, const OffsetMap &) const { return index == ri.index; } }; class RoseInstrSetGroups : public RoseInstrBaseNoTargets { public: rose_group groups; explicit RoseInstrSetGroups(rose_group groups_in) : groups(groups_in) {} bool operator==(const RoseInstrSetGroups &ri) const { return groups == ri.groups; } size_t hash() const override { return hash_all(static_cast(opcode), groups); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrSetGroups &ri, const OffsetMap &, const OffsetMap &) const { return groups == ri.groups; } }; class RoseInstrSquashGroups : public RoseInstrBaseNoTargets { public: rose_group groups; explicit RoseInstrSquashGroups(rose_group groups_in) : groups(groups_in) {} bool operator==(const RoseInstrSquashGroups &ri) const { return groups == ri.groups; } size_t hash() const override { return hash_all(static_cast(opcode), groups); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrSquashGroups &ri, const OffsetMap &, const OffsetMap &) const { return groups == ri.groups; } }; class RoseInstrCheckState : public RoseInstrBaseOneTarget { public: u32 index; const RoseInstruction *target; RoseInstrCheckState(u32 index_in, const RoseInstruction *target_in) : index(index_in), target(target_in) {} bool operator==(const RoseInstrCheckState &ri) const { return index == ri.index && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), index); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckState &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return index == ri.index && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrSparseIterBegin : public RoseInstrBase { public: u32 num_keys; // total number of multibit keys std::vector> jump_table; const RoseInstruction *target; RoseInstrSparseIterBegin(u32 num_keys_in, const RoseInstruction *target_in) : num_keys(num_keys_in), target(target_in) {} bool operator==(const RoseInstrSparseIterBegin &ri) const { return num_keys == ri.num_keys && jump_table == ri.jump_table && target == ri.target; } size_t hash() const override { size_t v = hash_all(static_cast(opcode), num_keys); for (const u32 &key : jump_table | boost::adaptors::map_keys) { boost::hash_combine(v, key); } return v; } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; void update_target(const RoseInstruction *old_target, const RoseInstruction *new_target) override { if (target == old_target) { target = new_target; } for (auto &jump : jump_table) { if (jump.second == old_target) { jump.second = new_target; } } } bool equiv_to(const RoseInstrSparseIterBegin &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { if (iter_offset != ri.iter_offset || offsets.at(target) != other_offsets.at(ri.target)) { return false; } if (jump_table.size() != ri.jump_table.size()) { return false; } auto it1 = jump_table.begin(), it2 = ri.jump_table.begin(); for (; it1 != jump_table.end(); ++it1, ++it2) { if (it1->first != it2->first) { return false; } if (offsets.at(it1->second) != other_offsets.at(it2->second)) { return false; } } return true; } private: friend class RoseInstrSparseIterNext; // These variables allow us to use the same multibit iterator and jump // table in subsequent SPARSE_ITER_NEXT write() operations. mutable bool is_written = false; mutable u32 iter_offset = 0; mutable u32 jump_table_offset = 0; }; class RoseInstrSparseIterNext : public RoseInstrBase { public: u32 state; const RoseInstrSparseIterBegin *begin; const RoseInstruction *target; RoseInstrSparseIterNext(u32 state_in, const RoseInstrSparseIterBegin *begin_in, const RoseInstruction *target_in) : state(state_in), begin(begin_in), target(target_in) {} bool operator==(const RoseInstrSparseIterNext &ri) const { return state == ri.state && begin == ri.begin && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), state); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; void update_target(const RoseInstruction *old_target, const RoseInstruction *new_target) override { if (target == old_target) { target = new_target; } if (begin == old_target) { assert(new_target->code() == ROSE_INSTR_SPARSE_ITER_BEGIN); begin = static_cast(new_target); } } bool equiv_to(const RoseInstrSparseIterNext &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return state == ri.state && offsets.at(begin) == other_offsets.at(ri.begin) && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrSparseIterAny : public RoseInstrBaseOneTarget { public: u32 num_keys; // total number of multibit keys std::vector keys; const RoseInstruction *target; RoseInstrSparseIterAny(u32 num_keys_in, std::vector keys_in, const RoseInstruction *target_in) : num_keys(num_keys_in), keys(std::move(keys_in)), target(target_in) {} bool operator==(const RoseInstrSparseIterAny &ri) const { return num_keys == ri.num_keys && keys == ri.keys && target == ri.target; } size_t hash() const override { return hash_all(static_cast(opcode), num_keys, keys); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrSparseIterAny &ri, const OffsetMap &offsets, const OffsetMap &other_offsets) const { return num_keys == ri.num_keys && keys == ri.keys && offsets.at(target) == other_offsets.at(ri.target); } }; class RoseInstrEnginesEod : public RoseInstrBaseNoTargets { public: u32 iter_offset; explicit RoseInstrEnginesEod(u32 iter_in) : iter_offset(iter_in) {} bool operator==(const RoseInstrEnginesEod &ri) const { return iter_offset == ri.iter_offset; } size_t hash() const override { return hash_all(static_cast(opcode), iter_offset); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrEnginesEod &ri, const OffsetMap &, const OffsetMap &) const { return iter_offset == ri.iter_offset; } }; class RoseInstrSuffixesEod : public RoseInstrBaseTrivial { public: ~RoseInstrSuffixesEod() override; }; class RoseInstrMatcherEod : public RoseInstrBaseTrivial { public: ~RoseInstrMatcherEod() override; }; class RoseInstrCheckLongLit : public RoseInstrBaseNoTargets { public: std::string literal; RoseInstrCheckLongLit(std::string literal_in) : literal(std::move(literal_in)) {} bool operator==(const RoseInstrCheckLongLit &ri) const { return literal == ri.literal; } size_t hash() const override { return hash_all(static_cast(opcode), literal); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckLongLit &ri, const OffsetMap &, const OffsetMap &) const { return literal == ri.literal; } }; class RoseInstrCheckLongLitNocase : public RoseInstrBaseNoTargets { public: std::string literal; RoseInstrCheckLongLitNocase(std::string literal_in) : literal(std::move(literal_in)) { upperString(literal); } bool operator==(const RoseInstrCheckLongLitNocase &ri) const { return literal == ri.literal; } size_t hash() const override { return hash_all(static_cast(opcode), literal); } void write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const override; bool equiv_to(const RoseInstrCheckLongLitNocase &ri, const OffsetMap &, const OffsetMap &) const { return literal == ri.literal; } }; class RoseInstrEnd : public RoseInstrBaseTrivial { public: ~RoseInstrEnd() override; }; /** * \brief Container for a list of program instructions. */ class RoseProgram { private: std::vector> prog; public: RoseProgram() { prog.push_back(make_unique()); } bool empty() const { assert(!prog.empty()); assert(prog.back()->code() == ROSE_INSTR_END); // Empty if we only have one element, the END instruction. return std::next(prog.begin()) == prog.end(); } size_t size() const { return prog.size(); } const RoseInstruction &back() const { return *prog.back(); } const RoseInstruction &front() const { return *prog.front(); } using iterator = decltype(prog)::iterator; iterator begin() { return prog.begin(); } iterator end() { return prog.end(); } using const_iterator = decltype(prog)::const_iterator; const_iterator begin() const { return prog.begin(); } const_iterator end() const { return prog.end(); } using reverse_iterator = decltype(prog)::reverse_iterator; reverse_iterator rbegin() { return prog.rbegin(); } reverse_iterator rend() { return prog.rend(); } using const_reverse_iterator = decltype(prog)::const_reverse_iterator; const_reverse_iterator rbegin() const { return prog.rbegin(); } const_reverse_iterator rend() const { return prog.rend(); } /** \brief Retrieve a pointer to the terminating ROSE_INSTR_END. */ const RoseInstruction *end_instruction() const { assert(!prog.empty()); assert(prog.back()->code() == ROSE_INSTR_END); return prog.back().get(); } private: static void update_targets(iterator it, iterator it_end, const RoseInstruction *old_target, const RoseInstruction *new_target) { assert(old_target && new_target && old_target != new_target); for (; it != it_end; ++it) { std::unique_ptr &ri = *it; assert(ri); ri->update_target(old_target, new_target); } } public: iterator insert(iterator it, std::unique_ptr ri) { assert(!prog.empty()); assert(it != end()); assert(prog.back()->code() == ROSE_INSTR_END); return prog.insert(it, std::move(ri)); } iterator insert(iterator it, RoseProgram &&block) { assert(!prog.empty()); assert(it != end()); assert(prog.back()->code() == ROSE_INSTR_END); if (block.empty()) { return it; } const RoseInstruction *end_ptr = block.end_instruction(); assert(end_ptr->code() == ROSE_INSTR_END); block.prog.pop_back(); const RoseInstruction *new_target = it->get(); update_targets(block.prog.begin(), block.prog.end(), end_ptr, new_target); // Workaround: container insert() for ranges doesn't return an iterator // in the version of the STL distributed with gcc 4.8. auto dist = distance(prog.begin(), it); prog.insert(it, std::make_move_iterator(block.prog.begin()), std::make_move_iterator(block.prog.end())); it = prog.begin(); std::advance(it, dist); return it; } /** * \brief Adds this instruction to the program just before the terminating * ROSE_INSTR_END. */ void add_before_end(std::unique_ptr ri) { assert(!prog.empty()); insert(std::prev(prog.end()), std::move(ri)); } /** * \brief Adds this block to the program just before the terminating * ROSE_INSTR_END. */ void add_before_end(RoseProgram &&block) { assert(!prog.empty()); assert(prog.back()->code() == ROSE_INSTR_END); if (block.empty()) { return; } insert(std::prev(prog.end()), std::move(block)); } /** * \brief Append this program block, replacing our current ROSE_INSTR_END. */ void add_block(RoseProgram &&block) { assert(!prog.empty()); assert(prog.back()->code() == ROSE_INSTR_END); if (block.empty()) { return; } // Replace pointers to the current END with pointers to the first // instruction in the new sequence. const RoseInstruction *end_ptr = end_instruction(); prog.pop_back(); update_targets(prog.begin(), prog.end(), end_ptr, block.prog.front().get()); prog.insert(prog.end(), std::make_move_iterator(block.prog.begin()), std::make_move_iterator(block.prog.end())); } /** * \brief Replace the instruction pointed to by the given iterator. */ template void replace(Iter it, std::unique_ptr ri) { assert(!prog.empty()); assert(prog.back()->code() == ROSE_INSTR_END); const RoseInstruction *old_ptr = it->get(); *it = move(ri); update_targets(prog.begin(), prog.end(), old_ptr, it->get()); assert(prog.back()->code() == ROSE_INSTR_END); } }; aligned_unique_ptr writeProgram(RoseEngineBlob &blob, const RoseProgram &program, u32 *total_len); class RoseProgramHash { public: size_t operator()(const RoseProgram &program) const { size_t v = 0; for (const auto &ri : program) { assert(ri); boost::hash_combine(v, ri->hash()); } return v; } }; class RoseProgramEquivalence { public: bool operator()(const RoseProgram &prog1, const RoseProgram &prog2) const; }; } // namespace ue2 #endif // ROSE_BUILD_PROGRAM_H hyperscan-4.4.1/src/rose/rose_build_scatter.cpp0000644000175000017500000001133413055426554022420 0ustar sleuthkidsleuthkid/* * 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. */ #include "rose_build_scatter.h" #include "ue2common.h" #include "util/container.h" #include "util/multibit_build.h" #include // memset #include using namespace std; namespace ue2 { template static void rebase(vector *p, u32 adj) { for (typename vector::iterator it = p->begin(); it != p->end(); ++it) { DEBUG_PRINTF("=%u+%u\n", it->offset, adj); it->offset += adj; } } static void rebase(scatter_plan_raw *raw, u32 adj) { rebase(&raw->p_u64a, adj); rebase(&raw->p_u32, adj); rebase(&raw->p_u16, adj); rebase(&raw->p_u8, adj); } static void merge_in(scatter_plan_raw *out, const scatter_plan_raw &in) { insert(&out->p_u64a, out->p_u64a.end(), in.p_u64a); insert(&out->p_u32, out->p_u32.end(), in.p_u32); insert(&out->p_u16, out->p_u16.end(), in.p_u16); insert(&out->p_u8, out->p_u8.end(), in.p_u8); } void buildStateScatterPlan(u32 role_state_offset, u32 role_state_count, u32 left_array_count, u32 left_prefix_count, const RoseStateOffsets &stateOffsets, bool streaming, u32 leaf_array_count, u32 outfix_begin, u32 outfix_end, scatter_plan_raw *out) { /* init role array */ scatter_plan_raw spr_role; mmbBuildClearPlan(role_state_count, &spr_role); rebase(&spr_role, role_state_offset); merge_in(out, spr_role); /* init rose array: turn on prefixes */ u32 rose_array_offset = stateOffsets.activeLeftArray; scatter_plan_raw spr_rose; mmbBuildInitRangePlan(left_array_count, 0, left_prefix_count, &spr_rose); rebase(&spr_rose, rose_array_offset); merge_in(out, spr_rose); /* suffix/outfix array */ scatter_plan_raw spr_leaf; if (streaming) { mmbBuildInitRangePlan(leaf_array_count, outfix_begin, outfix_end, &spr_leaf); } else { mmbBuildClearPlan(leaf_array_count, &spr_leaf); } rebase(&spr_leaf, stateOffsets.activeLeafArray); merge_in(out, spr_leaf); } u32 aux_size(const scatter_plan_raw &raw) { u32 rv = 0; rv += byte_length(raw.p_u64a); rv += byte_length(raw.p_u32); rv += byte_length(raw.p_u16); rv += byte_length(raw.p_u8); return rv; } void write_out(scatter_full_plan *plan_out, void *aux_out, const scatter_plan_raw &raw, u32 aux_base_offset) { memset(plan_out, 0, sizeof(*plan_out)); #define DO_CASE(t) \ if (!raw.p_##t.empty()) { \ plan_out->s_##t##_offset = aux_base_offset; \ plan_out->s_##t##_count = raw.p_##t.size(); \ assert(ISALIGNED_N((char *)aux_out + aux_base_offset, \ alignof(scatter_unit_##t))); \ memcpy((char *)aux_out + aux_base_offset, raw.p_##t.data(), \ byte_length(raw.p_##t)); \ aux_base_offset += byte_length(raw.p_##t); \ } DO_CASE(u64a); DO_CASE(u32); DO_CASE(u16); DO_CASE(u8); } } // namespace ue2 hyperscan-4.4.1/src/rose/stream_long_lit.h0000644000175000017500000003201513055426554021372 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 STREAM_LONG_LIT_H #define STREAM_LONG_LIT_H #include "rose.h" #include "rose_common.h" #include "rose_internal.h" #include "stream_long_lit_hash.h" #include "util/copybytes.h" static really_inline const struct RoseLongLitHashEntry * getHashTableBase(const struct RoseLongLitTable *ll_table, const struct RoseLongLitSubtable *ll_sub) { assert(ll_sub->hashOffset); return (const struct RoseLongLitHashEntry *)((const char *)ll_table + ll_sub->hashOffset); } // Reads from stream state and unpacks values into stream state table. static really_inline void loadLongLitStreamState(const struct RoseLongLitTable *ll_table, const u8 *ll_state, u32 *state_case, u32 *state_nocase) { assert(ll_table); assert(ll_state); assert(state_case && state_nocase); u8 ss_bytes = ll_table->streamStateBytes; u8 ssb = ll_table->caseful.streamStateBits; UNUSED u8 ssb_nc = ll_table->nocase.streamStateBits; assert(ss_bytes == (ssb + ssb_nc + 7) / 8); #if defined(ARCH_32_BIT) // On 32-bit hosts, we may be able to avoid having to do any u64a // manipulation at all. if (ss_bytes <= 4) { u32 ssb_mask = (1U << ssb) - 1; u32 streamVal = partial_load_u32(ll_state, ss_bytes); *state_case = (u32)(streamVal & ssb_mask); *state_nocase = (u32)(streamVal >> ssb); return; } #endif u64a ssb_mask = (1ULL << ssb) - 1; u64a streamVal = partial_load_u64a(ll_state, ss_bytes); *state_case = (u32)(streamVal & ssb_mask); *state_nocase = (u32)(streamVal >> ssb); } static rose_inline void loadLongLiteralStateMode(struct hs_scratch *scratch, const struct RoseLongLitTable *ll_table, const struct RoseLongLitSubtable *ll_sub, const u32 state, const char nocase) { if (!state) { DEBUG_PRINTF("no state for %s\n", nocase ? "caseless" : "caseful"); return; } const struct RoseLongLitHashEntry *tab = getHashTableBase(ll_table, ll_sub); const struct RoseLongLitHashEntry *ent = tab + state - 1; assert(ent->str_offset + ent->str_len <= ll_table->size); const u8 *found_buf = (const u8 *)ll_table + ent->str_offset; size_t found_sz = ent->str_len; struct RoseContext *tctxt = &scratch->tctxt; if (nocase) { tctxt->ll_buf_nocase = found_buf; tctxt->ll_len_nocase = found_sz; } else { tctxt->ll_buf = found_buf; tctxt->ll_len = found_sz; } } static rose_inline void loadLongLiteralState(const struct RoseEngine *t, char *state, struct hs_scratch *scratch) { if (!t->longLitTableOffset) { return; } // If we don't have any long literals in play, these values must point to // the real history buffer so that CHECK_LITERAL instructions examine the // history buffer. scratch->tctxt.ll_buf = scratch->core_info.hbuf; scratch->tctxt.ll_len = scratch->core_info.hlen; scratch->tctxt.ll_buf_nocase = scratch->core_info.hbuf; scratch->tctxt.ll_len_nocase = scratch->core_info.hlen; if (!scratch->core_info.hlen) { return; } const struct RoseLongLitTable *ll_table = getByOffset(t, t->longLitTableOffset); const u8 *ll_state = getLongLitState(t, state); u32 state_case; u32 state_nocase; loadLongLitStreamState(ll_table, ll_state, &state_case, &state_nocase); DEBUG_PRINTF("loaded {%u, %u}\n", state_case, state_nocase); loadLongLiteralStateMode(scratch, ll_table, &ll_table->caseful, state_case, 0); loadLongLiteralStateMode(scratch, ll_table, &ll_table->nocase, state_nocase, 1); } static rose_inline char confirmLongLiteral(const struct RoseLongLitTable *ll_table, const struct hs_scratch *scratch, const struct RoseLongLitHashEntry *ent, const char nocase) { assert(ent->str_offset + ent->str_len <= ll_table->size); const u8 *s = (const u8 *)ll_table + ent->str_offset; size_t len = ent->str_len; const u8 *buf = scratch->core_info.buf; const size_t buf_len = scratch->core_info.len; if (len > buf_len) { const struct RoseContext *tctxt = &scratch->tctxt; const u8 *hist = nocase ? tctxt->ll_buf_nocase : tctxt->ll_buf; size_t hist_len = nocase ? tctxt->ll_len_nocase : tctxt->ll_len; if (len > buf_len + hist_len) { return 0; // Break out - not enough total history } size_t overhang = len - buf_len; assert(overhang <= hist_len); if (cmpForward(hist + hist_len - overhang, s, overhang, nocase)) { return 0; } s += overhang; len -= overhang; } // if we got here, we don't need history or we compared ok out of history assert(len <= buf_len); if (cmpForward(buf + buf_len - len, s, len, nocase)) { return 0; } return 1; } static rose_inline const u8 *prepScanBuffer(const struct core_info *ci, const struct RoseLongLitTable *ll_table, u8 *tempbuf) { const u8 hash_len = ll_table->maxLen; assert(hash_len >= LONG_LIT_HASH_LEN); // Our hash function operates over LONG_LIT_HASH_LEN bytes, starting from // location (end of buffer - hash_len). If this block can be satisfied // entirely from either the current buffer or the history buffer, we pass // in the pointer directly; otherwise we must make a copy. const u8 *base; if (hash_len > ci->len) { size_t overhang = hash_len - ci->len; if (overhang >= LONG_LIT_HASH_LEN) { // Can read enough to hash from inside the history buffer. assert(overhang <= ci->hlen); base = ci->hbuf + ci->hlen - overhang; } else { // Copy: first chunk from history buffer. assert(overhang <= ci->hlen); copy_upto_32_bytes(tempbuf, ci->hbuf + ci->hlen - overhang, overhang); // Copy: second chunk from current buffer. size_t copy_buf_len = LONG_LIT_HASH_LEN - overhang; assert(copy_buf_len <= ci->len); copy_upto_32_bytes(tempbuf + overhang, ci->buf, copy_buf_len); // Read from our temporary buffer for the hash. base = tempbuf; } } else { // Can read enough to hash from inside the current buffer. base = ci->buf + ci->len - hash_len; } return base; } #ifndef NDEBUG // Defensive checking (used in assert) that these table values don't overflow // the range available. static really_inline char streamingTableOverflow(u32 state_case, u32 state_nocase, u8 ssb, u8 ssb_nc) { u32 ssb_mask = (1ULL << (ssb)) - 1; if (state_case & ~ssb_mask) { return 1; } u32 ssb_nc_mask = (1ULL << (ssb_nc)) - 1; if (state_nocase & ~ssb_nc_mask) { return 1; } return 0; } #endif // Reads from stream state table and packs values into stream state. static rose_inline void storeLongLitStreamState(const struct RoseLongLitTable *ll_table, u8 *ll_state, u32 state_case, u32 state_nocase) { assert(ll_table); assert(ll_state); u8 ss_bytes = ll_table->streamStateBytes; u8 ssb = ll_table->caseful.streamStateBits; UNUSED u8 ssb_nc = ll_table->nocase.streamStateBits; assert(ss_bytes == ROUNDUP_N(ssb + ssb_nc, 8) / 8); assert(!streamingTableOverflow(state_case, state_nocase, ssb, ssb_nc)); #if defined(ARCH_32_BIT) // On 32-bit hosts, we may be able to avoid having to do any u64a // manipulation at all. if (ss_bytes <= 4) { u32 stagingStreamState = state_case; stagingStreamState |= (state_nocase << ssb); partial_store_u32(ll_state, stagingStreamState, ss_bytes); return; } #endif u64a stagingStreamState = (u64a)state_case; stagingStreamState |= (u64a)state_nocase << ssb; partial_store_u64a(ll_state, stagingStreamState, ss_bytes); } static really_inline char has_bit(const u8 *data, u32 bit) { return (data[bit / 8] >> (bit % 8)) & 1; } static rose_inline char bloomHasKey(const u8 *bloom, u32 bloom_mask, u32 hash) { return has_bit(bloom, hash & bloom_mask); } static rose_inline char checkBloomFilter(const struct RoseLongLitTable *ll_table, const struct RoseLongLitSubtable *ll_sub, const u8 *scan_buf, char nocase) { assert(ll_sub->bloomBits); const u8 *bloom = (const u8 *)ll_table + ll_sub->bloomOffset; const u32 bloom_mask = (1U << ll_sub->bloomBits) - 1; char v = 1; v &= bloomHasKey(bloom, bloom_mask, bloomHash_1(scan_buf, nocase)); v &= bloomHasKey(bloom, bloom_mask, bloomHash_2(scan_buf, nocase)); v &= bloomHasKey(bloom, bloom_mask, bloomHash_3(scan_buf, nocase)); return v; } /** * \brief Look for a hit in the hash table. * * Returns zero if not found, otherwise returns (bucket + 1). */ static rose_inline u32 checkHashTable(const struct RoseLongLitTable *ll_table, const struct RoseLongLitSubtable *ll_sub, const u8 *scan_buf, const struct hs_scratch *scratch, char nocase) { const u32 nbits = ll_sub->hashBits; assert(nbits && nbits < 32); const u32 num_entries = 1U << nbits; const struct RoseLongLitHashEntry *tab = getHashTableBase(ll_table, ll_sub); u32 hash = hashLongLiteral(scan_buf, LONG_LIT_HASH_LEN, nocase); u32 bucket = hash & ((1U << nbits) - 1); while (tab[bucket].str_offset != 0) { DEBUG_PRINTF("checking bucket %u\n", bucket); if (confirmLongLiteral(ll_table, scratch, &tab[bucket], nocase)) { DEBUG_PRINTF("found hit for bucket %u\n", bucket); return bucket + 1; } if (++bucket == num_entries) { bucket = 0; } } return 0; } static rose_inline void storeLongLiteralState(const struct RoseEngine *t, char *state, struct hs_scratch *scratch) { if (!t->longLitTableOffset) { DEBUG_PRINTF("no table\n"); return; } struct core_info *ci = &scratch->core_info; const struct RoseLongLitTable *ll_table = getByOffset(t, t->longLitTableOffset); assert(ll_table->maxLen); DEBUG_PRINTF("maxLen=%u, len=%zu, hlen=%zu\n", ll_table->maxLen, ci->len, ci->hlen); u32 state_case = 0; u32 state_nocase = 0; // If we don't have enough history, we don't need to do anything. if (ll_table->maxLen <= ci->len + ci->hlen) { u8 tempbuf[LONG_LIT_HASH_LEN]; const u8 *scan_buf = prepScanBuffer(ci, ll_table, tempbuf); if (ll_table->caseful.hashBits && checkBloomFilter(ll_table, &ll_table->caseful, scan_buf, 0)) { state_case = checkHashTable(ll_table, &ll_table->caseful, scan_buf, scratch, 0); } if (ll_table->nocase.hashBits && checkBloomFilter(ll_table, &ll_table->nocase, scan_buf, 1)) { state_nocase = checkHashTable(ll_table, &ll_table->nocase, scan_buf, scratch, 1); } } else { DEBUG_PRINTF("not enough history (%zu bytes)\n", ci->len + ci->hlen); } DEBUG_PRINTF("store {%u, %u}\n", state_case, state_nocase); u8 *ll_state = getLongLitState(t, state); storeLongLitStreamState(ll_table, ll_state, state_case, state_nocase); } #endif // STREAM_LONG_LIT_H hyperscan-4.4.1/src/rose/stream.c0000644000175000017500000006337613055426554017514 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "catchup.h" #include "counting_miracle.h" #include "infix.h" #include "match.h" #include "miracle.h" #include "program_runtime.h" #include "rose.h" #include "rose_internal.h" #include "stream_long_lit.h" #include "hwlm/hwlm.h" #include "nfa/mcclellan.h" #include "nfa/nfa_api.h" #include "nfa/nfa_api_queue.h" #include "nfa/nfa_internal.h" #include "util/fatbit.h" static rose_inline void runAnchoredTableStream(const struct RoseEngine *t, const void *atable, size_t alen, u64a offset, struct hs_scratch *scratch) { char *state_base = scratch->core_info.state + t->stateOffsets.anchorState; const struct anchored_matcher_info *curr = atable; do { DEBUG_PRINTF("--anchored nfa (+%u) no %u so %u\n", curr->anchoredMinDistance, curr->next_offset, curr->state_offset); const struct NFA *nfa = (const struct NFA *)((const char *)curr + sizeof(*curr)); assert(ISALIGNED_CL(nfa)); assert(isMcClellanType(nfa->type)); char *state = state_base + curr->state_offset; char start = 0; size_t adj = 0; if (offset <= curr->anchoredMinDistance) { adj = curr->anchoredMinDistance - offset; if (adj >= alen) { goto next_nfa; } start = 1; } else { // (No state decompress necessary.) if (nfa->type == MCCLELLAN_NFA_8) { if (!*(u8 *)state) { goto next_nfa; } } else { if (!unaligned_load_u16(state)) { goto next_nfa; } } } if (nfa->type == MCCLELLAN_NFA_8) { nfaExecMcClellan8_SimpStream(nfa, state, scratch->core_info.buf, start, adj, alen, roseAnchoredCallback, scratch); } else { nfaExecMcClellan16_SimpStream(nfa, state, scratch->core_info.buf, start, adj, alen, roseAnchoredCallback, scratch); } next_nfa: if (!curr->next_offset) { break; } curr = (const void *)((const char *)curr + curr->next_offset); } while (1); } static really_inline void saveStreamState(const struct NFA *nfa, struct mq *q, s64a loc) { DEBUG_PRINTF("offset=%llu, length=%zu, hlength=%zu, loc=%lld\n", q->offset, q->length, q->hlength, loc); nfaQueueCompressState(nfa, q, loc); } static really_inline u8 getByteBefore(const struct core_info *ci, s64a sp) { if (sp > 0) { // in main buffer assert(sp <= (s64a)ci->len); return ci->buf[sp - 1]; } // in history buffer assert(-sp < (s64a)ci->hlen); return ci->hbuf[ci->hlen + sp - 1]; } /** \brief Return value for \ref roseScanForMiracles. */ enum MiracleAction { MIRACLE_DEAD, //!< kill off this engine MIRACLE_SAVED, //!< engine has been caught up and state saved MIRACLE_CONTINUE //!< continue running and catch up engine }; static really_inline enum MiracleAction roseScanForMiracles(const struct RoseEngine *t, char *state, struct hs_scratch *scratch, u32 qi, const struct LeftNfaInfo *left, const struct NFA *nfa) { struct core_info *ci = &scratch->core_info; const u32 qCount = t->queueCount; struct mq *q = scratch->queues + qi; const char q_active = fatbit_isset(scratch->aqa, qCount, qi); DEBUG_PRINTF("q_active=%d\n", q_active); const s64a begin_loc = q_active ? q_cur_loc(q) : 0; const s64a end_loc = ci->len; s64a miracle_loc; if (roseMiracleOccurs(t, left, ci, begin_loc, end_loc, &miracle_loc)) { goto found_miracle; } if (roseCountingMiracleOccurs(t, left, ci, begin_loc, end_loc, &miracle_loc)) { goto found_miracle; } DEBUG_PRINTF("no miracle\n"); return MIRACLE_CONTINUE; found_miracle: DEBUG_PRINTF("miracle at %lld\n", miracle_loc); if (left->infix) { if (!q_active) { DEBUG_PRINTF("killing infix\n"); return MIRACLE_DEAD; } DEBUG_PRINTF("skip q forward, %lld to %lld\n", begin_loc, miracle_loc); q_skip_forward_to(q, miracle_loc); if (q_last_type(q) == MQE_START) { DEBUG_PRINTF("miracle caused infix to die\n"); return MIRACLE_DEAD; } DEBUG_PRINTF("re-init infix state\n"); assert(q->items[q->cur].type == MQE_START); q->items[q->cur].location = miracle_loc; nfaQueueInitState(q->nfa, q); } else { if (miracle_loc > end_loc - t->historyRequired) { char *streamState = state + getNfaInfoByQueue(t, qi)->stateOffset; u64a offset = ci->buf_offset + miracle_loc; u8 key = offset ? getByteBefore(ci, miracle_loc) : 0; DEBUG_PRINTF("init state, key=0x%02x, offset=%llu\n", key, offset); if (!nfaInitCompressedState(nfa, offset, streamState, key)) { return MIRACLE_DEAD; } storeRoseDelay(t, state, left, (s64a)ci->len - miracle_loc); return MIRACLE_SAVED; } DEBUG_PRINTF("re-init prefix (skip %lld->%lld)\n", begin_loc, miracle_loc); if (!q_active) { fatbit_set(scratch->aqa, qCount, qi); initRoseQueue(t, qi, left, scratch); } q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, miracle_loc); pushQueueAt(q, 1, MQE_TOP, miracle_loc); nfaQueueInitState(q->nfa, q); } return MIRACLE_CONTINUE; } static really_inline char roseCatchUpLeftfix(const struct RoseEngine *t, char *state, struct hs_scratch *scratch, u32 qi, const struct LeftNfaInfo *left) { assert(!left->transient); // active roses only struct core_info *ci = &scratch->core_info; const u32 qCount = t->queueCount; struct mq *q = scratch->queues + qi; const struct NFA *nfa = getNfaByQueue(t, qi); if (nfaSupportsZombie(nfa) && ci->buf_offset /* prefix can be alive with no q */ && !fatbit_isset(scratch->aqa, qCount, qi) && isZombie(t, state, left)) { DEBUG_PRINTF("yawn - zombie\n"); return 1; } if (left->stopTable) { enum MiracleAction mrv = roseScanForMiracles(t, state, scratch, qi, left, nfa); switch (mrv) { case MIRACLE_DEAD: return 0; case MIRACLE_SAVED: return 1; default: assert(mrv == MIRACLE_CONTINUE); break; } } if (!fatbit_set(scratch->aqa, qCount, qi)) { initRoseQueue(t, qi, left, scratch); s32 sp; if (ci->buf_offset) { sp = -(s32)loadRoseDelay(t, state, left); } else { sp = 0; } DEBUG_PRINTF("ci->len=%zu, sp=%d, historyRequired=%u\n", ci->len, sp, t->historyRequired); if ( ci->len - sp + 1 < t->historyRequired) { // we'll end up safely in the history region. DEBUG_PRINTF("safely in history, skipping\n"); storeRoseDelay(t, state, left, (s64a)ci->len - sp); return 1; } pushQueueAt(q, 0, MQE_START, sp); if (left->infix || ci->buf_offset + sp > 0) { loadStreamState(nfa, q, sp); } else { pushQueueAt(q, 1, MQE_TOP, sp); nfaQueueInitState(nfa, q); } } else { DEBUG_PRINTF("queue already active\n"); if (q->end - q->cur == 1 && q_cur_type(q) == MQE_START) { DEBUG_PRINTF("empty queue, start loc=%lld\n", q_cur_loc(q)); s64a last_loc = q_cur_loc(q); if (ci->len - last_loc + 1 < t->historyRequired) { // we'll end up safely in the history region. DEBUG_PRINTF("safely in history, saving state and skipping\n"); saveStreamState(nfa, q, last_loc); storeRoseDelay(t, state, left, (s64a)ci->len - last_loc); return 1; } } } // Determine whether the byte before last_loc will be in the history // buffer on the next stream write. s64a last_loc = q_last_loc(q); s64a leftovers = ci->len - last_loc; if (leftovers + 1 >= t->historyRequired) { u32 catchup_offset = left->maxLag ? left->maxLag - 1 : 0; last_loc = (s64a)ci->len - catchup_offset; } if (left->infix) { if (infixTooOld(q, last_loc)) { DEBUG_PRINTF("infix died of old age\n"); return 0; } reduceInfixQueue(q, last_loc, left->maxQueueLen, q->nfa->maxWidth); } DEBUG_PRINTF("end scan at %lld\n", last_loc); pushQueueNoMerge(q, MQE_END, last_loc); #ifdef DEBUG debugQueue(q); #endif char rv = nfaQueueExecRose(nfa, q, MO_INVALID_IDX); if (!rv) { /* nfa is dead */ DEBUG_PRINTF("died catching up to stream boundary\n"); return 0; } else { DEBUG_PRINTF("alive, saving stream state\n"); if (nfaSupportsZombie(nfa) && nfaGetZombieStatus(nfa, q, last_loc) == NFA_ZOMBIE_ALWAYS_YES) { DEBUG_PRINTF("not so fast - zombie\n"); setAsZombie(t, state, left); } else { saveStreamState(nfa, q, last_loc); storeRoseDelay(t, state, left, (s64a)ci->len - last_loc); } } return 1; } static rose_inline void roseCatchUpLeftfixes(const struct RoseEngine *t, char *state, struct hs_scratch *scratch) { if (!t->activeLeftIterOffset) { // No sparse iter, no non-transient roses. return; } // As per UE-1629, we catch up leftfix engines to: // * current position (last location in the queue, or last location we // executed to if the queue is empty) if that position (and the byte // before so we can decompress the stream state) will be in the history // buffer on the next stream write; OR // * (stream_boundary - max_delay) other u8 *ara = getActiveLeftArray(t, state); /* indexed by offsets into * left_table */ const u32 arCount = t->activeLeftCount; const struct LeftNfaInfo *left_table = getLeftTable(t); const struct mmbit_sparse_iter *it = getActiveLeftIter(t); struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES]; u32 idx = 0; u32 ri = mmbit_sparse_iter_begin(ara, arCount, &idx, it, si_state); for (; ri != MMB_INVALID; ri = mmbit_sparse_iter_next(ara, arCount, ri, &idx, it, si_state)) { const struct LeftNfaInfo *left = left_table + ri; u32 qi = ri + t->leftfixBeginQueue; DEBUG_PRINTF("leftfix %u of %u, maxLag=%u, infix=%d\n", ri, arCount, left->maxLag, (int)left->infix); if (!roseCatchUpLeftfix(t, state, scratch, qi, left)) { DEBUG_PRINTF("removing rose %u from active list\n", ri); DEBUG_PRINTF("groups old=%016llx mask=%016llx\n", scratch->tctxt.groups, left->squash_mask); scratch->tctxt.groups &= left->squash_mask; mmbit_unset(ara, arCount, ri); } } } // Saves out stream state for all our active suffix NFAs. static rose_inline void roseSaveNfaStreamState(const struct RoseEngine *t, char *state, struct hs_scratch *scratch) { struct mq *queues = scratch->queues; u8 *aa = getActiveLeafArray(t, state); u32 aaCount = t->activeArrayCount; if (scratch->tctxt.mpv_inactive) { DEBUG_PRINTF("mpv is dead as a doornail\n"); /* mpv if it exists is queue 0 */ mmbit_unset(aa, aaCount, 0); } for (u32 qi = mmbit_iterate(aa, aaCount, MMB_INVALID); qi != MMB_INVALID; qi = mmbit_iterate(aa, aaCount, qi)) { DEBUG_PRINTF("saving stream state for qi=%u\n", qi); struct mq *q = queues + qi; // If it's active, it should have an active queue (as we should have // done some work!) assert(fatbit_isset(scratch->aqa, t->queueCount, qi)); const struct NFA *nfa = getNfaByQueue(t, qi); saveStreamState(nfa, q, q_cur_loc(q)); } } static rose_inline void ensureStreamNeatAndTidy(const struct RoseEngine *t, char *state, struct hs_scratch *scratch, size_t length, u64a offset) { struct RoseContext *tctxt = &scratch->tctxt; if (roseCatchUpTo(t, scratch, length + scratch->core_info.buf_offset) == HWLM_TERMINATE_MATCHING) { return; /* dead; no need to clean up state. */ } roseSaveNfaStreamState(t, state, scratch); roseCatchUpLeftfixes(t, state, scratch); roseFlushLastByteHistory(t, scratch, offset + length); tctxt->lastEndOffset = offset + length; storeGroups(t, state, tctxt->groups); storeLongLiteralState(t, state, scratch); } static really_inline void do_rebuild(const struct RoseEngine *t, const struct HWLM *ftable, struct hs_scratch *scratch) { assert(!can_stop_matching(scratch)); size_t len = MIN(scratch->core_info.hlen, t->delayRebuildLength); const u8 *buf = scratch->core_info.hbuf + scratch->core_info.hlen - len; DEBUG_PRINTF("BEGIN FLOATING REBUILD over %zu bytes\n", len); scratch->core_info.status &= ~STATUS_DELAY_DIRTY; hwlmExec(ftable, buf, len, 0, roseDelayRebuildCallback, scratch, scratch->tctxt.groups); assert(!can_stop_matching(scratch)); } static rose_inline void runEagerPrefixesStream(const struct RoseEngine *t, struct hs_scratch *scratch) { if (!t->eagerIterOffset || scratch->core_info.buf_offset >= EAGER_STOP_OFFSET) { return; } char *state = scratch->core_info.state; u8 *ara = getActiveLeftArray(t, state); /* indexed by offsets into * left_table */ const u32 arCount = t->activeLeftCount; const u32 qCount = t->queueCount; const struct LeftNfaInfo *left_table = getLeftTable(t); const struct mmbit_sparse_iter *it = getByOffset(t, t->eagerIterOffset); struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES]; u32 idx = 0; u32 ri = mmbit_sparse_iter_begin(ara, arCount, &idx, it, si_state); for (; ri != MMB_INVALID; ri = mmbit_sparse_iter_next(ara, arCount, ri, &idx, it, si_state)) { const struct LeftNfaInfo *left = left_table + ri; u32 qi = ri + t->leftfixBeginQueue; DEBUG_PRINTF("leftfix %u of %u, maxLag=%u\n", ri, arCount, left->maxLag); assert(!fatbit_isset(scratch->aqa, qCount, qi)); assert(left->eager); assert(!left->infix); struct mq *q = scratch->queues + qi; const struct NFA *nfa = getNfaByQueue(t, qi); s64a loc = MIN(scratch->core_info.len, EAGER_STOP_OFFSET - scratch->core_info.buf_offset); fatbit_set(scratch->aqa, qCount, qi); initRoseQueue(t, qi, left, scratch); if (scratch->core_info.buf_offset) { s64a sp = left->transient ? -(s64a)scratch->core_info.hlen : -(s64a)loadRoseDelay(t, state, left); pushQueueAt(q, 0, MQE_START, sp); if (scratch->core_info.buf_offset + sp > 0) { loadStreamState(nfa, q, sp); /* if the leftfix fix is currently in a match state, we cannot * advance it. */ if (nfaInAnyAcceptState(nfa, q)) { continue; } pushQueueAt(q, 1, MQE_END, loc); } else { pushQueueAt(q, 1, MQE_TOP, sp); pushQueueAt(q, 2, MQE_END, loc); nfaQueueInitState(q->nfa, q); } } else { pushQueueAt(q, 0, MQE_START, 0); pushQueueAt(q, 1, MQE_TOP, 0); pushQueueAt(q, 2, MQE_END, loc); nfaQueueInitState(nfa, q); } char alive = nfaQueueExecToMatch(q->nfa, q, loc); if (!alive) { DEBUG_PRINTF("queue %u dead, squashing\n", qi); mmbit_unset(ara, arCount, ri); fatbit_unset(scratch->aqa, qCount, qi); scratch->tctxt.groups &= left->squash_mask; } else if (q->cur == q->end) { assert(alive != MO_MATCHES_PENDING); /* unlike in block mode we cannot squash groups if there is no match * in this block as we need the groups on for later stream writes */ /* TODO: investigate possibility of a method to suppress groups for * a single stream block. */ DEBUG_PRINTF("queue %u finished, nfa lives\n", qi); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } else { assert(alive == MO_MATCHES_PENDING); DEBUG_PRINTF("queue %u unfinished, nfa lives\n", qi); q->end--; /* remove end item */ } } } void roseStreamExec(const struct RoseEngine *t, struct hs_scratch *scratch) { DEBUG_PRINTF("OH HAI [%llu, %llu)\n", scratch->core_info.buf_offset, scratch->core_info.buf_offset + (u64a)scratch->core_info.len); assert(t); assert(scratch->core_info.hbuf); assert(scratch->core_info.buf); // We should not have been called if we've already been told to terminate // matching. assert(!told_to_stop_matching(scratch)); assert(mmbit_sparse_iter_state_size(t->rolesWithStateCount) < MAX_SPARSE_ITER_STATES); size_t length = scratch->core_info.len; u64a offset = scratch->core_info.buf_offset; // We may have a maximum width (for engines constructed entirely // of bi-anchored patterns). If this write would result in us progressing // beyond this point, we cannot possibly match. if (t->maxBiAnchoredWidth != ROSE_BOUND_INF && offset + length > t->maxBiAnchoredWidth) { DEBUG_PRINTF("bailing, write would progress beyond maxBAWidth\n"); return; } char *state = scratch->core_info.state; struct RoseContext *tctxt = &scratch->tctxt; tctxt->mpv_inactive = 0; tctxt->groups = loadGroups(t, state); tctxt->lit_offset_adjust = offset + 1; // index after last byte tctxt->delayLastEndOffset = offset; tctxt->lastEndOffset = offset; tctxt->filledDelayedSlots = 0; tctxt->lastMatchOffset = 0; tctxt->minMatchOffset = offset; tctxt->minNonMpvMatchOffset = offset; tctxt->next_mpv_offset = 0; DEBUG_PRINTF("BEGIN: history len=%zu, buffer len=%zu groups=%016llx\n", scratch->core_info.hlen, scratch->core_info.len, tctxt->groups); fatbit_clear(scratch->aqa); scratch->al_log_sum = 0; scratch->catchup_pq.qm_size = 0; if (t->outfixBeginQueue != t->outfixEndQueue) { streamInitSufPQ(t, state, scratch); } runEagerPrefixesStream(t, scratch); u32 alen = t->anchoredDistance > offset ? MIN(length + offset, t->anchoredDistance) - offset : 0; const struct anchored_matcher_info *atable = getALiteralMatcher(t); if (atable && alen) { DEBUG_PRINTF("BEGIN ANCHORED %zu/%u\n", scratch->core_info.hlen, alen); runAnchoredTableStream(t, atable, alen, offset, scratch); if (can_stop_matching(scratch)) { goto exit; } } const struct HWLM *ftable = getFLiteralMatcher(t); if (ftable) { // Load in long literal table state and set up "fake history" buffers // (ll_buf, etc, used by the CHECK_LONG_LIT instruction). Note that this // must be done here in order to ensure that it happens before any path // that leads to storeLongLiteralState(), which relies on these buffers. loadLongLiteralState(t, state, scratch); if (t->noFloatingRoots && !roseHasInFlightMatches(t, state, scratch)) { DEBUG_PRINTF("skip FLOATING: no inflight matches\n"); goto flush_delay_and_exit; } size_t flen = length; if (t->floatingDistance != ROSE_BOUND_INF) { flen = t->floatingDistance > offset ? MIN(t->floatingDistance, length + offset) - offset : 0; } size_t hlength = scratch->core_info.hlen; char rebuild = hlength && (scratch->core_info.status & STATUS_DELAY_DIRTY) && (t->maxFloatingDelayedMatch == ROSE_BOUND_INF || offset < t->maxFloatingDelayedMatch); DEBUG_PRINTF("**rebuild %hhd status %hhu mfdm %u, offset %llu\n", rebuild, scratch->core_info.status, t->maxFloatingDelayedMatch, offset); if (!flen) { if (rebuild) { /* rebuild floating delayed match stuff */ do_rebuild(t, ftable, scratch); } goto flush_delay_and_exit; } if (rebuild) { /* rebuild floating delayed match stuff */ do_rebuild(t, ftable, scratch); } if (flen + offset <= t->floatingMinDistance) { DEBUG_PRINTF("skip FLOATING: before floating min\n"); goto flush_delay_and_exit; } size_t start = 0; if (offset < t->floatingMinDistance) { // This scan crosses the floating min distance, so we can use that // to set HWLM's "start" offset. start = t->floatingMinDistance - offset; } DEBUG_PRINTF("start=%zu\n", start); DEBUG_PRINTF("BEGIN FLOATING (over %zu/%zu)\n", flen, length); hwlmExecStreaming(ftable, scratch, flen, start, roseFloatingCallback, scratch, tctxt->groups & t->floating_group_mask); } flush_delay_and_exit: DEBUG_PRINTF("flushing floating\n"); if (cleanUpDelayed(t, scratch, length, offset) == HWLM_TERMINATE_MATCHING) { return; } exit: DEBUG_PRINTF("CLEAN UP TIME\n"); if (!can_stop_matching(scratch)) { ensureStreamNeatAndTidy(t, state, scratch, length, offset); } DEBUG_PRINTF("DONE STREAMING SCAN, status = %u\n", scratch->core_info.status); return; } static rose_inline void roseStreamInitEod(const struct RoseEngine *t, u64a offset, struct hs_scratch *scratch) { struct RoseContext *tctxt = &scratch->tctxt; /* TODO: diff groups for eod */ tctxt->groups = loadGroups(t, scratch->core_info.state); tctxt->lit_offset_adjust = scratch->core_info.buf_offset - scratch->core_info.hlen + 1; // index after last byte tctxt->delayLastEndOffset = offset; tctxt->lastEndOffset = offset; tctxt->filledDelayedSlots = 0; tctxt->lastMatchOffset = 0; tctxt->minMatchOffset = offset; tctxt->minNonMpvMatchOffset = offset; tctxt->next_mpv_offset = offset; scratch->catchup_pq.qm_size = 0; scratch->al_log_sum = 0; /* clear the anchored logs */ fatbit_clear(scratch->aqa); } void roseStreamEodExec(const struct RoseEngine *t, u64a offset, struct hs_scratch *scratch) { assert(scratch); assert(t->requiresEodCheck); DEBUG_PRINTF("ci buf %p/%zu his %p/%zu\n", scratch->core_info.buf, scratch->core_info.len, scratch->core_info.hbuf, scratch->core_info.hlen); // We should not have been called if we've already been told to terminate // matching. assert(!told_to_stop_matching(scratch)); if (t->maxBiAnchoredWidth != ROSE_BOUND_INF && offset > t->maxBiAnchoredWidth) { DEBUG_PRINTF("bailing, we are beyond max width\n"); /* also some of the history/state may be stale */ return; } if (!t->eodProgramOffset) { DEBUG_PRINTF("no eod program\n"); return; } roseStreamInitEod(t, offset, scratch); DEBUG_PRINTF("running eod program at %u\n", t->eodProgramOffset); // There should be no pending delayed literals. assert(!scratch->tctxt.filledDelayedSlots); const u64a som = 0; const size_t match_len = 0; const u8 flags = ROSE_PROG_FLAG_SKIP_MPV_CATCHUP; // Note: we ignore the result, as this is the last thing to ever happen on // a scan. roseRunProgram(t, scratch, t->eodProgramOffset, som, offset, match_len, flags); } hyperscan-4.4.1/src/rose/rose_common.h0000644000175000017500000000373713055426554020541 0ustar sleuthkidsleuthkid/* * 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 ROSE_COMMON_H #define ROSE_COMMON_H // Common defs available to build-time clients as well as runtime. #define ROSE_BOUND_INF (~0U) #define MAX_MASK2_WIDTH 32 // Max block width to use the combined small-block matcher on, instead of // running the floating and anchored tables. #define ROSE_SMALL_BLOCK_LEN 32 /** \brief Length in bytes of a reach bitvector, used by the lookaround code. */ #define REACH_BITVECTOR_LEN 32 #endif // ROSE_COMMON_H hyperscan-4.4.1/src/rose/program_runtime.h0000644000175000017500000022636313055426554021435 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** * \file * \brief Rose runtime: program interpreter. */ #ifndef PROGRAM_RUNTIME_H #define PROGRAM_RUNTIME_H #include "catchup.h" #include "counting_miracle.h" #include "infix.h" #include "match.h" #include "miracle.h" #include "report.h" #include "rose.h" #include "rose_internal.h" #include "rose_program.h" #include "rose_types.h" #include "validate_mask.h" #include "validate_shufti.h" #include "runtime.h" #include "scratch.h" #include "ue2common.h" #include "hwlm/hwlm.h" // for hwlmcb_rv_t #include "util/compare.h" #include "util/copybytes.h" #include "util/fatbit.h" #include "util/multibit.h" /* * Program context flags, which control the behaviour of some instructions at * based on runtime contexts (whether the program is triggered by the anchored * matcher, engine catchup, etc). */ #define ROSE_PROG_FLAG_IN_ANCHORED 1 #define ROSE_PROG_FLAG_IN_CATCHUP 2 #define ROSE_PROG_FLAG_FROM_MPV 4 #define ROSE_PROG_FLAG_SKIP_MPV_CATCHUP 8 hwlmcb_rv_t roseRunProgram(const struct RoseEngine *t, struct hs_scratch *scratch, u32 programOffset, u64a som, u64a end, size_t match_len, u8 prog_flags); /* Inline implementation follows. */ static rose_inline void rosePushDelayedMatch(const struct RoseEngine *t, struct hs_scratch *scratch, u32 delay, u32 delay_index, u64a offset) { assert(delay); const u32 src_slot_index = delay; u32 slot_index = (src_slot_index + offset) & DELAY_MASK; struct RoseContext *tctxt = &scratch->tctxt; if (offset + src_slot_index <= tctxt->delayLastEndOffset) { DEBUG_PRINTF("skip too late\n"); return; } const u32 delay_count = t->delay_count; struct fatbit **delaySlots = getDelaySlots(scratch); struct fatbit *slot = delaySlots[slot_index]; DEBUG_PRINTF("pushing tab %u into slot %u\n", delay_index, slot_index); if (!(tctxt->filledDelayedSlots & (1U << slot_index))) { tctxt->filledDelayedSlots |= 1U << slot_index; fatbit_clear(slot); } fatbit_set(slot, delay_count, delay_index); } static rose_inline void recordAnchoredLiteralMatch(const struct RoseEngine *t, struct hs_scratch *scratch, u32 literal_id, u64a end) { assert(end); if (end <= t->floatingMinLiteralMatchOffset) { return; } struct fatbit **anchoredLiteralRows = getAnchoredLiteralLog(scratch); DEBUG_PRINTF("record %u @ %llu\n", literal_id, end); if (!bf64_set(&scratch->al_log_sum, end - 1)) { // first time, clear row DEBUG_PRINTF("clearing %llu/%u\n", end - 1, t->anchored_count); fatbit_clear(anchoredLiteralRows[end - 1]); } u32 rel_idx = literal_id - t->anchored_base_id; DEBUG_PRINTF("record %u @ %llu index %u/%u\n", literal_id, end, rel_idx, t->anchored_count); assert(rel_idx < t->anchored_count); fatbit_set(anchoredLiteralRows[end - 1], t->anchored_count, rel_idx); } static rose_inline char roseLeftfixCheckMiracles(const struct RoseEngine *t, const struct LeftNfaInfo *left, struct core_info *ci, struct mq *q, u64a end, const char is_infix) { if (!is_infix && left->transient) { // Miracles won't help us with transient leftfix engines; they only // scan for a limited time anyway. return 1; } if (!left->stopTable) { return 1; } DEBUG_PRINTF("looking for miracle on queue %u\n", q->nfa->queueIndex); const s64a begin_loc = q_cur_loc(q); const s64a end_loc = end - ci->buf_offset; s64a miracle_loc; if (roseMiracleOccurs(t, left, ci, begin_loc, end_loc, &miracle_loc)) { goto found_miracle; } if (roseCountingMiracleOccurs(t, left, ci, begin_loc, end_loc, &miracle_loc)) { goto found_miracle; } return 1; found_miracle: DEBUG_PRINTF("miracle at %lld\n", miracle_loc); assert(miracle_loc >= begin_loc); // If we're a prefix, then a miracle effectively results in us needing to // re-init our state and start fresh. if (!is_infix) { if (miracle_loc != begin_loc) { DEBUG_PRINTF("re-init prefix state\n"); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, miracle_loc); pushQueueAt(q, 1, MQE_TOP, miracle_loc); nfaQueueInitState(q->nfa, q); } return 1; } // Otherwise, we're an infix. Remove tops before the miracle from the queue // and re-init at that location. q_skip_forward_to(q, miracle_loc); if (q_last_type(q) == MQE_START) { DEBUG_PRINTF("miracle caused infix to die\n"); return 0; } DEBUG_PRINTF("re-init infix state\n"); assert(q->items[q->cur].type == MQE_START); q->items[q->cur].location = miracle_loc; nfaQueueInitState(q->nfa, q); return 1; } static rose_inline hwlmcb_rv_t roseTriggerSuffix(const struct RoseEngine *t, struct hs_scratch *scratch, u32 qi, u32 top, u64a som, u64a end) { DEBUG_PRINTF("suffix qi=%u, top event=%u\n", qi, top); struct core_info *ci = &scratch->core_info; u8 *aa = getActiveLeafArray(t, ci->state); const u32 aaCount = t->activeArrayCount; const u32 qCount = t->queueCount; struct mq *q = &scratch->queues[qi]; const struct NfaInfo *info = getNfaInfoByQueue(t, qi); const struct NFA *nfa = getNfaByInfo(t, info); s64a loc = (s64a)end - ci->buf_offset; assert(loc <= (s64a)ci->len && loc >= -(s64a)ci->hlen); if (!mmbit_set(aa, aaCount, qi)) { initQueue(q, qi, t, scratch); nfaQueueInitState(nfa, q); pushQueueAt(q, 0, MQE_START, loc); fatbit_set(scratch->aqa, qCount, qi); } else if (info->no_retrigger) { DEBUG_PRINTF("yawn\n"); /* nfa only needs one top; we can go home now */ return HWLM_CONTINUE_MATCHING; } else if (!fatbit_set(scratch->aqa, qCount, qi)) { initQueue(q, qi, t, scratch); loadStreamState(nfa, q, 0); pushQueueAt(q, 0, MQE_START, 0); } else if (isQueueFull(q)) { DEBUG_PRINTF("queue %u full -> catching up nfas\n", qi); if (info->eod) { /* can catch up suffix independently no pq */ q->context = NULL; pushQueueNoMerge(q, MQE_END, loc); nfaQueueExecRose(q->nfa, q, MO_INVALID_IDX); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } else if (ensureQueueFlushed(t, scratch, qi, loc) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } assert(top == MQE_TOP || (top >= MQE_TOP_FIRST && top < MQE_INVALID)); pushQueueSom(q, top, loc, som); if (q_cur_loc(q) == (s64a)ci->len && !info->eod) { /* we may not run the nfa; need to ensure state is fine */ DEBUG_PRINTF("empty run\n"); pushQueueNoMerge(q, MQE_END, loc); char alive = nfaQueueExec(nfa, q, loc); if (alive) { q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } else { mmbit_unset(aa, aaCount, qi); fatbit_unset(scratch->aqa, qCount, qi); } } return HWLM_CONTINUE_MATCHING; } static really_inline char roseTestLeftfix(const struct RoseEngine *t, struct hs_scratch *scratch, u32 qi, u32 leftfixLag, ReportID leftfixReport, u64a end, const char is_infix) { struct core_info *ci = &scratch->core_info; u32 ri = queueToLeftIndex(t, qi); const struct LeftNfaInfo *left = getLeftTable(t) + ri; DEBUG_PRINTF("testing %s %s %u/%u with lag %u (maxLag=%u)\n", (left->transient ? "transient" : "active"), (is_infix ? "infix" : "prefix"), ri, qi, leftfixLag, left->maxLag); assert(leftfixLag <= left->maxLag); assert(left->infix == is_infix); assert(!is_infix || !left->transient); // Only prefixes can be transient. struct mq *q = scratch->queues + qi; char *state = scratch->core_info.state; u8 *activeLeftArray = getActiveLeftArray(t, state); u32 qCount = t->queueCount; u32 arCount = t->activeLeftCount; if (!mmbit_isset(activeLeftArray, arCount, ri)) { DEBUG_PRINTF("engine is dead nothing to see here\n"); return 0; } if (unlikely(end < leftfixLag)) { assert(0); /* lag is the literal length */ return 0; } if (nfaSupportsZombie(getNfaByQueue(t, qi)) && ci->buf_offset && !fatbit_isset(scratch->aqa, qCount, qi) && isZombie(t, state, left)) { DEBUG_PRINTF("zombie\n"); return 1; } if (!fatbit_set(scratch->aqa, qCount, qi)) { DEBUG_PRINTF("initing q %u\n", qi); initRoseQueue(t, qi, left, scratch); if (ci->buf_offset) { // there have been writes before us! s32 sp; if (!is_infix && left->transient) { sp = -(s32)ci->hlen; } else { sp = -(s32)loadRoseDelay(t, state, left); } /* transient nfas are always started fresh -> state not maintained * at stream boundary */ pushQueueAt(q, 0, MQE_START, sp); if (is_infix || (ci->buf_offset + sp > 0 && !left->transient)) { loadStreamState(q->nfa, q, sp); } else { pushQueueAt(q, 1, MQE_TOP, sp); nfaQueueInitState(q->nfa, q); } } else { // first write ever pushQueueAt(q, 0, MQE_START, 0); pushQueueAt(q, 1, MQE_TOP, 0); nfaQueueInitState(q->nfa, q); } } s64a loc = (s64a)end - ci->buf_offset - leftfixLag; assert(loc >= q_cur_loc(q) || left->eager); assert(leftfixReport != MO_INVALID_IDX); if (!is_infix && left->transient) { s64a start_loc = loc - left->transient; if (q_cur_loc(q) < start_loc) { q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, start_loc); pushQueueAt(q, 1, MQE_TOP, start_loc); nfaQueueInitState(q->nfa, q); } } if (q_cur_loc(q) < loc || q_last_type(q) != MQE_START) { if (is_infix) { if (infixTooOld(q, loc)) { DEBUG_PRINTF("infix %u died of old age\n", ri); goto nfa_dead; } reduceInfixQueue(q, loc, left->maxQueueLen, q->nfa->maxWidth); } if (!roseLeftfixCheckMiracles(t, left, ci, q, end, is_infix)) { DEBUG_PRINTF("leftfix %u died due to miracle\n", ri); goto nfa_dead; } #ifdef DEBUG debugQueue(q); #endif pushQueueNoMerge(q, MQE_END, loc); char rv = nfaQueueExecRose(q->nfa, q, leftfixReport); if (!rv) { /* nfa is dead */ DEBUG_PRINTF("leftfix %u died while trying to catch up\n", ri); goto nfa_dead; } // Queue must have next start loc before we call nfaInAcceptState. q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); DEBUG_PRINTF("checking for report %u\n", leftfixReport); DEBUG_PRINTF("leftfix done %hhd\n", (signed char)rv); return rv == MO_MATCHES_PENDING; } else if (q_cur_loc(q) > loc) { /* an eager leftfix may have already progressed past loc if there is no * match at loc. */ assert(left->eager); return 0; } else { assert(q_cur_loc(q) == loc); DEBUG_PRINTF("checking for report %u\n", leftfixReport); char rv = nfaInAcceptState(q->nfa, leftfixReport, q); DEBUG_PRINTF("leftfix done %hhd\n", (signed char)rv); return rv; } nfa_dead: mmbit_unset(activeLeftArray, arCount, ri); scratch->tctxt.groups &= left->squash_mask; return 0; } static rose_inline char roseTestPrefix(const struct RoseEngine *t, struct hs_scratch *scratch, u32 qi, u32 leftfixLag, ReportID leftfixReport, u64a end) { return roseTestLeftfix(t, scratch, qi, leftfixLag, leftfixReport, end, 0); } static rose_inline char roseTestInfix(const struct RoseEngine *t, struct hs_scratch *scratch, u32 qi, u32 leftfixLag, ReportID leftfixReport, u64a end) { return roseTestLeftfix(t, scratch, qi, leftfixLag, leftfixReport, end, 1); } static rose_inline void roseTriggerInfix(const struct RoseEngine *t, struct hs_scratch *scratch, u64a start, u64a end, u32 qi, u32 topEvent, u8 cancel) { struct core_info *ci = &scratch->core_info; s64a loc = (s64a)end - ci->buf_offset; u32 ri = queueToLeftIndex(t, qi); assert(topEvent < MQE_INVALID); const struct LeftNfaInfo *left = getLeftInfoByQueue(t, qi); assert(!left->transient); DEBUG_PRINTF("rose %u (qi=%u) event %u\n", ri, qi, topEvent); struct mq *q = scratch->queues + qi; const struct NfaInfo *info = getNfaInfoByQueue(t, qi); char *state = ci->state; u8 *activeLeftArray = getActiveLeftArray(t, state); const u32 arCount = t->activeLeftCount; char alive = mmbit_set(activeLeftArray, arCount, ri); if (alive && info->no_retrigger) { DEBUG_PRINTF("yawn\n"); return; } struct fatbit *aqa = scratch->aqa; const u32 qCount = t->queueCount; if (alive && nfaSupportsZombie(getNfaByInfo(t, info)) && ci->buf_offset && !fatbit_isset(aqa, qCount, qi) && isZombie(t, state, left)) { DEBUG_PRINTF("yawn - zombie\n"); return; } if (cancel) { DEBUG_PRINTF("dominating top: (re)init\n"); fatbit_set(aqa, qCount, qi); initRoseQueue(t, qi, left, scratch); pushQueueAt(q, 0, MQE_START, loc); nfaQueueInitState(q->nfa, q); } else if (!fatbit_set(aqa, qCount, qi)) { DEBUG_PRINTF("initing %u\n", qi); initRoseQueue(t, qi, left, scratch); if (alive) { s32 sp = -(s32)loadRoseDelay(t, state, left); pushQueueAt(q, 0, MQE_START, sp); loadStreamState(q->nfa, q, sp); } else { pushQueueAt(q, 0, MQE_START, loc); nfaQueueInitState(q->nfa, q); } } else if (!alive) { q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); nfaQueueInitState(q->nfa, q); } else if (isQueueFull(q)) { reduceInfixQueue(q, loc, left->maxQueueLen, q->nfa->maxWidth); if (isQueueFull(q)) { /* still full - reduceInfixQueue did nothing */ DEBUG_PRINTF("queue %u full (%u items) -> catching up nfa\n", qi, q->end - q->cur); pushQueueNoMerge(q, MQE_END, loc); nfaQueueExecRose(q->nfa, q, MO_INVALID_IDX); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } } pushQueueSom(q, topEvent, loc, start); } static rose_inline hwlmcb_rv_t roseReport(const struct RoseEngine *t, struct hs_scratch *scratch, u64a end, ReportID onmatch, s32 offset_adjust, u32 ekey) { assert(!t->needsCatchup || end == scratch->tctxt.minMatchOffset); DEBUG_PRINTF("firing callback onmatch=%u, end=%llu\n", onmatch, end); updateLastMatchOffset(&scratch->tctxt, end); int cb_rv = roseDeliverReport(end, onmatch, offset_adjust, scratch, ekey); if (cb_rv == MO_HALT_MATCHING) { DEBUG_PRINTF("termination requested\n"); return HWLM_TERMINATE_MATCHING; } if (ekey == INVALID_EKEY || cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) { return HWLM_CONTINUE_MATCHING; } return roseHaltIfExhausted(t, scratch); } /* catches up engines enough to ensure any earlier mpv triggers are enqueued * and then adds the trigger to the mpv queue. Must not be called during catch * up */ static rose_inline hwlmcb_rv_t roseCatchUpAndHandleChainMatch(const struct RoseEngine *t, struct hs_scratch *scratch, u32 event, u64a top_squash_distance, u64a end, const char in_catchup) { if (!in_catchup && roseCatchUpMpvFeeders(t, scratch, end) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } return roseHandleChainMatch(t, scratch, event, top_squash_distance, end, in_catchup); } static rose_inline void roseHandleSom(UNUSED const struct RoseEngine *t, struct hs_scratch *scratch, const struct som_operation *sr, u64a end) { DEBUG_PRINTF("end=%llu, minMatchOffset=%llu\n", end, scratch->tctxt.minMatchOffset); assert(!t->needsCatchup || end == scratch->tctxt.minMatchOffset); updateLastMatchOffset(&scratch->tctxt, end); handleSomInternal(scratch, sr, end); } static rose_inline hwlmcb_rv_t roseReportSom(const struct RoseEngine *t, struct hs_scratch *scratch, u64a start, u64a end, ReportID onmatch, s32 offset_adjust, u32 ekey) { assert(!t->needsCatchup || end == scratch->tctxt.minMatchOffset); DEBUG_PRINTF("firing som callback onmatch=%u, start=%llu, end=%llu\n", onmatch, start, end); updateLastMatchOffset(&scratch->tctxt, end); int cb_rv = roseDeliverSomReport(start, end, onmatch, offset_adjust, scratch, ekey); if (cb_rv == MO_HALT_MATCHING) { DEBUG_PRINTF("termination requested\n"); return HWLM_TERMINATE_MATCHING; } if (ekey == INVALID_EKEY || cb_rv == ROSE_CONTINUE_MATCHING_NO_EXHAUST) { return HWLM_CONTINUE_MATCHING; } return roseHaltIfExhausted(t, scratch); } static rose_inline void roseHandleSomSom(UNUSED const struct RoseEngine *t, struct hs_scratch *scratch, const struct som_operation *sr, u64a start, u64a end) { DEBUG_PRINTF("start=%llu, end=%llu, minMatchOffset=%llu\n", start, end, scratch->tctxt.minMatchOffset); assert(!t->needsCatchup || end == scratch->tctxt.minMatchOffset); updateLastMatchOffset(&scratch->tctxt, end); setSomFromSomAware(scratch, sr, start, end); } static really_inline int reachHasBit(const u8 *reach, u8 c) { return !!(reach[c / 8U] & (u8)1U << (c % 8U)); } /* * Generate a 8-byte valid_mask with #high bytes 0 from the highest side * and #low bytes 0 from the lowest side * and (8 - high - low) bytes '0xff' in the middle. */ static rose_inline u64a generateValidMask(const s32 high, const s32 low) { assert(high + low < 8); DEBUG_PRINTF("high %d low %d\n", high, low); const u64a ones = ~0ull; return (ones << ((high + low) * 8)) >> (high * 8); } /* * Do the single-byte check if only one lookaround entry exists * and it's a single mask. * Return success if the byte is in the future or before history * (offset is greater than (history) buffer length). */ static rose_inline int roseCheckByte(const struct core_info *ci, u8 and_mask, u8 cmp_mask, u8 negation, s32 checkOffset, u64a end) { DEBUG_PRINTF("end=%llu, buf_offset=%llu, buf_end=%llu\n", end, ci->buf_offset, ci->buf_offset + ci->len); if (unlikely(checkOffset < 0 && (u64a)(0 - checkOffset) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } const s64a base_offset = end - ci->buf_offset; s64a offset = base_offset + checkOffset; DEBUG_PRINTF("checkOffset=%d offset=%lld\n", checkOffset, offset); u8 c; if (offset >= 0) { if (offset >= (s64a)ci->len) { DEBUG_PRINTF("in the future\n"); return 1; } else { assert(offset < (s64a)ci->len); DEBUG_PRINTF("check byte in buffer\n"); c = ci->buf[offset]; } } else { if (offset >= -(s64a) ci->hlen) { DEBUG_PRINTF("check byte in history\n"); c = ci->hbuf[ci->hlen + offset]; } else { DEBUG_PRINTF("before history and return\n"); return 1; } } if (((and_mask & c) != cmp_mask) ^ negation) { DEBUG_PRINTF("char 0x%02x at offset %lld failed byte check\n", c, offset); return 0; } DEBUG_PRINTF("real offset=%lld char=%02x\n", offset, c); DEBUG_PRINTF("OK :)\n"); return 1; } static rose_inline int roseCheckMask(const struct core_info *ci, u64a and_mask, u64a cmp_mask, u64a neg_mask, s32 checkOffset, u64a end) { const s64a base_offset = (s64a)end - ci->buf_offset; s64a offset = base_offset + checkOffset; DEBUG_PRINTF("rel offset %lld\n",base_offset); DEBUG_PRINTF("checkOffset %d offset %lld\n", checkOffset, offset); if (unlikely(checkOffset < 0 && (u64a)(0 - checkOffset) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } u64a data = 0; u64a valid_data_mask = ~0ULL; // mask for validate check. //A 0xff byte means that this byte is in the buffer. s32 shift_l = 0; // size of bytes in the future. s32 shift_r = 0; // size of bytes before the history. s32 h_len = 0; // size of bytes in the history buffer. s32 c_len = 8; // size of bytes in the current buffer. if (offset < 0) { // in or before history buffer. if (offset + 8 <= -(s64a)ci->hlen) { DEBUG_PRINTF("before history and return\n"); return 1; } const u8 *h_start = ci->hbuf; // start pointer in history buffer. if (offset < -(s64a)ci->hlen) { // some bytes are before history. shift_r = -(offset + (s64a)ci->hlen); DEBUG_PRINTF("shift_r %d", shift_r); } else { h_start += ci->hlen + offset; } if (offset + 7 < 0) { DEBUG_PRINTF("all in history buffer\n"); data = partial_load_u64a(h_start, 8 - shift_r); } else { // history part c_len = offset + 8; h_len = -offset - shift_r; DEBUG_PRINTF("%d bytes in history\n", h_len); s64a data_h = 0; data_h = partial_load_u64a(h_start, h_len); // current part if (c_len > (s64a)ci->len) { shift_l = c_len - ci->len; c_len = ci->len; } data = partial_load_u64a(ci->buf, c_len); data <<= h_len << 3; data |= data_h; } if (shift_r) { data <<= shift_r << 3; } } else { // current buffer. if (offset + c_len > (s64a)ci->len) { if (offset >= (s64a)ci->len) { DEBUG_PRINTF("all in the future\n"); return 1; } // some bytes in the future. shift_l = offset + c_len - ci->len; c_len = ci->len - offset; data = partial_load_u64a(ci->buf + offset, c_len); } else { data = unaligned_load_u64a(ci->buf + offset); } } if (shift_l || shift_r) { valid_data_mask = generateValidMask(shift_l, shift_r); } DEBUG_PRINTF("valid_data_mask %llx\n", valid_data_mask); if (validateMask(data, valid_data_mask, and_mask, cmp_mask, neg_mask)) { DEBUG_PRINTF("check mask successfully\n"); return 1; } else { return 0; } } static rose_inline int roseCheckMask32(const struct core_info *ci, const u8 *and_mask, const u8 *cmp_mask, const u32 neg_mask, s32 checkOffset, u64a end) { const s64a base_offset = (s64a)end - ci->buf_offset; s64a offset = base_offset + checkOffset; DEBUG_PRINTF("end %lld base_offset %lld\n", end, base_offset); DEBUG_PRINTF("checkOffset %d offset %lld\n", checkOffset, offset); if (unlikely(checkOffset < 0 && (u64a)(0 - checkOffset) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } m256 data = zeroes256(); // consists of the following four parts. s32 c_shift = 0; // blank bytes after current. s32 h_shift = 0; // blank bytes before history. s32 h_len = 32; // number of bytes from history buffer. s32 c_len = 0; // number of bytes from current buffer. /* h_shift + h_len + c_len + c_shift = 32 need to be hold.*/ if (offset < 0) { s32 h_offset = 0; // the start offset in history buffer. if (offset < -(s64a)ci->hlen) { if (offset + 32 <= -(s64a)ci->hlen) { DEBUG_PRINTF("all before history\n"); return 1; } h_shift = -(offset + (s64a)ci->hlen); h_len = 32 - h_shift; } else { h_offset = ci->hlen + offset; } if (offset + 32 > 0) { // part in current buffer. c_len = offset + 32; h_len = -(offset + h_shift); if (c_len > (s64a)ci->len) { // out of current buffer. c_shift = c_len - ci->len; c_len = ci->len; } copy_upto_32_bytes((u8 *)&data - offset, ci->buf, c_len); } assert(h_shift + h_len + c_len + c_shift == 32); copy_upto_32_bytes((u8 *)&data + h_shift, ci->hbuf + h_offset, h_len); } else { if (offset + 32 > (s64a)ci->len) { if (offset >= (s64a)ci->len) { DEBUG_PRINTF("all in the future.\n"); return 1; } c_len = ci->len - offset; c_shift = 32 - c_len; copy_upto_32_bytes((u8 *)&data, ci->buf + offset, c_len); } else { data = loadu256(ci->buf + offset); } } DEBUG_PRINTF("h_shift %d c_shift %d\n", h_shift, c_shift); DEBUG_PRINTF("h_len %d c_len %d\n", h_len, c_len); // we use valid_data_mask to blind bytes before history/in the future. u32 valid_data_mask; valid_data_mask = (~0u) << (h_shift + c_shift) >> (c_shift); m256 and_mask_m256 = loadu256(and_mask); m256 cmp_mask_m256 = loadu256(cmp_mask); if (validateMask32(data, valid_data_mask, and_mask_m256, cmp_mask_m256, neg_mask)) { DEBUG_PRINTF("Mask32 passed\n"); return 1; } return 0; } // get 128/256 bits data from history and current buffer. // return data and valid_data_mask. static rose_inline u32 getBufferDataComplex(const struct core_info *ci, const s64a loc, u8 *data, const u32 data_len) { assert(data_len == 16 || data_len == 32); s32 c_shift = 0; // blank bytes after current. s32 h_shift = 0; // blank bytes before history. s32 h_len = data_len; // number of bytes from history buffer. s32 c_len = 0; // number of bytes from current buffer. if (loc < 0) { s32 h_offset = 0; // the start offset in history buffer. if (loc < -(s64a)ci->hlen) { if (loc + data_len <= -(s64a)ci->hlen) { DEBUG_PRINTF("all before history\n"); return 0; } h_shift = -(loc + (s64a)ci->hlen); h_len = data_len - h_shift; } else { h_offset = ci->hlen + loc; } if (loc + data_len > 0) { // part in current buffer. c_len = loc + data_len; h_len = -(loc + h_shift); if (c_len > (s64a)ci->len) { // out of current buffer. c_shift = c_len - ci->len; c_len = ci->len; } copy_upto_32_bytes(data - loc, ci->buf, c_len); } assert(h_shift + h_len + c_len + c_shift == (s32)data_len); copy_upto_32_bytes(data + h_shift, ci->hbuf + h_offset, h_len); } else { if (loc + data_len > (s64a)ci->len) { if (loc >= (s64a)ci->len) { DEBUG_PRINTF("all in the future.\n"); return 0; } c_len = ci->len - loc; c_shift = data_len - c_len; copy_upto_32_bytes(data, ci->buf + loc, c_len); } else { if (data_len == 16) { storeu128(data, loadu128(ci->buf + loc)); return 0xffff; } else { storeu256(data, loadu256(ci->buf + loc)); return 0xffffffff; } } } DEBUG_PRINTF("h_shift %d c_shift %d\n", h_shift, c_shift); DEBUG_PRINTF("h_len %d c_len %d\n", h_len, c_len); if (data_len == 16) { return (u16)(0xffff << (h_shift + c_shift)) >> c_shift; } else { return (~0u) << (h_shift + c_shift) >> c_shift; } } static rose_inline m128 getData128(const struct core_info *ci, s64a offset, u16 *valid_data_mask) { if (offset > 0 && offset + sizeof(m128) <= ci->len) { *valid_data_mask = 0xffff; return loadu128(ci->buf + offset); } ALIGN_DIRECTIVE u8 data[sizeof(m128)]; *valid_data_mask = (u16)getBufferDataComplex(ci, offset, data, 16); return *(m128 *)data; } static rose_inline m256 getData256(const struct core_info *ci, s64a offset, u32 *valid_data_mask) { if (offset > 0 && offset + sizeof(m256) <= ci->len) { *valid_data_mask = ~0u; return loadu256(ci->buf + offset); } ALIGN_AVX_DIRECTIVE u8 data[sizeof(m256)]; *valid_data_mask = getBufferDataComplex(ci, offset, data, 32); return *(m256 *)data; } static rose_inline int roseCheckShufti16x8(const struct core_info *ci, const u8 *nib_mask, const u8 *bucket_select_mask, u32 neg_mask, s32 checkOffset, u64a end) { const s64a base_offset = (s64a)end - ci->buf_offset; s64a offset = base_offset + checkOffset; DEBUG_PRINTF("end %lld base_offset %lld\n", end, base_offset); DEBUG_PRINTF("checkOffset %d offset %lld\n", checkOffset, offset); if (unlikely(checkOffset < 0 && (u64a)(0 - checkOffset) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } u16 valid_data_mask = 0; m128 data = getData128(ci, offset, &valid_data_mask); if (unlikely(!valid_data_mask)) { return 1; } m256 nib_mask_m256 = loadu256(nib_mask); m128 bucket_select_mask_m128 = loadu128(bucket_select_mask); if (validateShuftiMask16x8(data, nib_mask_m256, bucket_select_mask_m128, neg_mask, valid_data_mask)) { DEBUG_PRINTF("check shufti 16x8 successfully\n"); return 1; } else { return 0; } } static rose_inline int roseCheckShufti16x16(const struct core_info *ci, const u8 *hi_mask, const u8 *lo_mask, const u8 *bucket_select_mask, u32 neg_mask, s32 checkOffset, u64a end) { const s64a base_offset = (s64a)end - ci->buf_offset; s64a offset = base_offset + checkOffset; DEBUG_PRINTF("end %lld base_offset %lld\n", end, base_offset); DEBUG_PRINTF("checkOffset %d offset %lld\n", checkOffset, offset); if (unlikely(checkOffset < 0 && (u64a)(0 - checkOffset) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } u16 valid_data_mask = 0; m128 data = getData128(ci, offset, &valid_data_mask); if (unlikely(!valid_data_mask)) { return 1; } m256 data_m256 = set2x128(data); m256 hi_mask_m256 = loadu256(hi_mask); m256 lo_mask_m256 = loadu256(lo_mask); m256 bucket_select_mask_m256 = loadu256(bucket_select_mask); if (validateShuftiMask16x16(data_m256, hi_mask_m256, lo_mask_m256, bucket_select_mask_m256, neg_mask, valid_data_mask)) { DEBUG_PRINTF("check shufti 16x16 successfully\n"); return 1; } else { return 0; } } static rose_inline int roseCheckShufti32x8(const struct core_info *ci, const u8 *hi_mask, const u8 *lo_mask, const u8 *bucket_select_mask, u32 neg_mask, s32 checkOffset, u64a end) { const s64a base_offset = (s64a)end - ci->buf_offset; s64a offset = base_offset + checkOffset; DEBUG_PRINTF("end %lld base_offset %lld\n", end, base_offset); DEBUG_PRINTF("checkOffset %d offset %lld\n", checkOffset, offset); if (unlikely(checkOffset < 0 && (u64a)(0 - checkOffset) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } u32 valid_data_mask = 0; m256 data = getData256(ci, offset, &valid_data_mask); if (unlikely(!valid_data_mask)) { return 1; } m128 hi_mask_m128 = loadu128(hi_mask); m128 lo_mask_m128 = loadu128(lo_mask); m256 hi_mask_m256 = set2x128(hi_mask_m128); m256 lo_mask_m256 = set2x128(lo_mask_m128); m256 bucket_select_mask_m256 = loadu256(bucket_select_mask); if (validateShuftiMask32x8(data, hi_mask_m256, lo_mask_m256, bucket_select_mask_m256, neg_mask, valid_data_mask)) { DEBUG_PRINTF("check shufti 32x8 successfully\n"); return 1; } else { return 0; } } static rose_inline int roseCheckShufti32x16(const struct core_info *ci, const u8 *hi_mask, const u8 *lo_mask, const u8 *bucket_select_mask_hi, const u8 *bucket_select_mask_lo, u32 neg_mask, s32 checkOffset, u64a end) { const s64a base_offset = (s64a)end - ci->buf_offset; s64a offset = base_offset + checkOffset; DEBUG_PRINTF("end %lld base_offset %lld\n", end, base_offset); DEBUG_PRINTF("checkOffset %d offset %lld\n", checkOffset, offset); if (unlikely(checkOffset < 0 && (u64a)(0 - checkOffset) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } u32 valid_data_mask = 0; m256 data = getData256(ci, offset, &valid_data_mask); if (unlikely(!valid_data_mask)) { return 1; } m256 hi_mask_1 = loadu2x128(hi_mask); m256 hi_mask_2 = loadu2x128(hi_mask + 16); m256 lo_mask_1 = loadu2x128(lo_mask); m256 lo_mask_2 = loadu2x128(lo_mask + 16); m256 bucket_mask_hi = loadu256(bucket_select_mask_hi); m256 bucket_mask_lo = loadu256(bucket_select_mask_lo); if (validateShuftiMask32x16(data, hi_mask_1, hi_mask_2, lo_mask_1, lo_mask_2, bucket_mask_hi, bucket_mask_lo, neg_mask, valid_data_mask)) { DEBUG_PRINTF("check shufti 32x16 successfully\n"); return 1; } else { return 0; } } static rose_inline int roseCheckSingleLookaround(const struct RoseEngine *t, const struct hs_scratch *scratch, s8 checkOffset, u32 lookaroundIndex, u64a end) { assert(lookaroundIndex != MO_INVALID_IDX); const struct core_info *ci = &scratch->core_info; DEBUG_PRINTF("end=%llu, buf_offset=%llu, buf_end=%llu\n", end, ci->buf_offset, ci->buf_offset + ci->len); const s64a base_offset = end - ci->buf_offset; const s64a offset = base_offset + checkOffset; DEBUG_PRINTF("base_offset=%lld\n", base_offset); DEBUG_PRINTF("checkOffset=%d offset=%lld\n", checkOffset, offset); if (unlikely(checkOffset < 0 && (u64a)(0 - checkOffset) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } const u8 *reach_base = (const u8 *)t + t->lookaroundReachOffset; const u8 *reach = reach_base + lookaroundIndex * REACH_BITVECTOR_LEN; u8 c; if (offset >= 0 && offset < (s64a)ci->len) { c = ci->buf[offset]; } else if (offset < 0 && offset >= -(s64a)ci->hlen) { c = ci->hbuf[ci->hlen + offset]; } else { return 1; } if (!reachHasBit(reach, c)) { DEBUG_PRINTF("char 0x%02x failed reach check\n", c); return 0; } DEBUG_PRINTF("OK :)\n"); return 1; } /** * \brief Scan around a literal, checking that that "lookaround" reach masks * are satisfied. */ static rose_inline int roseCheckLookaround(const struct RoseEngine *t, const struct hs_scratch *scratch, u32 lookaroundIndex, u32 lookaroundCount, u64a end) { assert(lookaroundIndex != MO_INVALID_IDX); assert(lookaroundCount > 0); const struct core_info *ci = &scratch->core_info; DEBUG_PRINTF("end=%llu, buf_offset=%llu, buf_end=%llu\n", end, ci->buf_offset, ci->buf_offset + ci->len); const u8 *base = (const u8 *)t; const s8 *look_base = (const s8 *)(base + t->lookaroundTableOffset); const s8 *look = look_base + lookaroundIndex; const s8 *look_end = look + lookaroundCount; assert(look < look_end); const u8 *reach_base = base + t->lookaroundReachOffset; const u8 *reach = reach_base + lookaroundIndex * REACH_BITVECTOR_LEN; // The following code assumes that the lookaround structures are ordered by // increasing offset. const s64a base_offset = end - ci->buf_offset; DEBUG_PRINTF("base_offset=%lld\n", base_offset); DEBUG_PRINTF("first look has offset %d\n", *look); // If our first check tells us we need to look at an offset before the // start of the stream, this role cannot match. if (unlikely(*look < 0 && (u64a)(0 - *look) > end)) { DEBUG_PRINTF("too early, fail\n"); return 0; } // Skip over offsets that are before the history buffer. do { s64a offset = base_offset + *look; if (offset >= -(s64a)ci->hlen) { goto in_history; } DEBUG_PRINTF("look=%d before history\n", *look); look++; reach += REACH_BITVECTOR_LEN; } while (look < look_end); // History buffer. DEBUG_PRINTF("scan history (%zu looks left)\n", look_end - look); for (; look < look_end; ++look, reach += REACH_BITVECTOR_LEN) { in_history: ; s64a offset = base_offset + *look; DEBUG_PRINTF("reach=%p, rel offset=%lld\n", reach, offset); if (offset >= 0) { DEBUG_PRINTF("in buffer\n"); goto in_buffer; } assert(offset >= -(s64a)ci->hlen && offset < 0); u8 c = ci->hbuf[ci->hlen + offset]; if (!reachHasBit(reach, c)) { DEBUG_PRINTF("char 0x%02x failed reach check\n", c); return 0; } } // Current buffer. DEBUG_PRINTF("scan buffer (%zu looks left)\n", look_end - look); for (; look < look_end; ++look, reach += REACH_BITVECTOR_LEN) { in_buffer: ; s64a offset = base_offset + *look; DEBUG_PRINTF("reach=%p, rel offset=%lld\n", reach, offset); if (offset >= (s64a)ci->len) { DEBUG_PRINTF("in the future\n"); break; } assert(offset >= 0 && offset < (s64a)ci->len); u8 c = ci->buf[offset]; if (!reachHasBit(reach, c)) { DEBUG_PRINTF("char 0x%02x failed reach check\n", c); return 0; } } DEBUG_PRINTF("OK :)\n"); return 1; } int roseNfaEarliestSom(u64a start, u64a end, ReportID id, void *context); static rose_inline u64a roseGetHaigSom(const struct RoseEngine *t, struct hs_scratch *scratch, const u32 qi, UNUSED const u32 leftfixLag) { u32 ri = queueToLeftIndex(t, qi); UNUSED const struct LeftNfaInfo *left = getLeftTable(t) + ri; DEBUG_PRINTF("testing %s prefix %u/%u with lag %u (maxLag=%u)\n", left->transient ? "transient" : "active", ri, qi, leftfixLag, left->maxLag); assert(leftfixLag <= left->maxLag); struct mq *q = scratch->queues + qi; u64a start = ~0ULL; /* switch the callback + context for a fun one */ q->cb = roseNfaEarliestSom; q->context = &start; nfaReportCurrentMatches(q->nfa, q); /* restore the old callback + context */ q->cb = roseNfaAdaptor; q->context = NULL; DEBUG_PRINTF("earliest som is %llu\n", start); return start; } static rose_inline char roseCheckBounds(u64a end, u64a min_bound, u64a max_bound) { DEBUG_PRINTF("check offset=%llu against bounds [%llu,%llu]\n", end, min_bound, max_bound); assert(min_bound <= max_bound); return end >= min_bound && end <= max_bound; } static rose_inline hwlmcb_rv_t roseEnginesEod(const struct RoseEngine *rose, struct hs_scratch *scratch, u64a offset, u32 iter_offset) { const char is_streaming = rose->mode != HS_MODE_BLOCK; /* data, len is used for state decompress, should be full available data */ u8 key = 0; if (is_streaming) { const u8 *eod_data = scratch->core_info.hbuf; size_t eod_len = scratch->core_info.hlen; key = eod_len ? eod_data[eod_len - 1] : 0; } const u8 *aa = getActiveLeafArray(rose, scratch->core_info.state); const u32 aaCount = rose->activeArrayCount; const u32 qCount = rose->queueCount; struct fatbit *aqa = scratch->aqa; const struct mmbit_sparse_iter *it = getByOffset(rose, iter_offset); assert(ISALIGNED(it)); u32 idx = 0; struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES]; for (u32 qi = mmbit_sparse_iter_begin(aa, aaCount, &idx, it, si_state); qi != MMB_INVALID; qi = mmbit_sparse_iter_next(aa, aaCount, qi, &idx, it, si_state)) { DEBUG_PRINTF("checking nfa %u\n", qi); struct mq *q = scratch->queues + qi; if (!fatbit_set(aqa, qCount, qi)) { initQueue(q, qi, rose, scratch); } assert(q->nfa == getNfaByQueue(rose, qi)); assert(nfaAcceptsEod(q->nfa)); if (is_streaming) { // Decompress stream state. nfaExpandState(q->nfa, q->state, q->streamState, offset, key); } if (nfaCheckFinalState(q->nfa, q->state, q->streamState, offset, roseReportAdaptor, scratch) == MO_HALT_MATCHING) { DEBUG_PRINTF("user instructed us to stop\n"); return HWLM_TERMINATE_MATCHING; } } return HWLM_CONTINUE_MATCHING; } static rose_inline hwlmcb_rv_t roseSuffixesEod(const struct RoseEngine *rose, struct hs_scratch *scratch, u64a offset) { const u8 *aa = getActiveLeafArray(rose, scratch->core_info.state); const u32 aaCount = rose->activeArrayCount; for (u32 qi = mmbit_iterate(aa, aaCount, MMB_INVALID); qi != MMB_INVALID; qi = mmbit_iterate(aa, aaCount, qi)) { DEBUG_PRINTF("checking nfa %u\n", qi); struct mq *q = scratch->queues + qi; assert(q->nfa == getNfaByQueue(rose, qi)); assert(nfaAcceptsEod(q->nfa)); /* We have just been triggered. */ assert(fatbit_isset(scratch->aqa, rose->queueCount, qi)); pushQueueNoMerge(q, MQE_END, scratch->core_info.len); q->context = NULL; /* rose exec is used as we don't want to / can't raise matches in the * history buffer. */ if (!nfaQueueExecRose(q->nfa, q, MO_INVALID_IDX)) { DEBUG_PRINTF("nfa is dead\n"); continue; } if (nfaCheckFinalState(q->nfa, q->state, q->streamState, offset, roseReportAdaptor, scratch) == MO_HALT_MATCHING) { DEBUG_PRINTF("user instructed us to stop\n"); return HWLM_TERMINATE_MATCHING; } } return HWLM_CONTINUE_MATCHING; } static rose_inline hwlmcb_rv_t roseMatcherEod(const struct RoseEngine *rose, struct hs_scratch *scratch, u64a offset) { assert(rose->ematcherOffset); assert(rose->ematcherRegionSize); // Clear role state and active engines, since we have already handled all // outstanding work there. DEBUG_PRINTF("clear role state and active leaf array\n"); char *state = scratch->core_info.state; mmbit_clear(getRoleState(state), rose->rolesWithStateCount); mmbit_clear(getActiveLeafArray(rose, state), rose->activeArrayCount); const char is_streaming = rose->mode != HS_MODE_BLOCK; size_t eod_len; const u8 *eod_data; if (!is_streaming) { /* Block */ eod_data = scratch->core_info.buf; eod_len = scratch->core_info.len; } else { /* Streaming */ eod_len = scratch->core_info.hlen; eod_data = scratch->core_info.hbuf; } assert(eod_data); assert(eod_len); DEBUG_PRINTF("%zu bytes of eod data to scan at offset %llu\n", eod_len, offset); // If we don't have enough bytes to produce a match from an EOD table scan, // there's no point scanning. if (eod_len < rose->eodmatcherMinWidth) { DEBUG_PRINTF("too short for min width %u\n", rose->eodmatcherMinWidth); return HWLM_CONTINUE_MATCHING; } // Ensure that we only need scan the last N bytes, where N is the length of // the eod-anchored matcher region. size_t adj = eod_len - MIN(eod_len, rose->ematcherRegionSize); const struct HWLM *etable = getByOffset(rose, rose->ematcherOffset); hwlmExec(etable, eod_data, eod_len, adj, roseCallback, scratch, scratch->tctxt.groups); // We may need to fire delayed matches. if (cleanUpDelayed(rose, scratch, 0, offset) == HWLM_TERMINATE_MATCHING) { DEBUG_PRINTF("user instructed us to stop\n"); return HWLM_TERMINATE_MATCHING; } roseFlushLastByteHistory(rose, scratch, offset); return HWLM_CONTINUE_MATCHING; } static rose_inline int roseCheckLongLiteral(const struct RoseEngine *t, const struct hs_scratch *scratch, u64a end, u32 lit_offset, u32 lit_length, char nocase) { const struct core_info *ci = &scratch->core_info; const u8 *lit = getByOffset(t, lit_offset); DEBUG_PRINTF("check lit at %llu, length %u\n", end, lit_length); DEBUG_PRINTF("base buf_offset=%llu\n", ci->buf_offset); if (end < lit_length) { DEBUG_PRINTF("too short!\n"); return 0; } // If any portion of the literal matched in the current buffer, check it. if (end > ci->buf_offset) { u32 scan_len = MIN(end - ci->buf_offset, lit_length); u64a scan_start = end - ci->buf_offset - scan_len; DEBUG_PRINTF("checking suffix (%u bytes) in buf[%llu:%llu]\n", scan_len, scan_start, end); if (cmpForward(ci->buf + scan_start, lit + lit_length - scan_len, scan_len, nocase)) { DEBUG_PRINTF("cmp of suffix failed\n"); return 0; } } // If the entirety of the literal was in the current block, we are done. if (end - lit_length >= ci->buf_offset) { DEBUG_PRINTF("literal confirmed in current block\n"); return 1; } // We still have a prefix which we must test against the buffer prepared by // the long literal table. This is only done in streaming mode. assert(t->mode != HS_MODE_BLOCK); const u8 *ll_buf; size_t ll_len; if (nocase) { ll_buf = scratch->tctxt.ll_buf_nocase; ll_len = scratch->tctxt.ll_len_nocase; } else { ll_buf = scratch->tctxt.ll_buf; ll_len = scratch->tctxt.ll_len; } assert(ll_buf); u64a lit_start_offset = end - lit_length; u32 prefix_len = MIN(lit_length, ci->buf_offset - lit_start_offset); u32 hist_rewind = ci->buf_offset - lit_start_offset; DEBUG_PRINTF("ll_len=%zu, hist_rewind=%u\n", ll_len, hist_rewind); if (hist_rewind > ll_len) { DEBUG_PRINTF("not enough history\n"); return 0; } DEBUG_PRINTF("check prefix len=%u from hist (len %zu, rewind %u)\n", prefix_len, ll_len, hist_rewind); assert(hist_rewind <= ll_len); if (cmpForward(ll_buf + ll_len - hist_rewind, lit, prefix_len, nocase)) { DEBUG_PRINTF("cmp of prefix failed\n"); return 0; } DEBUG_PRINTF("cmp succeeded\n"); return 1; } static void updateSeqPoint(struct RoseContext *tctxt, u64a offset, const char from_mpv) { if (from_mpv) { updateMinMatchOffsetFromMpv(tctxt, offset); } else { updateMinMatchOffset(tctxt, offset); } } #define PROGRAM_CASE(name) \ case ROSE_INSTR_##name: { \ DEBUG_PRINTF("instruction: " #name " (pc=%u)\n", \ programOffset + (u32)(pc - pc_base)); \ const struct ROSE_STRUCT_##name *ri = \ (const struct ROSE_STRUCT_##name *)pc; #define PROGRAM_NEXT_INSTRUCTION \ pc += ROUNDUP_N(sizeof(*ri), ROSE_INSTR_MIN_ALIGN); \ break; \ } static rose_inline hwlmcb_rv_t roseRunProgram_i(const struct RoseEngine *t, struct hs_scratch *scratch, u32 programOffset, u64a som, u64a end, UNUSED size_t match_len, u8 prog_flags) { DEBUG_PRINTF("program=%u, offsets [%llu,%llu], flags=%u\n", programOffset, som, end, prog_flags); assert(programOffset >= sizeof(struct RoseEngine)); assert(programOffset < t->size); const char in_anchored = prog_flags & ROSE_PROG_FLAG_IN_ANCHORED; const char in_catchup = prog_flags & ROSE_PROG_FLAG_IN_CATCHUP; const char from_mpv = prog_flags & ROSE_PROG_FLAG_FROM_MPV; const char skip_mpv_catchup = prog_flags & ROSE_PROG_FLAG_SKIP_MPV_CATCHUP; const char *pc_base = getByOffset(t, programOffset); const char *pc = pc_base; // Local sparse iterator state for programs that use the SPARSE_ITER_BEGIN // and SPARSE_ITER_NEXT instructions. struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES]; // If this program has an effect, work_done will be set to one (which may // allow the program to squash groups). int work_done = 0; struct RoseContext *tctxt = &scratch->tctxt; assert(*(const u8 *)pc != ROSE_INSTR_END); for (;;) { assert(ISALIGNED_N(pc, ROSE_INSTR_MIN_ALIGN)); assert(pc >= pc_base); assert((size_t)(pc - pc_base) < t->size); const u8 code = *(const u8 *)pc; assert(code <= LAST_ROSE_INSTRUCTION); switch ((enum RoseInstructionCode)code) { PROGRAM_CASE(END) { DEBUG_PRINTF("finished\n"); return HWLM_CONTINUE_MATCHING; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(ANCHORED_DELAY) { if (in_anchored && end > t->floatingMinLiteralMatchOffset) { DEBUG_PRINTF("delay until playback\n"); tctxt->groups |= ri->groups; work_done = 1; assert(ri->done_jump); // must progress pc += ri->done_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_LIT_EARLY) { if (end < ri->min_offset) { DEBUG_PRINTF("halt: before min_offset=%u\n", ri->min_offset); return HWLM_CONTINUE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_GROUPS) { DEBUG_PRINTF("groups=0x%llx, checking instr groups=0x%llx\n", tctxt->groups, ri->groups); if (!(ri->groups & tctxt->groups)) { DEBUG_PRINTF("halt: no groups are set\n"); return HWLM_CONTINUE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_ONLY_EOD) { struct core_info *ci = &scratch->core_info; if (end != ci->buf_offset + ci->len) { DEBUG_PRINTF("should only match at end of data\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_BOUNDS) { if (!roseCheckBounds(end, ri->min_bound, ri->max_bound)) { DEBUG_PRINTF("failed bounds check\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_NOT_HANDLED) { struct fatbit *handled = scratch->handled_roles; if (fatbit_set(handled, t->handledKeyCount, ri->key)) { DEBUG_PRINTF("key %u already set\n", ri->key); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SINGLE_LOOKAROUND) { if (!roseCheckSingleLookaround(t, scratch, ri->offset, ri->reach_index, end)) { DEBUG_PRINTF("failed lookaround check\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_LOOKAROUND) { if (!roseCheckLookaround(t, scratch, ri->index, ri->count, end)) { DEBUG_PRINTF("failed lookaround check\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_MASK) { struct core_info *ci = &scratch->core_info; if (!roseCheckMask(ci, ri->and_mask, ri->cmp_mask, ri->neg_mask, ri->offset, end)) { DEBUG_PRINTF("failed mask check\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_MASK_32) { struct core_info *ci = &scratch->core_info; if (!roseCheckMask32(ci, ri->and_mask, ri->cmp_mask, ri->neg_mask, ri->offset, end)) { assert(ri->fail_jump); pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_BYTE) { const struct core_info *ci = &scratch->core_info; if (!roseCheckByte(ci, ri->and_mask, ri->cmp_mask, ri->negation, ri->offset, end)) { DEBUG_PRINTF("failed byte check\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SHUFTI_16x8) { const struct core_info *ci = &scratch->core_info; if (!roseCheckShufti16x8(ci, ri->nib_mask, ri->bucket_select_mask, ri->neg_mask, ri->offset, end)) { assert(ri->fail_jump); pc += ri-> fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SHUFTI_32x8) { const struct core_info *ci = &scratch->core_info; if (!roseCheckShufti32x8(ci, ri->hi_mask, ri->lo_mask, ri->bucket_select_mask, ri->neg_mask, ri->offset, end)) { assert(ri->fail_jump); pc += ri-> fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SHUFTI_16x16) { const struct core_info *ci = &scratch->core_info; if (!roseCheckShufti16x16(ci, ri->hi_mask, ri->lo_mask, ri->bucket_select_mask, ri->neg_mask, ri->offset, end)) { assert(ri->fail_jump); pc += ri-> fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_SHUFTI_32x16) { const struct core_info *ci = &scratch->core_info; if (!roseCheckShufti32x16(ci, ri->hi_mask, ri->lo_mask, ri->bucket_select_mask_hi, ri->bucket_select_mask_lo, ri->neg_mask, ri->offset, end)) { assert(ri->fail_jump); pc += ri-> fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_INFIX) { if (!roseTestInfix(t, scratch, ri->queue, ri->lag, ri->report, end)) { DEBUG_PRINTF("failed infix check\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_PREFIX) { if (!roseTestPrefix(t, scratch, ri->queue, ri->lag, ri->report, end)) { DEBUG_PRINTF("failed prefix check\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(PUSH_DELAYED) { rosePushDelayedMatch(t, scratch, ri->delay, ri->index, end); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(RECORD_ANCHORED) { recordAnchoredLiteralMatch(t, scratch, ri->id, end); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CATCH_UP) { if (roseCatchUpTo(t, scratch, end) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CATCH_UP_MPV) { if (from_mpv || skip_mpv_catchup) { DEBUG_PRINTF("skipping mpv catchup\n"); } else if (roseCatchUpMPV(t, end - scratch->core_info.buf_offset, scratch) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SOM_ADJUST) { assert(ri->distance <= end); som = end - ri->distance; DEBUG_PRINTF("som is (end - %u) = %llu\n", ri->distance, som); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SOM_LEFTFIX) { som = roseGetHaigSom(t, scratch, ri->queue, ri->lag); DEBUG_PRINTF("som from leftfix is %llu\n", som); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SOM_FROM_REPORT) { som = handleSomExternal(scratch, &ri->som, end); DEBUG_PRINTF("som from report %u is %llu\n", ri->som.onmatch, som); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SOM_ZERO) { DEBUG_PRINTF("setting SOM to zero\n"); som = 0; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(TRIGGER_INFIX) { roseTriggerInfix(t, scratch, som, end, ri->queue, ri->event, ri->cancel); work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(TRIGGER_SUFFIX) { if (roseTriggerSuffix(t, scratch, ri->queue, ri->event, som, end) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(DEDUPE) { updateSeqPoint(tctxt, end, from_mpv); const char do_som = t->hasSom; // TODO: constant propagate const char is_external_report = 1; enum DedupeResult rv = dedupeCatchup(t, scratch, end, som, end + ri->offset_adjust, ri->dkey, ri->offset_adjust, is_external_report, ri->quash_som, do_som); switch (rv) { case DEDUPE_HALT: return HWLM_TERMINATE_MATCHING; case DEDUPE_SKIP: assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; case DEDUPE_CONTINUE: break; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(DEDUPE_SOM) { updateSeqPoint(tctxt, end, from_mpv); const char is_external_report = 0; const char do_som = 1; enum DedupeResult rv = dedupeCatchup(t, scratch, end, som, end + ri->offset_adjust, ri->dkey, ri->offset_adjust, is_external_report, ri->quash_som, do_som); switch (rv) { case DEDUPE_HALT: return HWLM_TERMINATE_MATCHING; case DEDUPE_SKIP: assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; case DEDUPE_CONTINUE: break; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_CHAIN) { // Note: sequence points updated inside this function. if (roseCatchUpAndHandleChainMatch( t, scratch, ri->event, ri->top_squash_distance, end, in_catchup) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_SOM_INT) { updateSeqPoint(tctxt, end, from_mpv); roseHandleSom(t, scratch, &ri->som, end); work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_SOM_AWARE) { updateSeqPoint(tctxt, end, from_mpv); roseHandleSomSom(t, scratch, &ri->som, som, end); work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT) { updateSeqPoint(tctxt, end, from_mpv); if (roseReport(t, scratch, end, ri->onmatch, ri->offset_adjust, INVALID_EKEY) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_EXHAUST) { updateSeqPoint(tctxt, end, from_mpv); if (roseReport(t, scratch, end, ri->onmatch, ri->offset_adjust, ri->ekey) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_SOM) { updateSeqPoint(tctxt, end, from_mpv); if (roseReportSom(t, scratch, som, end, ri->onmatch, ri->offset_adjust, INVALID_EKEY) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(REPORT_SOM_EXHAUST) { updateSeqPoint(tctxt, end, from_mpv); if (roseReportSom(t, scratch, som, end, ri->onmatch, ri->offset_adjust, ri->ekey) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(DEDUPE_AND_REPORT) { updateSeqPoint(tctxt, end, from_mpv); const char do_som = t->hasSom; // TODO: constant propagate const char is_external_report = 1; enum DedupeResult rv = dedupeCatchup(t, scratch, end, som, end + ri->offset_adjust, ri->dkey, ri->offset_adjust, is_external_report, ri->quash_som, do_som); switch (rv) { case DEDUPE_HALT: return HWLM_TERMINATE_MATCHING; case DEDUPE_SKIP: assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; case DEDUPE_CONTINUE: break; } const u32 ekey = INVALID_EKEY; if (roseReport(t, scratch, end, ri->onmatch, ri->offset_adjust, ekey) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(FINAL_REPORT) { updateSeqPoint(tctxt, end, from_mpv); if (roseReport(t, scratch, end, ri->onmatch, ri->offset_adjust, INVALID_EKEY) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } /* One-shot specialisation: this instruction always terminates * execution of the program. */ return HWLM_CONTINUE_MATCHING; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_EXHAUSTED) { DEBUG_PRINTF("check ekey %u\n", ri->ekey); assert(ri->ekey != INVALID_EKEY); assert(ri->ekey < t->ekeyCount); const char *evec = scratch->core_info.exhaustionVector; if (isExhausted(t, evec, ri->ekey)) { DEBUG_PRINTF("ekey %u already set, match is exhausted\n", ri->ekey); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_MIN_LENGTH) { DEBUG_PRINTF("check min length %llu (adj %d)\n", ri->min_length, ri->end_adj); assert(ri->min_length > 0); assert(ri->end_adj == 0 || ri->end_adj == -1); assert(som == HS_OFFSET_PAST_HORIZON || som <= end); if (som != HS_OFFSET_PAST_HORIZON && ((end + ri->end_adj) - som < ri->min_length)) { DEBUG_PRINTF("failed check, match len %llu\n", (u64a)((end + ri->end_adj) - som)); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SET_STATE) { DEBUG_PRINTF("set state index %u\n", ri->index); mmbit_set(getRoleState(scratch->core_info.state), t->rolesWithStateCount, ri->index); work_done = 1; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SET_GROUPS) { tctxt->groups |= ri->groups; DEBUG_PRINTF("set groups 0x%llx -> 0x%llx\n", ri->groups, tctxt->groups); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SQUASH_GROUPS) { assert(popcount64(ri->groups) == 63); // Squash only one group. if (work_done) { tctxt->groups &= ri->groups; DEBUG_PRINTF("squash groups 0x%llx -> 0x%llx\n", ri->groups, tctxt->groups); } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_STATE) { DEBUG_PRINTF("check state %u\n", ri->index); const u8 *roles = getRoleState(scratch->core_info.state); if (!mmbit_isset(roles, t->rolesWithStateCount, ri->index)) { DEBUG_PRINTF("state not on\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SPARSE_ITER_BEGIN) { DEBUG_PRINTF("iter_offset=%u\n", ri->iter_offset); const struct mmbit_sparse_iter *it = getByOffset(t, ri->iter_offset); assert(ISALIGNED(it)); const u8 *roles = getRoleState(scratch->core_info.state); u32 idx = 0; u32 i = mmbit_sparse_iter_begin(roles, t->rolesWithStateCount, &idx, it, si_state); if (i == MMB_INVALID) { DEBUG_PRINTF("no states in sparse iter are on\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } fatbit_clear(scratch->handled_roles); const u32 *jumps = getByOffset(t, ri->jump_table); DEBUG_PRINTF("state %u (idx=%u) is on, jump to %u\n", i, idx, jumps[idx]); pc = pc_base + jumps[idx]; continue; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SPARSE_ITER_NEXT) { DEBUG_PRINTF("iter_offset=%u, state=%u\n", ri->iter_offset, ri->state); const struct mmbit_sparse_iter *it = getByOffset(t, ri->iter_offset); assert(ISALIGNED(it)); const u8 *roles = getRoleState(scratch->core_info.state); u32 idx = 0; u32 i = mmbit_sparse_iter_next(roles, t->rolesWithStateCount, ri->state, &idx, it, si_state); if (i == MMB_INVALID) { DEBUG_PRINTF("no more states in sparse iter are on\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } const u32 *jumps = getByOffset(t, ri->jump_table); DEBUG_PRINTF("state %u (idx=%u) is on, jump to %u\n", i, idx, jumps[idx]); pc = pc_base + jumps[idx]; continue; } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SPARSE_ITER_ANY) { DEBUG_PRINTF("iter_offset=%u\n", ri->iter_offset); const struct mmbit_sparse_iter *it = getByOffset(t, ri->iter_offset); assert(ISALIGNED(it)); const u8 *roles = getRoleState(scratch->core_info.state); u32 idx = 0; u32 i = mmbit_sparse_iter_begin(roles, t->rolesWithStateCount, &idx, it, si_state); if (i == MMB_INVALID) { DEBUG_PRINTF("no states in sparse iter are on\n"); assert(ri->fail_jump); // must progress pc += ri->fail_jump; continue; } DEBUG_PRINTF("state %u (idx=%u) is on\n", i, idx); fatbit_clear(scratch->handled_roles); } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(ENGINES_EOD) { if (roseEnginesEod(t, scratch, end, ri->iter_offset) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(SUFFIXES_EOD) { if (roseSuffixesEod(t, scratch, end) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(MATCHER_EOD) { if (roseMatcherEod(t, scratch, end) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_LONG_LIT) { const char nocase = 0; if (!roseCheckLongLiteral(t, scratch, end, ri->lit_offset, ri->lit_length, nocase)) { DEBUG_PRINTF("halt: failed long lit check\n"); return HWLM_CONTINUE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION PROGRAM_CASE(CHECK_LONG_LIT_NOCASE) { const char nocase = 1; if (!roseCheckLongLiteral(t, scratch, end, ri->lit_offset, ri->lit_length, nocase)) { DEBUG_PRINTF("halt: failed nocase long lit check\n"); return HWLM_CONTINUE_MATCHING; } } PROGRAM_NEXT_INSTRUCTION } } assert(0); // unreachable return HWLM_CONTINUE_MATCHING; } #undef PROGRAM_CASE #undef PROGRAM_NEXT_INSTRUCTION #endif // PROGRAM_RUNTIME_H hyperscan-4.4.1/src/rose/rose_in_util.cpp0000644000175000017500000002117313055426554021241 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_in_util.h" #include "rose_build_util.h" #include "nfa/goughcompile.h" #include "nfagraph/ng_depth.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_width.h" #include "util/container.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/ue2_containers.h" #include #include #include #include using namespace std; namespace ue2 { /* Returns a topological ordering of the vertices in g. That is the starts are * at the front and all the predecessors of a vertex occur earlier in the list * than the vertex. */ vector topo_order(const RoseInGraph &g) { assert(hasCorrectlyNumberedVertices(g)); vector v_order; v_order.reserve(num_vertices(g)); boost::topological_sort(g, back_inserter(v_order)); reverse(v_order.begin(), v_order.end()); /* put starts at the front */ return v_order; } namespace { struct RoseEdgeCopier { typedef unordered_map> GraphMap; typedef unordered_map> HaigMap; RoseEdgeCopier(const RoseInGraph &g1, RoseInGraph &g2, const GraphMap &graph_map_in, const HaigMap &haig_map_in) : ig(g1), out(g2), graph_map(graph_map_in), haig_map(haig_map_in) {} void operator()(const RoseInEdge &e1, RoseInEdge &e2) { // Clone all properties. put(boost::edge_all, out, e2, get(boost::edge_all, ig, e1)); // Substitute in cloned graphs. if (ig[e1].graph) { out[e2].graph = graph_map.at(ig[e1].graph.get()); } if (ig[e1].haig) { out[e2].haig = haig_map.at(ig[e1].haig.get()); } } private: const RoseInGraph &ig; RoseInGraph &out; const GraphMap &graph_map; const HaigMap &haig_map; }; } unique_ptr cloneRoseGraph(const RoseInGraph &ig) { assert(hasCorrectlyNumberedVertices(ig)); unique_ptr out = make_unique(); unordered_map> graph_map; unordered_map> haig_map; for (const auto &e : edges_range(ig)) { const RoseInEdgeProps &ep = ig[e]; if (ep.graph && !contains(graph_map, ep.graph.get())) { graph_map[ep.graph.get()] = cloneHolder(*ep.graph); } if (ep.haig && !contains(haig_map, ep.haig.get())) { haig_map[ep.haig.get()] = make_shared(*ep.haig); } } copy_graph(ig, *out, boost::edge_copy(RoseEdgeCopier(ig, *out, graph_map, haig_map))); return out; } void calcVertexOffsets(RoseInGraph &g) { vector v_order = topo_order(g); for (RoseInVertex v : v_order) { if (g[v].type == RIV_START) { g[v].min_offset = 0; g[v].max_offset = ROSE_BOUND_INF; continue; } else if (g[v].type == RIV_ANCHORED_START) { g[v].min_offset = 0; g[v].max_offset = 0; continue; } DEBUG_PRINTF("vertex '%s'\n", dumpString(g[v].s).c_str()); // Min and max predecessor depths. u32 min_d = ROSE_BOUND_INF; u32 max_d = 0; for (const auto &e : in_edges_range(v, g)) { RoseInVertex u = source(e, g); u32 e_min = g[u].min_offset; u32 e_max = g[u].max_offset; DEBUG_PRINTF("in-edge from u with offsets [%u,%u]\n", e_min, e_max); if (g[e].graph) { const NGHolder &h = *g[e].graph; depth g_min_width = findMinWidth(h); depth g_max_width = isAnchored(h) ? findMaxWidth(h) : depth::infinity(); u32 graph_lag = g[e].graph_lag; DEBUG_PRINTF("edge has graph, depths [%s,%s] and lag %u\n", g_min_width.str().c_str(), g_max_width.str().c_str(), graph_lag); g_min_width += graph_lag; g_max_width += graph_lag; e_min = add_rose_depth(e_min, g_min_width); if (g_max_width.is_finite()) { e_max = add_rose_depth(e_max, g_max_width); } else { e_max = ROSE_BOUND_INF; } } else { DEBUG_PRINTF("edge has bounds [%u,%u]\n", g[e].minBound, g[e].maxBound); e_min = add_rose_depth(e_min, g[e].minBound); e_max = add_rose_depth(e_max, g[e].maxBound); if (g[v].type == RIV_LITERAL) { u32 len = g[v].s.length(); DEBUG_PRINTF("lit len %u\n", len); e_min = add_rose_depth(e_min, len); e_max = add_rose_depth(e_max, len); } } min_d = min(min_d, e_min); max_d = max(max_d, e_max); } DEBUG_PRINTF("vertex depths [%u,%u]\n", min_d, max_d); assert(max_d >= min_d); g[v].min_offset = min_d; g[v].max_offset = max_d; } // It's possible that we may have literal delays assigned to vertices here // as well. If so, these need to be added to the min/max offsets. for (RoseInVertex v : v_order) { const u32 delay = g[v].delay; g[v].min_offset = add_rose_depth(g[v].min_offset, delay); g[v].max_offset = add_rose_depth(g[v].max_offset, delay); } } nfa_kind whatRoseIsThis(const RoseInGraph &in, const RoseInEdge &e) { RoseInVertex u = source(e, in); RoseInVertex v = target(e, in); bool start = in[u].type == RIV_START || in[u].type == RIV_ANCHORED_START; bool end = in[v].type == RIV_ACCEPT || in[v].type == RIV_ACCEPT_EOD; if (start && !end) { return NFA_PREFIX; } else if (!start && end) { return NFA_SUFFIX; } else if (!start && !end) { return NFA_INFIX; } else { assert(in[v].type == RIV_ACCEPT_EOD); return NFA_OUTFIX; } } void pruneUseless(RoseInGraph &g) { DEBUG_PRINTF("pruning useless vertices\n"); set dead; RoseInVertex dummy_start = add_vertex(RoseInVertexProps::makeStart(true), g); RoseInVertex dummy_end = add_vertex(RoseInVertexProps::makeAccept(set()), g); dead.insert(dummy_start); dead.insert(dummy_end); for (auto v : vertices_range(g)) { if (v == dummy_start || v == dummy_end) { continue; } switch (g[v].type) { case RIV_ANCHORED_START: case RIV_START: add_edge(dummy_start, v, g); break; case RIV_ACCEPT: case RIV_ACCEPT_EOD: add_edge(v, dummy_end, g); break; default: break; } } find_unreachable(g, vector(1, dummy_start), &dead); find_unreachable(boost::reverse_graph(g), vector(1, dummy_end), &dead); for (auto v : dead) { clear_vertex(v, g); remove_vertex(v, g); } } } hyperscan-4.4.1/src/rose/rose_build_width.cpp0000644000175000017500000002016513055426554022074 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_width.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng_width.h" #include "rose_build_impl.h" #include "ue2common.h" #include "util/graph.h" #include "util/graph_range.h" #include using namespace std; namespace ue2 { static bool is_end_anchored(const RoseGraph &g, RoseVertex v) { for (auto w : adjacent_vertices_range(v, g)) { if (g[w].eod_accept) { return true; } } return false; } u32 findMinWidth(const RoseBuildImpl &tbi, enum rose_literal_table table) { if (table != ROSE_FLOATING && table != ROSE_ANCHORED && table != ROSE_EOD_ANCHORED) { /* handle other tables if ever required */ assert(0); return 0; } const RoseGraph &g = tbi.g; vector table_verts; for (auto v : vertices_range(g)) { if (tbi.hasLiteralInTable(v, table)) { table_verts.push_back(v); } } set reachable; find_reachable(g, table_verts, &reachable); u32 minWidth = ROSE_BOUND_INF; for (auto v : reachable) { if (g[v].eod_accept) { DEBUG_PRINTF("skipping %zu - not a real vertex\n", g[v].index); continue; } const u32 w = g[v].min_offset; if (!g[v].reports.empty()) { DEBUG_PRINTF("%zu can fire report at offset %u\n", g[v].index, w); minWidth = min(minWidth, w); } if (is_end_anchored(g, v)) { DEBUG_PRINTF("%zu can fire eod report at offset %u\n", g[v].index, w); minWidth = min(minWidth, w); } if (g[v].suffix) { depth suffix_width = findMinWidth(g[v].suffix, g[v].suffix.top); assert(suffix_width.is_reachable()); DEBUG_PRINTF("%zu has suffix with top %u (width %s), can fire " "report at %u\n", g[v].index, g[v].suffix.top, suffix_width.str().c_str(), w + suffix_width); minWidth = min(minWidth, w + suffix_width); } } /* TODO: take into account the chain relationship between the mpv and other * engines */ DEBUG_PRINTF("min width %u\n", minWidth); return minWidth; } u32 findMaxBAWidth(const RoseBuildImpl &tbi) { const RoseGraph &g = tbi.g; if (!isLeafNode(tbi.root, g)) { DEBUG_PRINTF("floating literal -> no max width\n"); return ROSE_BOUND_INF; } u64a maxWidth = 0; for (const auto &outfix : tbi.outfixes) { maxWidth = max(maxWidth, (u64a)outfix.maxBAWidth); if (maxWidth >= ROSE_BOUND_INF) { DEBUG_PRINTF("outfix with no max ba width\n"); return ROSE_BOUND_INF; } } // Everyone's anchored, so the max width can be taken from the max // max_offset on our vertices (so long as all accepts are EOD). for (auto v : vertices_range(g)) { if (!g[v].reports.empty() && !g[v].eod_accept) { DEBUG_PRINTF("accept not at eod\n"); return ROSE_BOUND_INF; } if (g[v].reports.empty() && !g[v].suffix) { continue; } assert(g[v].eod_accept || g[v].suffix); u64a w = g[v].max_offset; if (g[v].suffix) { if (has_non_eod_accepts(g[v].suffix)) { return ROSE_BOUND_INF; } depth suffix_width = findMaxWidth(g[v].suffix, g[v].suffix.top); DEBUG_PRINTF("suffix max width for top %u is %s\n", g[v].suffix.top, suffix_width.str().c_str()); assert(suffix_width.is_reachable()); if (!suffix_width.is_finite()) { DEBUG_PRINTF("suffix too wide\n"); return ROSE_BOUND_INF; } w += suffix_width; } maxWidth = max(maxWidth, w); if (maxWidth >= ROSE_BOUND_INF) { DEBUG_PRINTF("too wide\n"); return ROSE_BOUND_INF; } } DEBUG_PRINTF("max ba width %llu\n", maxWidth); assert(maxWidth < ROSE_BOUND_INF); return maxWidth; } u32 findMaxBAWidth(const RoseBuildImpl &tbi, enum rose_literal_table table) { const RoseGraph &g = tbi.g; if (!isLeafNode(tbi.root, g) && table == ROSE_FLOATING) { DEBUG_PRINTF("floating literal -> no max width\n"); return ROSE_BOUND_INF; } if (table != ROSE_FLOATING && table != ROSE_ANCHORED) { /* handle other tables if ever required */ assert(0); return ROSE_BOUND_INF; } DEBUG_PRINTF("looking for a max ba width for %s\n", table == ROSE_FLOATING ? "floating" : "anchored"); vector table_verts; for (auto v : vertices_range(g)) { if ((table == ROSE_FLOATING && tbi.isFloating(v)) || (table == ROSE_ANCHORED && tbi.isAnchored(v))) { table_verts.push_back(v); } } set reachable; find_reachable(g, table_verts, &reachable); u64a maxWidth = 0; // Everyone's anchored, so the max width can be taken from the max // max_offset on our vertices (so long as all accepts are ACCEPT_EOD). for (auto v : reachable) { DEBUG_PRINTF("inspecting vert %zu\n", g[v].index); if (g[v].eod_accept) { DEBUG_PRINTF("skipping %zu - not a real vertex\n", g[v].index); continue; } if (!g[v].reports.empty()) { DEBUG_PRINTF("accept not at eod\n"); return ROSE_BOUND_INF; } u64a w = g[v].max_offset; u64a follow_max = tbi.calcSuccMaxBound(v); /* may have a long bound to accept_eod node */ if (g[v].suffix) { if (has_non_eod_accepts(g[v].suffix)) { DEBUG_PRINTF("has accept\n"); return ROSE_BOUND_INF; } depth suffix_width = findMaxWidth(g[v].suffix); DEBUG_PRINTF("suffix max width %s\n", suffix_width.str().c_str()); assert(suffix_width.is_reachable()); if (!suffix_width.is_finite()) { DEBUG_PRINTF("suffix too wide\n"); return ROSE_BOUND_INF; } follow_max = max(follow_max, (u64a)suffix_width); } w += follow_max; DEBUG_PRINTF("w %llu\n", w); maxWidth = max(maxWidth, w); if (maxWidth >= ROSE_BOUND_INF) { DEBUG_PRINTF("too wide\n"); return ROSE_BOUND_INF; } } DEBUG_PRINTF("max ba width %llu\n", maxWidth); assert(maxWidth < ROSE_BOUND_INF); return maxWidth; } } // namespace ue2 hyperscan-4.4.1/src/rose/miracle.h0000644000175000017500000001142513055426554017626 0ustar sleuthkidsleuthkid/* * 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 ROSE_MIRACLE_H #define ROSE_MIRACLE_H #include "ue2common.h" #include "runtime.h" #include "rose_internal.h" /** \brief Maximum number of bytes to scan when looking for a "miracle" stop * character. */ #define MIRACLE_LEN_MAX 32 static really_inline u64a roseMiracleScan(const u8 *stop, const u8 *d, const u8 *d_start) { assert(d >= d_start); // Note: unrolling this loop manually does appear to reduce its // performance. I'm sick of tilting at this particular windmill. u32 mshift = 0; do { u64a s = (u64a)stop[*d]; if (s) { s <<= mshift; return s; } mshift++; } while (--d >= d_start); return 0; } /** * \brief "Miracle" scan: uses stop table to check if we can skip forward to a * location where we know that the given rose engine will be in a known state. * * Scans the buffer/history between relative locations \a begin_loc and \a * end_loc, and returns a miracle location (if any) that appears in the stream * after \a begin_loc. * * Returns 1 if some bytes can be skipped and sets \a miracle_loc * appropriately, 0 otherwise. */ static rose_inline char roseMiracleOccurs(const struct RoseEngine *t, const struct LeftNfaInfo *left, const struct core_info *ci, const s64a begin_loc, const s64a end_loc, s64a *miracle_loc) { assert(!left->transient); assert(left->stopTable); DEBUG_PRINTF("looking for miracle over [%lld,%lld], maxLag=%u\n", begin_loc, end_loc, left->maxLag); DEBUG_PRINTF("ci->len=%zu, ci->hlen=%zu\n", ci->len, ci->hlen); assert(begin_loc <= end_loc); assert(begin_loc >= -(s64a)ci->hlen); assert(end_loc <= (s64a)ci->len); const u8 *stop = getByOffset(t, left->stopTable); const s64a scan_end_loc = end_loc - left->maxLag; if (scan_end_loc <= begin_loc) { DEBUG_PRINTF("nothing to scan\n"); return 0; } const s64a start = MAX(begin_loc, scan_end_loc - MIRACLE_LEN_MAX); DEBUG_PRINTF("scan [%lld..%lld]\n", start, scan_end_loc); u64a s = 0; // state, on bits are miracle locations // Scan buffer. const s64a buf_scan_start = MAX(0, start); if (scan_end_loc > buf_scan_start) { const u8 *buf = ci->buf; const u8 *d = buf + scan_end_loc - 1; const u8 *d_start = buf + buf_scan_start; s = roseMiracleScan(stop, d, d_start); if (s) { goto miracle_found; } } // Scan history. if (start < 0) { const u8 *hbuf_end = ci->hbuf + ci->hlen; const u8 *d = hbuf_end + MIN(0, scan_end_loc) - 1; const u8 *d_start = hbuf_end + start; s = roseMiracleScan(stop, d, d_start); if (scan_end_loc > 0) { // Shift s over to account for the buffer scan above. s <<= scan_end_loc; } } if (s) { miracle_found: DEBUG_PRINTF("s=0x%llx, ctz=%u\n", s, ctz64(s)); s64a loc = end_loc - left->maxLag - ctz64(s) - 1; if (loc > begin_loc) { DEBUG_PRINTF("miracle at %lld\n", loc); *miracle_loc = loc; return 1; } } DEBUG_PRINTF("no viable miraculous stop characters found\n"); return 0; } #endif // ROSE_MIRACLE_H hyperscan-4.4.1/src/rose/match.h0000644000175000017500000003202213055426554017302 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ROSE_MATCH_H #define ROSE_MATCH_H #include "catchup.h" #include "runtime.h" #include "scratch.h" #include "report.h" #include "rose_common.h" #include "rose_internal.h" #include "ue2common.h" #include "hwlm/hwlm.h" #include "nfa/nfa_api.h" #include "nfa/nfa_api_queue.h" #include "nfa/nfa_api_util.h" #include "som/som_runtime.h" #include "util/bitutils.h" #include "util/exhaust.h" #include "util/fatbit.h" #include "util/multibit.h" /* Callbacks, defined in catchup.c */ int roseNfaAdaptor(u64a start, u64a end, ReportID id, void *context); /* Callbacks, defined in match.c */ hwlmcb_rv_t roseCallback(size_t start, size_t end, u32 id, void *ctx); hwlmcb_rv_t roseFloatingCallback(size_t start, size_t end, u32 id, void *ctx); hwlmcb_rv_t roseDelayRebuildCallback(size_t start, size_t end, u32 id, void *ctx); int roseAnchoredCallback(u64a start, u64a end, u32 id, void *ctx); /* Common code, used all over Rose runtime */ hwlmcb_rv_t roseHandleChainMatch(const struct RoseEngine *t, struct hs_scratch *scratch, u32 event, u64a top_squash_distance, u64a end, char in_catchup); static really_inline void initQueue(struct mq *q, u32 qi, const struct RoseEngine *t, struct hs_scratch *scratch) { const struct NfaInfo *info = getNfaInfoByQueue(t, qi); assert(scratch->fullState); q->nfa = getNfaByInfo(t, info); q->end = 0; q->cur = 0; q->state = scratch->fullState + info->fullStateOffset; q->streamState = scratch->core_info.state + info->stateOffset; q->offset = scratch->core_info.buf_offset; q->buffer = scratch->core_info.buf; q->length = scratch->core_info.len; q->history = scratch->core_info.hbuf; q->hlength = scratch->core_info.hlen; q->cb = roseNfaAdaptor; q->context = scratch; q->report_current = 0; DEBUG_PRINTF("qi=%u, offset=%llu, fullState=%u, streamState=%u, " "state=%u\n", qi, q->offset, info->fullStateOffset, info->stateOffset, *(u32 *)q->state); } static really_inline void initRoseQueue(const struct RoseEngine *t, u32 qi, const struct LeftNfaInfo *left, struct hs_scratch *scratch) { struct mq *q = scratch->queues + qi; const struct NfaInfo *info = getNfaInfoByQueue(t, qi); q->nfa = getNfaByInfo(t, info); q->end = 0; q->cur = 0; q->state = scratch->fullState + info->fullStateOffset; // Transient roses don't have stream state, we use tstate in scratch // instead. The only reason we need this at ALL is for LimEx extended // regions, which assume that they have access to q->streamState + // compressedStateSize. if (left->transient) { q->streamState = (char *)scratch->tstate + info->stateOffset; } else { q->streamState = scratch->core_info.state + info->stateOffset; } q->offset = scratch->core_info.buf_offset; q->buffer = scratch->core_info.buf; q->length = scratch->core_info.len; q->history = scratch->core_info.hbuf; q->hlength = scratch->core_info.hlen; q->cb = NULL; q->context = NULL; q->report_current = 0; DEBUG_PRINTF("qi=%u, offset=%llu, fullState=%u, streamState=%u, " "state=%u\n", qi, q->offset, info->fullStateOffset, info->stateOffset, *(u32 *)q->state); } /** returns 0 if space for two items (top and end) on the queue */ static really_inline char isQueueFull(const struct mq *q) { return q->end + 2 > MAX_MQE_LEN; } static really_inline void loadStreamState(const struct NFA *nfa, struct mq *q, s64a loc) { DEBUG_PRINTF("offset=%llu, length=%zu, hlength=%zu, loc=%lld\n", q->offset, q->length, q->hlength, loc); nfaExpandState(nfa, q->state, q->streamState, q->offset + loc, queue_prev_byte(q, loc)); } static really_inline void storeRoseDelay(const struct RoseEngine *t, char *state, const struct LeftNfaInfo *left, u32 loc) { u32 di = left->lagIndex; if (di == ROSE_OFFSET_INVALID) { return; } assert(loc < 256); // ONE WHOLE BYTE! DEBUG_PRINTF("storing rose delay %u in slot %u\n", loc, di); u8 *leftfixDelay = getLeftfixLagTable(t, state); assert(loc <= MAX_STORED_LEFTFIX_LAG); leftfixDelay[di] = loc; } static really_inline void setAsZombie(const struct RoseEngine *t, char *state, const struct LeftNfaInfo *left) { u32 di = left->lagIndex; assert(di != ROSE_OFFSET_INVALID); if (di == ROSE_OFFSET_INVALID) { return; } u8 *leftfixDelay = getLeftfixLagTable(t, state); leftfixDelay[di] = OWB_ZOMBIE_ALWAYS_YES; } /* loadRoseDelay MUST NOT be called on the first stream write as it is only * initialized for running nfas on stream boundaries */ static really_inline u32 loadRoseDelay(const struct RoseEngine *t, const char *state, const struct LeftNfaInfo *left) { u32 di = left->lagIndex; if (di == ROSE_OFFSET_INVALID) { return 0; } const u8 *leftfixDelay = getLeftfixLagTableConst(t, state); u32 loc = leftfixDelay[di]; DEBUG_PRINTF("read rose delay %u from slot %u\n", loc, di); return loc; } static really_inline char isZombie(const struct RoseEngine *t, const char *state, const struct LeftNfaInfo *left) { u32 di = left->lagIndex; assert(di != ROSE_OFFSET_INVALID); if (di == ROSE_OFFSET_INVALID) { return 0; } const u8 *leftfixDelay = getLeftfixLagTableConst(t, state); DEBUG_PRINTF("read owb %hhu from slot %u\n", leftfixDelay[di], di); return leftfixDelay[di] == OWB_ZOMBIE_ALWAYS_YES; } hwlmcb_rv_t flushQueuedLiterals_i(const struct RoseEngine *t, struct hs_scratch *scratch, u64a end); static really_inline hwlmcb_rv_t flushQueuedLiterals(const struct RoseEngine *t, struct hs_scratch *scratch, u64a end) { struct RoseContext *tctxt = &scratch->tctxt; if (tctxt->delayLastEndOffset == end) { DEBUG_PRINTF("no progress, no flush\n"); return HWLM_CONTINUE_MATCHING; } if (!tctxt->filledDelayedSlots && !scratch->al_log_sum) { tctxt->delayLastEndOffset = end; return HWLM_CONTINUE_MATCHING; } return flushQueuedLiterals_i(t, scratch, end); } static really_inline hwlmcb_rv_t cleanUpDelayed(const struct RoseEngine *t, struct hs_scratch *scratch, size_t length, u64a offset) { if (can_stop_matching(scratch)) { return HWLM_TERMINATE_MATCHING; } if (flushQueuedLiterals(t, scratch, length + offset) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } struct RoseContext *tctxt = &scratch->tctxt; if (tctxt->filledDelayedSlots) { DEBUG_PRINTF("dirty\n"); scratch->core_info.status |= STATUS_DELAY_DIRTY; } else { scratch->core_info.status &= ~STATUS_DELAY_DIRTY; } tctxt->filledDelayedSlots = 0; tctxt->delayLastEndOffset = offset; return HWLM_CONTINUE_MATCHING; } static rose_inline void roseFlushLastByteHistory(const struct RoseEngine *t, struct hs_scratch *scratch, u64a currEnd) { if (!t->lastByteHistoryIterOffset) { return; } struct RoseContext *tctxt = &scratch->tctxt; struct core_info *ci = &scratch->core_info; /* currEnd is last byte of string + 1 */ if (tctxt->lastEndOffset == ci->buf_offset + ci->len || currEnd != ci->buf_offset + ci->len) { /* already flushed or it is not yet time to flush */ return; } DEBUG_PRINTF("flushing\n"); const struct mmbit_sparse_iter *it = getByOffset(t, t->lastByteHistoryIterOffset); assert(ISALIGNED(it)); const u32 numStates = t->rolesWithStateCount; void *role_state = getRoleState(scratch->core_info.state); struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES]; mmbit_sparse_iter_unset(role_state, numStates, it, si_state); } static rose_inline int roseHasInFlightMatches(const struct RoseEngine *t, char *state, const struct hs_scratch *scratch) { if (scratch->al_log_sum) { DEBUG_PRINTF("anchored literals in log\n"); return 1; } if (scratch->tctxt.filledDelayedSlots) { DEBUG_PRINTF("delayed literal\n"); return 1; } if (mmbit_any(getRoleState(state), t->rolesWithStateCount)) { DEBUG_PRINTF("role state is set\n"); return 1; } return 0; } static rose_inline hwlmcb_rv_t roseHaltIfExhausted(const struct RoseEngine *t, struct hs_scratch *scratch) { struct core_info *ci = &scratch->core_info; if (isAllExhausted(t, ci->exhaustionVector)) { ci->status |= STATUS_EXHAUSTED; scratch->tctxt.groups = 0; DEBUG_PRINTF("all exhausted, termination requested\n"); return HWLM_TERMINATE_MATCHING; } return HWLM_CONTINUE_MATCHING; } static really_inline hwlmcb_rv_t ensureQueueFlushed_i(const struct RoseEngine *t, struct hs_scratch *scratch, u32 qi, s64a loc, char is_mpv, char in_catchup) { struct RoseContext *tctxt = &scratch->tctxt; u8 *aa = getActiveLeafArray(t, scratch->core_info.state); struct fatbit *activeQueues = scratch->aqa; u32 aaCount = t->activeArrayCount; u32 qCount = t->queueCount; struct mq *q = &scratch->queues[qi]; DEBUG_PRINTF("qcl %lld, loc: %lld, min (non mpv) match offset: %llu\n", q_cur_loc(q), loc, tctxt->minNonMpvMatchOffset); if (q_cur_loc(q) == loc) { /* too many tops enqueued at the one spot; need to flatten this queue. * We can use the full catchups as it will short circuit as we are * already at this location. It also saves waking everybody up */ pushQueueNoMerge(q, MQE_END, loc); nfaQueueExec(q->nfa, q, loc); q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } else if (!in_catchup) { if (is_mpv) { tctxt->next_mpv_offset = 0; /* force us to catch the mpv */ if (loc + scratch->core_info.buf_offset <= tctxt->minNonMpvMatchOffset) { DEBUG_PRINTF("flushing chained\n"); if (roseCatchUpMPV(t, loc, scratch) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } goto done_queue_empty; } } if (roseCatchUpTo(t, scratch, loc + scratch->core_info.buf_offset) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } else { /* we must be a chained nfa */ assert(is_mpv); DEBUG_PRINTF("flushing chained\n"); tctxt->next_mpv_offset = 0; /* force us to catch the mpv */ if (roseCatchUpMPV(t, loc, scratch) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } done_queue_empty: if (!mmbit_set(aa, aaCount, qi)) { initQueue(q, qi, t, scratch); nfaQueueInitState(q->nfa, q); pushQueueAt(q, 0, MQE_START, loc); fatbit_set(activeQueues, qCount, qi); } assert(!isQueueFull(q)); return roseHaltIfExhausted(t, scratch); } static rose_inline hwlmcb_rv_t ensureQueueFlushed(const struct RoseEngine *t, struct hs_scratch *scratch, u32 qi, s64a loc) { return ensureQueueFlushed_i(t, scratch, qi, loc, 0, 0); } #endif hyperscan-4.4.1/src/rose/rose_build_merge.h0000644000175000017500000000550213055426554021517 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Rose Build: functions for reducing the size of the Rose graph * through merging. */ #ifndef ROSE_BUILD_MERGE_H #define ROSE_BUILD_MERGE_H #include "rose_graph.h" #include #include namespace ue2 { class NGHolder; class RoseBuildImpl; void mergeDupeLeaves(RoseBuildImpl &tbi); void uncalcLeaves(RoseBuildImpl &tbi); bool dedupeLeftfixes(RoseBuildImpl &tbi); void mergeLeftfixesVariableLag(RoseBuildImpl &tbi); void dedupeLeftfixesVariableLag(RoseBuildImpl &tbi); void dedupeSuffixes(RoseBuildImpl &tbi); void mergeAcyclicSuffixes(RoseBuildImpl &tbi); void mergeSmallSuffixes(RoseBuildImpl &tbi); void mergeSmallLeftfixes(RoseBuildImpl &tbi); void mergeCastleLeftfixes(RoseBuildImpl &tbi); void mergeOutfixes(RoseBuildImpl &tbi); void mergePuffixes(RoseBuildImpl &tbi); void mergeCastleSuffixes(RoseBuildImpl &tbi); bool mergeableRoseVertices(const RoseBuildImpl &tbi, RoseVertex u, RoseVertex v); bool mergeableRoseVertices(const RoseBuildImpl &tbi, const std::set &v1, const std::set &v2); bool setDistinctRoseTops(RoseGraph &g, NGHolder &h1, const NGHolder &h2, const std::deque &verts1); } // namespace ue2 #endif // ROSE_BUILD_MERGE_H hyperscan-4.4.1/src/rose/validate_mask.h0000644000175000017500000001066013055426554021016 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 VALIDATE_MASK_H #define VALIDATE_MASK_H #include "ue2common.h" #include "util/simd_utils.h" #if defined(DEBUG) static void validateMask32Print(const u8 *mask) { int i; for (i = 0; i < 32; i++) { printf("%02x", mask[i]); } printf("\n"); } #endif // check positive bytes in cmp_result. // return one if the check passed, zero otherwise. static really_inline int posValidateMask(const u64a cmp_result, const u64a pos_mask) { return !(cmp_result & pos_mask); } /* * check negative bytes in cmp_result. * return one if any byte in cmp_result is not 0, zero otherwise. * check lowest 7 bits and highest bit of every byte respectively. */ static really_inline int negValidateMask(const u64a cmp_result, const u64a neg_mask) { const u64a count_mask = 0x7f7f7f7f7f7f7f7f; // check lowest 7 bits of every byte. // the highest bit should be 1 if check passed. u64a check_low = (cmp_result & count_mask) + count_mask; // check the highest bit of every byte. // combine the highest bit and 0x7f to 0xff if check passes. // flip all 0xff to 0x00 and 0x7f to 0x80. u64a check_all = ~(check_low | cmp_result | count_mask); return !(check_all & neg_mask); } static really_inline int validateMask(u64a data, u64a valid_data_mask, u64a and_mask, u64a cmp_mask, u64a neg_mask) { // skip some byte where valid_data_mask is 0x00 there. and_mask &= valid_data_mask; cmp_mask &= valid_data_mask; neg_mask &= valid_data_mask; u64a cmp_result = (data & and_mask) ^ cmp_mask; /* do the positive check first since it's cheaper */ if (posValidateMask(cmp_result, ~neg_mask) && negValidateMask(cmp_result, neg_mask)) { return 1; } else { DEBUG_PRINTF("data %llx valid_data_mask(vdm) %llx\n", data, valid_data_mask); DEBUG_PRINTF("and_mask & vdm %llx cmp_mask & vdm %llx\n", and_mask, cmp_mask); DEBUG_PRINTF("cmp_result %llx neg_mask & vdm %llx\n", cmp_result, neg_mask); return 0; } } static really_inline int validateMask32(const m256 data, const u32 valid_data_mask, const m256 and_mask, const m256 cmp_mask, const u32 neg_mask) { m256 cmp_result_256 = eq256(and256(data, and_mask), cmp_mask); u32 cmp_result = ~movemask256(cmp_result_256); #ifdef DEBUG DEBUG_PRINTF("data\n"); validateMask32Print((const u8 *)&data); DEBUG_PRINTF("cmp_result\n"); validateMask32Print((const u8 *)&cmp_result_256); #endif DEBUG_PRINTF("cmp_result %08x neg_mask %08x\n", cmp_result, neg_mask); DEBUG_PRINTF("valid_data_mask %08x\n", valid_data_mask); if ((cmp_result & valid_data_mask) == (neg_mask & valid_data_mask)) { DEBUG_PRINTF("checkCompareResult32 passed\n"); return 1; } else { DEBUG_PRINTF("checkCompareResult32 failed\n"); return 0; } } #endif hyperscan-4.4.1/src/rose/match.c0000644000175000017500000005466013055426554017311 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "catchup.h" #include "match.h" #include "program_runtime.h" #include "rose.h" #include "util/bitutils.h" #include "util/fatbit.h" #if defined(DEBUG) || defined(DUMP_SUPPORT) #include "util/compare.h" /** A debugging crutch: print a hex-escaped version of the match for our * perusal. The start and end offsets are stream offsets. */ static UNUSED void printMatch(const struct core_info *ci, u64a start, u64a end) { assert(start <= end); assert(end <= ci->buf_offset + ci->len); printf("'"); u64a i = start; for (; i <= MIN(ci->buf_offset, end); i++) { u64a h_idx = ci->buf_offset - i; u8 c = h_idx >= ci->hlen ? '?' : ci->hbuf[ci->hlen - h_idx - 1]; if (ourisprint(c) && c != '\'') { printf("%c", c); } else { printf("\\x%02x", c); } } for (; i <= end; i++) { u64a b_idx = i - ci->buf_offset - 1; u8 c = b_idx >= ci->len ? '?' : ci->buf[b_idx]; if (ourisprint(c) && c != '\'') { printf("%c", c); } else { printf("\\x%02x", c); } } printf("'"); } #endif hwlmcb_rv_t roseDelayRebuildCallback(size_t start, size_t end, u32 id, void *ctx) { struct hs_scratch *scratch = ctx; struct RoseContext *tctx = &scratch->tctxt; struct core_info *ci = &scratch->core_info; const struct RoseEngine *t = ci->rose; size_t rb_len = MIN(ci->hlen, t->delayRebuildLength); u64a real_end = ci->buf_offset - rb_len + end + 1; // index after last byte #ifdef DEBUG DEBUG_PRINTF("REBUILD MATCH id=%u offsets=[%llu,%llu]: ", id, start + ci->buf_offset - rb_len, real_end); printMatch(ci, start + ci->buf_offset - rb_len, real_end); printf("\n"); #endif DEBUG_PRINTF("STATE groups=0x%016llx\n", tctx->groups); const u32 *delayRebuildPrograms = getByOffset(t, t->litDelayRebuildProgramOffset); assert(id < t->literalCount); const u32 program = delayRebuildPrograms[id]; if (program) { const u64a som = 0; const size_t match_len = end - start + 1; const u8 flags = 0; UNUSED hwlmcb_rv_t rv = roseRunProgram(t, scratch, program, som, real_end, match_len, flags); assert(rv != HWLM_TERMINATE_MATCHING); } /* we are just repopulating the delay queue, groups should be * already set from the original scan. */ return tctx->groups; } static really_inline hwlmcb_rv_t ensureMpvQueueFlushed(const struct RoseEngine *t, struct hs_scratch *scratch, u32 qi, s64a loc, char in_chained) { return ensureQueueFlushed_i(t, scratch, qi, loc, 1, in_chained); } hwlmcb_rv_t roseHandleChainMatch(const struct RoseEngine *t, struct hs_scratch *scratch, u32 event, u64a top_squash_distance, u64a end, char in_catchup) { assert(event == MQE_TOP || event >= MQE_TOP_FIRST); struct core_info *ci = &scratch->core_info; u8 *aa = getActiveLeafArray(t, scratch->core_info.state); u32 aaCount = t->activeArrayCount; struct fatbit *activeQueues = scratch->aqa; u32 qCount = t->queueCount; const u32 qi = 0; /* MPV is always queue 0 if it exists */ struct mq *q = &scratch->queues[qi]; const struct NfaInfo *info = getNfaInfoByQueue(t, qi); s64a loc = (s64a)end - ci->buf_offset; assert(loc <= (s64a)ci->len && loc >= -(s64a)ci->hlen); if (!mmbit_set(aa, aaCount, qi)) { initQueue(q, qi, t, scratch); nfaQueueInitState(q->nfa, q); pushQueueAt(q, 0, MQE_START, loc); fatbit_set(activeQueues, qCount, qi); } else if (info->no_retrigger) { DEBUG_PRINTF("yawn\n"); /* nfa only needs one top; we can go home now */ return HWLM_CONTINUE_MATCHING; } else if (!fatbit_set(activeQueues, qCount, qi)) { initQueue(q, qi, t, scratch); loadStreamState(q->nfa, q, 0); pushQueueAt(q, 0, MQE_START, 0); } else if (isQueueFull(q)) { DEBUG_PRINTF("queue %u full -> catching up nfas\n", qi); /* we know it is a chained nfa and the suffixes/outfixes must already * be known to be consistent */ if (ensureMpvQueueFlushed(t, scratch, qi, loc, in_catchup) == HWLM_TERMINATE_MATCHING) { DEBUG_PRINTF("terminating...\n"); return HWLM_TERMINATE_MATCHING; } } if (top_squash_distance) { assert(q->cur != q->end); struct mq_item *last = &q->items[q->end - 1]; if (last->type == event && last->location >= loc - (s64a)top_squash_distance) { last->location = loc; goto event_enqueued; } } pushQueue(q, event, loc); event_enqueued: if (q_cur_loc(q) == (s64a)ci->len) { /* we may not run the nfa; need to ensure state is fine */ DEBUG_PRINTF("empty run\n"); pushQueueNoMerge(q, MQE_END, loc); char alive = nfaQueueExec(q->nfa, q, loc); if (alive) { scratch->tctxt.mpv_inactive = 0; q->cur = q->end = 0; pushQueueAt(q, 0, MQE_START, loc); } else { mmbit_unset(aa, aaCount, qi); fatbit_unset(scratch->aqa, qCount, qi); } } DEBUG_PRINTF("added mpv event at %lld\n", loc); scratch->tctxt.next_mpv_offset = 0; /* the top event may result in matches * earlier than expected */ return HWLM_CONTINUE_MATCHING; } int roseAnchoredCallback(u64a start, u64a end, u32 id, void *ctx) { struct hs_scratch *scratch = ctx; assert(scratch && scratch->magic == SCRATCH_MAGIC); struct RoseContext *tctxt = &scratch->tctxt; struct core_info *ci = &scratch->core_info; const struct RoseEngine *t = ci->rose; u64a real_end = ci->buf_offset + end; // index after last byte DEBUG_PRINTF("MATCH id=%u offsets=[???,%llu]\n", id, real_end); DEBUG_PRINTF("STATE groups=0x%016llx\n", tctxt->groups); if (can_stop_matching(scratch)) { DEBUG_PRINTF("received a match when we're already dead!\n"); return MO_HALT_MATCHING; } const size_t match_len = 0; /* delayed literals need to be delivered before real literals; however * delayed literals only come from the floating table so if we are going * to deliver a literal here it must be too early for a delayed literal */ /* no history checks from anchored region and we are before the flush * boundary */ if (real_end <= t->floatingMinLiteralMatchOffset) { roseFlushLastByteHistory(t, scratch, real_end); tctxt->lastEndOffset = real_end; } // Note that the "id" we have been handed is the program offset. const u8 flags = ROSE_PROG_FLAG_IN_ANCHORED; if (roseRunProgram(t, scratch, id, start, real_end, match_len, flags) == HWLM_TERMINATE_MATCHING) { assert(can_stop_matching(scratch)); DEBUG_PRINTF("caller requested termination\n"); return MO_HALT_MATCHING; } DEBUG_PRINTF("DONE groups=0x%016llx\n", tctxt->groups); return MO_CONTINUE_MATCHING; } /** * \brief Run the program for the given literal ID, with the interpreter * inlined into this call. * * Assumes not in_anchored. */ static really_inline hwlmcb_rv_t roseProcessMatchInline(const struct RoseEngine *t, struct hs_scratch *scratch, u64a end, size_t match_len, u32 id) { DEBUG_PRINTF("id=%u\n", id); const u32 *programs = getByOffset(t, t->litProgramOffset); assert(id < t->literalCount); const u64a som = 0; const u8 flags = 0; return roseRunProgram_i(t, scratch, programs[id], som, end, match_len, flags); } /** * \brief Run the program for the given literal ID, with the interpreter * out of line. * * Assumes not in_anchored. */ static really_inline hwlmcb_rv_t roseProcessMatch(const struct RoseEngine *t, struct hs_scratch *scratch, u64a end, size_t match_len, u32 id) { DEBUG_PRINTF("id=%u\n", id); const u32 *programs = getByOffset(t, t->litProgramOffset); assert(id < t->literalCount); const u64a som = 0; const u8 flags = 0; return roseRunProgram(t, scratch, programs[id], som, end, match_len, flags); } static rose_inline hwlmcb_rv_t playDelaySlot(const struct RoseEngine *t, struct hs_scratch *scratch, struct fatbit **delaySlots, u32 vicIndex, u64a offset) { /* assert(!tctxt->in_anchored); */ assert(vicIndex < DELAY_SLOT_COUNT); const struct fatbit *vicSlot = delaySlots[vicIndex]; u32 delay_count = t->delay_count; if (offset < t->floatingMinLiteralMatchOffset) { DEBUG_PRINTF("too soon\n"); return HWLM_CONTINUE_MATCHING; } struct RoseContext *tctxt = &scratch->tctxt; roseFlushLastByteHistory(t, scratch, offset); tctxt->lastEndOffset = offset; for (u32 it = fatbit_iterate(vicSlot, delay_count, MMB_INVALID); it != MMB_INVALID; it = fatbit_iterate(vicSlot, delay_count, it)) { u32 literal_id = t->delay_base_id + it; UNUSED rose_group old_groups = tctxt->groups; DEBUG_PRINTF("DELAYED MATCH id=%u offset=%llu\n", literal_id, offset); hwlmcb_rv_t rv = roseProcessMatch(t, scratch, offset, 0, literal_id); DEBUG_PRINTF("DONE groups=0x%016llx\n", tctxt->groups); /* delayed literals can't safely set groups. * However we may be setting groups that successors already have * worked out that we don't need to match the group */ DEBUG_PRINTF("groups in %016llx out %016llx\n", old_groups, tctxt->groups); if (rv == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } return HWLM_CONTINUE_MATCHING; } static really_inline hwlmcb_rv_t flushAnchoredLiteralAtLoc(const struct RoseEngine *t, struct hs_scratch *scratch, u32 curr_loc) { struct RoseContext *tctxt = &scratch->tctxt; struct fatbit *curr_row = getAnchoredLiteralLog(scratch)[curr_loc - 1]; u32 region_width = t->anchored_count; DEBUG_PRINTF("report matches at curr loc\n"); for (u32 it = fatbit_iterate(curr_row, region_width, MMB_INVALID); it != MMB_INVALID; it = fatbit_iterate(curr_row, region_width, it)) { DEBUG_PRINTF("it = %u/%u\n", it, region_width); u32 literal_id = t->anchored_base_id + it; rose_group old_groups = tctxt->groups; DEBUG_PRINTF("ANCH REPLAY MATCH id=%u offset=%u\n", literal_id, curr_loc); hwlmcb_rv_t rv = roseProcessMatch(t, scratch, curr_loc, 0, literal_id); DEBUG_PRINTF("DONE groups=0x%016llx\n", tctxt->groups); /* anchored literals can't safely set groups. * However we may be setting groups that successors already * have worked out that we don't need to match the group */ DEBUG_PRINTF("groups in %016llx out %016llx\n", old_groups, tctxt->groups); tctxt->groups &= old_groups; if (rv == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } /* clear row; does not invalidate iteration */ bf64_unset(&scratch->al_log_sum, curr_loc - 1); return HWLM_CONTINUE_MATCHING; } static really_inline u32 anchored_it_begin(struct hs_scratch *scratch) { struct RoseContext *tctxt = &scratch->tctxt; if (tctxt->lastEndOffset >= scratch->anchored_literal_region_len) { return MMB_INVALID; } u32 begin = tctxt->lastEndOffset; begin--; return bf64_iterate(scratch->al_log_sum, begin); } static really_inline hwlmcb_rv_t flushAnchoredLiterals(const struct RoseEngine *t, struct hs_scratch *scratch, u32 *anchored_it_param, u64a to_off) { struct RoseContext *tctxt = &scratch->tctxt; u32 anchored_it = *anchored_it_param; /* catch up any remaining anchored matches */ for (; anchored_it != MMB_INVALID && anchored_it < to_off; anchored_it = bf64_iterate(scratch->al_log_sum, anchored_it)) { assert(anchored_it < scratch->anchored_literal_region_len); DEBUG_PRINTF("loc_it = %u\n", anchored_it); u32 curr_off = anchored_it + 1; roseFlushLastByteHistory(t, scratch, curr_off); tctxt->lastEndOffset = curr_off; if (flushAnchoredLiteralAtLoc(t, scratch, curr_off) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } *anchored_it_param = anchored_it; return HWLM_CONTINUE_MATCHING; } static really_inline hwlmcb_rv_t playVictims(const struct RoseEngine *t, struct hs_scratch *scratch, u32 *anchored_it, u64a lastEnd, u64a victimDelaySlots, struct fatbit **delaySlots) { while (victimDelaySlots) { u32 vic = findAndClearLSB_64(&victimDelaySlots); DEBUG_PRINTF("vic = %u\n", vic); u64a vicOffset = vic + (lastEnd & ~(u64a)DELAY_MASK); if (flushAnchoredLiterals(t, scratch, anchored_it, vicOffset) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } if (playDelaySlot(t, scratch, delaySlots, vic % DELAY_SLOT_COUNT, vicOffset) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } return HWLM_CONTINUE_MATCHING; } /* call flushQueuedLiterals instead */ hwlmcb_rv_t flushQueuedLiterals_i(const struct RoseEngine *t, struct hs_scratch *scratch, u64a currEnd) { struct RoseContext *tctxt = &scratch->tctxt; u64a lastEnd = tctxt->delayLastEndOffset; DEBUG_PRINTF("flushing backed up matches @%llu up from %llu\n", currEnd, lastEnd); assert(currEnd != lastEnd); /* checked in main entry point */ u32 anchored_it = anchored_it_begin(scratch); if (!tctxt->filledDelayedSlots) { DEBUG_PRINTF("no delayed, no flush\n"); goto anchored_leftovers; } { struct fatbit **delaySlots = getDelaySlots(scratch); u32 lastIndex = lastEnd & DELAY_MASK; u32 currIndex = currEnd & DELAY_MASK; int wrapped = (lastEnd | DELAY_MASK) < currEnd; u64a victimDelaySlots; /* needs to be twice as wide as the number of * slots. */ DEBUG_PRINTF("hello %08x\n", tctxt->filledDelayedSlots); if (!wrapped) { victimDelaySlots = tctxt->filledDelayedSlots; DEBUG_PRINTF("unwrapped %016llx %08x\n", victimDelaySlots, tctxt->filledDelayedSlots); /* index vars < 32 so 64bit shifts are safe */ /* clear all slots at last index and below, */ victimDelaySlots &= ~((1LLU << (lastIndex + 1)) - 1); /* clear all slots above curr index */ victimDelaySlots &= (1LLU << (currIndex + 1)) - 1; tctxt->filledDelayedSlots &= ~victimDelaySlots; DEBUG_PRINTF("unwrapped %016llx %08x\n", victimDelaySlots, tctxt->filledDelayedSlots); } else { DEBUG_PRINTF("wrapped %08x\n", tctxt->filledDelayedSlots); /* 1st half: clear all slots at last index and below, */ u64a first_half = tctxt->filledDelayedSlots; first_half &= ~((1ULL << (lastIndex + 1)) - 1); tctxt->filledDelayedSlots &= (1ULL << (lastIndex + 1)) - 1; u64a second_half = tctxt->filledDelayedSlots; if (currEnd > lastEnd + DELAY_SLOT_COUNT) { /* 2nd half: clear all slots above last index */ second_half &= (1ULL << (lastIndex + 1)) - 1; } else { /* 2nd half: clear all slots above curr index */ second_half &= (1ULL << (currIndex + 1)) - 1; } tctxt->filledDelayedSlots &= ~second_half; victimDelaySlots = first_half | (second_half << DELAY_SLOT_COUNT); DEBUG_PRINTF("-- %016llx %016llx = %016llx (li %u)\n", first_half, second_half, victimDelaySlots, lastIndex); } if (playVictims(t, scratch, &anchored_it, lastEnd, victimDelaySlots, delaySlots) == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } } anchored_leftovers:; hwlmcb_rv_t rv = flushAnchoredLiterals(t, scratch, &anchored_it, currEnd); tctxt->delayLastEndOffset = currEnd; return rv; } static really_inline hwlmcb_rv_t roseCallback_i(size_t start, size_t end, u32 id, void *ctxt) { struct hs_scratch *scratch = ctxt; struct RoseContext *tctx = &scratch->tctxt; const struct RoseEngine *t = scratch->core_info.rose; u64a real_end = end + tctx->lit_offset_adjust; #if defined(DEBUG) DEBUG_PRINTF("MATCH id=%u offsets=[%llu,%llu]: ", id, start + tctx->lit_offset_adjust, real_end); printMatch(&scratch->core_info, start + tctx->lit_offset_adjust, real_end); printf("\n"); #endif DEBUG_PRINTF("last end %llu\n", tctx->lastEndOffset); DEBUG_PRINTF("STATE groups=0x%016llx\n", tctx->groups); if (can_stop_matching(scratch)) { DEBUG_PRINTF("received a match when we're already dead!\n"); return HWLM_TERMINATE_MATCHING; } hwlmcb_rv_t rv = flushQueuedLiterals(t, scratch, real_end); /* flushDelayed may have advanced tctx->lastEndOffset */ if (real_end >= t->floatingMinLiteralMatchOffset) { roseFlushLastByteHistory(t, scratch, real_end); tctx->lastEndOffset = real_end; } if (rv == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATE_MATCHING; } size_t match_len = end - start + 1; rv = roseProcessMatchInline(t, scratch, real_end, match_len, id); DEBUG_PRINTF("DONE groups=0x%016llx\n", tctx->groups); if (rv != HWLM_TERMINATE_MATCHING) { return tctx->groups; } assert(can_stop_matching(scratch)); DEBUG_PRINTF("user requested halt\n"); return HWLM_TERMINATE_MATCHING; } hwlmcb_rv_t roseCallback(size_t start, size_t end, u32 id, void *ctxt) { return roseCallback_i(start, end, id, ctxt); } hwlmcb_rv_t roseFloatingCallback(size_t start, size_t end, u32 id, void *ctxt) { struct hs_scratch *scratch = ctxt; const struct RoseEngine *t = scratch->core_info.rose; return roseCallback_i(start, end, id, ctxt) & t->floating_group_mask; } /** * \brief Execute a boundary report program. * * Returns MO_HALT_MATCHING if the stream is exhausted or the user has * instructed us to halt, or MO_CONTINUE_MATCHING otherwise. */ int roseRunBoundaryProgram(const struct RoseEngine *rose, u32 program, u64a stream_offset, struct hs_scratch *scratch) { DEBUG_PRINTF("running boundary program at offset %u\n", program); if (can_stop_matching(scratch)) { DEBUG_PRINTF("can stop matching\n"); return MO_HALT_MATCHING; } if (rose->hasSom && scratch->deduper.current_report_offset == ~0ULL) { /* we cannot delay the initialization of the som deduper logs any longer * as we are reporting matches. This is done explicitly as we are * shortcutting the som handling in the vacuous repeats as we know they * all come from non-som patterns. */ fatbit_clear(scratch->deduper.som_log[0]); fatbit_clear(scratch->deduper.som_log[1]); scratch->deduper.som_log_dirty = 0; } // Keep assertions in program report path happy. At offset zero, there can // have been no earlier reports. At EOD, all earlier reports should have // been handled and we will have been caught up to the stream offset by the // time we are running boundary report programs. scratch->tctxt.minMatchOffset = stream_offset; const u64a som = 0; const size_t match_len = 0; const u8 flags = 0; hwlmcb_rv_t rv = roseRunProgram(rose, scratch, program, som, stream_offset, match_len, flags); if (rv == HWLM_TERMINATE_MATCHING) { return MO_HALT_MATCHING; } return MO_CONTINUE_MATCHING; } int roseReportAdaptor(u64a start, u64a end, ReportID id, void *context) { struct hs_scratch *scratch = context; assert(scratch && scratch->magic == SCRATCH_MAGIC); DEBUG_PRINTF("id=%u matched at [%llu,%llu]\n", id, start, end); const struct RoseEngine *rose = scratch->core_info.rose; // Our match ID is the program offset. const u32 program = id; const size_t match_len = 0; // Unused in this path. const u8 flags = ROSE_PROG_FLAG_SKIP_MPV_CATCHUP; hwlmcb_rv_t rv = roseRunProgram(rose, scratch, program, start, end, match_len, flags); if (rv == HWLM_TERMINATE_MATCHING) { return MO_HALT_MATCHING; } return can_stop_matching(scratch) ? MO_HALT_MATCHING : MO_CONTINUE_MATCHING; } hyperscan-4.4.1/src/rose/rose_build_dump.cpp0000644000175000017500000003542513055426554021727 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "rose_build_dump.h" #include "rose_build_impl.h" #include "rose_build_matchers.h" #include "rose/rose_dump.h" #include "rose_internal.h" #include "ue2common.h" #include "hwlm/hwlm_build.h" #include "nfa/castlecompile.h" #include "nfa/nfa_internal.h" #include "nfagraph/ng_dump.h" #include "som/slot_manager_dump.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/ue2string.h" #include #include #include #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { /** \brief Return the kind of a left_id or a suffix_id. */ template string render_kind(const Graph &g) { if (g.graph()) { return to_string(g.graph()->kind); } if (g.dfa()) { return to_string(g.dfa()->kind); } if (g.haig()) { return to_string(g.haig()->kind); } if (g.castle()) { return to_string(g.castle()->kind); } return "UNKNOWN"; } namespace { class RoseGraphWriter { public: RoseGraphWriter(const RoseBuildImpl &b_in, const RoseEngine *t_in) : build(b_in), t(t_in) { for (const auto &m : build.ghost) { ghost.insert(m.second); } } void operator() (ostream &os, const RoseVertex &v) const { const RoseGraph &g = build.g; if (v == build.root) { os << "[label=\"\"]"; return; } if (v == build.anchored_root) { os << "[label=\"<^>\"]"; return; } os << "[label=\""; os << "index=" << g[v].index <<"\\n"; for (u32 lit_id : g[v].literals) { writeLiteral(os, lit_id); os << "\\n"; } os << "min_offset=" << g[v].min_offset; if (g[v].max_offset >= ROSE_BOUND_INF) { os << ", max_offset=inf"; } else { os << ", max_offset=" << g[v].max_offset; } os << "\\n"; if (!g[v].reports.empty()) { if (g[v].eod_accept) { os << "\\nACCEPT_EOD"; } else { os << "\\nACCEPT"; } os << " (rep=" << as_string_list(g[v].reports) << ")"; } if (g[v].suffix) { suffix_id suff(g[v].suffix); os << "\\n" << render_kind(suff) << " (top " << g[v].suffix.top; auto it = build.suffix_queue_map.find(suff); if (it != end(build.suffix_queue_map)) { os << ", queue " << it->second; } os << ")"; } if (ghost.find(v) != ghost.end()) { os << "\\nGHOST"; } if (g[v].left) { left_id left(g[v].left); os << "\\n" << render_kind(left) << " (queue "; auto it = build.leftfix_queue_map.find(left); if (it != end(build.leftfix_queue_map)) { os << it->second; } else { os << "??"; } os << ", report " << g[v].left.leftfix_report << ")"; } os << "\""; // Roles with a rose prefix get a colour. if (g[v].left) { os << " color=violetred "; } // Our accepts get different colours. if (!g[v].reports.empty()) { os << " color=blue "; } if (g[v].suffix) { os << " color=forestgreen "; } os << "]"; } void operator() (ostream &os, const RoseEdge &e) const { const RoseGraph &g = build.g; // Render the bounds on this edge. u32 minBound = g[e].minBound; u32 maxBound = g[e].maxBound; os << "[label=\""; if (minBound == 0 && maxBound == ROSE_BOUND_INF) { os << ".*"; } else if (minBound == 1 && maxBound == ROSE_BOUND_INF) { os << ".+"; } else { os << ".{" << minBound << ","; if (maxBound != ROSE_BOUND_INF) { os << maxBound; } os << "}"; } // If we lead to an infix, display which top we're using. RoseVertex v = target(e, g); if (g[v].left) { os << "\\nROSE TOP " << g[e].rose_top; } switch (g[e].history) { case ROSE_ROLE_HISTORY_NONE: break; case ROSE_ROLE_HISTORY_ANCH: os << "\\nANCH history"; break; case ROSE_ROLE_HISTORY_LAST_BYTE: os << "\\nLAST_BYTE history"; break; case ROSE_ROLE_HISTORY_INVALID: os << "\\nINVALID history"; break; } os << "\"]"; } private: // Render the literal associated with a vertex. void writeLiteral(ostream &os, u32 id) const { os << "lit=" << id; if (id < build.literal_info.size()) { os << "/" << build.literal_info[id].final_id << " "; } else { os << "/nofinal "; } if (contains(build.literals.right, id)) { const auto &lit = build.literals.right.at(id); os << '\'' << dotEscapeString(lit.s.get_string()) << '\''; if (lit.s.any_nocase()) { os << " (nocase)"; } if (lit.delay) { os << " +" << lit.delay; } } else { os << ""; } } set ghost; const RoseBuildImpl &build; const RoseEngine *t; }; } // namespace void dumpRoseGraph(const RoseBuild &build_base, const RoseEngine *t, const char *filename) { const RoseBuildImpl &build = dynamic_cast(build_base); const Grey &grey = build.cc.grey; /* "early" rose graphs should only be dumped if we are dumping intermediate * graphs. Early graphs can be identified by the lack of a RoseEngine. */ u32 flag_test = t ? Grey::DUMP_IMPL : Grey::DUMP_INT_GRAPH; if (!(grey.dumpFlags & flag_test)) { return; } stringstream ss; ss << grey.dumpPath << filename; DEBUG_PRINTF("dumping graph to %s\n", ss.str().c_str()); ofstream os(ss.str()); RoseGraphWriter writer(build, t); writeGraphviz(os, build.g, writer, get(boost::vertex_index, build.g)); } namespace { struct CompareVertexRole { explicit CompareVertexRole(const RoseGraph &g_in) : g(g_in) {} inline bool operator()(const RoseVertex &a, const RoseVertex &b) const { return g[a].index < g[b].index; } private: const RoseGraph &g; }; } static void lit_graph_info(const RoseBuildImpl &build, const rose_literal_info &li, u32 *min_offset, bool *in_root_role) { *min_offset = ~0U; *in_root_role = false; for (auto v : li.vertices) { *in_root_role |= build.isRootSuccessor(v); LIMIT_TO_AT_MOST(min_offset, build.g[v].min_offset); } } static void dumpRoseLiterals(const RoseBuildImpl &build, const char *filename) { const RoseGraph &g = build.g; DEBUG_PRINTF("dumping literals\n"); ofstream os(filename); os << "ROSE LITERALS: a total of " << build.literals.right.size() << " literals and " << num_vertices(g) << " roles." << endl << endl; for (const auto &e : build.literals.right) { u32 id = e.first; const ue2_literal &s = e.second.s; const rose_literal_info &lit_info = build.literal_info[id]; switch (e.second.table) { case ROSE_ANCHORED: os << "ANCHORED"; break; case ROSE_FLOATING: os << "FLOATING"; break; case ROSE_EOD_ANCHORED: os << "EOD-ANCHORED"; break; case ROSE_ANCHORED_SMALL_BLOCK: os << "SMALL-BLOCK"; break; case ROSE_EVENT: os << "EVENT"; break; } os << " ID " << id << "/" << lit_info.final_id << ": \"" << escapeString(s.get_string()) << "\"" << " (len " << s.length() << ","; if (s.any_nocase()) { os << " nocase,"; } if (lit_info.requires_benefits) { os << " benefits,"; } if (e.second.delay) { os << " delayed "<< e.second.delay << ","; } os << " groups 0x" << hex << setw(16) << setfill('0') << lit_info.group_mask << dec << ","; if (lit_info.squash_group) { os << " squashes group,"; } u32 min_offset; bool in_root_role; lit_graph_info(build, lit_info, &min_offset, &in_root_role); os << " min offset " << min_offset; if (in_root_role) { os << " root literal"; } os << ") roles=" << lit_info.vertices.size() << endl; if (!lit_info.delayed_ids.empty()) { os << " Children:"; for (u32 d_id : lit_info.delayed_ids) { os << " " << d_id; } os << endl; } // Temporary vector, so that we can sort the output by role. vector verts(lit_info.vertices.begin(), lit_info.vertices.end()); sort(verts.begin(), verts.end(), CompareVertexRole(g)); for (RoseVertex v : verts) { // role info os << " Index " << g[v].index << ": groups=0x" << hex << setw(16) << setfill('0') << g[v].groups << dec; if (g[v].reports.empty()) { os << ", report=NONE"; } else { os << ", report={" << as_string_list(g[v].reports) << "}"; } os << ", min_offset=" << g[v].min_offset; os << ", max_offset=" << g[v].max_offset << endl; // pred info for (const auto &ie : in_edges_range(v, g)) { const auto &u = source(ie, g); os << " Predecessor index="; if (u == build.root) { os << "ROOT"; } else if (u == build.anchored_root) { os << "ANCHORED_ROOT"; } else { os << g[u].index; } os << ": bounds [" << g[ie].minBound << ", "; if (g[ie].maxBound == ROSE_BOUND_INF) { os << "inf"; } else { os << g[ie].maxBound; } os << "]" << endl; } } } os.close(); } template static string toHex(Iter i, const Iter &end) { ostringstream oss; for (; i != end; ++i) { u8 c = *i; oss << hex << setw(2) << setfill('0') << ((unsigned)c & 0xff); } return oss.str(); } static void dumpTestLiterals(const string &filename, const vector &lits) { ofstream of(filename.c_str()); for (const hwlmLiteral &lit : lits) { of << lit.id << "="; if (lit.nocase) { of << "!"; } of << toHex(lit.s.begin(), lit.s.end()); if (!lit.msk.empty()) { of << " " << toHex(lit.msk.begin(), lit.msk.end()); of << " " << toHex(lit.cmp.begin(), lit.cmp.end()); } of << endl; } of.close(); } static void dumpRoseTestLiterals(const RoseBuildImpl &build, const string &base) { size_t historyRequired = build.calcHistoryRequired(); size_t longLitLengthThreshold = calcLongLitThreshold(build, historyRequired); auto lits = fillHamsterLiteralList(build, ROSE_ANCHORED, longLitLengthThreshold); dumpTestLiterals(base + "rose_anchored_test_literals.txt", lits); lits = fillHamsterLiteralList(build, ROSE_FLOATING, longLitLengthThreshold); dumpTestLiterals(base + "rose_float_test_literals.txt", lits); lits = fillHamsterLiteralList(build, ROSE_EOD_ANCHORED, build.ematcher_region_size); dumpTestLiterals(base + "rose_eod_test_literals.txt", lits); if (!build.cc.streaming) { lits = fillHamsterLiteralList(build, ROSE_FLOATING, ROSE_SMALL_BLOCK_LEN, ROSE_SMALL_BLOCK_LEN); auto lits2 = fillHamsterLiteralList(build, ROSE_ANCHORED_SMALL_BLOCK, ROSE_SMALL_BLOCK_LEN, ROSE_SMALL_BLOCK_LEN); lits.insert(end(lits), begin(lits2), end(lits2)); dumpTestLiterals(base + "rose_smallblock_test_literals.txt", lits); } } void dumpRose(const RoseBuild &build_base, const RoseEngine *t, const Grey &grey) { if (!grey.dumpFlags) { return; } const RoseBuildImpl &build = dynamic_cast(build_base); stringstream ss; ss << grey.dumpPath << "rose.txt"; FILE *f = fopen(ss.str().c_str(), "w"); if (!t) { fprintf(f, "<< no rose >>\n"); fclose(f); return; } // Dump Rose table info roseDumpText(t, f); fclose(f); roseDumpComponents(t, false, grey.dumpPath); // Graph. dumpRoseGraph(build, t, "rose.dot"); // Literals. ss.str(""); ss.clear(); ss << grey.dumpPath << "rose_literals.txt"; dumpRoseLiterals(build, ss.str().c_str()); dumpRoseTestLiterals(build, grey.dumpPath); f = fopen((grey.dumpPath + "/rose_struct.txt").c_str(), "w"); roseDumpStructRaw(t, f); fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_program.h0000644000175000017500000004434413055426554020717 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose data structures to do with role programs. */ #ifndef ROSE_ROSE_PROGRAM_H #define ROSE_ROSE_PROGRAM_H #include "som/som_operation.h" #include "rose_internal.h" #include "ue2common.h" /** \brief Minimum alignment for each instruction in memory. */ #define ROSE_INSTR_MIN_ALIGN 8U /** \brief Role program instruction opcodes. */ enum RoseInstructionCode { ROSE_INSTR_END, //!< End of program. ROSE_INSTR_ANCHORED_DELAY, //!< Delay until after anchored matcher. ROSE_INSTR_CHECK_LIT_EARLY, //!< Skip matches before floating min offset. ROSE_INSTR_CHECK_GROUPS, //!< Check that literal groups are on. ROSE_INSTR_CHECK_ONLY_EOD, //!< Role matches only at EOD. ROSE_INSTR_CHECK_BOUNDS, //!< Bounds on distance from offset 0. ROSE_INSTR_CHECK_NOT_HANDLED, //!< Test & set role in "handled". ROSE_INSTR_CHECK_SINGLE_LOOKAROUND, //!< Single lookaround check. ROSE_INSTR_CHECK_LOOKAROUND, //!< Lookaround check. ROSE_INSTR_CHECK_MASK, //!< 8-bytes mask check. ROSE_INSTR_CHECK_MASK_32, //!< 32-bytes and/cmp/neg mask check. ROSE_INSTR_CHECK_BYTE, //!< Single Byte check. ROSE_INSTR_CHECK_SHUFTI_16x8, //!< Check 16-byte data by 8-bucket shufti. ROSE_INSTR_CHECK_SHUFTI_32x8, //!< Check 32-byte data by 8-bucket shufti. ROSE_INSTR_CHECK_SHUFTI_16x16, //!< Check 16-byte data by 16-bucket shufti. ROSE_INSTR_CHECK_SHUFTI_32x16, //!< Check 32-byte data by 16-bucket shufti. ROSE_INSTR_CHECK_INFIX, //!< Infix engine must be in accept state. ROSE_INSTR_CHECK_PREFIX, //!< Prefix engine must be in accept state. ROSE_INSTR_PUSH_DELAYED, //!< Push delayed literal matches. ROSE_INSTR_RECORD_ANCHORED, //!< Record an anchored literal match. ROSE_INSTR_CATCH_UP, //!< Catch up engines, anchored matches. ROSE_INSTR_CATCH_UP_MPV, //!< Catch up the MPV. ROSE_INSTR_SOM_ADJUST, //!< Set SOM from a distance to EOM. ROSE_INSTR_SOM_LEFTFIX, //!< Acquire SOM from a leftfix engine. ROSE_INSTR_SOM_FROM_REPORT, //!< Acquire SOM from a som_operation. ROSE_INSTR_SOM_ZERO, //!< Set SOM to zero. ROSE_INSTR_TRIGGER_INFIX, //!< Trigger an infix engine. ROSE_INSTR_TRIGGER_SUFFIX, //!< Trigger a suffix engine. ROSE_INSTR_DEDUPE, //!< Run deduplication for report. ROSE_INSTR_DEDUPE_SOM, //!< Run deduplication for SOM report. ROSE_INSTR_REPORT_CHAIN, //!< Fire a chained report (MPV). ROSE_INSTR_REPORT_SOM_INT, //!< Manipulate SOM only. ROSE_INSTR_REPORT_SOM_AWARE, //!< Manipulate SOM from SOM-aware source. /** \brief Fire a report. */ ROSE_INSTR_REPORT, /** \brief Fire an exhaustible report. */ ROSE_INSTR_REPORT_EXHAUST, /** \brief Fire a SOM report. */ ROSE_INSTR_REPORT_SOM, /** \brief Fire an exhaustible SOM report. */ ROSE_INSTR_REPORT_SOM_EXHAUST, /** \brief Super-instruction combining DEDUPE and REPORT. */ ROSE_INSTR_DEDUPE_AND_REPORT, /** * \brief Fire a report and stop program execution. This is a * specialisation intended for short, frequently-executed programs. */ ROSE_INSTR_FINAL_REPORT, ROSE_INSTR_CHECK_EXHAUSTED, //!< Check if an ekey has already been set. ROSE_INSTR_CHECK_MIN_LENGTH, //!< Check (EOM - SOM) against min length. ROSE_INSTR_SET_STATE, //!< Switch a state index on. ROSE_INSTR_SET_GROUPS, //!< Set some literal group bits. ROSE_INSTR_SQUASH_GROUPS, //!< Conditionally turn off some groups. ROSE_INSTR_CHECK_STATE, //!< Test a single bit in the state multibit. ROSE_INSTR_SPARSE_ITER_BEGIN, //!< Begin running a sparse iter over states. ROSE_INSTR_SPARSE_ITER_NEXT, //!< Continue running sparse iter over states. ROSE_INSTR_SPARSE_ITER_ANY, //!< Test for any bit in the sparse iterator. /** \brief Check outfixes and suffixes for EOD and fire reports if so. */ ROSE_INSTR_ENGINES_EOD, /** \brief Catch up and check active suffixes for EOD and fire reports if * so. */ ROSE_INSTR_SUFFIXES_EOD, /** \brief Run the EOD-anchored HWLM literal matcher. */ ROSE_INSTR_MATCHER_EOD, /** * \brief Confirm a case-sensitive literal at the current offset. In * streaming mode, this makes use of the long literal table. */ ROSE_INSTR_CHECK_LONG_LIT, /** * \brief Confirm a case-insensitive literal at the current offset. In * streaming mode, this makes use of the long literal table. */ ROSE_INSTR_CHECK_LONG_LIT_NOCASE, LAST_ROSE_INSTRUCTION = ROSE_INSTR_CHECK_LONG_LIT_NOCASE //!< Sentinel. }; struct ROSE_STRUCT_END { u8 code; //!< From enum RoseInstructionCode. }; struct ROSE_STRUCT_ANCHORED_DELAY { u8 code; //!< From enum RoseInstructionCode. rose_group groups; //!< Bitmask. u32 done_jump; //!< Jump forward this many bytes if successful. }; /** Note: check failure will halt program. */ struct ROSE_STRUCT_CHECK_LIT_EARLY { u8 code; //!< From enum RoseInstructionCode. u32 min_offset; //!< Minimum offset for this literal. }; /** Note: check failure will halt program. */ struct ROSE_STRUCT_CHECK_GROUPS { u8 code; //!< From enum RoseInstructionCode. rose_group groups; //!< Bitmask. }; struct ROSE_STRUCT_CHECK_ONLY_EOD { u8 code; //!< From enum RoseInstructionCode. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_BOUNDS { u8 code; //!< From enum RoseInstructionCode. u64a min_bound; //!< Min distance from zero. u64a max_bound; //!< Max distance from zero. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_NOT_HANDLED { u8 code; //!< From enum RoseInstructionCode. u32 key; //!< Key in the "handled_roles" fatbit in scratch. u32 fail_jump; //!< Jump forward this many bytes if we have seen key before. }; struct ROSE_STRUCT_CHECK_SINGLE_LOOKAROUND { u8 code; //!< From enum RoseInstructionCode. s8 offset; //!< The offset of the byte to examine. u32 reach_index; //!< The index of the reach table entry to use. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_LOOKAROUND { u8 code; //!< From enum RoseInstructionCode. u32 index; u32 count; u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_MASK { u8 code; //!< From enum roseInstructionCode. u64a and_mask; //!< 8-byte and mask. u64a cmp_mask; //!< 8-byte cmp mask. u64a neg_mask; //!< 8-byte negation mask. s32 offset; //!< Relative offset of the first byte. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_MASK_32 { u8 code; //!< From enum RoseInstructionCode. u8 and_mask[32]; //!< 32-byte and mask. u8 cmp_mask[32]; //!< 32-byte cmp mask. u32 neg_mask; //!< negation mask with 32 bits. s32 offset; //!< Relative offset of the first byte. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_BYTE { u8 code; //!< From enum RoseInstructionCode. u8 and_mask; //!< 8-bits and mask. u8 cmp_mask; //!< 8-bits cmp mask. u8 negation; //!< Flag about negation. s32 offset; //!< The relative offset. u32 fail_jump; //!< Jump forward this many bytes on failure. }; // Since m128 and m256 could be missaligned in the bytecode, // we'll use u8[16] and u8[32] instead in all rose_check_shufti structures. struct ROSE_STRUCT_CHECK_SHUFTI_16x8 { u8 code; //!< From enum RoseInstructionCode. u8 nib_mask[32]; //!< High 16 and low 16 bits nibble mask in shufti. u8 bucket_select_mask[16]; //!< Mask for bucket assigning. u32 neg_mask; //!< Negation mask in low 16 bits. s32 offset; //!< Relative offset of the first byte. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_SHUFTI_32x8 { u8 code; //!< From enum RoseInstructionCode. u8 hi_mask[16]; //!< High nibble mask in shufti. u8 lo_mask[16]; //!< Low nibble mask in shufti. u8 bucket_select_mask[32]; //!< Mask for bucket assigning. u32 neg_mask; //!< 32 bits negation mask. s32 offset; //!< Relative offset of the first byte. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_SHUFTI_16x16 { u8 code; //!< From enum RoseInstructionCode. u8 hi_mask[32]; //!< High nibble mask in shufti. u8 lo_mask[32]; //!< Low nibble mask in shufti. u8 bucket_select_mask[32]; //!< Mask for bucket assigning. u32 neg_mask; //!< Negation mask in low 16 bits. s32 offset; //!< Relative offset of the first byte. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_SHUFTI_32x16 { u8 code; //!< From enum RoseInstructionCode. u8 hi_mask[32]; //!< High nibble mask in shufti. u8 lo_mask[32]; //!< Low nibble mask in shufti. u8 bucket_select_mask_hi[32]; //!< Bucket mask for high 8 buckets. u8 bucket_select_mask_lo[32]; //!< Bucket mask for low 8 buckets. u32 neg_mask; //!< 32 bits negation mask. s32 offset; //!< Relative offset of the first byte. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_INFIX { u8 code; //!< From enum RoseInstructionCode. u32 queue; //!< Queue of leftfix to check. u32 lag; //!< Lag of leftfix for this case. ReportID report; //!< ReportID of leftfix to check. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_PREFIX { u8 code; //!< From enum RoseInstructionCode. u32 queue; //!< Queue of leftfix to check. u32 lag; //!< Lag of leftfix for this case. ReportID report; //!< ReportID of leftfix to check. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_PUSH_DELAYED { u8 code; //!< From enum RoseInstructionCode. u8 delay; // Number of bytes to delay. u32 index; // Delay literal index (relative to first delay lit). }; struct ROSE_STRUCT_RECORD_ANCHORED { u8 code; //!< From enum RoseInstructionCode. u32 id; //!< Literal ID. }; struct ROSE_STRUCT_CATCH_UP { u8 code; //!< From enum RoseInstructionCode. }; struct ROSE_STRUCT_CATCH_UP_MPV { u8 code; //!< From enum RoseInstructionCode. }; struct ROSE_STRUCT_SOM_ADJUST { u8 code; //!< From enum RoseInstructionCode. u32 distance; //!< Distance to EOM. }; struct ROSE_STRUCT_SOM_LEFTFIX { u8 code; //!< From enum RoseInstructionCode. u32 queue; //!< Queue index of leftfix providing SOM. u32 lag; //!< Lag of leftfix for this case. }; struct ROSE_STRUCT_SOM_FROM_REPORT { u8 code; //!< From enum RoseInstructionCode. struct som_operation som; }; struct ROSE_STRUCT_SOM_ZERO { u8 code; //!< From enum RoseInstructionCode. }; struct ROSE_STRUCT_TRIGGER_INFIX { u8 code; //!< From enum RoseInstructionCode. u8 cancel; //!< Cancels previous top event. u32 queue; //!< Queue index of infix. u32 event; //!< Queue event, from MQE_*. }; struct ROSE_STRUCT_TRIGGER_SUFFIX { u8 code; //!< From enum RoseInstructionCode. u32 queue; //!< Queue index of suffix. u32 event; //!< Queue event, from MQE_*. }; struct ROSE_STRUCT_DEDUPE { u8 code; //!< From enum RoseInstructionCode. u8 quash_som; //!< Force SOM to zero for this report. u32 dkey; //!< Dedupe key. s32 offset_adjust; //!< Offset adjustment to apply to end offset. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_DEDUPE_SOM { u8 code; //!< From enum RoseInstructionCode. u8 quash_som; //!< Force SOM to zero for this report. u32 dkey; //!< Dedupe key. s32 offset_adjust; //!< Offset adjustment to apply to end offset. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_REPORT_CHAIN { u8 code; //!< From enum RoseInstructionCode. u32 event; //!< Queue event, from MQE_*. Must be a top. /** * \brief Number of bytes behind us that we are allowed to squash * identical top events on the queue. */ u64a top_squash_distance; }; struct ROSE_STRUCT_REPORT_SOM_INT { u8 code; //!< From enum RoseInstructionCode. struct som_operation som; }; struct ROSE_STRUCT_REPORT_SOM_AWARE { u8 code; //!< From enum RoseInstructionCode. struct som_operation som; }; struct ROSE_STRUCT_REPORT { u8 code; //!< From enum RoseInstructionCode. ReportID onmatch; //!< Report ID to deliver to user. s32 offset_adjust; //!< Offset adjustment to apply to end offset. }; struct ROSE_STRUCT_REPORT_EXHAUST { u8 code; //!< From enum RoseInstructionCode. ReportID onmatch; //!< Report ID to deliver to user. s32 offset_adjust; //!< Offset adjustment to apply to end offset. u32 ekey; //!< Exhaustion key. }; struct ROSE_STRUCT_REPORT_SOM { u8 code; //!< From enum RoseInstructionCode. ReportID onmatch; //!< Report ID to deliver to user. s32 offset_adjust; //!< Offset adjustment to apply to end offset. }; struct ROSE_STRUCT_REPORT_SOM_EXHAUST { u8 code; //!< From enum RoseInstructionCode. ReportID onmatch; //!< Report ID to deliver to user. s32 offset_adjust; //!< Offset adjustment to apply to end offset. u32 ekey; //!< Exhaustion key. }; struct ROSE_STRUCT_DEDUPE_AND_REPORT { u8 code; //!< From enum RoseInstructionCode. u8 quash_som; //!< Force SOM to zero for this report. u32 dkey; //!< Dedupe key. ReportID onmatch; //!< Report ID to deliver to user. s32 offset_adjust; //!< Offset adjustment to apply to end offset. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_FINAL_REPORT { u8 code; //!< From enum RoseInstructionCode. ReportID onmatch; //!< Report ID to deliver to user. s32 offset_adjust; //!< Offset adjustment to apply to end offset. }; struct ROSE_STRUCT_CHECK_EXHAUSTED { u8 code; //!< From enum RoseInstructionCode. u32 ekey; //!< Exhaustion key to check. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_CHECK_MIN_LENGTH { u8 code; //!< From enum RoseInstructionCode. s32 end_adj; //!< Offset adjustment to add to EOM first. u64a min_length; //!< Minimum distance from SOM to EOM. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_SET_STATE { u8 code; //!< From enum RoseInstructionCode. u32 index; //!< State index in multibit. }; struct ROSE_STRUCT_SET_GROUPS { u8 code; //!< From enum RoseInstructionCode. rose_group groups; //!< Bitmask to OR into groups. }; struct ROSE_STRUCT_SQUASH_GROUPS { u8 code; //!< From enum RoseInstructionCode. rose_group groups; //!< Bitmask to AND into groups. }; struct ROSE_STRUCT_CHECK_STATE { u8 code; //!< From enum RoseInstructionCode. u32 index; //!< State index in the role multibit. u32 fail_jump; //!< Jump forward this many bytes on failure. }; /** * Note that the offsets in the jump table are always relative to the start of * the program, not the current instruction. */ struct ROSE_STRUCT_SPARSE_ITER_BEGIN { u8 code; //!< From enum RoseInstructionCode. u32 iter_offset; //!< Offset of mmbit_sparse_iter structure. u32 jump_table; //!< Offset of jump table indexed by sparse iterator. u32 fail_jump; //!< Jump forward this many bytes on failure. }; /** * Note that the offsets in the jump table are always relative to the start of * the program, not the current instruction. */ struct ROSE_STRUCT_SPARSE_ITER_NEXT { u8 code; //!< From enum RoseInstructionCode. u32 iter_offset; //!< Offset of mmbit_sparse_iter structure. u32 jump_table; //!< Offset of jump table indexed by sparse iterator. u32 state; // Current state index. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_SPARSE_ITER_ANY { u8 code; //!< From enum RoseInstructionCode. u32 iter_offset; //!< Offset of mmbit_sparse_iter structure. u32 fail_jump; //!< Jump forward this many bytes on failure. }; struct ROSE_STRUCT_ENGINES_EOD { u8 code; //!< From enum RoseInstructionCode. u32 iter_offset; //!< Offset of mmbit_sparse_iter structure. }; struct ROSE_STRUCT_SUFFIXES_EOD { u8 code; //!< From enum RoseInstructionCode. }; struct ROSE_STRUCT_MATCHER_EOD { u8 code; //!< From enum RoseInstructionCode. }; /** Note: check failure will halt program. */ struct ROSE_STRUCT_CHECK_LONG_LIT { u8 code; //!< From enum RoseInstructionCode. u32 lit_offset; //!< Offset of literal string. u32 lit_length; //!< Length of literal string. }; /** Note: check failure will halt program. */ struct ROSE_STRUCT_CHECK_LONG_LIT_NOCASE { u8 code; //!< From enum RoseInstructionCode. u32 lit_offset; //!< Offset of literal string. u32 lit_length; //!< Length of literal string. }; #endif // ROSE_ROSE_PROGRAM_H hyperscan-4.4.1/src/rose/rose_build_anchored.h0000644000175000017500000000543013055426554022203 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ROSE_BUILD_ANCHORED #define ROSE_BUILD_ANCHORED #include "ue2common.h" #include "rose_build.h" #include "nfagraph/ng_holder.h" #include "util/alloc.h" #include #include #include struct anchored_matcher_info; namespace ue2 { class RoseBuildImpl; struct raw_dfa; /** * \brief Construct a set of anchored DFAs from our anchored literals/engines. */ std::vector buildAnchoredDfas(RoseBuildImpl &build); /** * \brief Construct an anchored_matcher_info runtime structure from the given * set of DFAs. * * Remap the literal final_ids used for raw_dfa reports to the program offsets * given in litPrograms. */ aligned_unique_ptr buildAnchoredMatcher(RoseBuildImpl &build, std::vector &dfas, const std::vector &litPrograms, size_t *asize); u32 anchoredStateSize(const anchored_matcher_info &atable); #define ANCHORED_FAIL 0 #define ANCHORED_SUCCESS 1 #define ANCHORED_REMAP 2 int addAnchoredNFA(RoseBuildImpl &tbi, const NGHolder &wrapper, const std::map> &reportMap); int addToAnchoredMatcher(RoseBuildImpl &tbi, const NGHolder &anchored, u32 exit_id, ReportID *remap); } // namespace ue2 #endif hyperscan-4.4.1/src/rose/counting_miracle.h0000644000175000017500000002130413055426554021531 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ROSE_COUNTING_MIRACLE_H #define ROSE_COUNTING_MIRACLE_H #include "ue2common.h" #include "runtime.h" #include "rose_internal.h" #include "nfa/nfa_api_queue.h" #include "util/simd_utils.h" /** \brief Maximum number of bytes to scan when looking for a "counting miracle" * stop character. */ #define COUNTING_MIRACLE_LEN_MAX 256 static really_inline char roseCountingMiracleScan(u8 c, const u8 *d, const u8 *d_end, u32 target_count, u32 *count_inout, const u8 **d_out) { assert(d <= d_end); u32 count = *count_inout; m128 chars = set16x8(c); for (; d + 16 <= d_end; d_end -= 16) { m128 data = loadu128(d_end - 16); u32 z1 = movemask128(eq128(chars, data)); count += popcount32(z1); if (count >= target_count) { *d_out = d_end - 16; *count_inout = count; return 1; } } if (d != d_end) { char temp[sizeof(m128)]; assert(d + sizeof(temp) > d_end); memset(temp, c + 1, sizeof(temp)); memcpy(temp, d, d_end - d); m128 data = loadu128(temp); u32 z1 = movemask128(eq128(chars, data)); count += popcount32(z1); if (count >= target_count) { *d_out = d; *count_inout = count; return 1; } } *count_inout = count; return 0; } #define GET_LO_4(chars) and128(chars, low4bits) #define GET_HI_4(chars) rshift64_m128(andnot128(low4bits, chars), 4) static really_inline u32 roseCountingMiracleScanShufti(m128 mask_lo, m128 mask_hi, u8 poison, const u8 *d, const u8 *d_end, u32 target_count, u32 *count_inout, const u8 **d_out) { assert(d <= d_end); u32 count = *count_inout; const m128 zeroes = zeroes128(); const m128 low4bits = _mm_set1_epi8(0xf); for (; d + 16 <= d_end; d_end -= 16) { m128 data = loadu128(d_end - 16); m128 c_lo = pshufb(mask_lo, GET_LO_4(data)); m128 c_hi = pshufb(mask_hi, GET_HI_4(data)); m128 t = and128(c_lo, c_hi); u32 z1 = movemask128(eq128(t, zeroes)); count += popcount32(z1 ^ 0xffff); if (count >= target_count) { *d_out = d_end - 16; *count_inout = count; return 1; } } if (d != d_end) { char temp[sizeof(m128)]; assert(d + sizeof(temp) > d_end); memset(temp, poison, sizeof(temp)); memcpy(temp, d, d_end - d); m128 data = loadu128(temp); m128 c_lo = pshufb(mask_lo, GET_LO_4(data)); m128 c_hi = pshufb(mask_hi, GET_HI_4(data)); m128 t = and128(c_lo, c_hi); u32 z1 = movemask128(eq128(t, zeroes)); count += popcount32(z1 ^ 0xffff); if (count >= target_count) { *d_out = d; *count_inout = count; return 1; } } *count_inout = count; return 0; } /** * \brief "Counting Miracle" scan: If we see more than N instances of a * particular character class we know that the engine must be dead. * * Scans the buffer/history between relative locations \a begin_loc and \a * end_loc, and returns a miracle location (if any) that appears in the stream * after \a begin_loc. * * Returns 1 if some bytes can be skipped and sets \a miracle_loc * appropriately, 0 otherwise. */ static never_inline int roseCountingMiracleOccurs(const struct RoseEngine *t, const struct LeftNfaInfo *left, const struct core_info *ci, s64a begin_loc, const s64a end_loc, s64a *miracle_loc) { if (!left->countingMiracleOffset) { return 0; } const struct RoseCountingMiracle *cm = (const void *)((const char *)t + left->countingMiracleOffset); assert(!left->transient); assert(cm->count > 1); /* should be a normal miracle then */ DEBUG_PRINTF("looking for counting miracle over [%lld,%lld], maxLag=%u\n", begin_loc, end_loc, left->maxLag); DEBUG_PRINTF("ci->len=%zu, ci->hlen=%zu\n", ci->len, ci->hlen); assert(begin_loc <= end_loc); assert(begin_loc >= -(s64a)ci->hlen); assert(end_loc <= (s64a)ci->len); const s64a scan_end_loc = end_loc - left->maxLag; if (scan_end_loc <= begin_loc) { DEBUG_PRINTF("nothing to scan\n"); return 0; } const s64a start = MAX(begin_loc, scan_end_loc - COUNTING_MIRACLE_LEN_MAX); DEBUG_PRINTF("scan [%lld..%lld]\n", start, scan_end_loc); u32 count = 0; s64a m_loc = start; if (!cm->shufti) { u8 c = cm->c; // Scan buffer. const s64a buf_scan_start = MAX(0, start); if (scan_end_loc > buf_scan_start) { const u8 *buf = ci->buf; const u8 *d = buf + scan_end_loc; const u8 *d_start = buf + buf_scan_start; const u8 *d_out; if (roseCountingMiracleScan(c, d_start, d, cm->count, &count, &d_out)) { assert(d_out >= d_start); m_loc = (d_out - d_start) + buf_scan_start; goto success; } } // Scan history. if (start < 0) { const u8 *hbuf_end = ci->hbuf + ci->hlen; const u8 *d = hbuf_end + MIN(0, scan_end_loc); const u8 *d_start = hbuf_end + start; const u8 *d_out; if (roseCountingMiracleScan(c, d_start, d, cm->count, &count, &d_out)) { assert(d_out >= d_start); m_loc = (d_out - d_start) + start; goto success; } } } else { m128 lo = cm->lo; m128 hi = cm->hi; u8 poison = cm->poison; // Scan buffer. const s64a buf_scan_start = MAX(0, start); if (scan_end_loc > buf_scan_start) { const u8 *buf = ci->buf; const u8 *d = buf + scan_end_loc; const u8 *d_start = buf + buf_scan_start; const u8 *d_out; if (roseCountingMiracleScanShufti(lo, hi, poison, d_start, d, cm->count, &count, &d_out)) { assert(d_out >= d_start); m_loc = (d_out - d_start) + buf_scan_start; goto success; } } // Scan history. if (start < 0) { const u8 *hbuf_end = ci->hbuf + ci->hlen; const u8 *d = hbuf_end + MIN(0, scan_end_loc); const u8 *d_start = hbuf_end + start; const u8 *d_out; if (roseCountingMiracleScanShufti(lo, hi, poison, d_start, d, cm->count, &count, &d_out)) { assert(d_out >= d_start); m_loc = (d_out - d_start) + start; goto success; } } } DEBUG_PRINTF("found %u/%u\n", count, cm->count); return 0; success: DEBUG_PRINTF("found %u/%u\n", count, cm->count); assert(count >= cm->count); assert(m_loc < scan_end_loc); assert(m_loc >= start); *miracle_loc = m_loc; return 1; } #endif hyperscan-4.4.1/src/rose/rose_build_castle.h0000644000175000017500000000477713055426554021710 0ustar sleuthkidsleuthkid/* * 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 ROSE_BUILD_CASTLE_H #define ROSE_BUILD_CASTLE_H #include "rose_graph.h" #include namespace ue2 { class RoseBuildImpl; struct left_id; struct ue2_literal; /** * Runs over all rose infix/suffix engines and converts those that are pure * repeats with one report into CastleProto engines. */ void makeCastles(RoseBuildImpl &tbi); /** * Identifies all the CastleProto prototypes that are small enough that they * would be better implemented as NFAs, and converts them back to NGHolder * prototypes. * * Returns true if any changes were made. */ bool unmakeCastles(RoseBuildImpl &tbi); /** * Runs over all the Castle engine prototypes in the graph and ensures that * they have tops in a contiguous range, ready for construction. */ void remapCastleTops(RoseBuildImpl &tbi); bool triggerKillsRoseCastle(const RoseBuildImpl &tbi, const left_id &left, const std::set &all_lits, const RoseEdge &e); } #endif hyperscan-4.4.1/src/rose/rose_build_long_lit.h0000644000175000017500000000407413055426554022232 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 ROSE_BUILD_LONG_LIT_H #define ROSE_BUILD_LONG_LIT_H #include "ue2common.h" #include namespace ue2 { class RoseBuildImpl; class RoseEngineBlob; struct ue2_case_string; u32 buildLongLiteralTable(const RoseBuildImpl &build, RoseEngineBlob &blob, std::vector &lits, size_t longLitLengthThreshold, size_t *historyRequired, size_t *longLitStreamStateRequired); } // namespace ue2 #endif // ROSE_BUILD_LONG_LIT_H hyperscan-4.4.1/src/rose/rose_build_castle.cpp0000644000175000017500000003067213055426554022234 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_castle.h" #include "rose_build_impl.h" #include "ue2common.h" #include "nfa/castlecompile.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_puff.h" #include "util/charreach.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include "util/ue2string.h" #include #include #include #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { static void makeCastle(LeftEngInfo &left, unordered_map> &cache) { if (left.dfa || left.haig || left.castle) { return; } if (!left.graph) { return; } const NGHolder &h = *left.graph; DEBUG_PRINTF("prefix %p\n", &h); if (contains(cache, &h)) { DEBUG_PRINTF("using cached CastleProto\n"); left.castle = cache[&h]; left.graph.reset(); return; } PureRepeat pr; if (isPureRepeat(h, pr) && pr.reports.size() == 1) { DEBUG_PRINTF("vertex preceded by infix repeat %s\n", pr.bounds.str().c_str()); left.castle = make_shared(h.kind, pr); cache[&h] = left.castle; left.graph.reset(); } } static void makeCastleSuffix(RoseBuildImpl &tbi, RoseVertex v, ue2::unordered_map > &cache) { RoseSuffixInfo &suffix = tbi.g[v].suffix; if (!suffix.graph) { return; } const NGHolder &h = *suffix.graph; DEBUG_PRINTF("suffix %p\n", &h); if (contains(cache, &h)) { DEBUG_PRINTF("using cached CastleProto\n"); suffix.castle = cache[&h]; suffix.graph.reset(); return; } // The MPV will probably do a better job on the cases it's designed // for. const bool fixed_depth = tbi.g[v].min_offset == tbi.g[v].max_offset; if (isPuffable(h, fixed_depth, tbi.rm, tbi.cc.grey)) { DEBUG_PRINTF("leaving suffix for puff\n"); return; } PureRepeat pr; if (isPureRepeat(h, pr) && pr.reports.size() == 1) { DEBUG_PRINTF("suffix repeat %s\n", pr.bounds.str().c_str()); // Right now, the Castle uses much more stream state to represent a // {m,1} repeat than just leaving it to an NFA. if (pr.bounds.max <= depth(1)) { DEBUG_PRINTF("leaving for other engines\n"); return; } suffix.castle = make_shared(h.kind, pr); cache[&h] = suffix.castle; suffix.graph.reset(); } } static vector literals_for_vertex(const RoseBuildImpl &tbi, RoseVertex v) { vector rv; for (const u32 id : tbi.g[v].literals) { rv.push_back(tbi.literals.right.at(id)); } return rv; } static void renovateCastle(RoseBuildImpl &tbi, CastleProto *castle, const vector &verts) { DEBUG_PRINTF("looking to renovate\n"); if (castle->repeats.size() != 1) { assert(0); /* should not have merged castles yet */ return; } PureRepeat &pr = castle->repeats.begin()->second; if (pr.bounds.max.is_finite()) { /* repeat cannot be turned into pseudo .* */ return; } RoseGraph &g = tbi.g; const CharReach &cr = castle->reach(); DEBUG_PRINTF("cr || %zu\n", cr.count()); u32 allowed_to_remove = ~0; size_t min_succ_lit_len = 0; for (RoseVertex v : verts) { assert(g[v].left.castle.get() == castle); DEBUG_PRINTF("%zu checks at lag %u\n", g[v].index, g[v].left.lag); vector lits = literals_for_vertex(tbi, v); for (const auto &e : lits) { DEBUG_PRINTF("%s +%u\n", dumpString(e.s).c_str(), e.delay); if (e.delay) { return; /* bail - TODO: be less lazy */ } vector rem_local_cr; u32 ok_count = 0; for (auto it = e.s.end() - g[v].left.lag; it != e.s.end(); ++it) { if (!isSubsetOf(*it, cr)) { break; } ok_count++; } LIMIT_TO_AT_MOST(&allowed_to_remove, ok_count); ENSURE_AT_LEAST(&min_succ_lit_len, e.elength()); } } DEBUG_PRINTF("possible to decrease lag by %u\n", allowed_to_remove); for (RoseVertex v : verts) { assert(g[v].left.lag >= allowed_to_remove); g[v].left.lag -= allowed_to_remove; } assert(castle->repeats.size() == 1); /* should not have merged castles yet */ pr.bounds.max += allowed_to_remove; /* Although it is always safe to increase the min bound as well, we would * rather not as a >0 min bound means that we have to store state as well. * * As it was legal to run with the original lag, we know that it is not * possible to have an overlapping match which finishes within the trigger * literal past the original lag point. However, if there is already a min * bound constraint this would be broken if we did not also increase the * min bound. */ if (pr.bounds.min > 0ULL || allowed_to_remove > min_succ_lit_len) { pr.bounds.min += allowed_to_remove; } } void makeCastles(RoseBuildImpl &tbi) { if (!tbi.cc.grey.allowCastle && !tbi.cc.grey.allowLbr) { return; } RoseGraph &g = tbi.g; // Caches so that we can reuse analysis on graphs we've seen already. unordered_map > left_cache; unordered_map > suffix_cache; unordered_map> rev; for (RoseVertex v : vertices_range(g)) { if (g[v].left && !tbi.isRootSuccessor(v)) { makeCastle(g[v].left, left_cache); if (g[v].left.castle) { rev[g[v].left.castle.get()].push_back(v); } } if (g[v].suffix) { makeCastleSuffix(tbi, v, suffix_cache); } } for (const auto &e : rev) { renovateCastle(tbi, e.first, e.second); } } bool unmakeCastles(RoseBuildImpl &tbi) { RoseGraph &g = tbi.g; const size_t MAX_UNMAKE_VERTICES = 64; map > left_castles; map > suffix_castles; bool changed = false; for (auto v : vertices_range(g)) { const LeftEngInfo &left = g[v].left; if (left.castle && left.castle->repeats.size() > 1) { left_castles[left].push_back(v); } const RoseSuffixInfo &suffix = g[v].suffix; if (suffix.castle && suffix.castle->repeats.size() > 1) { suffix_castles[suffix].push_back(v); } } for (const auto &e : left_castles) { assert(e.first.castle()); shared_ptr h = makeHolder(*e.first.castle(), tbi.cc); if (!h || num_vertices(*h) > MAX_UNMAKE_VERTICES) { continue; } DEBUG_PRINTF("replace rose with holder (%zu vertices)\n", num_vertices(*h)); for (auto v : e.second) { assert(g[v].left.castle.get() == e.first.castle()); g[v].left.graph = h; g[v].left.castle.reset(); changed = true; } } for (const auto &e : suffix_castles) { assert(e.first.castle()); shared_ptr h = makeHolder(*e.first.castle(), tbi.cc); if (!h || num_vertices(*h) > MAX_UNMAKE_VERTICES) { continue; } DEBUG_PRINTF("replace suffix with holder (%zu vertices)\n", num_vertices(*h)); for (auto v : e.second) { assert(g[v].suffix.castle.get() == e.first.castle()); g[v].suffix.graph = h; g[v].suffix.castle.reset(); changed = true; } } return changed; } void remapCastleTops(RoseBuildImpl &tbi) { ue2::unordered_map > rose_castles; ue2::unordered_map > suffix_castles; RoseGraph &g = tbi.g; for (auto v : vertices_range(g)) { if (g[v].left.castle) { rose_castles[g[v].left.castle.get()].push_back(v); } if (g[v].suffix.castle) { suffix_castles[g[v].suffix.castle.get()].push_back(v); } } DEBUG_PRINTF("%zu rose castles, %zu suffix castles\n", rose_castles.size(), suffix_castles.size()); map top_map; // Remap Rose Castles. for (const auto &rc : rose_castles) { CastleProto *c = rc.first; const vector &verts = rc.second; DEBUG_PRINTF("rose castle %p (%zu repeats) has %zu verts\n", c, c->repeats.size(), verts.size()); top_map.clear(); remapCastleTops(*c, top_map); // Update the tops on the edges leading into vertices in v. for (auto v : verts) { for (const auto &e : in_edges_range(v, g)) { g[e].rose_top = top_map.at(g[e].rose_top); } } } // Remap Suffix Castles. for (const auto &e : suffix_castles) { CastleProto *c = e.first; const vector &verts = e.second; DEBUG_PRINTF("suffix castle %p (%zu repeats) has %zu verts\n", c, c->repeats.size(), verts.size()); top_map.clear(); remapCastleTops(*c, top_map); // Update the tops on the suffixes. for (auto v : verts) { assert(g[v].suffix); g[v].suffix.top = top_map.at(g[v].suffix.top); } } } bool triggerKillsRoseCastle(const RoseBuildImpl &tbi, const left_id &left, const set &all_lits, const RoseEdge &e) { assert(left.castle()); const CastleProto &c = *left.castle(); const depth max_width = findMaxWidth(c); DEBUG_PRINTF("castle max width is %s\n", max_width.str().c_str()); /* check each pred literal to see if they all kill previous castle * state */ for (u32 lit_id : tbi.g[source(e, tbi.g)].literals) { const rose_literal_id &pred_lit = tbi.literals.right.at(lit_id); const ue2_literal s = findNonOverlappingTail(all_lits, pred_lit.s); const CharReach &cr = c.reach(); DEBUG_PRINTF("s=%s, castle reach=%s\n", dumpString(s).c_str(), describeClass(cr).c_str()); for (const auto &s_cr : s) { if (!overlaps(cr, s_cr)) { DEBUG_PRINTF("reach %s kills castle\n", describeClass(s_cr).c_str()); goto next_pred; } } if (max_width < depth(s.length())) { DEBUG_PRINTF("literal width >= castle max width\n"); goto next_pred; } return false; next_pred:; } return true; } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_dump.h0000644000175000017500000000373213055426554020211 0ustar sleuthkidsleuthkid/* * 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 ROSE_DUMP_H #define ROSE_DUMP_H #ifdef DUMP_SUPPORT #include #include struct RoseEngine; namespace ue2 { void roseDumpText(const RoseEngine *t, FILE *f); void roseDumpInternals(const RoseEngine *t, const std::string &base); void roseDumpComponents(const RoseEngine *t, bool dump_raw, const std::string &base); void roseDumpStructRaw(const RoseEngine *t, FILE *f); } // namespace ue2 #endif #endif hyperscan-4.4.1/src/rose/infix.h0000644000175000017500000001233713055426554017332 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 INFIX_H #define INFIX_H #include "ue2common.h" #include "nfa/nfa_api.h" #include "nfa/nfa_api_queue.h" #include "nfa/nfa_internal.h" static really_inline int infixTooOld(struct mq *q, s64a curr_loc) { u32 maxAge = q->nfa->maxWidth; if (!maxAge) { return 0; } return q_last_loc(q) + maxAge < curr_loc; } static really_inline int canReduceQueue(const struct mq *q, s64a curr_loc, u32 maxTops, u32 maxAge) { u32 qlen = q->end - q->cur; /* includes MQE_START */ if (maxAge && q->items[q->cur].location + maxAge < curr_loc) { return 1; } if (qlen - 1 > maxTops) { return 1; } if (qlen - 1 == maxTops && q->items[q->cur].location != q->items[q->cur + 1].location) { /* we can advance start to the first top location */ return 1; } return 0; } /** * Removes tops which are known not to affect the final state from the queue. * May also reinitialise the engine state if it is unneeded. * * maxAge is the maximum width of the infix. Any tops/state before this can be * ignored. 0 is used to indicate that there is no upper bound on the width of * the pattern. * * maxTops is the maximum number of locations of tops that can affect the top. * It is only possible for the last maxTops tops to affect the final state - * earlier ones can be safely removed. Also, any state before the max tops may * be ignored. * * This code assumes/requires that there are not multiple tops at the same * location in the queue. This code also assumes that it is not a multitop * engine. */ static really_inline void reduceInfixQueue(struct mq *q, s64a curr_loc, u32 maxTops, u32 maxAge) { assert(q->end > q->cur); assert(maxTops); u32 qlen = q->end - q->cur; /* includes MQE_START */ DEBUG_PRINTF("q=%p, len=%u, maxTops=%u maxAge=%u\n", q, qlen, maxTops, maxAge); if (!canReduceQueue(q, curr_loc, maxTops, maxAge)) { DEBUG_PRINTF("nothing to do\n"); return; } #ifdef DEBUG debugQueue(q); #endif char drop_state = qlen - 1 >= maxTops || (maxAge && q->items[q->cur].location + maxAge < curr_loc); LIMIT_TO_AT_MOST(&maxTops, qlen - 1); // We leave our START where it is, at the front of the queue. assert(q->items[q->cur].type == MQE_START); // We want to shuffle maxQueueLen items from the end of the queue to just // after the start, effectively dequeuing old items. We could use memmove // for this, but it's probably not a good idea to take the cost of the // function call. const struct mq_item *src = &q->items[q->cur + qlen - maxTops]; q->items[0] = q->items[q->cur]; /* shift start event to 0 slot */ q->cur = 0; q->end = 1; struct mq_item *dst = &q->items[1]; u32 i = 0; if (maxAge) { /* any event which is older than maxAge can be dropped */ for (; i < maxTops; i++, src++) { if (src->location >= curr_loc - maxAge) { break; } } } for (; i < maxTops; i++) { *dst = *src; src++; dst++; q->end++; } if (drop_state) { /* clear state and shift start up to first top */ s64a new_loc; if (q->end > 1) { new_loc = q->items[1].location; } else { DEBUG_PRINTF("no tops\n"); new_loc = curr_loc; } DEBUG_PRINTF("advancing start from %lld to %lld\n", q->items[0].location, new_loc); assert(new_loc > q->items[0].location); q->items[0].location = new_loc; nfaQueueInitState(q->nfa, q); } DEBUG_PRINTF("reduced queue to len=%u\n", q->end - q->cur); #ifdef DEBUG debugQueue(q); #endif } #endif hyperscan-4.4.1/src/rose/rose_build_compile.cpp0000644000175000017500000015024313055426554022406 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "rose_build_impl.h" #include "grey.h" #include "hs_internal.h" #include "rose_build_anchored.h" #include "rose_build_castle.h" #include "rose_build_convert.h" #include "rose_build_dump.h" #include "rose_build_groups.h" #include "rose_build_matchers.h" #include "rose_build_merge.h" #include "rose_build_role_aliasing.h" #include "rose_build_util.h" #include "ue2common.h" #include "nfa/nfa_internal.h" #include "nfa/rdfa.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_execute.h" #include "nfagraph/ng_is_equal.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_mcclellan.h" #include "nfagraph/ng_prune.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_reports.h" #include "nfagraph/ng_stop.h" #include "nfagraph/ng_util.h" #include "nfagraph/ng_width.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/charreach_util.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include #include #include #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { #define ANCHORED_REHOME_MIN_FLOATING 800 #define ANCHORED_REHOME_MIN_FLOATING_SHORT 50 #define ANCHORED_REHOME_ALLOW_SHORT 20 #define ANCHORED_REHOME_DEEP 25 #define ANCHORED_REHOME_SHORT_LEN 3 #define MAX_EXPLOSION_NC 3 static bool limited_explosion(const ue2_literal &s) { u32 nc_count = 0; for (const auto &e : s) { if (e.nocase) { nc_count++; } } return nc_count <= MAX_EXPLOSION_NC; } void RoseBuildImpl::handleMixedSensitivity(void) { for (const auto &e : literals.right) { u32 id = e.first; const rose_literal_id &lit = e.second; if (lit.delay) { continue; /* delay id's are virtual-ish */ } if (lit.table == ROSE_ANCHORED || lit.table == ROSE_EVENT) { continue; /* wrong table */ } if (!mixed_sensitivity(lit.s)) { continue; } // We don't want to explode long literals, as they require confirmation // with a CHECK_LITERAL instruction and need unique final_ids. // TODO: we could allow explosion for literals where the prefixes // covered by CHECK_LITERAL are identical. if (lit.s.length() <= ROSE_LONG_LITERAL_THRESHOLD_MIN && limited_explosion(lit.s)) { DEBUG_PRINTF("need to explode existing string '%s'\n", dumpString(lit.s).c_str()); literal_info[id].requires_explode = true; } else { literal_info[id].requires_benefits = true; } } } // Returns the length of the longest prefix of s that is (a) also a suffix of s // and (b) not s itself. static size_t maxPeriod(const ue2_literal &s) { /* overly conservative if only part of the string is nocase */ if (s.empty()) { return 0; } const size_t len = s.length(); const char *begin = s.c_str(), *end = begin + len; size_t i; for (i = len - 1; i != 0; i--) { if (!cmp(begin, end - i, i, s.any_nocase())) { break; } } return i; } bool RoseBuildImpl::isPseudoStar(const RoseEdge &e) const { return !g[e].minBound && isPseudoStarOrFirstOnly(e); } bool RoseBuildImpl::isPseudoStarOrFirstOnly(const RoseEdge &e) const { RoseVertex u = source(e, g); RoseVertex v = target(e, g); if (g[e].maxBound != ROSE_BOUND_INF) { return false; } if (isAnyStart(u)) { return true; } if (isAnchored(u)) { /* anchored table runs out of order */ return false; } if (hasDelayedLiteral(u)) { return false; } if (g[v].left) { return false; } if (g[v].eod_accept) { return true; } assert(!g[v].literals.empty()); if (maxLiteralOverlap(u, v)) { return false; } return true; } bool RoseBuildImpl::hasOnlyPseudoStarInEdges(RoseVertex v) const { for (const auto &e : in_edges_range(v, g)) { if (!isPseudoStar(e)) { return false; } } return true; } static size_t trailerDueToSelf(const rose_literal_id &lit) { size_t trailer = lit.s.length() - maxPeriod(lit.s); if (trailer > 255) { return 255; } if (!trailer) { return 1; } return trailer; } static RoseRoleHistory findHistoryScheme(const RoseBuildImpl &tbi, const RoseEdge &e) { const RoseGraph &g = tbi.g; const RoseVertex u = source(e, g); /* pred role */ const RoseVertex v = target(e, g); /* current role */ DEBUG_PRINTF("find history for [%zu,%zu]\n", g[u].index, g[v].index); DEBUG_PRINTF("u has min_offset=%u, max_offset=%u\n", g[u].min_offset, g[u].max_offset); if (g[v].left) { if (!tbi.isAnyStart(u)) { /* infix nfa will track history, treat as pseudo .*. Note: rose lits * may overlap so rose history track would be wrong anyway */ DEBUG_PRINTF("skipping history as prefix\n"); return ROSE_ROLE_HISTORY_NONE; } if (g[e].minBound || g[e].maxBound != ROSE_BOUND_INF) { DEBUG_PRINTF("rose prefix with external bounds\n"); return ROSE_ROLE_HISTORY_ANCH; } else { return ROSE_ROLE_HISTORY_NONE; } } // Handle EOD cases. if (g[v].eod_accept) { const u32 minBound = g[e].minBound, maxBound = g[e].maxBound; DEBUG_PRINTF("EOD edge with bounds [%u,%u]\n", minBound, maxBound); // Trivial case: we don't need history for {0,inf} bounds if (minBound == 0 && maxBound == ROSE_BOUND_INF) { return ROSE_ROLE_HISTORY_NONE; } // Event literals store no history. if (tbi.hasLiteralInTable(u, ROSE_EVENT)) { return ROSE_ROLE_HISTORY_NONE; } // Trivial case: fixed offset from anchor if (g[u].fixedOffset()) { return ROSE_ROLE_HISTORY_ANCH; } // If the bounds are {0,0}, this role can only match precisely at EOD. if (minBound == 0 && maxBound == 0) { /* last byte history will squash the state byte so cannot have other * succ */ assert(out_degree(u, g) == 1); return ROSE_ROLE_HISTORY_LAST_BYTE; } // XXX: No other history schemes should be possible any longer. assert(0); } // Non-EOD cases. DEBUG_PRINTF("examining edge [%zu,%zu] with bounds {%u,%u}\n", g[u].index, g[v].index, g[e].minBound, g[e].maxBound); if (tbi.isAnchored(v)) { // Matches for literals in the anchored table will always arrive at the // right offsets, so there's no need for history-based confirmation. DEBUG_PRINTF("v in anchored table, no need for history\n"); assert(u == tbi.anchored_root); return ROSE_ROLE_HISTORY_NONE; } if (g[u].fixedOffset() && (g[e].minBound || g[e].maxBound != ROSE_BOUND_INF)) { DEBUG_PRINTF("fixed offset -> anch\n"); return ROSE_ROLE_HISTORY_ANCH; } return ROSE_ROLE_HISTORY_NONE; } static void assignHistories(RoseBuildImpl &tbi) { for (const auto &e : edges_range(tbi.g)) { if (tbi.g[e].history == ROSE_ROLE_HISTORY_INVALID) { tbi.g[e].history = findHistoryScheme(tbi, e); } } } bool RoseBuildImpl::isDirectReport(u32 id) const { assert(id < literal_info.size()); // Literal info properties. const rose_literal_info &info = literal_info[id]; if (info.vertices.empty()) { return false; } if (!info.delayed_ids.empty() /* dr's don't set groups */ || info.requires_benefits) { /* dr's don't require confirm */ return false; } if (isDelayed(id)) { /* can't handle delayed dr atm as we require delay * ids to be dense */ return false; } // Role properties. // Note that a literal can have multiple roles and still be a direct // report; it'll become a multi-direct report ("MDR") that fires each // role's reports from a list. for (auto v : info.vertices) { assert(contains(g[v].literals, id)); if (g[v].reports.empty() || g[v].eod_accept || // no accept EOD !g[v].isBoring() || !isLeafNode(v, g) || // Must have no out-edges in_degree(v, g) != 1) { // Role must have exactly one in-edge return false; } // Use the program to handle cases that aren't external reports. for (const ReportID &rid : g[v].reports) { if (!isExternalReport(rm.getReport(rid))) { return false; } } if (literals.right.at(id).table == ROSE_ANCHORED) { /* in-edges are irrelevant for anchored region. */ continue; } /* The in-edge must be an (0, inf) edge from root. */ assert(in_degree(v, g) != 0); RoseEdge e = *(in_edges(v, g).first); if (source(e, g) != root || g[e].minBound != 0 || g[e].maxBound != ROSE_BOUND_INF) { return false; } // Note: we allow ekeys; they will result in unused roles being built as // direct reporting will be used when actually matching in Rose. /* TODO: prevent roles being created */ } DEBUG_PRINTF("literal %u ('%s') is a %s report\n", id, dumpString(literals.right.at(id).s).c_str(), info.vertices.size() > 1 ? "multi-direct" : "direct"); return true; } /* If we have prefixes that can squash all the floating roots, we can have a * somewhat-conditional floating table. As we can't yet look at squash_masks, we * have to make some guess as to if we are in this case but the win for not * running a floating table over a large portion of the stream is significantly * larger than avoiding running an eod table over the last N bytes. */ static bool checkFloatingKillableByPrefixes(const RoseBuildImpl &tbi) { for (auto v : vertices_range(tbi.g)) { if (!tbi.isRootSuccessor(v)) { continue; } if (!tbi.isFloating(v)) { continue; } if (!tbi.g[v].left) { DEBUG_PRINTF("unguarded floating root\n"); return false; } if (tbi.g[v].left.graph) { const NGHolder &h = *tbi.g[v].left.graph; if (proper_out_degree(h.startDs, h)) { DEBUG_PRINTF("floating nfa prefix, won't die\n"); return false; } } else if (tbi.g[v].left.dfa) { if (tbi.g[v].left.dfa->start_floating != DEAD_STATE) { DEBUG_PRINTF("floating dfa prefix, won't die\n"); return false; } } } return true; } static bool checkEodStealFloating(const RoseBuildImpl &tbi, const vector &eodLiteralsForFloating, u32 numFloatingLiterals, size_t shortestFloatingLen) { if (eodLiteralsForFloating.empty()) { DEBUG_PRINTF("no eod literals\n"); return true; } if (!numFloatingLiterals) { DEBUG_PRINTF("no floating table\n"); return false; } if (tbi.hasNoFloatingRoots()) { DEBUG_PRINTF("skipping as floating table is conditional\n"); /* TODO: investigate putting stuff in atable */ return false; } if (checkFloatingKillableByPrefixes(tbi)) { DEBUG_PRINTF("skipping as prefixes may make ftable conditional\n"); return false; } DEBUG_PRINTF("%zu are eod literals, %u floating; floating len=%zu\n", eodLiteralsForFloating.size(), numFloatingLiterals, shortestFloatingLen); u32 new_floating_lits = 0; for (u32 eod_id : eodLiteralsForFloating) { const rose_literal_id &lit = tbi.literals.right.at(eod_id); DEBUG_PRINTF("checking '%s'\n", dumpString(lit.s).c_str()); if (tbi.hasLiteral(lit.s, ROSE_FLOATING)) { DEBUG_PRINTF("skip; there is already a floating version\n"); continue; } // Don't want to make the shortest floating literal shorter/worse. if (trailerDueToSelf(lit) < 4 || lit.s.length() < shortestFloatingLen) { DEBUG_PRINTF("len=%zu, selfOverlap=%zu\n", lit.s.length(), trailerDueToSelf(lit)); DEBUG_PRINTF("would shorten, bailing\n"); return false; } new_floating_lits++; } DEBUG_PRINTF("..would require %u new floating literals\n", new_floating_lits); // Magic number thresholds: we only want to get rid of our EOD table if it // would make no real difference to the FDR. if (numFloatingLiterals / 8 < new_floating_lits && (new_floating_lits > 3 || numFloatingLiterals <= 2)) { DEBUG_PRINTF("leaving eod table alone.\n"); return false; } return true; } static void promoteEodToFloating(RoseBuildImpl &tbi, const vector &eodLiterals) { DEBUG_PRINTF("promoting eod literals to floating table\n"); for (u32 eod_id : eodLiterals) { const rose_literal_id &lit = tbi.literals.right.at(eod_id); u32 floating_id = tbi.getLiteralId(lit.s, lit.msk, lit.cmp, lit.delay, ROSE_FLOATING); auto &float_verts = tbi.literal_info[floating_id].vertices; auto &eod_verts = tbi.literal_info[eod_id].vertices; insert(&float_verts, eod_verts); eod_verts.clear(); DEBUG_PRINTF("eod_lit=%u -> float_lit=%u\n", eod_id, floating_id); for (auto v : float_verts) { tbi.g[v].literals.erase(eod_id); tbi.g[v].literals.insert(floating_id); } tbi.literal_info[floating_id].requires_explode = tbi.literal_info[eod_id].requires_explode; tbi.literal_info[floating_id].requires_benefits = tbi.literal_info[eod_id].requires_benefits; } } static bool promoteEodToAnchored(RoseBuildImpl &tbi, const vector &eodLiterals) { DEBUG_PRINTF("promoting eod literals to anchored table\n"); bool rv = true; for (u32 eod_id : eodLiterals) { const rose_literal_id &lit = tbi.literals.right.at(eod_id); NGHolder h; add_edge(h.start, h.accept, h); appendLiteral(h, lit.s); /* we only accept cases which are anchored * hard up against start */ u32 a_id = tbi.getNewLiteralId(); u32 remap_id = 0; DEBUG_PRINTF(" trying to add dfa stuff\n"); int anch_ok = addToAnchoredMatcher(tbi, h, a_id, &remap_id); if (anch_ok == ANCHORED_FAIL) { DEBUG_PRINTF("failed to promote to anchored need to keep etable\n"); rv = false; continue; } else if (anch_ok == ANCHORED_REMAP) { DEBUG_PRINTF("remapped\n"); a_id = remap_id; } else { assert(anch_ok == ANCHORED_SUCCESS); } // Store the literal itself in a side structure so that we can use it // for overlap calculations later. This may be obsolete when the old // Rose construction path (and its history selection code) goes away. tbi.anchoredLitSuffix.insert(make_pair(a_id, lit)); auto &a_verts = tbi.literal_info[a_id].vertices; auto &eod_verts = tbi.literal_info[eod_id].vertices; for (auto v : eod_verts) { for (const auto &e : in_edges_range(v, tbi.g)) { assert(tbi.g[e].maxBound != ROSE_BOUND_INF); tbi.g[e].minBound += lit.s.length(); tbi.g[e].maxBound += lit.s.length(); } } insert(&a_verts, eod_verts); eod_verts.clear(); for (auto v : a_verts) { tbi.g[v].literals.erase(eod_id); tbi.g[v].literals.insert(a_id); } } return rv; } static bool suitableForAnchored(const RoseBuildImpl &tbi, const rose_literal_id &l_id, const rose_literal_info &lit) { const RoseGraph &g = tbi.g; bool seen = false; u32 min_offset = 0; u32 max_offset = 0; if (!lit.delayed_ids.empty() || l_id.delay) { DEBUG_PRINTF("delay\n"); return false; } if (!l_id.msk.empty()) { DEBUG_PRINTF("msk\n"); return false; } for (auto v : lit.vertices) { if (!seen) { min_offset = g[v].min_offset; max_offset = g[v].max_offset; seen = true; if (max_offset > tbi.cc.grey.maxAnchoredRegion) { DEBUG_PRINTF("too deep %u\n", max_offset); return false; } } if (max_offset != g[v].max_offset || min_offset != g[v].min_offset) { DEBUG_PRINTF(":(\n"); return false; } if (!g[v].isBoring()) { DEBUG_PRINTF(":(\n"); return false; } if (g[v].literals.size() != 1) { DEBUG_PRINTF("shared\n"); return false; } if (tbi.isNonRootSuccessor(v)) { DEBUG_PRINTF("non root\n"); return false; } if (max_offset != l_id.s.length() || min_offset != l_id.s.length()) { DEBUG_PRINTF("|%zu| (%u,%u):(\n", l_id.s.length(), min_offset, max_offset); /* TODO: handle cases with small bounds */ return false; } for (auto w : adjacent_vertices_range(v, g)) { if (!g[w].eod_accept) { DEBUG_PRINTF("non eod accept literal\n"); return false; } } } return true; } // If we've got a small number of long, innocuous EOD literals and a large // floating table, we consider promoting those EOD literals to the floating // table to avoid having to run both. See UE-2069, consider deleting this and // replacing with an elegant reverse DFA. /* We do not want to do this if we would otherwise avoid running the floating * table altogether. */ static void stealEodVertices(RoseBuildImpl &tbi) { u32 numFloatingLiterals = 0; u32 numAnchoredLiterals = 0; size_t shortestFloatingLen = SIZE_MAX; vector eodLiteralsForFloating; vector eodLiteralsForAnchored; DEBUG_PRINTF("hi\n"); for (u32 i = 0; i < tbi.literal_info.size(); i++) { const auto &info = tbi.literal_info[i]; if (info.vertices.empty()) { continue; // skip unused literals } const rose_literal_id &lit = tbi.literals.right.at(i); if (lit.table == ROSE_EOD_ANCHORED) { if (suitableForAnchored(tbi, lit, info)) { eodLiteralsForAnchored.push_back(i); } else { eodLiteralsForFloating.push_back(i); } } else if (lit.table == ROSE_FLOATING) { numFloatingLiterals++; shortestFloatingLen = min(shortestFloatingLen, lit.s.length()); } else if (lit.table == ROSE_ANCHORED) { numAnchoredLiterals++; } } /* given a choice of having either an eod table or an anchored table, we * always favour having an anchored table */ if (!checkEodStealFloating(tbi, eodLiteralsForFloating, numFloatingLiterals, shortestFloatingLen)) { DEBUG_PRINTF("removing etable weakens ftable\n"); return; } promoteEodToFloating(tbi, eodLiteralsForFloating); if (!promoteEodToAnchored(tbi, eodLiteralsForAnchored)) { DEBUG_PRINTF("still need ematcher\n"); return; } // We're no longer using the EOD matcher. tbi.ematcher_region_size = 0; } bool RoseBuildImpl::isDelayed(u32 id) const { return literal_info.at(id).undelayed_id != id; } bool RoseBuildImpl::hasFinalId(u32 id) const { return literal_info.at(id).final_id != MO_INVALID_IDX; } bool RoseBuildImpl::hasDelayedLiteral(RoseVertex v) const { for (u32 lit_id : g[v].literals) { if (literals.right.at(lit_id).delay) { return true; } } return false; } bool RoseBuildImpl::hasDelayPred(RoseVertex v) const { for (auto u : inv_adjacent_vertices_range(v, g)) { if (hasDelayedLiteral(u)) { return true; } } return false; } bool RoseBuildImpl::hasAnchoredTablePred(RoseVertex v) const { for (auto u : inv_adjacent_vertices_range(v, g)) { if (isAnchored(u)) { return true; } } return false; } void RoseBuildImpl::findTransientLeftfixes(void) { for (auto v : vertices_range(g)) { if (!g[v].left) { continue; } /* infixes can never (or at least not yet) be transient */ if (isNonRootSuccessor(v)) { continue; } const left_id &left(g[v].left); if (::ue2::isAnchored(left) && !isInETable(v)) { /* etable prefixes currently MUST be transient as we do not know * where we can safely catch them up to (yet). */ DEBUG_PRINTF("anchored roses in rocky soil are not fleeting\n"); continue; } const depth max_width = findMaxWidth(left); if (!max_width.is_finite()) { DEBUG_PRINTF("inf max width\n"); continue; } if (cc.streaming) { /* STREAMING: transient prefixes must be able to run using history * rather than storing state. */ u32 his = g[v].left.lag + max_width; // If this vertex has an event literal, we need to add one to cope // with it. if (hasLiteralInTable(v, ROSE_EVENT)) { his++; } /* +1 as trigger must appear in main buffer and no byte is needed to * decompress the state */ if (his <= cc.grey.maxHistoryAvailable + 1) { transient.insert(left); DEBUG_PRINTF("a transient leftfix spotted his=%u\n", his); } } else { /* BLOCK: transientness is less important and more fuzzy, ideally * it should be quick to calculate the state. No need to worry about * history (and hence lag). */ if (max_width < depth(ROSE_BLOCK_TRANSIENT_MAX_WIDTH)) { transient.insert(left); DEBUG_PRINTF("a transient block leftfix spotted [%u]\n", (u32)max_width); } } } } /** Find all the different roses and their associated literals. */ static map> findLeftSucc(const RoseBuildImpl &build) { map> leftfixes; for (auto v : vertices_range(build.g)) { if (build.g[v].left) { const LeftEngInfo &lei = build.g[v].left; leftfixes[lei].push_back(v); } } return leftfixes; } namespace { struct infix_info { set preds; set succs; }; } static map findInfixGraphInfo(const RoseBuildImpl &build) { map rv; for (auto v : vertices_range(build.g)) { if (!build.g[v].left) { continue; } if (build.isRootSuccessor(v)) { DEBUG_PRINTF("a prefix is never an infix\n"); continue; } /* ensure only proper nfas */ const LeftEngInfo &lei = build.g[v].left; if (!lei.graph) { continue; } if (lei.haig || lei.dfa) { continue; } assert(!lei.castle); infix_info &info = rv[lei.graph.get()]; insert(&info.preds, inv_adjacent_vertices_range(v, build.g)); info.succs.insert(v); } return rv; } static map> getTopInfo(const NGHolder &h) { map> rv; for (NFAEdge e : out_edges_range(h.start, h)) { for (u32 t : h[e].tops) { rv[t].insert(e); } } return rv; } static u32 findUnusedTop(const map> &tops) { u32 i = 0; while (contains(tops, i)) { i++; } return i; } static bool reduceTopTriggerLoad(RoseBuildImpl &build, NGHolder &h, RoseVertex u) { RoseGraph &g = build.g; set tops; /* tops triggered by u */ for (RoseEdge e : out_edges_range(u, g)) { RoseVertex v = target(e, g); if (g[v].left.graph.get() != &h) { continue; } tops.insert(g[e].rose_top); } assert(!tops.empty()); if (tops.size() <= 1) { return false; } DEBUG_PRINTF("%zu triggers %zu tops for %p\n", build.g[u].index, tops.size(), &h); auto h_top_info = getTopInfo(h); flat_set edges_to_trigger; for (u32 t : tops) { insert(&edges_to_trigger, h_top_info[t]); } u32 new_top = ~0U; /* check if there is already a top with the right the successor set */ for (const auto &elem : h_top_info) { if (elem.second == edges_to_trigger) { new_top = elem.first; break; } } /* if no existing suitable top, add a new top for us */ if (new_top == ~0U) { new_top = findUnusedTop(h_top_info); /* add top to edges out of start */ for (NFAEdge e : out_edges_range(h.start, h)) { if (has_intersection(tops, h[e].tops)) { h[e].tops.insert(new_top); } } /* check still implementable if we add a new top */ if (!isImplementableNFA(h, nullptr, build.cc)) { DEBUG_PRINTF("unable to add new top\n"); for (NFAEdge e : out_edges_range(h.start, h)) { h[e].tops.erase(new_top); } /* we should be back to the original graph */ assert(isImplementableNFA(h, nullptr, build.cc)); return false; } } DEBUG_PRINTF("using new merged top %u\n", new_top); assert(new_top != ~0U); for (RoseEdge e: out_edges_range(u, g)) { RoseVertex v = target(e, g); if (g[v].left.graph.get() != &h) { continue; } g[e].rose_top = new_top; } return true; } static void packInfixTops(NGHolder &h, RoseGraph &g, const set &verts) { if (!is_triggered(h)) { DEBUG_PRINTF("not triggered, no tops\n"); return; } assert(isCorrectlyTopped(h)); DEBUG_PRINTF("pruning unused tops\n"); flat_set used_tops; for (auto v : verts) { assert(g[v].left.graph.get() == &h); for (const auto &e : in_edges_range(v, g)) { u32 top = g[e].rose_top; used_tops.insert(top); } } map top_mapping; for (u32 t : used_tops) { u32 new_top = top_mapping.size(); top_mapping[t] = new_top; } for (auto v : verts) { assert(g[v].left.graph.get() == &h); for (const auto &e : in_edges_range(v, g)) { g[e].rose_top = top_mapping.at(g[e].rose_top); } } vector dead; for (const auto &e : out_edges_range(h.start, h)) { NFAVertex v = target(e, h); if (v == h.startDs) { continue; // stylised edge, leave it alone. } flat_set updated_tops; for (u32 t : h[e].tops) { if (contains(top_mapping, t)) { updated_tops.insert(top_mapping.at(t)); } } h[e].tops = move(updated_tops); if (h[e].tops.empty()) { DEBUG_PRINTF("edge (start,%zu) has only unused tops\n", h[v].index); dead.push_back(e); } } if (dead.empty()) { return; } remove_edges(dead, h); pruneUseless(h); clearReports(h); // As we may have removed vacuous edges. } static void reduceTopTriggerLoad(RoseBuildImpl &build) { auto infixes = findInfixGraphInfo(build); for (auto &p : infixes) { if (onlyOneTop(*p.first)) { continue; } bool changed = false; for (RoseVertex v : p.second.preds) { changed |= reduceTopTriggerLoad(build, *p.first, v); } if (changed) { packInfixTops(*p.first, build.g, p.second.succs); reduceImplementableGraph(*p.first, SOM_NONE, nullptr, build.cc); } } } static bool triggerKillsRoseGraph(const RoseBuildImpl &build, const left_id &left, const set &all_lits, const RoseEdge &e) { assert(left.graph()); const NGHolder &h = *left.graph(); ue2::flat_set all_states; insert(&all_states, vertices(h)); assert(out_degree(h.startDs, h) == 1); /* triggered don't use sds */ DEBUG_PRINTF("removing sds\n"); all_states.erase(h.startDs); ue2::flat_set states; /* check each pred literal to see if they all kill previous graph * state */ for (u32 lit_id : build.g[source(e, build.g)].literals) { const rose_literal_id &pred_lit = build.literals.right.at(lit_id); const ue2_literal s = findNonOverlappingTail(all_lits, pred_lit.s); DEBUG_PRINTF("running graph %zu\n", states.size()); states = execute_graph(h, s, all_states, true); DEBUG_PRINTF("ran, %zu states on\n", states.size()); if (!states.empty()) { return false; } } return true; } static bool triggerKillsRose(const RoseBuildImpl &build, const left_id &left, const set &all_lits, const RoseEdge &e) { if (left.haig()) { /* TODO: To allow this for som-based engines we would also need to * ensure as well that no other triggers can occur at the same location * with a different som. */ return false; } if (left.graph()) { return triggerKillsRoseGraph(build, left, all_lits, e); } if (left.castle()) { return triggerKillsRoseCastle(build, left, all_lits, e); } return false; } /* Sometimes the arrival of a top for a rose infix can ensure that the nfa would * be dead at that time. In the case of multiple trigger literals, we can only * base our decision on that portion of literal after any overlapping literals. */ static void findTopTriggerCancels(RoseBuildImpl &build) { auto left_succ = findLeftSucc(build); /* leftfixes -> succ verts */ for (const auto &r : left_succ) { const left_id &left = r.first; const vector &succs = r.second; assert(!succs.empty()); if (build.isRootSuccessor(*succs.begin())) { /* a prefix is never an infix */ continue; } set tops_seen; set rose_edges; set pred_lit_ids; for (auto v : succs) { for (const auto &e : in_edges_range(v, build.g)) { RoseVertex u = source(e, build.g); tops_seen.insert(build.g[e].rose_top); insert(&pred_lit_ids, build.g[u].literals); rose_edges.insert(e); } } set all_lits; if (tops_seen.size() > 1) { goto next_rose; /* slightly tricky to deal with overlap case */ } for (u32 lit_id : pred_lit_ids) { const rose_literal_id &p_lit = build.literals.right.at(lit_id); if (p_lit.delay || p_lit.table == ROSE_ANCHORED) { goto next_rose; } all_lits.insert(p_lit.s); DEBUG_PRINTF("trigger: '%s'\n", dumpString(p_lit.s).c_str()); } DEBUG_PRINTF("rose has %zu trigger literals, %zu edges\n", all_lits.size(), rose_edges.size()); for (const auto &e : rose_edges) { if (triggerKillsRose(build, left, all_lits, e)) { DEBUG_PRINTF("top will override previous rose state\n"); build.g[e].rose_cancel_prev_top = true; } } next_rose:; } } static void optimiseRoseTops(RoseBuildImpl &build) { reduceTopTriggerLoad(build); /* prune unused tops ? */ findTopTriggerCancels(build); } static void buildRoseSquashMasks(RoseBuildImpl &tbi) { /* Rose nfa squash masks are applied to the groups when the nfa can no * longer match */ map> roses = findLeftSucc(tbi); /* rose -> succ verts */ /* a rose nfa can squash a group if all literals in that group are a * successor of the nfa and all the literals */ for (const auto &e : roses) { const left_id &left = e.first; const vector &succs = e.second; set lit_ids; bool anchored_pred = false; for (auto v : succs) { lit_ids.insert(tbi.g[v].literals.begin(), tbi.g[v].literals.end()); for (auto u : inv_adjacent_vertices_range(v, tbi.g)) { anchored_pred |= tbi.isAnchored(u); } } /* Due to the anchored table not being able to set groups again, * we cannot use a rose nfa for group squashing if it is being triggered * from the anchored table and can match more than once. */ if (anchored_pred) { /* infix with pred in anchored table */ u32 min_off = ~0U; u32 max_off = 0U; for (auto v : succs) { for (auto u : inv_adjacent_vertices_range(v, tbi.g)) { min_off = min(min_off, tbi.g[u].min_offset); max_off = max(max_off, tbi.g[u].max_offset); } } if (min_off != max_off) { /* leave all groups alone */ tbi.rose_squash_masks[left] = ~0ULL; continue; } } rose_group unsquashable = 0; for (u32 lit_id : lit_ids) { const rose_literal_info &info = tbi.literal_info[lit_id]; if (info.vertices.size() > 1 || !info.delayed_ids.empty()) { unsquashable |= info.group_mask; } } rose_group squash_mask = ~0ULL; /* leave all groups alone */ for (u32 i = 0; i < ROSE_GROUPS_MAX; i++) { if (is_subset_of(tbi.group_to_literal[i], lit_ids)) { squash_mask &= ~(1ULL << i); } } squash_mask |= unsquashable; tbi.rose_squash_masks[left] = squash_mask; } } static void countFloatingLiterals(const RoseBuildImpl &tbi, u32 *total_count, u32 *short_count) { *total_count = 0; *short_count = 0; for (const rose_literal_id &lit : tbi.literals.right | map_values) { if (lit.delay) { continue; /* delay id's are virtual-ish */ } if (lit.table != ROSE_FLOATING) { continue; /* wrong table */ } ++*total_count; if (lit.s.length() <= ANCHORED_REHOME_SHORT_LEN) { ++*short_count; } } } static void rehomeAnchoredLiteral(RoseBuildImpl &tbi, const simple_anchored_info &sai, const set &lit_ids) { /* TODO: verify that vertices only have a single literal at the moment */ DEBUG_PRINTF("rehoming ^.{%u,%u}%s\n", sai.min_bound, sai.max_bound, dumpString(sai.literal).c_str()); /* Get a floating literal corresponding to the anchored literal */ u32 new_literal_id = tbi.getLiteralId(sai.literal, 0, ROSE_FLOATING); rose_literal_info &new_lit_info = tbi.literal_info[new_literal_id]; DEBUG_PRINTF("floating literal id -> %u\n", new_literal_id); for (u32 lit_id : lit_ids) { rose_literal_info &old_lit_info = tbi.literal_info[lit_id]; assert(old_lit_info.delayed_ids.empty()); for (auto v : old_lit_info.vertices) { /* Transfer vertex over to new literal id */ assert(tbi.g[v].literals.size() == 1); tbi.g[v].literals.clear(); tbi.g[v].literals.insert(new_literal_id); new_lit_info.vertices.insert(v); /* ensure bounds on the vertex's in-edge are correct */ assert(in_degree(v, tbi.g) == 1); const RoseEdge &e = *in_edges(v, tbi.g).first; assert(tbi.g[e].minBound == sai.min_bound + sai.literal.length()); assert(tbi.g[e].maxBound == sai.max_bound + sai.literal.length()); tbi.g[e].minBound = sai.min_bound; tbi.g[e].maxBound = sai.max_bound; } /* mark the old literal as empty */ old_lit_info.vertices.clear(); } } static void rehomeAnchoredLiterals(RoseBuildImpl &tbi) { /* if we have many literals in the floating table, we want to push * literals which are anchored but deep into the floating table as they * are unlikely to reduce the performance of the floating table. */ u32 total_count; u32 short_count; countFloatingLiterals(tbi, &total_count, &short_count); DEBUG_PRINTF("considering rehoming options\n"); if (total_count < ANCHORED_REHOME_MIN_FLOATING && short_count < ANCHORED_REHOME_MIN_FLOATING_SHORT) { DEBUG_PRINTF("not a heavy case %u %u\n", total_count, short_count); return; } u32 min_rehome_len = ANCHORED_REHOME_SHORT_LEN + 1; if (short_count >= ANCHORED_REHOME_ALLOW_SHORT) { min_rehome_len--; } for (map >::iterator it = tbi.anchored_simple.begin(); it != tbi.anchored_simple.end();) { if (it->first.max_bound < ANCHORED_REHOME_DEEP || it->first.literal.length() < min_rehome_len) { ++it; continue; } rehomeAnchoredLiteral(tbi, it->first, it->second); tbi.anchored_simple.erase(it++); } } /** \brief Maximum number of single-byte literals to add to the small block * table. */ static const size_t MAX_1BYTE_SMALL_BLOCK_LITERALS = 20; static void addSmallBlockLiteral(RoseBuildImpl &tbi, const simple_anchored_info &sai, const set &lit_ids) { DEBUG_PRINTF("anchored ^.{%u,%u}%s\n", sai.min_bound, sai.max_bound, dumpString(sai.literal).c_str()); u32 lit_id = tbi.getLiteralId(sai.literal, 0, ROSE_ANCHORED_SMALL_BLOCK); rose_literal_info &lit_info = tbi.literal_info[lit_id]; DEBUG_PRINTF("anchored small block literal id -> %u\n", lit_id); RoseGraph &g = tbi.g; const RoseVertex anchored_root = tbi.anchored_root; for (u32 old_id : lit_ids) { assert(old_id < tbi.literal_info.size()); const rose_literal_info &li = tbi.literal_info[old_id]; for (auto lit_v : li.vertices) { // Clone vertex with the new literal ID. RoseVertex v = add_vertex(g[lit_v], g); g[v].literals.clear(); g[v].literals.insert(lit_id); g[v].min_offset = sai.min_bound + sai.literal.length(); g[v].max_offset = sai.max_bound + sai.literal.length(); lit_info.vertices.insert(v); RoseEdge e = add_edge(anchored_root, v, g); g[e].minBound = sai.min_bound; g[e].maxBound = sai.max_bound; } } } static void addSmallBlockLiteral(RoseBuildImpl &tbi, const ue2_literal &lit, const flat_set &reports) { DEBUG_PRINTF("lit %s, reports: %s\n", dumpString(lit).c_str(), as_string_list(reports).c_str()); assert(!reports.empty()); u32 lit_id = tbi.getLiteralId(lit, 0, ROSE_ANCHORED_SMALL_BLOCK); assert(lit_id < tbi.literal_info.size()); rose_literal_info &lit_info = tbi.literal_info[lit_id]; RoseGraph &g = tbi.g; RoseVertex v = add_vertex(g); g[v].literals.insert(lit_id); g[v].reports = reports; RoseEdge e = add_edge(tbi.root, v, g); g[e].minBound = 0; g[e].maxBound = ROSE_BOUND_INF; g[v].min_offset = 1; g[v].max_offset = ROSE_BOUND_INF; lit_info.vertices.insert(v); } static bool stateIsSEPLiteral(const dstate_id_t &s, const symbol_t &sym, const raw_dfa &rdfa) { const dstate &ds = rdfa.states[s]; if (!ds.reports_eod.empty() || ds.reports.empty()) { DEBUG_PRINTF("badly formed reports\n"); return false; } DEBUG_PRINTF("examine state %u reached by sym %u\n", s, sym); for (symbol_t i = 0; i < rdfa.getImplAlphaSize(); i++) { const auto &s_next = ds.next[i]; DEBUG_PRINTF("state %u -> %u on sym %u\n", s, s_next, i); if (s_next == DEAD_STATE) { continue; // dead, probably pruned } else if (s_next == s && i == sym) { continue; // self loop on same symbol } else if (s_next == rdfa.start_floating) { continue; // return to floating start } // We don't handle any other transitions. DEBUG_PRINTF("not single-byte\n"); return false; } return true; } static bool extractSEPLiterals(const raw_dfa &rdfa, map> &lits_out) { if (rdfa.start_floating == DEAD_STATE) { DEBUG_PRINTF("not floating?\n"); return false; } if (rdfa.start_anchored != rdfa.start_floating) { DEBUG_PRINTF("not all floating?\n"); return false; } map, vector> lits; // reports -> symbols const dstate &start = rdfa.states[rdfa.start_floating]; const symbol_t alpha_size = rdfa.getImplAlphaSize(); for (symbol_t i = 0; i < alpha_size; i++) { auto next = start.next[i]; if (next == DEAD_STATE || next == rdfa.start_floating) { continue; } if (!stateIsSEPLiteral(next, i, rdfa)) { return false; } lits[rdfa.states[next].reports].push_back(i); } // Map from symbols back to character reachability. vector reach(alpha_size); for (u32 i = 0; i < N_CHARS; i++) { assert(rdfa.alpha_remap[i] < alpha_size); reach[rdfa.alpha_remap[i]].set(i); } for (const auto &m : lits) { const auto &reports = m.first; const auto &symbols = m.second; CharReach cr; for (const auto &sym : symbols) { cr |= reach[sym]; } for (size_t i = cr.find_first(); i != cr.npos; i = cr.find_next(i)) { if (myisupper(i) && cr.test(mytolower(i))) { // ignore upper half of a nocase pair continue; } bool nocase = myislower(i) && cr.test(mytoupper(i)); insert(&lits_out[ue2_literal((char)i, nocase)], reports); } } return true; } static bool extractSEPLiterals(const OutfixInfo &outfix, const ReportManager &rm, map> &lits_out) { if (outfix.minWidth != depth(1) || outfix.maxWidth != depth(1)) { DEBUG_PRINTF("outfix must be fixed width of one\n"); return false; } for (const auto &report_id : all_reports(outfix)) { const auto &report = rm.getReport(report_id); if (!isSimpleExhaustible(report)) { DEBUG_PRINTF("report id %u not simple exhaustible\n", report_id); return false; } } // SEP cases should always become DFAs, so that's the only extract code we // have implemented here. if (outfix.rdfa()) { return extractSEPLiterals(*outfix.rdfa(), lits_out); } DEBUG_PRINTF("cannot extract literals from outfix type\n"); return false; } static void addAnchoredSmallBlockLiterals(RoseBuildImpl &tbi) { if (tbi.cc.streaming) { DEBUG_PRINTF("not block mode\n"); return; } if (!tbi.anchored_nfas.empty()) { DEBUG_PRINTF("anchored table is not purely literal\n"); return; } // At the moment, we only use the small-block matcher if all our anchored // literals are direct reports (i.e. leaf nodes in the Rose graph). for (const set &lits : tbi.anchored_simple | map_values) { for (u32 lit_id : lits) { if (!tbi.isDirectReport(lit_id)) { DEBUG_PRINTF("not all anchored lits are direct reports\n"); return; } } } vector > > anchored_lits; vector sep_outfixes; size_t oneByteLiterals = 0; for (const auto &e : tbi.anchored_simple) { const simple_anchored_info &sai = e.first; const set &lit_ids = e.second; if (sai.literal.length() + sai.min_bound > ROSE_SMALL_BLOCK_LEN) { DEBUG_PRINTF("skipping literal '%s' with min bound %u that cannot " "match inside small block width\n", dumpString(sai.literal).c_str(), sai.min_bound); } anchored_lits.push_back(make_pair(sai, lit_ids)); if (sai.literal.length() == 1) { oneByteLiterals++; } } // Capture SEP outfixes as well, adding them as literals to the small block // table. map> sep_literals; for (OutfixInfo &oi : tbi.outfixes) { if (extractSEPLiterals(oi, tbi.rm, sep_literals)) { sep_outfixes.push_back(&oi); } } oneByteLiterals += sep_literals.size(); DEBUG_PRINTF("%zu one-byte literals\n", oneByteLiterals); if (oneByteLiterals > MAX_1BYTE_SMALL_BLOCK_LITERALS) { DEBUG_PRINTF("too many one-byte literals, not building small block " "table!\n"); return; } for (const auto &e : tbi.anchored_simple) { const simple_anchored_info &sai = e.first; const set &lit_ids = e.second; addSmallBlockLiteral(tbi, sai, lit_ids); } for (const auto &m : sep_literals) { addSmallBlockLiteral(tbi, m.first, m.second); } for (OutfixInfo *oi : sep_outfixes) { assert(oi); oi->in_sbmatcher = true; } } #ifndef NDEBUG static bool historiesAreValid(const RoseGraph &g) { for (const auto &e : edges_range(g)) { if (g[e].history == ROSE_ROLE_HISTORY_INVALID) { DEBUG_PRINTF("edge [%zu,%zu] has invalid history\n", g[source(e, g)].index, g[target(e, g)].index); return false; } } return true; } /** * Assertion: Returns true if we have a reference hanging around to a vertex * that no longer exists in the graph. */ static bool danglingVertexRef(RoseBuildImpl &tbi) { RoseGraph::vertex_iterator vi, ve; tie(vi, ve) = vertices(tbi.g); const ue2::unordered_set valid_vertices(vi, ve); if (!contains(valid_vertices, tbi.anchored_root)) { DEBUG_PRINTF("anchored root vertex %zu not in graph\n", tbi.g[tbi.anchored_root].index); return true; } for (const auto &e : tbi.ghost) { if (!contains(valid_vertices, e.first)) { DEBUG_PRINTF("ghost key vertex %zu not in graph\n", tbi.g[e.first].index); return true; } if (!contains(valid_vertices, e.second)) { DEBUG_PRINTF("ghost value vertex %zu not in graph\n", tbi.g[e.second].index); return true; } } return false; } static bool roleOffsetsAreValid(const RoseGraph &g) { for (auto v : vertices_range(g)) { if (g[v].min_offset >= ROSE_BOUND_INF) { DEBUG_PRINTF("invalid min_offset for role %zu\n", g[v].index); return false; } if (g[v].min_offset > g[v].max_offset) { DEBUG_PRINTF("min_offset > max_offset for %zu\n", g[v].index); return false; } } return true; } #endif // NDEBUG aligned_unique_ptr RoseBuildImpl::buildRose(u32 minWidth) { dumpRoseGraph(*this, nullptr, "rose_early.dot"); // Early check for Rose implementability. assert(canImplementGraphs(*this)); // Sanity check vertex role offsets. assert(roleOffsetsAreValid(g)); convertPrefixToBounds(*this); // Turn flood-prone suffixes into suffix NFAs. convertFloodProneSuffixes(*this); // Turn repeats into Castle prototypes. makeCastles(*this); rehomeAnchoredLiterals(*this); // If we've got a very small number of EOD-anchored literals, consider // moving them into the floating table so that we only have one literal // matcher to run. Note that this needs to happen before // addAnchoredSmallBlockLiterals as it may create anchored literals. assert(roleOffsetsAreValid(g)); stealEodVertices(*this); addAnchoredSmallBlockLiterals(*this); // Merge duplicate leaf nodes dedupeSuffixes(*this); if (cc.grey.roseGraphReduction) { mergeDupeLeaves(*this); uncalcLeaves(*this); } assert(roleOffsetsAreValid(g)); handleMixedSensitivity(); assignHistories(*this); convertAnchPrefixToBounds(*this); // Do some final graph reduction. dedupeLeftfixes(*this); aliasRoles(*this, false); // Don't merge leftfixes. dedupeLeftfixes(*this); convertBadLeaves(*this); uncalcLeaves(*this); /* note the leftfixes which do not need to keep state across stream boundaries */ findTransientLeftfixes(); dedupeLeftfixesVariableLag(*this); mergeLeftfixesVariableLag(*this); mergeSmallLeftfixes(*this); mergeCastleLeftfixes(*this); // Do a rose-merging aliasing pass. aliasRoles(*this, true); // Merging of suffixes _below_ role aliasing, as otherwise we'd have to // teach role aliasing about suffix tops. mergeCastleSuffixes(*this); mergePuffixes(*this); mergeAcyclicSuffixes(*this); mergeSmallSuffixes(*this); // Convert Castles that would be better off as NFAs back to NGHolder // infixes/suffixes. if (unmakeCastles(*this)) { // We may be able to save some stream state by merging the newly // "unmade" Castles. mergeSmallSuffixes(*this); mergeSmallLeftfixes(*this); } assert(!hasOrphanedTops(*this)); // Do a rose-merging aliasing pass. aliasRoles(*this, true); assert(!hasOrphanedTops(*this)); // Run a merge pass over the outfixes as well. mergeOutfixes(*this); assert(!danglingVertexRef(*this)); assert(!hasOrphanedTops(*this)); findMoreLiteralMasks(*this); assignGroupsToLiterals(*this); assignGroupsToRoles(*this); findGroupSquashers(*this); /* final prep work */ remapCastleTops(*this); optimiseRoseTops(*this); buildRoseSquashMasks(*this); rm.assignDkeys(this); /* transfer mpv outfix to main queue */ if (mpv_outfix) { outfixes.push_back(move(*mpv_outfix)); mpv_outfix = nullptr; } assert(canImplementGraphs(*this)); assert(!hasOrphanedTops(*this)); assert(roleOffsetsAreValid(g)); assert(historiesAreValid(g)); dumpRoseGraph(*this, nullptr, "rose_pre_norm.dot"); return buildFinalEngine(minWidth); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_program.cpp0000644000175000017500000005326313055426554022431 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "rose_build_engine_blob.h" #include "rose_build_program.h" #include "util/container.h" #include "util/multibit_build.h" #include "util/verify_types.h" #include #include using namespace std; namespace ue2 { /* Destructors to avoid weak vtables. */ RoseInstruction::~RoseInstruction() = default; RoseInstrCatchUp::~RoseInstrCatchUp() = default; RoseInstrCatchUpMpv::~RoseInstrCatchUpMpv() = default; RoseInstrSomZero::~RoseInstrSomZero() = default; RoseInstrSuffixesEod::~RoseInstrSuffixesEod() = default; RoseInstrMatcherEod::~RoseInstrMatcherEod() = default; RoseInstrEnd::~RoseInstrEnd() = default; using OffsetMap = RoseInstruction::OffsetMap; static u32 calc_jump(const OffsetMap &offset_map, const RoseInstruction *from, const RoseInstruction *to) { DEBUG_PRINTF("computing relative jump from %p to %p\n", from, to); assert(from && contains(offset_map, from)); assert(to && contains(offset_map, to)); u32 from_offset = offset_map.at(from); u32 to_offset = offset_map.at(to); DEBUG_PRINTF("offsets: %u -> %u\n", from_offset, to_offset); assert(from_offset <= to_offset); return to_offset - from_offset; } void RoseInstrAnchoredDelay::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->groups = groups; inst->done_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckLitEarly::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->min_offset = min_offset; } void RoseInstrCheckGroups::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->groups = groups; } void RoseInstrCheckOnlyEod::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckBounds::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->min_bound = min_bound; inst->max_bound = max_bound; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckNotHandled::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->key = key; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckSingleLookaround::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->offset = offset; inst->reach_index = reach_index; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckLookaround::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->index = index; inst->count = count; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckMask::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->and_mask = and_mask; inst->cmp_mask = cmp_mask; inst->neg_mask = neg_mask; inst->offset = offset; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckMask32::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); copy(begin(and_mask), end(and_mask), inst->and_mask); copy(begin(cmp_mask), end(cmp_mask), inst->cmp_mask); inst->neg_mask = neg_mask; inst->offset = offset; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckByte::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->and_mask = and_mask; inst->cmp_mask = cmp_mask; inst->negation = negation; inst->offset = offset; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckShufti16x8::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); copy(begin(nib_mask), end(nib_mask), inst->nib_mask); copy(begin(bucket_select_mask), end(bucket_select_mask), inst->bucket_select_mask); inst->neg_mask = neg_mask; inst->offset = offset; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckShufti32x8::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); copy(begin(hi_mask), end(hi_mask), inst->hi_mask); copy(begin(lo_mask), end(lo_mask), inst->lo_mask); copy(begin(bucket_select_mask), end(bucket_select_mask), inst->bucket_select_mask); inst->neg_mask = neg_mask; inst->offset = offset; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckShufti16x16::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); copy(begin(hi_mask), end(hi_mask), inst->hi_mask); copy(begin(lo_mask), end(lo_mask), inst->lo_mask); copy(begin(bucket_select_mask), end(bucket_select_mask), inst->bucket_select_mask); inst->neg_mask = neg_mask; inst->offset = offset; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckShufti32x16::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); copy(begin(hi_mask), end(hi_mask), inst->hi_mask); copy(begin(lo_mask), end(lo_mask), inst->lo_mask); copy(begin(bucket_select_mask_hi), end(bucket_select_mask_hi), inst->bucket_select_mask_hi); copy(begin(bucket_select_mask_lo), end(bucket_select_mask_lo), inst->bucket_select_mask_lo); inst->neg_mask = neg_mask; inst->offset = offset; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckInfix::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->queue = queue; inst->lag = lag; inst->report = report; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckPrefix::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->queue = queue; inst->lag = lag; inst->report = report; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrPushDelayed::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->delay = delay; inst->index = index; } void RoseInstrRecordAnchored::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->id = id; } void RoseInstrSomAdjust::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->distance = distance; } void RoseInstrSomLeftfix::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->queue = queue; inst->lag = lag; } void RoseInstrSomFromReport::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->som = som; } void RoseInstrTriggerInfix::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->cancel = cancel; inst->queue = queue; inst->event = event; } void RoseInstrTriggerSuffix::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->queue = queue; inst->event = event; } void RoseInstrDedupe::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->quash_som = quash_som; inst->dkey = dkey; inst->offset_adjust = offset_adjust; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrDedupeSom::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->quash_som = quash_som; inst->dkey = dkey; inst->offset_adjust = offset_adjust; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrReportChain::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->event = event; inst->top_squash_distance = top_squash_distance; } void RoseInstrReportSomInt::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->som = som; } void RoseInstrReportSomAware::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->som = som; } void RoseInstrReport::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->onmatch = onmatch; inst->offset_adjust = offset_adjust; } void RoseInstrReportExhaust::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->onmatch = onmatch; inst->offset_adjust = offset_adjust; inst->ekey = ekey; } void RoseInstrReportSom::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->onmatch = onmatch; inst->offset_adjust = offset_adjust; } void RoseInstrReportSomExhaust::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->onmatch = onmatch; inst->offset_adjust = offset_adjust; inst->ekey = ekey; } void RoseInstrDedupeAndReport::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->quash_som = quash_som; inst->dkey = dkey; inst->onmatch = onmatch; inst->offset_adjust = offset_adjust; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrFinalReport::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->onmatch = onmatch; inst->offset_adjust = offset_adjust; } void RoseInstrCheckExhausted::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->ekey = ekey; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrCheckMinLength::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->end_adj = end_adj; inst->min_length = min_length; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrSetState::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->index = index; } void RoseInstrSetGroups::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->groups = groups; } void RoseInstrSquashGroups::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->groups = groups; } void RoseInstrCheckState::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->index = index; inst->fail_jump = calc_jump(offset_map, this, target); } void RoseInstrSparseIterBegin::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->fail_jump = calc_jump(offset_map, this, target); // Resolve and write the multibit sparse iterator and the jump table. vector keys; vector jump_offsets; for (const auto &jump : jump_table) { keys.push_back(jump.first); assert(contains(offset_map, jump.second)); jump_offsets.push_back(offset_map.at(jump.second)); } vector iter; mmbBuildSparseIterator(iter, keys, num_keys); assert(!iter.empty()); inst->iter_offset = blob.add_iterator(iter); inst->jump_table = blob.add(jump_offsets.begin(), jump_offsets.end()); // Store offsets for corresponding SPARSE_ITER_NEXT operations. is_written = true; iter_offset = inst->iter_offset; jump_table_offset = inst->jump_table; } void RoseInstrSparseIterNext::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->state = state; inst->fail_jump = calc_jump(offset_map, this, target); // Use the same sparse iterator and jump table as the SPARSE_ITER_BEGIN // instruction. assert(begin); assert(contains(offset_map, begin)); assert(begin->is_written); inst->iter_offset = begin->iter_offset; inst->jump_table = begin->jump_table_offset; } void RoseInstrSparseIterAny::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->fail_jump = calc_jump(offset_map, this, target); // Write the multibit sparse iterator. vector iter; mmbBuildSparseIterator(iter, keys, num_keys); assert(!iter.empty()); inst->iter_offset = blob.add_iterator(iter); } void RoseInstrEnginesEod::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); inst->iter_offset = iter_offset; } void RoseInstrCheckLongLit::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); assert(!literal.empty()); inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1); inst->lit_length = verify_u32(literal.size()); } void RoseInstrCheckLongLitNocase::write(void *dest, RoseEngineBlob &blob, const OffsetMap &offset_map) const { RoseInstrBase::write(dest, blob, offset_map); auto *inst = static_cast(dest); assert(!literal.empty()); inst->lit_offset = blob.add(literal.c_str(), literal.size(), 1); inst->lit_length = verify_u32(literal.size()); } static OffsetMap makeOffsetMap(const RoseProgram &program, u32 *total_len) { OffsetMap offset_map; u32 offset = 0; for (const auto &ri : program) { offset = ROUNDUP_N(offset, ROSE_INSTR_MIN_ALIGN); DEBUG_PRINTF("instr %p (opcode %d) -> offset %u\n", ri.get(), ri->code(), offset); assert(!contains(offset_map, ri.get())); offset_map.emplace(ri.get(), offset); offset += ri->byte_length(); } *total_len = offset; return offset_map; } aligned_unique_ptr writeProgram(RoseEngineBlob &blob, const RoseProgram &program, u32 *total_len) { const auto offset_map = makeOffsetMap(program, total_len); DEBUG_PRINTF("%zu instructions, len %u\n", program.size(), *total_len); auto bytecode = aligned_zmalloc_unique(*total_len); char *ptr = bytecode.get(); for (const auto &ri : program) { assert(contains(offset_map, ri.get())); const u32 offset = offset_map.at(ri.get()); ri->write(ptr + offset, blob, offset_map); } return bytecode; } bool RoseProgramEquivalence::operator()(const RoseProgram &prog1, const RoseProgram &prog2) const { if (prog1.size() != prog2.size()) { return false; } u32 len_1 = 0, len_2 = 0; const auto offset_map_1 = makeOffsetMap(prog1, &len_1); const auto offset_map_2 = makeOffsetMap(prog2, &len_2); if (len_1 != len_2) { return false; } auto is_equiv = [&](const unique_ptr &a, const unique_ptr &b) { assert(a && b); return a->equiv(*b, offset_map_1, offset_map_2); }; return std::equal(prog1.begin(), prog1.end(), prog2.begin(), is_equiv); } } // namespace ue2 hyperscan-4.4.1/src/rose/rose_build_width.h0000644000175000017500000000552013055426554021537 0ustar sleuthkidsleuthkid/* * 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 ROSE_BUILD_WIDTH_H #define ROSE_BUILD_WIDTH_H #include "rose_build_impl.h" #include "ue2common.h" namespace ue2 { class RoseBuildImpl; /* returns a lower bound on the minimum number of bytes required for match to be * raised up to the user which requires the given literal table to be used * * returns ROSE_BOUND_INF if the table can never produce matches */ u32 findMinWidth(const RoseBuildImpl &tbi, enum rose_literal_table table); /* returns an upper bound on the maximum length of a buffer that can result in * matches. If there are any patterns which are not bianchored (start and end * anchored), then there is no such limit and ROSE_BOUND_INF is returned. */ u32 findMaxBAWidth(const RoseBuildImpl &tbi); /* returns an upper bound on the maximum length of a buffer that can result in * matches and requires that the given table to be used. If there are any * patterns which are not bianchored (start and end anchored), then there is no * such limit and ROSE_BOUND_INF is returned. */ u32 findMaxBAWidth(const RoseBuildImpl &tbi, enum rose_literal_table table); /** * Note: there is no function for determining the min width of the whole rose * as this is more easily done by the NG layer which has access to the full * nfagraphs before they are chopped into little pieces. */ } // namespace ue2 #endif hyperscan-4.4.1/src/rose/init.h0000644000175000017500000000362413055426554017157 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ROSE_INIT_H #define ROSE_INIT_H #include "rose_internal.h" #include "ue2common.h" #include "util/scatter_runtime.h" /* * Initialisation code common to streaming mode Rose (init.c) and block mode * Rose (block.c) code. */ static really_inline void init_state(const struct RoseEngine *t, char *state) { scatter(state, t, &t->state_init); } #endif // ROSE_INIT_H hyperscan-4.4.1/src/rose/rose_graph.h0000644000175000017500000001713413055426554020346 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief BGL graph structures used internally by the Rose build process. * * BGL graph structures used internally by the build-time portion of Rose. The * graph used for input is in rose_in_graph.h since it's part of the RoseBuild * external API. */ #ifndef ROSE_GRAPH_H #define ROSE_GRAPH_H #include "ue2common.h" #include "rose_build.h" #include "rose_internal.h" #include "nfa/nfa_internal.h" // for MO_INVALID_IDX #include "util/charreach.h" #include "util/depth.h" #include "util/ue2_containers.h" #include "util/ue2_graph.h" #include #include namespace ue2 { struct CastleProto; struct raw_dfa; struct raw_som_dfa; struct TamaProto; /** \brief Table type for a literal. */ enum rose_literal_table { ROSE_ANCHORED, //!< literals anchored to start ROSE_FLOATING, //!< general floating literals ROSE_EOD_ANCHORED, //!< literals that match near EOD ROSE_ANCHORED_SMALL_BLOCK, //!< anchored literals for small block table ROSE_EVENT //!< "literal-like" events, such as EOD }; /** \brief Edge history types. */ enum RoseRoleHistory { ROSE_ROLE_HISTORY_NONE, //!< no special history ROSE_ROLE_HISTORY_ANCH, //!< previous role is at a fixed offset ROSE_ROLE_HISTORY_LAST_BYTE, //!< previous role can only match at EOD ROSE_ROLE_HISTORY_INVALID //!< history not yet assigned }; #include "util/order_check.h" /** \brief Provides information about the (pre|in)fix engine to the left of a * role. */ struct LeftEngInfo { std::shared_ptr graph; std::shared_ptr castle; std::shared_ptr dfa; std::shared_ptr haig; std::shared_ptr tamarama; u32 lag = 0U; ReportID leftfix_report = MO_INVALID_IDX; depth dfa_min_width = 0; depth dfa_max_width = depth::infinity(); bool operator==(const LeftEngInfo &other) const { return other.graph == graph && other.castle == castle && other.dfa == dfa && other.haig == haig && other.tamarama == tamarama && other.lag == lag && other.leftfix_report == leftfix_report; } bool operator!=(const LeftEngInfo &other) const { return !(*this == other); } bool operator<(const LeftEngInfo &b) const { const LeftEngInfo &a = *this; ORDER_CHECK(graph); ORDER_CHECK(castle); ORDER_CHECK(dfa); ORDER_CHECK(haig); ORDER_CHECK(tamarama); ORDER_CHECK(lag); ORDER_CHECK(leftfix_report); return false; } void reset(void); operator bool() const; bool tracksSom() const { return !!haig; } }; /** \brief Provides information about the suffix engine to the right of a * role. */ struct RoseSuffixInfo { u32 top = 0; std::shared_ptr graph; /* if triggers a trailing nfa */ std::shared_ptr castle; std::shared_ptr haig; std::shared_ptr rdfa; std::shared_ptr tamarama; depth dfa_min_width = 0; depth dfa_max_width = depth::infinity(); bool operator==(const RoseSuffixInfo &b) const; bool operator!=(const RoseSuffixInfo &b) const { return !(*this == b); } bool operator<(const RoseSuffixInfo &b) const; void reset(void); operator bool() const { return graph || castle || haig || rdfa || tamarama; } }; /** \brief Properties attached to each Rose graph vertex. */ struct RoseVertexProps { /** \brief Unique dense vertex index. Used for BGL algorithms. */ size_t index = ~size_t{0}; /** \brief IDs of literals in the Rose literal map. */ flat_set literals; /** * \brief If true, this vertex is a virtual vertex for firing reports at * EOD. These vertices must have reports and have no associated literals. */ bool eod_accept = false; /** \brief Report IDs to fire. */ flat_set reports; /** \brief Bitmask of groups that this role sets. */ rose_group groups = 0; /** \brief Minimum role (end of literal) offset depth in bytes. */ u32 min_offset = ~u32{0}; /** \brief Maximum role (end of literal) offset depth in bytes */ u32 max_offset = 0; /** \brief SOM for the role is offset from end match offset */ u32 som_adjust = 0; /** \brief Prefix/infix engine to the left of this role. */ LeftEngInfo left; /** * \brief Suffix engine to the right of this role. * * Note: information about triggered infixes is associated with the left of * the destination role. */ RoseSuffixInfo suffix; bool isBoring(void) const; bool fixedOffset(void) const; }; /** \brief Properties attached to each Rose graph edge. */ /* bounds are distance from end of prev to start of the next */ struct RoseEdgeProps { /** \brief Unique dense vertex index. Used for BGL algorithms. */ size_t index = ~size_t{0}; /** * \brief Minimum distance from the end of the source role's match to the * start of the target role's match. * * Not used when the target has a left engine (as the engine represents * bounds). */ u32 minBound = 0; /** * \brief Maximum distance from the end of the source role's match to the * start of the target role's match. * * Not used when the target has a left engine (as the engine represents * bounds). */ u32 maxBound = 0; /** \brief Which top to trigger on the target role's left engine. */ u32 rose_top = 0; /** \brief True if the rose_top can clear all other previous tops. */ u8 rose_cancel_prev_top = false; /** \brief History required by this edge. */ RoseRoleHistory history = ROSE_ROLE_HISTORY_INVALID; }; bool operator<(const RoseEdgeProps &a, const RoseEdgeProps &b); /** * \brief Core Rose graph structure. */ struct RoseGraph : public ue2_graph { friend class RoseBuildImpl; /* to allow index renumbering */ }; using RoseVertex = RoseGraph::vertex_descriptor; using RoseEdge = RoseGraph::edge_descriptor; } // namespace ue2 #endif // ROSE_GRAPH_H hyperscan-4.4.1/src/rose/rose_build_groups.h0000644000175000017500000000410313055426554021733 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** * \file * \brief Rose build: code for analysing literal groups. */ #ifndef ROSE_BUILD_GROUPS_H #define ROSE_BUILD_GROUPS_H #include "rose_build_impl.h" #include "util/ue2_containers.h" namespace ue2 { unordered_map getVertexGroupMap(const RoseBuildImpl &build); rose_group getSquashableGroups(const RoseBuildImpl &build); void assignGroupsToLiterals(RoseBuildImpl &build); void assignGroupsToRoles(RoseBuildImpl &build); void findGroupSquashers(RoseBuildImpl &build); } // namespace ue2 #endif // ROSE_BUILD_GROUPS_H hyperscan-4.4.1/src/ue2common.h0000644000175000017500000001556513055426554017157 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Core UE2 global types, defines, utilities. * * NOTE WELL: this file is included into both C and C++ source code, so * be sure to remain compatible with both. */ #ifndef UE2COMMON_H #define UE2COMMON_H #include "config.h" /* standard types used across ue2 */ // We use the size_t type all over the place, usually defined in stddef.h. #include // stdint.h for things like uintptr_t and friends #include /* ick */ #if defined(_WIN32) #define ALIGN_ATTR(x) __declspec(align(x)) #else #define ALIGN_ATTR(x) __attribute__((aligned((x)))) #endif #define ALIGN_DIRECTIVE ALIGN_ATTR(16) #define ALIGN_AVX_DIRECTIVE ALIGN_ATTR(32) #define ALIGN_CL_DIRECTIVE ALIGN_ATTR(64) typedef signed char s8; typedef unsigned char u8; typedef signed short s16; typedef unsigned short u16; typedef unsigned int u32; typedef signed int s32; /* We append the 'a' for aligned, since these aren't common, garden variety * 64 bit values. The alignment is necessary for structs on some platforms, * so we don't end up performing accidental unaligned accesses. */ typedef unsigned long long ALIGN_ATTR(8) u64a; typedef signed long long ALIGN_ATTR(8) s64a; /* get the SIMD types */ #include "util/simd_types.h" /** \brief Report identifier, used for internal IDs and external IDs (those * reported on match). */ typedef u32 ReportID; /* Shorthand for attribute to mark a function as part of our public API. * Functions without this attribute will be hidden. */ #if !defined(_WIN32) #define HS_PUBLIC_API __attribute__((visibility("default"))) #else // TODO: dllexport defines for windows #define HS_PUBLIC_API #endif #define ARRAY_LENGTH(a) (sizeof(a)/sizeof((a)[0])) /** \brief Shorthand for the attribute to shut gcc about unused parameters */ #if !defined(_WIN32) #define UNUSED __attribute__ ((unused)) #else #define UNUSED #endif /* really_inline forces inlining always */ #if !defined(_WIN32) #if defined(HS_OPTIMIZE) #define really_inline inline __attribute__ ((always_inline, unused)) #else #define really_inline __attribute__ ((unused)) #endif /** no, seriously, inline it, even if building in debug mode */ #define really_really_inline inline __attribute__ ((always_inline, unused)) #define never_inline __attribute__ ((noinline)) #define alignof __alignof #define HAVE_TYPEOF 1 #else // ms windows #define really_inline __forceinline #define really_really_inline __forceinline #define never_inline #define __builtin_prefetch(...) do {} while(0) #if defined(__cplusplus) #define __typeof__ decltype #define HAVE_TYPEOF 1 #else // C /* msvc doesn't have decltype or typeof in C */ #define inline __inline #define alignof __alignof #endif #endif // We use C99-style "restrict". #ifdef _WIN32 #ifdef __cplusplus #define restrict #else #define restrict __restrict #endif #else #define restrict __restrict #endif // Align to 16-byte boundary #define ROUNDUP_16(a) (((a) + 0xf) & ~0xf) #define ROUNDDOWN_16(a) ((a) & ~0xf) // Align to N-byte boundary #define ROUNDUP_N(a, n) (((a) + ((n)-1)) & ~((n)-1)) #define ROUNDDOWN_N(a, n) ((a) & ~((n)-1)) // Align to a cacheline - assumed to be 64 bytes #define ROUNDUP_CL(a) ROUNDUP_N(a, 64) // Align ptr to next N-byte boundary #if defined(HAVE_TYPEOF) #define ROUNDUP_PTR(ptr, n) (__typeof__(ptr))(ROUNDUP_N((uintptr_t)(ptr), (n))) #define ROUNDDOWN_PTR(ptr, n) (__typeof__(ptr))(ROUNDDOWN_N((uintptr_t)(ptr), (n))) #else #define ROUNDUP_PTR(ptr, n) (void*)(ROUNDUP_N((uintptr_t)(ptr), (n))) #define ROUNDDOWN_PTR(ptr, n) (void*)(ROUNDDOWN_N((uintptr_t)(ptr), (n))) #endif #define ISALIGNED_N(ptr, n) (((uintptr_t)(ptr) & ((n) - 1)) == 0) #define ISALIGNED_16(ptr) ISALIGNED_N((ptr), 16) #define ISALIGNED_CL(ptr) ISALIGNED_N((ptr), 64) #if defined(HAVE_TYPEOF) #define ISALIGNED(ptr) ISALIGNED_N((ptr), alignof(__typeof__(*(ptr)))) #else /* we should probably avoid using this test in C */ #define ISALIGNED(ptr) (1) #endif #define N_CHARS 256 // Maximum offset representable in the 'unsigned long long' we use to return // offset values. #define MAX_OFFSET 0xffffffffffffffffULL #if !defined(MIN) #define MIN(a,b) ((a) < (b) ? (a) : (b)) #endif #if !defined(MAX) #define MAX(a,b) ((a) > (b) ? (a) : (b)) #endif #define LIMIT_TO_AT_MOST(a, b) (*(a) = MIN(*(a),(b))) #define ENSURE_AT_LEAST(a, b) (*(a) = MAX(*(a),(b))) #ifndef _WIN32 #ifndef likely #define likely(x) __builtin_expect(!!(x), 1) #endif #ifndef unlikely #define unlikely(x) __builtin_expect(!!(x), 0) #endif #else #define likely(x) (x) #define unlikely(x) (x) #endif #if !defined(RELEASE_BUILD) || defined(DEBUG) #ifdef _WIN32 #define PATH_SEP '\\' #else #define PATH_SEP '/' #endif #endif #if defined(DEBUG) && !defined(DEBUG_PRINTF) #include #include #define DEBUG_PRINTF(format, ...) printf("%s:%s:%d:" format, \ strrchr(__FILE__, PATH_SEP) + 1, \ __func__, __LINE__, ## __VA_ARGS__) #elif !defined(DEBUG_PRINTF) #define DEBUG_PRINTF(format, ...) do { } while(0) #endif #if !defined(RELEASE_BUILD) #include #include #define ADEBUG_PRINTF(format, ...) printf("!%s:%s:%d:" format, \ strrchr(__FILE__, PATH_SEP) + 1, \ __func__, __LINE__, ## __VA_ARGS__) #else #define ADEBUG_PRINTF(format, ...) do { } while(0) #endif #include #endif hyperscan-4.4.1/src/hs_valid_platform.c0000644000175000017500000000344113055426554020731 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "hs_common.h" #include "util/cpuid_flags.h" HS_PUBLIC_API hs_error_t hs_valid_platform(void) { /* Hyperscan requires SSSE3, anything else is a bonus */ if (check_ssse3()) { return HS_SUCCESS; } else { return HS_ARCH_ERROR; } } hyperscan-4.4.1/src/crc32.h0000644000175000017500000000343213055426554016155 0ustar sleuthkidsleuthkid/* * 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 CRC32_H_36A5015B5840C1 #define CRC32_H_36A5015B5840C1 #include "ue2common.h" #ifdef __cplusplus extern "C" { #endif u32 Crc32c_ComputeBuf(u32 inCrc32, const void *buf, size_t bufLen); #ifdef __cplusplus } #endif #endif /* CRC32_H_36A5015B5840C1 */ hyperscan-4.4.1/src/som/0000755000175000017500000000000013055426554015664 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/som/som_stream.c0000644000175000017500000001430513055426554020204 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief SOM streaming runtime code. * * Code in this file handles storing and loading SOM slot information from * stream state. */ #include "scratch.h" #include "som_stream.h" #include "rose/rose_internal.h" #include "util/multibit.h" // Sentinel values stored in stream state and used to represent an SOM distance // that is too far in the past to be stored in the available space in stream // state. #define SOM_SENTINEL_LARGE (~0ull) #define SOM_SENTINEL_MEDIUM (~0u) #define SOM_SENTINEL_SMALL ((u16)~0u) static really_inline void storeSomValue(void *stream_som_store, u64a som_value, u64a stream_offset, u8 som_size) { // Special case for sentinel value. if (som_value == SOM_SENTINEL_LARGE) { switch (som_size) { case 2: *(u16 *)stream_som_store = SOM_SENTINEL_SMALL; break; case 4: *(u32 *)stream_som_store = SOM_SENTINEL_MEDIUM; break; case 8: *(u64a *)stream_som_store = SOM_SENTINEL_LARGE; break; default: break; } return; } assert(som_value <= stream_offset); u64a rel_offset = stream_offset - som_value; DEBUG_PRINTF("rel_offset=%llu\n", rel_offset); switch (som_size) { case 2: rel_offset = MIN(rel_offset, SOM_SENTINEL_SMALL); assert(ISALIGNED_N(stream_som_store, alignof(u16))); *(u16 *)stream_som_store = rel_offset; break; case 4: rel_offset = MIN(rel_offset, SOM_SENTINEL_MEDIUM); assert(ISALIGNED_N(stream_som_store, alignof(u32))); *(u32 *)stream_som_store = rel_offset; break; case 8: assert(ISALIGNED_N(stream_som_store, alignof(u64a))); *(u64a *)stream_som_store = rel_offset; break; default: assert(0); break; } } void storeSomToStream(struct hs_scratch *scratch, const u64a offset) { assert(scratch); DEBUG_PRINTF("stream offset %llu\n", offset); struct core_info *ci = &scratch->core_info; const struct RoseEngine *rose = ci->rose; const u32 som_store_count = rose->somLocationCount; assert(som_store_count); // Caller should ensure that we have work to do. u8 *som_store_valid = (u8 *)ci->state + rose->stateOffsets.somValid; char *stream_som_store = ci->state + rose->stateOffsets.somLocation; const u64a *som_store = scratch->som_store; const u8 som_size = rose->somHorizon; for (u32 i = mmbit_iterate(som_store_valid, som_store_count, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(som_store_valid, som_store_count, i)) { DEBUG_PRINTF("storing %llu in %u\n", som_store[i], i); storeSomValue(stream_som_store + (i * som_size), som_store[i], offset, som_size); } } static really_inline u64a loadSomValue(const void *stream_som_store, u64a stream_offset, u8 som_size) { u64a rel_offset; switch (som_size) { case 2: assert(ISALIGNED_N(stream_som_store, alignof(u16))); rel_offset = *(const u16 *)stream_som_store; if (rel_offset == SOM_SENTINEL_SMALL) { return SOM_SENTINEL_LARGE; } break; case 4: assert(ISALIGNED_N(stream_som_store, alignof(u32))); rel_offset = *(const u32 *)stream_som_store; if (rel_offset == SOM_SENTINEL_MEDIUM) { return SOM_SENTINEL_LARGE; } break; case 8: assert(ISALIGNED_N(stream_som_store, alignof(u64a))); rel_offset = *(const u64a *)stream_som_store; break; default: assert(0); rel_offset = 0; break; } DEBUG_PRINTF("rel_offset=%llu\n", rel_offset); return stream_offset - rel_offset; } void loadSomFromStream(struct hs_scratch *scratch, const u64a offset) { assert(scratch); DEBUG_PRINTF("stream offset %llu\n", offset); struct core_info *ci = &scratch->core_info; const struct RoseEngine *rose = ci->rose; const u32 som_store_count = rose->somLocationCount; assert(som_store_count); // Caller should ensure that we have work to do. const u8 *som_store_valid = (u8 *)ci->state + rose->stateOffsets.somValid; const char *stream_som_store = ci->state + rose->stateOffsets.somLocation; u64a *som_store = scratch->som_store; const u8 som_size = rose->somHorizon; for (u32 i = mmbit_iterate(som_store_valid, som_store_count, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(som_store_valid, som_store_count, i)) { som_store[i] = loadSomValue(stream_som_store + (i*som_size), offset, som_size); DEBUG_PRINTF("loaded %llu from %u\n", som_store[i], i); } } hyperscan-4.4.1/src/som/slot_manager_internal.h0000644000175000017500000000760213055426554022411 0ustar sleuthkidsleuthkid/* * 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 SLOT_MANAGER_INTERNAL_H #define SLOT_MANAGER_INTERNAL_H #include "nfagraph/ng.h" #include "nfagraph/ng_is_equal.h" #include "util/charreach.h" #include "util/ue2_containers.h" #include "ue2common.h" #include #include namespace ue2 { struct InitialResetEntry { InitialResetEntry(std::shared_ptr sent_in, std::shared_ptr body_in, const ue2::unordered_map &body_regions_in, u32 sent_region_in, u32 first_bad_region_in) : sent(sent_in), body(body_in), body_regions(body_regions_in), sent_region(sent_region_in), first_bad_region(first_bad_region_in) {} std::shared_ptr sent; std::shared_ptr body; ue2::unordered_map body_regions; u32 sent_region; u32 first_bad_region; /* ~0U if it must cover the whole g */ }; struct InitialResetInfo { explicit InitialResetInfo(u32 slot_in) : slot(slot_in) {} std::vector entries; u32 slot; }; struct SlotCacheEntry { // We store our own copy of the prefix so we control its lifetime. A // pointer is used so that this entry can be placed in STL containers, as // NGHolder is not copy-constructible. SlotCacheEntry(const NGHolder &prefix_in, const CharReach &escapes_in, u32 parent_in, bool is_reset_in, u32 slot_in); std::unique_ptr prefix; CharReach escapes; u32 parent_slot; bool is_reset; u32 slot; }; struct SlotEntryHasher { size_t operator()(const SlotCacheEntry &e) const; }; struct SlotEntryEqual { bool operator()(const SlotCacheEntry &a, const SlotCacheEntry &b) const; }; struct SlotCache { typedef ue2::unordered_set CacheStore; void insert(const NGHolder &prefix, const CharReach &escapes, u32 parent_slot, bool is_reset, u32 slot); const SlotCacheEntry *find(const NGHolder &prefix, const CharReach &escapes, u32 parent_slot, bool is_reset); CacheStore store; ue2::unordered_set, NGHolderHasher, NGHolderEqual> initial_prefixes; std::vector initial_resets; }; } // namespace ue2 #endif hyperscan-4.4.1/src/som/som.h0000644000175000017500000000344713055426554016643 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Common SOM definitions. */ #ifndef UE2_SOM_H #define UE2_SOM_H /** \brief Enumeration specifying a start of match behaviour. */ enum som_type { SOM_NONE, //!< No SOM required SOM_LEFT //!< Exact leftmost SOM }; #endif // UE2_SOM_H hyperscan-4.4.1/src/som/som_runtime.c0000644000175000017500000005222413055426554020376 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief SOM runtime code. * * * Runtime code for SOM handling called by the Rose callback adaptors. * * Note: * Races between escapes making a som loc writeable and attempts to write to it * at the same to_offset are always resolved as if the escape arrived first * and then the request to write to that location. */ #include "hs_internal.h" #include "som_operation.h" #include "som_runtime.h" #include "scratch.h" #include "ue2common.h" #include "rose/rose_internal.h" #include "nfa/nfa_api.h" #include "nfa/nfa_internal.h" #include "util/fatbit.h" #include "util/multibit.h" static really_inline void setSomLoc(struct fatbit *som_set_now, u64a *som_store, u32 som_store_count, const struct som_operation *ri, u64a to_offset) { /* validity handled by callers */ assert(to_offset >= ri->aux.somDistance); u64a start_offset = to_offset - ri->aux.somDistance; u32 som_loc = ri->onmatch; /* resolve any races for matches at this point in favour of the earliest som */ if (!fatbit_set(som_set_now, som_store_count, som_loc)) { som_store[som_loc] = start_offset; } else { LIMIT_TO_AT_MOST(&som_store[som_loc], start_offset); } DEBUG_PRINTF("som_store[%u] set to %llu\n", som_loc, som_store[som_loc]); } static really_inline char ok_and_mark_if_write(u8 *som_store_valid, struct fatbit *som_set_now, u8 *som_store_writable, u32 som_store_count, u32 loc) { return !mmbit_set(som_store_valid, som_store_count, loc) /* unwritten */ || fatbit_isset(som_set_now, som_store_count, loc) /* write here, need * to resolve race */ || mmbit_isset(som_store_writable, som_store_count, loc); /* writable */ } static really_inline char ok_and_mark_if_unset(u8 *som_store_valid, struct fatbit *som_set_now, u32 som_store_count, u32 loc) { return !mmbit_set(som_store_valid, som_store_count, loc) /* unwritten */ || fatbit_isset(som_set_now, som_store_count, loc); /* write here, need * to resolve race */ } static int somRevCallback(UNUSED u64a start, u64a end, ReportID id, void *ctx) { DEBUG_PRINTF("offset=%llu, id=%u\n", end, id); // We use the id to store the offset adjustment (for assertions like a // leading \b or multiline mode). assert(id <= 1); u64a *from_offset = ctx; LIMIT_TO_AT_MOST(from_offset, end + id); return 1; // continue matching. } static really_inline const struct NFA *getSomRevNFA(const struct RoseEngine *t, u32 i) { assert(t->somRevOffsetOffset); const u32 *rev_offsets = (const u32 *)((const u8 *)t + t->somRevOffsetOffset); u32 nfa_offset = rev_offsets[i]; assert(nfa_offset && nfa_offset < t->size); const struct NFA *n = (const struct NFA *)(((const u8 *)t + nfa_offset)); assert(ISALIGNED(n)); return n; } static void runRevNfa(struct hs_scratch *scratch, const struct som_operation *ri, const u64a to_offset, u64a *from_offset) { struct core_info *ci = &scratch->core_info; DEBUG_PRINTF("buf has %zu bytes total, history has %zu\n", ci->len, ci->hlen); u32 nfa_idx = ri->aux.revNfaIndex; DEBUG_PRINTF("run rev nfa %u from to_offset=%llu\n", nfa_idx, to_offset); const struct NFA *nfa = getSomRevNFA(ci->rose, nfa_idx); assert(nfa->maxWidth); // No inf width rev NFAs. size_t buf_bytes = to_offset - ci->buf_offset; size_t history_bytes = ci->hlen; DEBUG_PRINTF("nfa min/max widths [%u,%u], %zu in buffer, %zu in history\n", nfa->minWidth, nfa->maxWidth, buf_bytes, history_bytes); assert(nfa->minWidth <= buf_bytes + history_bytes); const u8 *buf = ci->buf; const u8 *hbuf = ci->hbuf; // Work out if we need to scan any history as well. if (history_bytes && buf_bytes < nfa->maxWidth) { assert(hbuf); size_t remainder = nfa->maxWidth - buf_bytes; if (remainder < history_bytes) { hbuf += history_bytes - remainder; history_bytes = remainder; } } DEBUG_PRINTF("scanning %zu from buffer and %zu from history\n", buf_bytes, history_bytes); *from_offset = to_offset; nfaBlockExecReverse(nfa, to_offset, buf, buf_bytes, hbuf, history_bytes, somRevCallback, from_offset); assert(*from_offset <= to_offset); } static really_inline void setSomLocRevNfa(struct hs_scratch *scratch, struct fatbit *som_set_now, u64a *som_store, u32 som_store_count, const struct som_operation *ri, u64a to_offset) { /* validity handled by callers */ u64a from_offset = 0; runRevNfa(scratch, ri, to_offset, &from_offset); u32 som_loc = ri->onmatch; /* resolve any races for matches at this point in favour of the earliest som */ if (!fatbit_set(som_set_now, som_store_count, som_loc)) { som_store[som_loc] = from_offset; } else { LIMIT_TO_AT_MOST(&som_store[som_loc], from_offset); } DEBUG_PRINTF("som_store[%u] set to %llu\n", som_loc, som_store[som_loc]); } void handleSomInternal(struct hs_scratch *scratch, const struct som_operation *ri, const u64a to_offset) { assert(scratch); assert(ri); DEBUG_PRINTF("-->som action required at %llu\n", to_offset); // SOM handling at scan time operates on data held in scratch. In // streaming mode, this data is read from / written out to stream state at // stream write boundaries. struct core_info *ci = &scratch->core_info; const struct RoseEngine *rose = ci->rose; assert(rose->hasSom); const u32 som_store_count = rose->somLocationCount; u8 *som_store_valid = (u8 *)ci->state + rose->stateOffsets.somValid; u8 *som_store_writable = (u8 *)ci->state + rose->stateOffsets.somWritable; struct fatbit *som_set_now = scratch->som_set_now; struct fatbit *som_attempted_set = scratch->som_attempted_set; u64a *som_store = scratch->som_store; u64a *som_failed_store = scratch->som_attempted_store; if (to_offset != scratch->som_set_now_offset) { assert(scratch->som_set_now_offset == ~0ULL || to_offset > scratch->som_set_now_offset); DEBUG_PRINTF("setting som_set_now_offset=%llu\n", to_offset); fatbit_clear(som_set_now); fatbit_clear(som_attempted_set); scratch->som_set_now_offset = to_offset; } switch (ri->type) { case SOM_INTERNAL_LOC_SET: DEBUG_PRINTF("SOM_INTERNAL_LOC_SET\n"); mmbit_set(som_store_valid, som_store_count, ri->onmatch); setSomLoc(som_set_now, som_store, som_store_count, ri, to_offset); return; case SOM_INTERNAL_LOC_SET_IF_UNSET: DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_IF_UNSET\n"); if (ok_and_mark_if_unset(som_store_valid, som_set_now, som_store_count, ri->onmatch)) { setSomLoc(som_set_now, som_store, som_store_count, ri, to_offset); } return; case SOM_INTERNAL_LOC_SET_IF_WRITABLE: { u32 slot = ri->onmatch; DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_IF_WRITABLE\n"); if (ok_and_mark_if_write(som_store_valid, som_set_now, som_store_writable, som_store_count, slot)) { setSomLoc(som_set_now, som_store, som_store_count, ri, to_offset); mmbit_unset(som_store_writable, som_store_count, slot); } else { /* not writable, stash as an attempted write in case we are * racing our escape. */ DEBUG_PRINTF("not writable, stashing attempt\n"); assert(to_offset >= ri->aux.somDistance); u64a start_offset = to_offset - ri->aux.somDistance; if (!fatbit_set(som_attempted_set, som_store_count, slot)) { som_failed_store[slot] = start_offset; } else { LIMIT_TO_AT_MOST(&som_failed_store[slot], start_offset); } DEBUG_PRINTF("som_failed_store[%u] = %llu\n", slot, som_failed_store[slot]); } return; } case SOM_INTERNAL_LOC_SET_REV_NFA: DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_REV_NFA\n"); mmbit_set(som_store_valid, som_store_count, ri->onmatch); setSomLocRevNfa(scratch, som_set_now, som_store, som_store_count, ri, to_offset); return; case SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET: DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET\n"); if (ok_and_mark_if_unset(som_store_valid, som_set_now, som_store_count, ri->onmatch)) { setSomLocRevNfa(scratch, som_set_now, som_store, som_store_count, ri, to_offset); } return; case SOM_INTERNAL_LOC_SET_REV_NFA_IF_WRITABLE: { u32 slot = ri->onmatch; DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_IF_WRITABLE\n"); if (ok_and_mark_if_write(som_store_valid, som_set_now, som_store_writable, som_store_count, slot)) { setSomLocRevNfa(scratch, som_set_now, som_store, som_store_count, ri, to_offset); mmbit_unset(som_store_writable, som_store_count, slot); } else { /* not writable, stash as an attempted write in case we are * racing our escape. */ DEBUG_PRINTF("not writable, stashing attempt\n"); u64a from_offset = 0; runRevNfa(scratch, ri, to_offset, &from_offset); if (!fatbit_set(som_attempted_set, som_store_count, slot)) { som_failed_store[slot] = from_offset; } else { LIMIT_TO_AT_MOST(&som_failed_store[slot], from_offset); } DEBUG_PRINTF("som_failed_store[%u] = %llu\n", slot, som_failed_store[slot]); } return; } case SOM_INTERNAL_LOC_COPY: { u32 slot_in = ri->aux.somDistance; u32 slot_out = ri->onmatch; DEBUG_PRINTF("SOM_INTERNAL_LOC_COPY S[%u] = S[%u]\n", slot_out, slot_in); assert(mmbit_isset(som_store_valid, som_store_count, slot_in)); mmbit_set(som_store_valid, som_store_count, slot_out); fatbit_set(som_set_now, som_store_count, slot_out); som_store[slot_out] = som_store[slot_in]; return; } case SOM_INTERNAL_LOC_COPY_IF_WRITABLE: { u32 slot_in = ri->aux.somDistance; u32 slot_out = ri->onmatch; DEBUG_PRINTF("SOM_INTERNAL_LOC_COPY_IF_WRITABLE S[%u] = S[%u]\n", slot_out, slot_in); assert(mmbit_isset(som_store_valid, som_store_count, slot_in)); if (ok_and_mark_if_write(som_store_valid, som_set_now, som_store_writable, som_store_count, slot_out)) { DEBUG_PRINTF("copy, set som_store[%u]=%llu\n", slot_out, som_store[slot_in]); som_store[slot_out] = som_store[slot_in]; fatbit_set(som_set_now, som_store_count, slot_out); mmbit_unset(som_store_writable, som_store_count, slot_out); } else { /* not writable, stash as an attempted write in case we are * racing our escape */ DEBUG_PRINTF("not writable, stashing attempt\n"); fatbit_set(som_attempted_set, som_store_count, slot_out); som_failed_store[slot_out] = som_store[slot_in]; DEBUG_PRINTF("som_failed_store[%u] = %llu\n", slot_out, som_failed_store[slot_out]); } return; } case SOM_INTERNAL_LOC_MAKE_WRITABLE: { u32 slot = ri->onmatch; DEBUG_PRINTF("SOM_INTERNAL_LOC_MAKE_WRITABLE\n"); /* if just written to the loc, ignore the racing escape */ if (fatbit_isset(som_set_now, som_store_count, slot)) { DEBUG_PRINTF("just written\n"); return; } if (fatbit_isset(som_attempted_set, som_store_count, slot)) { /* writes were waiting for an escape to arrive */ DEBUG_PRINTF("setting som_store[%u] = %llu from " "som_failed_store[%u]\n", slot, som_failed_store[slot], slot); som_store[slot] = som_failed_store[slot]; fatbit_set(som_set_now, som_store_count, slot); return; } mmbit_set(som_store_writable, som_store_count, slot); return; } default: DEBUG_PRINTF("unknown report type!\n"); break; } // All valid som_operation types should be handled and returned above. assert(0); return; } // Returns the SOM offset. u64a handleSomExternal(struct hs_scratch *scratch, const struct som_operation *ri, const u64a to_offset) { assert(scratch); assert(ri); // SOM handling at scan time operates on data held in scratch. In // streaming mode, this data is read from / written out to stream state at // stream write boundaries. struct core_info *ci = &scratch->core_info; const struct RoseEngine *rose = ci->rose; assert(rose->hasSom); switch (ri->type) { case SOM_EXTERNAL_CALLBACK_REL: DEBUG_PRINTF("SOM_EXTERNAL_CALLBACK_REL: som is %llu chars back\n", ri->aux.somDistance); assert(to_offset >= ri->aux.somDistance); return to_offset - ri->aux.somDistance; case SOM_EXTERNAL_CALLBACK_ABS: DEBUG_PRINTF("SOM_EXTERNAL_CALLBACK_ABS: som is at %llu\n", ri->aux.somDistance); assert(to_offset >= ri->aux.somDistance); return ri->aux.somDistance; case SOM_EXTERNAL_CALLBACK_STORED: { const u64a *som_store = scratch->som_store; u32 slot = ri->aux.somDistance; DEBUG_PRINTF("SOM_EXTERNAL_CALLBACK_STORED: <- som_store[%u]=%llu\n", slot, som_store[slot]); UNUSED const u32 som_store_count = rose->somLocationCount; UNUSED const u8 *som_store_valid = (u8 *)ci->state + rose->stateOffsets.somValid; assert(mmbit_isset(som_store_valid, som_store_count, slot)); return som_store[slot]; } case SOM_EXTERNAL_CALLBACK_REV_NFA: { DEBUG_PRINTF("SOM_EXTERNAL_CALLBACK_REV_NFA\n"); u64a from_offset = 0; runRevNfa(scratch, ri, to_offset, &from_offset); return from_offset; } default: DEBUG_PRINTF("unknown report type!\n"); break; } // All valid som_operation types should be handled and returned above. assert(0); return 0; } void setSomFromSomAware(struct hs_scratch *scratch, const struct som_operation *ri, u64a from_offset, u64a to_offset) { assert(scratch); assert(ri); assert(to_offset); assert(ri->type == SOM_INTERNAL_LOC_SET_FROM || ri->type == SOM_INTERNAL_LOC_SET_FROM_IF_WRITABLE); struct core_info *ci = &scratch->core_info; const struct RoseEngine *rose = ci->rose; assert(rose->hasSom); const u32 som_store_count = rose->somLocationCount; u8 *som_store_valid = (u8 *)ci->state + rose->stateOffsets.somValid; u8 *som_store_writable = (u8 *)ci->state + rose->stateOffsets.somWritable; struct fatbit *som_set_now = scratch->som_set_now; struct fatbit *som_attempted_set = scratch->som_attempted_set; u64a *som_store = scratch->som_store; u64a *som_failed_store = scratch->som_attempted_store; if (to_offset != scratch->som_set_now_offset) { DEBUG_PRINTF("setting som_set_now_offset=%llu\n", to_offset); fatbit_clear(som_set_now); fatbit_clear(som_attempted_set); scratch->som_set_now_offset = to_offset; } if (ri->type == SOM_INTERNAL_LOC_SET_FROM) { DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_FROM\n"); mmbit_set(som_store_valid, som_store_count, ri->onmatch); setSomLoc(som_set_now, som_store, som_store_count, ri, from_offset); } else { DEBUG_PRINTF("SOM_INTERNAL_LOC_SET_FROM_IF_WRITABLE\n"); if (ok_and_mark_if_write(som_store_valid, som_set_now, som_store_writable, som_store_count, ri->onmatch)) { setSomLoc(som_set_now, som_store, som_store_count, ri, from_offset); mmbit_unset(som_store_writable, som_store_count, ri->onmatch); } else { /* not writable, stash as an attempted write in case we are * racing our escape. */ DEBUG_PRINTF("not writable, stashing attempt\n"); assert(to_offset >= ri->aux.somDistance); u32 som_loc = ri->onmatch; if (!fatbit_set(som_attempted_set, som_store_count, ri->onmatch)) { som_failed_store[som_loc] = from_offset; } else { LIMIT_TO_AT_MOST(&som_failed_store[som_loc], from_offset); } DEBUG_PRINTF("som_failed_store[%u] = %llu\n", som_loc, som_failed_store[som_loc]); } } } static really_inline int clearSomLog(struct hs_scratch *scratch, u64a offset, struct fatbit *log, const u64a *starts) { DEBUG_PRINTF("at %llu\n", offset); struct core_info *ci = &scratch->core_info; const struct RoseEngine *rose = ci->rose; const u32 dkeyCount = rose->dkeyCount; const u32 *dkey_to_report = (const u32 *) ((const char *)rose + rose->invDkeyOffset); u32 flags = 0; #ifndef RELEASE_BUILD if (scratch->deduper.current_report_offset != offset) { flags |= HS_MATCH_FLAG_ADJUSTED; } #endif for (u32 it = fatbit_iterate(log, dkeyCount, MMB_INVALID); it != MMB_INVALID; it = fatbit_iterate(log, dkeyCount, it)) { u64a from_offset = starts[it]; u32 onmatch = dkey_to_report[it]; int halt = ci->userCallback(onmatch, from_offset, offset, flags, ci->userContext); if (halt) { ci->status |= STATUS_TERMINATED; return 1; } } fatbit_clear(log); return 0; } int flushStoredSomMatches_i(struct hs_scratch *scratch, u64a offset) { DEBUG_PRINTF("flush som matches\n"); int halt = 0; assert(!told_to_stop_matching(scratch)); if (scratch->deduper.current_report_offset == ~0ULL) { /* no matches recorded yet; just need to clear the logs */ fatbit_clear(scratch->deduper.som_log[0]); fatbit_clear(scratch->deduper.som_log[1]); scratch->deduper.som_log_dirty = 0; return 0; } /* fire any reports from the logs and clear them */ if (offset == scratch->deduper.current_report_offset + 1) { struct fatbit *done_log = scratch->deduper.som_log[offset % 2]; u64a *done_starts = scratch->deduper.som_start_log[offset % 2]; halt = clearSomLog(scratch, scratch->deduper.current_report_offset - 1, done_log, done_starts); scratch->deduper.som_log_dirty >>= 1; } else { /* need to report both logs */ u64a f_offset = scratch->deduper.current_report_offset - 1; u64a s_offset = scratch->deduper.current_report_offset; struct fatbit *first_log = scratch->deduper.som_log[f_offset % 2]; u64a *first_starts = scratch->deduper.som_start_log[f_offset % 2]; struct fatbit *second_log = scratch->deduper.som_log[s_offset % 2]; u64a *second_starts = scratch->deduper.som_start_log[s_offset % 2]; halt = clearSomLog(scratch, f_offset, first_log, first_starts) || clearSomLog(scratch, s_offset, second_log, second_starts); scratch->deduper.som_log_dirty = 0; } return halt; } hyperscan-4.4.1/src/som/slot_manager_dump.cpp0000644000175000017500000000652013055426554022073 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "slot_manager_dump.h" #include "slot_manager_internal.h" #include "slot_manager.h" #include "grey.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng_is_equal.h" #include "util/container.h" #include "ue2common.h" #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { void dumpSomSlotManager(const SomSlotManager &ssm, const Grey &grey) { if (!grey.dumpFlags) { return; } string filename = grey.dumpPath + "/ssm.txt"; map by_slot; map by_slot_ir; for (const auto &e : ssm.cache->store) { by_slot[e.slot] = &e; } for (const auto &e : ssm.cache->initial_resets) { by_slot_ir[e.slot] = &e; } FILE *f = fopen(filename.c_str(), "w"); fprintf(f, "slot width %u bytes\n\n", ssm.precision); if (by_slot.empty()) { fprintf(f, "\n"); } for (u32 i = 0; i < ssm.numSomSlots(); i++) { fprintf(f, "%u", i); if (contains(by_slot_ir, i)) { const InitialResetInfo &ir = *by_slot_ir[i]; fprintf(f, "\t shared reset (users = %zu)\n", ir.entries.size()); } else if (contains(by_slot, i)) { const SlotCacheEntry &ce = *by_slot.at(i); if (ce.parent_slot != SomSlotManager::NO_PARENT) { fprintf(f, "\tparent:%u", ce.parent_slot); } if (ce.is_reset) { fprintf(f, "\treset"); } fprintf(f, "\n"); } else { fprintf(f, "\t\n"); } } fclose(f); for (const auto &h : ssm.cache->initial_prefixes) { dumpHolder(*h, hash_holder(*h), "ssm_prefix", grey); } } } // namespace ue2 hyperscan-4.4.1/src/som/som_operation.h0000644000175000017500000000641513055426554020721 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** * \file * \brief SOM runtime: data structures. * * Data structures used for SOM operations. */ #ifndef SOM_OPERATION_H #define SOM_OPERATION_H #include "ue2common.h" #define SOM_EXTERNAL_CALLBACK_REL 1 #define SOM_INTERNAL_LOC_SET 2 #define SOM_INTERNAL_LOC_SET_IF_UNSET 3 #define SOM_INTERNAL_LOC_SET_IF_WRITABLE 4 #define SOM_INTERNAL_LOC_SET_REV_NFA 5 #define SOM_INTERNAL_LOC_SET_REV_NFA_IF_UNSET 6 #define SOM_INTERNAL_LOC_SET_REV_NFA_IF_WRITABLE 7 #define SOM_INTERNAL_LOC_COPY 8 #define SOM_INTERNAL_LOC_COPY_IF_WRITABLE 9 #define SOM_INTERNAL_LOC_MAKE_WRITABLE 10 #define SOM_EXTERNAL_CALLBACK_STORED 11 #define SOM_EXTERNAL_CALLBACK_ABS 12 #define SOM_EXTERNAL_CALLBACK_REV_NFA 13 #define SOM_INTERNAL_LOC_SET_FROM 14 #define SOM_INTERNAL_LOC_SET_FROM_IF_WRITABLE 15 struct som_operation { /** \brief Report type, from the definitions above. */ u8 type; /* \brief SOM loc to modify. */ u32 onmatch; union { /** \brief SOM distance value, use varies according to type. * * - for SOM_EXTERNAL_CALLBACK_REL, from-offset is this many bytes * before the to-offset. * - for SOM_EXTERNAL_CALLBACK_ABS, set from-offset to this value. * - for SOM_INTERNAL_LOC_COPY*, som location read_from. */ u64a somDistance; /** \brief Index of the reverse nfa. * * Used by SOM_EXTERNAL_CALLBACK_REV_NFA and * SOM_INTERNAL_LOC_SET_REV_NFA*. */ u64a revNfaIndex; } aux; }; #endif // SOM_OPERATION_H hyperscan-4.4.1/src/som/slot_manager.cpp0000644000175000017500000002205713055426554021051 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief SOM Slot Manager. */ #include "slot_manager.h" #include "slot_manager_internal.h" #include "ue2common.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_is_equal.h" #include "nfagraph/ng_som_util.h" #include "nfagraph/ng_region.h" #include "util/charreach.h" #include "util/make_unique.h" #include "util/dump_charclass.h" #include "util/verify_types.h" #include #include #include #include using namespace std; namespace ue2 { /** \brief Define this to disable the cache and have everyone get their own * SOM slot. */ //#define NO_SLOT_CACHING SlotCacheEntry::SlotCacheEntry(const NGHolder &prefix_in, const CharReach &escapes_in, u32 parent_in, bool is_reset_in, u32 slot_in) : prefix(cloneHolder(prefix_in)), escapes(escapes_in), parent_slot(parent_in), is_reset(is_reset_in), slot(slot_in) {} size_t SlotEntryHasher::operator()(const SlotCacheEntry &e) const { assert(e.prefix); using boost::hash_combine; size_t v = 0; hash_combine(v, hash_holder(*e.prefix)); hash_combine(v, e.parent_slot); hash_combine(v, e.is_reset); hash_combine(v, e.escapes.hash()); DEBUG_PRINTF("%zu vertices, parent_slot=%u, escapes=%s, is_reset=%d " "hashes to %zx\n", num_vertices(*e.prefix), e.parent_slot, describeClass(e.escapes, 10, CC_OUT_TEXT).c_str(), (int)e.is_reset, v); return v; } bool SlotEntryEqual::operator()(const SlotCacheEntry &a, const SlotCacheEntry &b) const { assert(a.prefix); assert(b.prefix); return a.parent_slot == b.parent_slot && a.is_reset == b.is_reset && a.escapes == b.escapes && is_equal(*a.prefix, *b.prefix); // NOTE: slot not compared. } void SlotCache::insert(const NGHolder &prefix, const CharReach &escapes, u32 parent_slot, bool is_reset, u32 slot) { store.emplace(prefix, escapes, parent_slot, is_reset, slot); } const SlotCacheEntry *SlotCache::find(const NGHolder &prefix, const CharReach &escapes, u32 parent_slot, bool is_reset) { SlotCacheEntry entry(prefix, escapes, parent_slot, is_reset, 0 /* unused for searching with SlotEntryEqual */); CacheStore::const_iterator it = store.find(entry); if (it != store.end()) { return &(*it); } return nullptr; } SomSlotManager::SomSlotManager(u8 p) : nextSomSlot(0), cache(ue2::make_unique()), historyRequired(0), precision(p) {} SomSlotManager::~SomSlotManager() { } u32 SomSlotManager::getSomSlot(const NGHolder &prefix, const CharReach &escapes, bool is_reset, u32 parent_slot) { assert(parent_slot == NO_PARENT || parent_slot < nextSomSlot); DEBUG_PRINTF("prefix with %zu vertices, parent_slot=%u\n", num_vertices(prefix), parent_slot); DEBUG_PRINTF("nextSomSlot=%u\n", nextSomSlot); #ifdef NO_SLOT_CACHING return nextSomSlot++; #endif const SlotCacheEntry *entry = cache->find(prefix, escapes, parent_slot, is_reset); if (entry) { DEBUG_PRINTF("cache hit: slot %u\n", entry->slot); return entry->slot; } DEBUG_PRINTF("cache miss: handing out new slot %u\n", nextSomSlot); cache->insert(prefix, escapes, parent_slot, is_reset, nextSomSlot); return nextSomSlot++; } u32 SomSlotManager::getInitialResetSomSlot(const NGHolder &prefix, const NGHolder &g, const ue2::unordered_map ®ion_map, u32 last_sent_region, bool *prefix_already_implemented) { DEBUG_PRINTF("getting initial reset; last sent region %u\n", last_sent_region); assert(last_sent_region); assert(!hasBigCycles(prefix)); *prefix_already_implemented = false; #ifdef NO_SLOT_CACHING return nextSomSlot++; #endif shared_ptr pp = cloneHolder(prefix); assert(hash_holder(*pp) == hash_holder(prefix)); auto hs_it = cache->initial_prefixes.find(pp); if (hs_it != cache->initial_prefixes.end()) { DEBUG_PRINTF("pulling from cache\n"); pp = *hs_it; } else { DEBUG_PRINTF("storing in cache entry %zu, hash=%llu\n", cache->initial_prefixes.size(), hash_holder(*pp)); cache->initial_prefixes.insert(pp); } // Clone a copy of g (and its region map) that we will be able to store // later on. shared_ptr gg = make_shared(); ue2::unordered_map orig_to_copy; cloneHolder(*gg, g, &orig_to_copy); ue2::unordered_map gg_region_map; for (const auto &m : region_map) { assert(contains(region_map, m.first)); gg_region_map.emplace(orig_to_copy.at(m.first), m.second); } u32 first_bad_region = ~0U; UNUSED bool rv = sentClearsTail(g, region_map, *pp, last_sent_region, &first_bad_region); assert(!rv || first_bad_region == ~0U); InitialResetInfo *ir = nullptr; for (auto &reset : cache->initial_resets) { /* is this prefix already in our list? */ auto has_prefix_func = [&pp](const InitialResetEntry &e) { return e.sent == pp; }; bool already_seen_prefix = find_if(reset.entries.begin(), reset.entries.end(), has_prefix_func) != reset.entries.end(); for (auto &e : reset.entries) { u32 temp = 0; /* we don't need to test against sentinels which are identical to * our current one as races don't matter and we know it clears * sufficiently. */ if (e.sent != pp && !sentClearsTail(g, region_map, *e.sent, last_sent_region - 1, &temp) && (temp < first_bad_region || first_bad_region == ~0U)) { goto try_next; } /* if we have already seen the prefix it must be fine */ if (!already_seen_prefix && !sentClearsTail(*e.body, e.body_regions, prefix, e.sent_region - 1, &temp) && (temp < e.first_bad_region || e.first_bad_region == ~0U)) { goto try_next; } } DEBUG_PRINTF("sharing\n"); if (already_seen_prefix) { /* if we have already created this prefix using this som slot, we * can avoid creating another copy of the prefix. */ *prefix_already_implemented = true; } ir = &reset; goto found; try_next:; } cache->initial_resets.emplace_back(nextSomSlot++); ir = &cache->initial_resets.back(); found: ir->entries.emplace_back(pp, gg, gg_region_map, last_sent_region, first_bad_region); return ir->slot; } u32 SomSlotManager::getPrivateSomSlot(void) { return nextSomSlot++; } void SomSlotManager::rollbackSomTo(u32 num) { assert(nextSomSlot >= num); nextSomSlot = num; } u32 SomSlotManager::numSomSlots() const { return nextSomSlot; } u32 SomSlotManager::addRevNfa(aligned_unique_ptr nfa, u32 maxWidth) { u32 rv = verify_u32(rev_nfas.size()); rev_nfas.push_back(move(nfa)); // A rev nfa commits us to having enough history around to handle its // max width. historyRequired = max(historyRequired, maxWidth); return rv; } } // namespace ue2 hyperscan-4.4.1/src/som/slot_manager_dump.h0000644000175000017500000000354013055426554021537 0ustar sleuthkidsleuthkid/* * 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 SLOT_MANAGER_DUMP_H #define SLOT_MANAGER_DUMP_H namespace ue2 { class SomSlotManager; struct Grey; #ifdef DUMP_SUPPORT void dumpSomSlotManager(const SomSlotManager &ssm, const Grey &grey); #else static inline UNUSED void dumpSomSlotManager(const SomSlotManager &, const Grey &) { } #endif } // namespace ue2 #endif hyperscan-4.4.1/src/som/som_runtime.h0000644000175000017500000000501213055426554020374 0ustar sleuthkidsleuthkid/* * 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. */ /** * \file * \brief SOM runtime code. * * Runtime code for SOM handling called by the Rose callback adaptors. */ #ifndef SOM_RUNTIME_H #define SOM_RUNTIME_H #include "scratch.h" #include "ue2common.h" struct som_operation; void handleSomInternal(struct hs_scratch *scratch, const struct som_operation *ri, const u64a to_offset); // Returns the from_offset. u64a handleSomExternal(struct hs_scratch *scratch, const struct som_operation *ri, const u64a to_offset); void setSomFromSomAware(struct hs_scratch *scratch, const struct som_operation *ri, u64a from_offset, u64a to_offset); int flushStoredSomMatches_i(struct hs_scratch *scratch, u64a offset); static really_inline int flushStoredSomMatches(struct hs_scratch *scratch, u64a offset) { if (scratch->deduper.som_log_dirty) { return flushStoredSomMatches_i(scratch, offset); } else { return 0; } } #endif // SOM_RUNTIME_H hyperscan-4.4.1/src/som/som_stream.h0000644000175000017500000000403313055426554020206 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief SOM streaming runtime code. */ #ifndef SOM_STREAM_H #define SOM_STREAM_H #include "ue2common.h" struct hs_scratch; /** \brief Write all SOM slot information from scratch out to stream state * (given the current stream offset). */ void storeSomToStream(struct hs_scratch *scratch, const u64a offset); /** \brief Read all SOM slot information from stream state into scratch (given * the current stream offset). */ void loadSomFromStream(struct hs_scratch *scratch, const u64a offset); #endif hyperscan-4.4.1/src/som/slot_manager.h0000644000175000017500000000741013055426554020512 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief SOM Slot Manager. */ #ifndef SLOT_MANAGER_H #define SLOT_MANAGER_H #include "ue2common.h" #include "nfagraph/ng_holder.h" #include "util/alloc.h" #include "util/ue2_containers.h" #include #include #include struct NFA; namespace ue2 { class CharReach; class NGHolder; struct Grey; struct SlotCache; /** \brief SOM slot manager. Used to hand out SOM slots and track their * relationships during SOM construction. Also stores reverse NFAs used for * SOM. */ class SomSlotManager : boost::noncopyable { public: explicit SomSlotManager(u8 precision); ~SomSlotManager(); /** \brief Sentinel value used to specify that a slot has no parent. */ static constexpr u32 NO_PARENT = ~0; u32 getSomSlot(const NGHolder &prefix, const CharReach &escapes, bool is_reset, u32 parent_slot); /** prefix must be acting as a resetting sentinel and should be a dag (if * not how are we establish som?) */ u32 getInitialResetSomSlot(const NGHolder &prefix, const NGHolder &g, const ue2::unordered_map ®ion_map, u32 last_sent_region, bool *prefix_already_implemented); u32 getPrivateSomSlot(void); void rollbackSomTo(u32 num); u32 numSomSlots() const; const std::deque> &getRevNfas() const { return rev_nfas; } u32 addRevNfa(aligned_unique_ptr nfa, u32 maxWidth); u32 somHistoryRequired() const { return historyRequired; } u32 somPrecision() const { return precision; } void somPrecision(u32 p) { precision = p; } private: u32 nextSomSlot; std::unique_ptr cache; /** \brief Reverse NFAs used for SOM support. */ std::deque> rev_nfas; /** \brief In streaming mode, the amount of history we've committed to * using for SOM rev NFAs. */ u32 historyRequired; /** \brief Number of bytes of SOM precision requested by the user, zero if * not in SOM mode. */ u32 precision; #ifdef DUMP_SUPPORT friend void dumpSomSlotManager(const SomSlotManager &ssm, const Grey &grey); #endif }; } // namespace ue2 #endif hyperscan-4.4.1/src/alloc.c0000644000175000017500000000673513055426554016337 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Runtime functions for setting custom allocators. */ #include #include #include "allocator.h" #define default_malloc malloc #define default_free free hs_alloc_t hs_database_alloc = default_malloc; hs_alloc_t hs_misc_alloc = default_malloc; hs_alloc_t hs_scratch_alloc = default_malloc; hs_alloc_t hs_stream_alloc = default_malloc; hs_free_t hs_database_free = default_free; hs_free_t hs_misc_free = default_free; hs_free_t hs_scratch_free = default_free; hs_free_t hs_stream_free = default_free; static hs_alloc_t normalise_alloc(hs_alloc_t a) { if (!a) { return default_malloc; } else { return a; } } static hs_free_t normalise_free(hs_free_t f) { if (!f) { return default_free; } else { return f; } } HS_PUBLIC_API hs_error_t hs_set_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) { hs_set_database_allocator(allocfunc, freefunc); hs_set_misc_allocator(allocfunc, freefunc); hs_set_stream_allocator(allocfunc, freefunc); hs_set_scratch_allocator(allocfunc, freefunc); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_set_database_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) { hs_database_alloc = normalise_alloc(allocfunc); hs_database_free = normalise_free(freefunc); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_set_misc_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) { hs_misc_alloc = normalise_alloc(allocfunc); hs_misc_free = normalise_free(freefunc); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_set_scratch_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) { hs_scratch_alloc = normalise_alloc(allocfunc); hs_scratch_free = normalise_free(freefunc); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_set_stream_allocator(hs_alloc_t allocfunc, hs_free_t freefunc) { hs_stream_alloc = normalise_alloc(allocfunc); hs_stream_free = normalise_free(freefunc); return HS_SUCCESS; } hyperscan-4.4.1/src/hs.cpp0000644000175000017500000003605213055426554016212 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Compiler front-end, including public API calls for compilation. */ #include "allocator.h" #include "ue2common.h" #include "grey.h" #include "hs_compile.h" #include "hs_internal.h" #include "database.h" #include "compiler/compiler.h" #include "compiler/error.h" #include "nfagraph/ng.h" #include "nfagraph/ng_expr_info.h" #include "nfagraph/ng_extparam.h" #include "parser/parse_error.h" #include "parser/Parser.h" #include "parser/prefilter.h" #include "util/compile_error.h" #include "util/cpuid_flags.h" #include "util/depth.h" #include "util/popcount.h" #include "util/target_info.h" #include #include #include #include #include #include using namespace std; using namespace ue2; /** \brief Cheap check that no unexpected mode flags are on. */ static bool validModeFlags(unsigned int mode) { static const unsigned allModeFlags = HS_MODE_BLOCK | HS_MODE_STREAM | HS_MODE_VECTORED | HS_MODE_SOM_HORIZON_LARGE | HS_MODE_SOM_HORIZON_MEDIUM | HS_MODE_SOM_HORIZON_SMALL; return !(mode & ~allModeFlags); } /** \brief Validate mode flags. */ static bool checkMode(unsigned int mode, hs_compile_error **comp_error) { // First, check that only bits with meaning are on. if (!validModeFlags(mode)) { *comp_error = generateCompileError("Invalid parameter: " "unrecognised mode flags.", -1); return false; } // Our mode must be ONE of (block, streaming, vectored). unsigned checkmode = mode & (HS_MODE_STREAM | HS_MODE_BLOCK | HS_MODE_VECTORED); if (popcount32(checkmode) != 1) { *comp_error = generateCompileError( "Invalid parameter: mode must have one " "(and only one) of HS_MODE_BLOCK, HS_MODE_STREAM or " "HS_MODE_VECTORED set.", -1); return false; } // If you specify SOM precision, you must be in streaming mode and you only // get to have one. unsigned somMode = mode & (HS_MODE_SOM_HORIZON_LARGE | HS_MODE_SOM_HORIZON_MEDIUM | HS_MODE_SOM_HORIZON_SMALL); if (somMode) { if (!(mode & HS_MODE_STREAM)) { *comp_error = generateCompileError("Invalid parameter: the " "HS_MODE_SOM_HORIZON_ mode flags may only be set in " "streaming mode.", -1); return false; } if ((somMode & (somMode - 1)) != 0) { *comp_error = generateCompileError("Invalid parameter: only one " "HS_MODE_SOM_HORIZON_ mode flag can be set.", -1); return false; } } return true; } static bool checkPlatform(const hs_platform_info *p, hs_compile_error **comp_error) { #define HS_TUNE_LAST HS_TUNE_FAMILY_BDW #define HS_CPU_FEATURES_ALL (HS_CPU_FEATURES_AVX2) if (!p) { return true; } if (p->cpu_features & ~HS_CPU_FEATURES_ALL) { *comp_error = generateCompileError("Invalid cpu features specified in " "the platform information.", -1); return false; } if (p->tune > HS_TUNE_LAST) { *comp_error = generateCompileError("Invalid tuning value specified in " "the platform information.", -1); return false; } return true; } /** \brief Convert from SOM mode to bytes of precision. */ static unsigned getSomPrecision(unsigned mode) { if (mode & HS_MODE_VECTORED) { /* always assume full precision for vectoring */ return 8; } if (mode & HS_MODE_SOM_HORIZON_LARGE) { return 8; } else if (mode & HS_MODE_SOM_HORIZON_MEDIUM) { return 4; } else if (mode & HS_MODE_SOM_HORIZON_SMALL) { return 2; } return 0; } namespace ue2 { hs_error_t hs_compile_multi_int(const char *const *expressions, const unsigned *flags, const unsigned *ids, const hs_expr_ext *const *ext, unsigned elements, unsigned mode, const hs_platform_info_t *platform, hs_database_t **db, hs_compile_error_t **comp_error, const Grey &g) { // Check the args: note that it's OK for flags, ids or ext to be null. if (!comp_error) { if (db) { *db = nullptr; } // nowhere to write the string, but we can still report an error code return HS_COMPILER_ERROR; } if (!db) { *comp_error = generateCompileError("Invalid parameter: db is NULL", -1); return HS_COMPILER_ERROR; } if (!expressions) { *db = nullptr; *comp_error = generateCompileError("Invalid parameter: expressions is NULL", -1); return HS_COMPILER_ERROR; } if (elements == 0) { *db = nullptr; *comp_error = generateCompileError("Invalid parameter: elements is zero", -1); return HS_COMPILER_ERROR; } #if defined(FAT_RUNTIME) if (!check_ssse3()) { *db = nullptr; *comp_error = generateCompileError("Unsupported architecture", -1); return HS_ARCH_ERROR; } #endif if (!checkMode(mode, comp_error)) { *db = nullptr; assert(*comp_error); // set by checkMode. return HS_COMPILER_ERROR; } if (!checkPlatform(platform, comp_error)) { *db = nullptr; assert(*comp_error); // set by checkPlatform. return HS_COMPILER_ERROR; } if (elements > g.limitPatternCount) { *db = nullptr; *comp_error = generateCompileError("Number of patterns too large", -1); return HS_COMPILER_ERROR; } // This function is simply a wrapper around both the parser and compiler bool isStreaming = mode & (HS_MODE_STREAM | HS_MODE_VECTORED); bool isVectored = mode & HS_MODE_VECTORED; unsigned somPrecision = getSomPrecision(mode); target_t target_info = platform ? target_t(*platform) : get_current_target(); CompileContext cc(isStreaming, isVectored, target_info, g); NG ng(cc, elements, somPrecision); try { for (unsigned int i = 0; i < elements; i++) { // Add this expression to the compiler try { addExpression(ng, i, expressions[i], flags ? flags[i] : 0, ext ? ext[i] : nullptr, ids ? ids[i] : 0); } catch (CompileError &e) { /* Caught a parse error: * throw it upstream as a CompileError with a specific index */ e.setExpressionIndex(i); throw; /* do not slice */ } } unsigned length = 0; struct hs_database *out = build(ng, &length); assert(out); // should have thrown exception on error assert(length); *db = out; *comp_error = nullptr; return HS_SUCCESS; } catch (const CompileError &e) { // Compiler error occurred *db = nullptr; *comp_error = generateCompileError(e.reason, e.hasIndex ? (int)e.index : -1); return HS_COMPILER_ERROR; } catch (std::bad_alloc) { *db = nullptr; *comp_error = const_cast(&hs_enomem); return HS_COMPILER_ERROR; } catch (...) { assert(!"Internal error, unexpected exception"); *db = nullptr; *comp_error = const_cast(&hs_einternal); return HS_COMPILER_ERROR; } } } // namespace ue2 extern "C" HS_PUBLIC_API hs_error_t hs_compile(const char *expression, unsigned flags, unsigned mode, const hs_platform_info_t *platform, hs_database_t **db, hs_compile_error_t **error) { if (expression == nullptr) { *db = nullptr; *error = generateCompileError("Invalid parameter: expression is NULL", -1); return HS_COMPILER_ERROR; } unsigned id = 0; // single expressions get zero as an ID const hs_expr_ext * const *ext = nullptr; // unused for this call. return hs_compile_multi_int(&expression, &flags, &id, ext, 1, mode, platform, db, error, Grey()); } extern "C" HS_PUBLIC_API hs_error_t hs_compile_multi(const char * const *expressions, const unsigned *flags, const unsigned *ids, unsigned elements, unsigned mode, const hs_platform_info_t *platform, hs_database_t **db, hs_compile_error_t **error) { const hs_expr_ext * const *ext = nullptr; // unused for this call. return hs_compile_multi_int(expressions, flags, ids, ext, elements, mode, platform, db, error, Grey()); } extern "C" HS_PUBLIC_API hs_error_t hs_compile_ext_multi(const char * const *expressions, const unsigned *flags, const unsigned *ids, const hs_expr_ext * const *ext, unsigned elements, unsigned mode, const hs_platform_info_t *platform, hs_database_t **db, hs_compile_error_t **error) { return hs_compile_multi_int(expressions, flags, ids, ext, elements, mode, platform, db, error, Grey()); } static hs_error_t hs_expression_info_int(const char *expression, unsigned int flags, const hs_expr_ext_t *ext, unsigned int mode, hs_expr_info_t **info, hs_compile_error_t **error) { if (!error) { // nowhere to write an error, but we can still return an error code. return HS_COMPILER_ERROR; } #if defined(FAT_RUNTIME) if (!check_ssse3()) { *error = generateCompileError("Unsupported architecture", -1); return HS_ARCH_ERROR; } #endif if (!info) { *error = generateCompileError("Invalid parameter: info is NULL", -1); return HS_COMPILER_ERROR; } if (!expression) { *error = generateCompileError("Invalid parameter: expression is NULL", -1); return HS_COMPILER_ERROR; } *info = nullptr; *error = nullptr; hs_expr_info local_info; memset(&local_info, 0, sizeof(local_info)); try { bool isStreaming = mode & (HS_MODE_STREAM | HS_MODE_VECTORED); bool isVectored = mode & HS_MODE_VECTORED; CompileContext cc(isStreaming, isVectored, get_current_target(), Grey()); // Ensure that our pattern isn't too long (in characters). if (strlen(expression) > cc.grey.limitPatternLength) { throw ParseError("Pattern length exceeds limit."); } ReportManager rm(cc.grey); ParsedExpression pe(0, expression, flags, 0, ext); assert(pe.component); // Apply prefiltering transformations if desired. if (pe.prefilter) { prefilterTree(pe.component, ParseMode(flags)); } unique_ptr g = buildWrapper(rm, cc, pe); if (!g) { DEBUG_PRINTF("NFA build failed, but no exception was thrown.\n"); throw ParseError("Internal error."); } handleExtendedParams(rm, *g, cc); fillExpressionInfo(rm, *g, &local_info); } catch (const CompileError &e) { // Compiler error occurred *error = generateCompileError(e); return HS_COMPILER_ERROR; } catch (std::bad_alloc) { *error = const_cast(&hs_enomem); return HS_COMPILER_ERROR; } catch (...) { assert(!"Internal error, unexpected exception"); *error = const_cast(&hs_einternal); return HS_COMPILER_ERROR; } hs_expr_info *rv = (hs_expr_info *)hs_misc_alloc(sizeof(*rv)); if (!rv) { *error = const_cast(&hs_enomem); return HS_COMPILER_ERROR; } *rv = local_info; *info = rv; return HS_SUCCESS; } extern "C" HS_PUBLIC_API hs_error_t hs_expression_info(const char *expression, unsigned int flags, hs_expr_info_t **info, hs_compile_error_t **error) { return hs_expression_info_int(expression, flags, nullptr, HS_MODE_BLOCK, info, error); } extern "C" HS_PUBLIC_API hs_error_t hs_expression_ext_info(const char *expression, unsigned int flags, const hs_expr_ext_t *ext, hs_expr_info_t **info, hs_compile_error_t **error) { return hs_expression_info_int(expression, flags, ext, HS_MODE_BLOCK, info, error); } extern "C" HS_PUBLIC_API hs_error_t hs_populate_platform(hs_platform_info_t *platform) { if (!platform) { return HS_INVALID; } memset(platform, 0, sizeof(*platform)); platform->cpu_features = cpuid_flags(); platform->tune = cpuid_tune(); return HS_SUCCESS; } extern "C" HS_PUBLIC_API hs_error_t hs_free_compile_error(hs_compile_error_t *error) { #if defined(FAT_RUNTIME) if (!check_ssse3()) { return HS_ARCH_ERROR; } #endif freeCompileError(error); return HS_SUCCESS; } hyperscan-4.4.1/src/hs_version.c0000644000175000017500000000325013055426554017411 0ustar sleuthkidsleuthkid/* * 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. */ #include "ue2common.h" #include "hs_common.h" #include "hs_version.h" HS_PUBLIC_API const char *hs_version(void) { return HS_VERSION_STRING; } hyperscan-4.4.1/src/util/0000755000175000017500000000000013055426554016043 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/util/accel_scheme.h0000644000175000017500000000362113055426554020611 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 ACCEL_SCHEME_H #define ACCEL_SCHEME_H #include "util/charreach.h" #include "util/ue2_containers.h" #include namespace ue2 { #define MAX_ACCEL_DEPTH 4 struct AccelScheme { flat_set > double_byte; CharReach cr = CharReach::dot(); CharReach double_cr; u32 offset = MAX_ACCEL_DEPTH + 1; u32 double_offset = 0; }; } #endif hyperscan-4.4.1/src/util/join.h0000644000175000017500000000345213055426554017157 0ustar sleuthkidsleuthkid/* * 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 JOIN_H #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 hyperscan-4.4.1/src/util/exhaust.h0000644000175000017500000000340613055426554017700 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Inline functions for manipulating exhaustion vector. */ #ifndef EXHAUST_H #define EXHAUST_H #include "ue2common.h" /** Index meaning a given exhaustion key is invalid. */ #define INVALID_EKEY (~(u32)0) #endif hyperscan-4.4.1/src/util/graph_range.h0000644000175000017500000000757413055426554020506 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Convenience functions allowing range-based-for over BGL graphs. * * Normally with the BGL in C++98 you need to do this to iterate over graph * elements: * * Graph:out_edge_iterator ei, ee; * for (tie(ei, ee) = out_edges(v, g); ei != ee; ++ei) { * do_thing_with_edge(*ei, g); * } * * But now, with C++11 range-based-for and these functions, you can do this * instead: * * for (auto e : out_edges_range(v, g)) { * do_thing_with_edge(e, g); * } * * This syntax is much more compact and keeps the iterator vars from cluttering * the outer scope. */ #ifndef UTIL_GRAPH_RANGE_H #define UTIL_GRAPH_RANGE_H #include namespace ue2 { /** Adapts a pair of iterators into a range. */ template inline boost::iterator_range pair_range(const std::pair &p) { return boost::make_iterator_range(p.first, p.second); } /** vertices(g) */ template inline auto vertices_range(const Graph &g) -> decltype(pair_range(vertices(g))) { return pair_range(vertices(g)); } /** edges(g) */ template inline auto edges_range(const Graph &g) -> decltype(pair_range(edges(g))) { return pair_range(edges(g)); } /** out_edges(v, g) */ template inline auto out_edges_range(const typename Graph::vertex_descriptor &v, const Graph &g) -> decltype(pair_range(out_edges(v, g))) { return pair_range(out_edges(v, g)); } /** in_edges(v, g) */ template inline auto in_edges_range(const typename Graph::vertex_descriptor &v, const Graph &g) -> decltype(pair_range(in_edges(v, g))) { return pair_range(in_edges(v, g)); } /** adjacent_vertices(v, g) */ template inline auto adjacent_vertices_range(const typename Graph::vertex_descriptor &v, const Graph &g) -> decltype(pair_range(adjacent_vertices(v, g))) { return pair_range(adjacent_vertices(v, g)); } /** inv_adjacent_vertices(v, g) */ template inline auto inv_adjacent_vertices_range( const typename Graph::vertex_descriptor &v, const Graph &g) -> decltype(pair_range(inv_adjacent_vertices(v, g))) { return pair_range(inv_adjacent_vertices(v, g)); } } // namespace ue2 #endif // UTIL_GRAPH_RANGE_H hyperscan-4.4.1/src/util/target_info.h0000644000175000017500000000420613055426554020517 0ustar sleuthkidsleuthkid/* * 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 TARGET_INFO_H #define TARGET_INFO_H #include "ue2common.h" struct hs_platform_info; namespace ue2 { struct target_t { explicit target_t(const hs_platform_info &pi); bool has_avx2(void) const; bool is_atom_class(void) const; // This asks: can this target (the object) run on code that was built for // "code_target". Very wordy but less likely to be misinterpreted than // is_compatible() or some such. bool can_run_on_code_built_for(const target_t &code_target) const; private: u32 tune; u64a cpu_features; }; target_t get_current_target(void); } // namespace ue2 #endif hyperscan-4.4.1/src/util/report.h0000644000175000017500000001711713055426554017536 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Report structure used to manage data associated with a report at * compile time. */ #ifndef UTIL_REPORT_H #define UTIL_REPORT_H #include "util/exhaust.h" // for INVALID_EKEY #include "order_check.h" #include "ue2common.h" #include namespace ue2 { class ReportManager; enum ReportType { EXTERNAL_CALLBACK, EXTERNAL_CALLBACK_SOM_REL, INTERNAL_SOM_LOC_SET, INTERNAL_SOM_LOC_SET_IF_UNSET, INTERNAL_SOM_LOC_SET_IF_WRITABLE, INTERNAL_SOM_LOC_SET_SOM_REV_NFA, INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET, INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE, INTERNAL_SOM_LOC_COPY, INTERNAL_SOM_LOC_COPY_IF_WRITABLE, INTERNAL_SOM_LOC_MAKE_WRITABLE, EXTERNAL_CALLBACK_SOM_STORED, EXTERNAL_CALLBACK_SOM_ABS, EXTERNAL_CALLBACK_SOM_REV_NFA, INTERNAL_SOM_LOC_SET_FROM, INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE, INTERNAL_ROSE_CHAIN, EXTERNAL_CALLBACK_SOM_PASS }; /** * \brief All the data we use for handling a match. * * Includes extparam constraints and bounds, exhaustion/dedupe keys, offset * adjustment and SOM information. * * The data in this structure eventually becomes a list of Rose programs * instructions. */ struct Report { Report(ReportType type_in, u32 onmatch_in) : type(type_in), onmatch(onmatch_in) {} /** \brief True if this report has bounds from extended parameters, i.e. * min offset, max offset, min length. */ bool hasBounds() const { return minOffset > 0 || maxOffset < MAX_OFFSET || minLength > 0; } /** \brief Type of this report. */ ReportType type; /** \brief use SOM for minLength, but don't report it to user callback. */ bool quashSom = false; /** \brief min offset in the stream at which this report can match. */ u64a minOffset = 0; /** \brief max offset in the stream at which this report can match. */ u64a maxOffset = MAX_OFFSET; /** \brief min match length (start of match to current offset) */ u64a minLength = 0; /** \brief Exhaustion key. * * If exhaustible, the ekey to check before reporting a match. * Additionally after reporting a match the ekey will be set. If not * exhaustible, this will be INVALID_EKEY. */ u32 ekey = INVALID_EKEY; /** \brief Adjustment to add to the match offset when we report a match. * * This is usually used for reports attached to states that form part of a * zero-width assertion, like '$'. */ s32 offsetAdjust = 0; /** \brief Match report ID, for external reports. * * - external callback -> external report id * - internal_som_* -> som loc to modify * - INTERNAL_ROSE_CHAIN -> top event to push on * - otherwise -> target subnfa */ u32 onmatch; /** \brief Index of the reverse nfa. * * Used by EXTERNAL_CALLBACK_SOM_REV_NFA and * INTERNAL_SOM_LOC_SET_SOM_REV_NFA*. */ u32 revNfaIndex = 0; /** \brief SOM distance value, use varies according to type. * * - for EXTERNAL_CALLBACK_SOM_REL, from-offset is this many bytes * before the to-offset. * - for EXTERNAL_CALLBACK_SOM_ABS, set from-offset to this value. * - for INTERNAL_SOM_LOC_COPY*, som location read_from. */ u64a somDistance = 0; /** \brief Number of bytes behind us that we are allowed to squash * identical top events on the queue. * * Used by INTERNAL_ROSE_CHAIN. */ u64a topSquashDistance = 0; }; static inline bool isExternalReport(const Report &r) { switch (r.type) { case INTERNAL_SOM_LOC_SET: case INTERNAL_SOM_LOC_SET_IF_UNSET: case INTERNAL_SOM_LOC_SET_IF_WRITABLE: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE: case INTERNAL_SOM_LOC_COPY: case INTERNAL_SOM_LOC_COPY_IF_WRITABLE: case INTERNAL_SOM_LOC_MAKE_WRITABLE: case INTERNAL_SOM_LOC_SET_FROM: case INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE: case INTERNAL_ROSE_CHAIN: return false; case EXTERNAL_CALLBACK: case EXTERNAL_CALLBACK_SOM_REL: case EXTERNAL_CALLBACK_SOM_STORED: case EXTERNAL_CALLBACK_SOM_ABS: case EXTERNAL_CALLBACK_SOM_REV_NFA: case EXTERNAL_CALLBACK_SOM_PASS: return true; default: break; // fall through } assert(0); // unknown? return true; } static inline bool isExternalSomReport(const Report &r) { return r.type != EXTERNAL_CALLBACK && isExternalReport(r); } static inline bool operator<(const Report &a, const Report &b) { ORDER_CHECK(type); ORDER_CHECK(quashSom); ORDER_CHECK(ekey); ORDER_CHECK(offsetAdjust); ORDER_CHECK(onmatch); ORDER_CHECK(minOffset); ORDER_CHECK(maxOffset); ORDER_CHECK(minLength); ORDER_CHECK(somDistance); ORDER_CHECK(revNfaIndex); ORDER_CHECK(topSquashDistance); return false; } static inline Report makeECallback(u32 report, s32 offsetAdjust, u32 ekey) { Report ir(EXTERNAL_CALLBACK, report); ir.offsetAdjust = offsetAdjust; ir.ekey = ekey; return ir; } static inline Report makeCallback(u32 report, s32 offsetAdjust) { return makeECallback(report, offsetAdjust, INVALID_EKEY); } static inline Report makeSomRelativeCallback(u32 report, s32 offsetAdjust, u64a distance) { Report ir(EXTERNAL_CALLBACK_SOM_REL, report); ir.offsetAdjust = offsetAdjust; ir.ekey = INVALID_EKEY; ir.somDistance = distance; return ir; } static inline Report makeMpvTrigger(u32 event, u64a squashDistance) { Report ir(INTERNAL_ROSE_CHAIN, event); ir.ekey = INVALID_EKEY; ir.topSquashDistance = squashDistance; return ir; } /** simple exhaustible: exhaustible and if the first attempted match does not * succeed, no later matches will succeed either */ static inline bool isSimpleExhaustible(const Report &ir) { if (ir.ekey == INVALID_EKEY) { return false; } if (ir.hasBounds() && (ir.minOffset || ir.minLength)) { return false; } if (!isExternalReport(ir)) { return false; } return true; } } // namespace #endif // UTIL_REPORT_H hyperscan-4.4.1/src/util/popcount.h0000644000175000017500000000572213055426554020071 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Platform specific popcount functions */ #ifndef POPCOUNT_H_075D843B4545B6 #define POPCOUNT_H_075D843B4545B6 #include "ue2common.h" // We have a native popcount where the compiler has defined __POPCNT__. #if defined(__POPCNT__) #define HAVE_POPCOUNT_INSTR #elif defined(_WIN32) && defined(__AVX__) // TODO: fix win preproc #define HAVE_POPCOUNT_INSTR #endif static really_inline u32 popcount32(u32 x) { #if defined(HAVE_POPCOUNT_INSTR) // Single-instruction builtin. return _mm_popcnt_u32(x); #else // Fast branch-free version from bit-twiddling hacks as older Intel // processors do not have a POPCNT instruction. x -= (x >> 1) & 0x55555555; x = (x & 0x33333333) + ((x >> 2) & 0x33333333); return (((x + (x >> 4)) & 0xf0f0f0f) * 0x1010101) >> 24; #endif } static really_inline u32 popcount64(u64a x) { #if defined(ARCH_X86_64) # if defined(HAVE_POPCOUNT_INSTR) // Single-instruction builtin. return (u32)_mm_popcnt_u64(x); # else // Fast branch-free version from bit-twiddling hacks as older Intel // processors do not have a POPCNT instruction. x -= (x >> 1) & 0x5555555555555555; x = (x & 0x3333333333333333) + ((x >> 2) & 0x3333333333333333); x = (x + (x >> 4)) & 0x0f0f0f0f0f0f0f0f; return (x * 0x0101010101010101) >> 56; # endif #else // Synthesise from two 32-bit cases. return popcount32(x >> 32) + popcount32(x); #endif } #endif /* POPCOUNT_H_075D843B4545B6 */ hyperscan-4.4.1/src/util/dump_mask.h0000644000175000017500000000373713055426554020206 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Dump code for bitmasks. * * Note that these functions are only emitted in builds with DUMP_SUPPORT. */ #ifndef DUMP_MASK_H #define DUMP_MASK_H #ifdef DUMP_SUPPORT #include "ue2common.h" #include namespace ue2 { /** * Returns a representation of the given mask in binary, as a string of 1s and * 0s. */ std::string dumpMask(const u8 *mask, size_t len); } // namespace ue2 #endif // DUMP_SUPPORT #endif // DUMP_MASK_H hyperscan-4.4.1/src/util/multibit.h0000644000175000017500000014401313055426554020050 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Multibit: fast bitset structure, main runtime. * * *Structure* * * For sizes <= MMB_FLAT_MAX_BITS, a flat bit vector is used, stored as N * 64-bit blocks followed by one "runt block". * * In larger cases, we use a sequence of blocks forming a tree. Each bit in an * internal block indicates whether its child block contains valid data. Every * level bar the last is complete. The last level is just a basic bit vector. * * ----------------------------------------------------------------------------- * WARNING: * * mmbit code assumes that it is legal to load 8 bytes before the end of the * mmbit. This means that for small mmbits (< 8byte), data may be read from * before the base pointer. It is the user's responsibility to ensure that this * is possible. * ----------------------------------------------------------------------------- */ #ifndef MULTIBIT_H #define MULTIBIT_H #include "config.h" #include "ue2common.h" #include "bitutils.h" #include "partial_store.h" #include "unaligned.h" #include "multibit_internal.h" #include #ifdef __cplusplus extern "C" { #endif #define MMB_ONE (1ULL) #define MMB_ALL_ONES (0xffffffffffffffffULL) /** \brief Number of bits in a block. */ #define MMB_KEY_BITS (sizeof(MMB_TYPE) * 8) #define MMB_KEY_MASK (MMB_KEY_BITS - 1) // Key structure defines #define MMB_KEY_SHIFT 6 /** \brief Max size of a flat multibit. */ #define MMB_FLAT_MAX_BITS 256 // Utility functions and data // see multibit.c for contents extern const u8 mmbit_keyshift_lut[32]; extern const u8 mmbit_maxlevel_from_keyshift_lut[32]; extern const u8 mmbit_maxlevel_direct_lut[32]; extern const u32 mmbit_root_offset_from_level[7]; extern const u64a mmbit_zero_to_lut[65]; static really_inline MMB_TYPE mmb_load(const u8 * bits) { return unaligned_load_u64a(bits); } static really_inline void mmb_store(u8 *bits, MMB_TYPE val) { unaligned_store_u64a(bits, val); } static really_inline void mmb_store_partial(u8 *bits, MMB_TYPE val, u32 block_bits) { assert(block_bits <= MMB_KEY_BITS); partial_store_u64a(bits, val, ROUNDUP_N(block_bits, 8U) / 8U); } static really_inline MMB_TYPE mmb_single_bit(u32 bit) { assert(bit < MMB_KEY_BITS); return MMB_ONE << bit; } static really_inline MMB_TYPE mmb_mask_zero_to(u32 bit) { assert(bit <= MMB_KEY_BITS); #ifdef ARCH_32_BIT return mmbit_zero_to_lut[bit]; #else if (bit == MMB_KEY_BITS) { return MMB_ALL_ONES; } else { return mmb_single_bit(bit) - MMB_ONE; } #endif } /** \brief Returns a mask of set bits up to position \a bit. Does not handle * the case where bit == MMB_KEY_BITS. */ static really_inline MMB_TYPE mmb_mask_zero_to_nocheck(u32 bit) { assert(bit < MMB_KEY_BITS); #ifdef ARCH_32_BIT return mmbit_zero_to_lut[bit]; #else return mmb_single_bit(bit) - MMB_ONE; #endif } static really_inline u32 mmb_test(MMB_TYPE val, u32 bit) { assert(bit < MMB_KEY_BITS); return (val >> bit) & MMB_ONE; } static really_inline void mmb_set(MMB_TYPE * val, u32 bit) { assert(bit < MMB_KEY_BITS); *val |= mmb_single_bit(bit); } static really_inline void mmb_clear(MMB_TYPE * val, u32 bit) { assert(bit < MMB_KEY_BITS); *val &= ~mmb_single_bit(bit); } static really_inline u32 mmb_ctz(MMB_TYPE val) { return ctz64(val); } static really_inline u32 mmb_popcount(MMB_TYPE val) { return popcount64(val); } #ifndef MMMB_DEBUG #define MDEBUG_PRINTF(x, ...) do { } while(0) #else #define MDEBUG_PRINTF DEBUG_PRINTF #endif // Switch the following define on to trace writes to multibit. //#define MMB_TRACE_WRITES #ifdef MMB_TRACE_WRITES #define MMB_TRACE(format, ...) \ printf("mmb [%u bits @ %p] " format, total_bits, bits, ##__VA_ARGS__) #else #define MMB_TRACE(format, ...) \ do { \ } while (0) #endif static really_inline u32 mmbit_keyshift(u32 total_bits) { assert(total_bits > 1); u32 n = clz32(total_bits - 1); // subtract one as we're rounding down return mmbit_keyshift_lut[n]; } static really_inline u32 mmbit_maxlevel(u32 total_bits) { assert(total_bits > 1); u32 n = clz32(total_bits - 1); // subtract one as we're rounding down u32 max_level = mmbit_maxlevel_direct_lut[n]; assert(max_level <= MMB_MAX_LEVEL); return max_level; } static really_inline u32 mmbit_maxlevel_from_keyshift(u32 ks) { assert(ks <= 30); assert(ks % MMB_KEY_SHIFT == 0); u32 max_level = mmbit_maxlevel_from_keyshift_lut[ks]; assert(max_level <= MMB_MAX_LEVEL); return max_level; } /** \brief get our keyshift for the current level */ static really_inline u32 mmbit_get_ks(u32 max_level, u32 level) { assert(max_level <= MMB_MAX_LEVEL); assert(level <= max_level); return (max_level - level) * MMB_KEY_SHIFT; } /** \brief get our key value for the current level */ static really_inline u32 mmbit_get_key_val(u32 max_level, u32 level, u32 key) { return (key >> mmbit_get_ks(max_level, level)) & MMB_KEY_MASK; } /** \brief get the level root for the current level */ static really_inline u8 *mmbit_get_level_root(u8 *bits, u32 level) { assert(level < ARRAY_LENGTH(mmbit_root_offset_from_level)); return bits + mmbit_root_offset_from_level[level] * sizeof(MMB_TYPE); } /** \brief get the level root for the current level as const */ static really_inline const u8 *mmbit_get_level_root_const(const u8 *bits, u32 level) { assert(level < ARRAY_LENGTH(mmbit_root_offset_from_level)); return bits + mmbit_root_offset_from_level[level] * sizeof(MMB_TYPE); } /** \brief get the block for this key on the current level as a u8 ptr */ static really_inline u8 *mmbit_get_block_ptr(u8 *bits, u32 max_level, u32 level, u32 key) { u8 *level_root = mmbit_get_level_root(bits, level); u32 ks = mmbit_get_ks(max_level, level); return level_root + ((u64a)key >> (ks + MMB_KEY_SHIFT)) * sizeof(MMB_TYPE); } /** \brief get the block for this key on the current level as a const u8 ptr */ static really_inline const u8 *mmbit_get_block_ptr_const(const u8 *bits, u32 max_level, u32 level, u32 key) { const u8 *level_root = mmbit_get_level_root_const(bits, level); u32 ks = mmbit_get_ks(max_level, level); return level_root + ((u64a)key >> (ks + MMB_KEY_SHIFT)) * sizeof(MMB_TYPE); } /** \brief get the _byte_ for this key on the current level as a u8 ptr */ static really_inline u8 *mmbit_get_byte_ptr(u8 *bits, u32 max_level, u32 level, u32 key) { u8 *level_root = mmbit_get_level_root(bits, level); u32 ks = mmbit_get_ks(max_level, level); return level_root + ((u64a)key >> (ks + MMB_KEY_SHIFT - 3)); } /** \brief get our key value for the current level */ static really_inline u32 mmbit_get_key_val_byte(u32 max_level, u32 level, u32 key) { return (key >> (mmbit_get_ks(max_level, level))) & 0x7; } /** \brief Load a flat bitvector block corresponding to N bits. */ static really_inline MMB_TYPE mmbit_get_flat_block(const u8 *bits, u32 n_bits) { assert(n_bits <= MMB_KEY_BITS); u32 n_bytes = ROUNDUP_N(n_bits, 8) / 8; switch (n_bytes) { case 1: return *bits; case 2: return unaligned_load_u16(bits); case 3: case 4: { u32 rv; assert(n_bytes <= sizeof(rv)); memcpy(&rv, bits + n_bytes - sizeof(rv), sizeof(rv)); rv >>= (sizeof(rv) - n_bytes) * 8; /* need to shift to get things in * the right position and remove * junk */ assert(rv == partial_load_u32(bits, n_bytes)); return rv; } default: { u64a rv; assert(n_bytes <= sizeof(rv)); memcpy(&rv, bits + n_bytes - sizeof(rv), sizeof(rv)); rv >>= (sizeof(rv) - n_bytes) * 8; /* need to shift to get things in * the right position and remove * junk */ assert(rv == partial_load_u64a(bits, n_bytes)); return rv; } } } /** \brief True if this multibit is small enough to use a flat model */ static really_inline u32 mmbit_is_flat_model(u32 total_bits) { return total_bits <= MMB_FLAT_MAX_BITS; } static really_inline u32 mmbit_flat_size(u32 total_bits) { assert(mmbit_is_flat_model(total_bits)); return ROUNDUP_N(total_bits, 8) / 8; } static really_inline u32 mmbit_flat_select_byte(u32 key, UNUSED u32 total_bits) { return key / 8; } /** \brief returns the dense index of the bit in the given mask. */ static really_inline u32 mmbit_mask_index(u32 bit, MMB_TYPE mask) { assert(bit < MMB_KEY_BITS); assert(mmb_test(mask, bit)); mask &= mmb_mask_zero_to(bit); if (mask == 0ULL) { return 0; // Common case. } return mmb_popcount(mask); } /** \brief Clear all bits. */ static really_inline void mmbit_clear(u8 *bits, u32 total_bits) { MDEBUG_PRINTF("%p total_bits %u\n", bits, total_bits); MMB_TRACE("CLEAR\n"); if (!total_bits) { return; } if (mmbit_is_flat_model(total_bits)) { memset(bits, 0, mmbit_flat_size(total_bits)); return; } mmb_store(bits, 0); } /** \brief Specialisation of \ref mmbit_set for flat models. */ static really_inline char mmbit_set_flat(u8 *bits, u32 total_bits, u32 key) { bits += mmbit_flat_select_byte(key, total_bits); u8 mask = 1U << (key % 8); char was_set = !!(*bits & mask); *bits |= mask; return was_set; } static really_inline char mmbit_set_big(u8 *bits, u32 total_bits, u32 key) { const u32 max_level = mmbit_maxlevel(total_bits); u32 level = 0; do { u8 * byte_ptr = mmbit_get_byte_ptr(bits, max_level, level, key); u8 keymask = 1U << mmbit_get_key_val_byte(max_level, level, key); u8 byte = *byte_ptr; if (likely(!(byte & keymask))) { *byte_ptr = byte | keymask; while (level++ != max_level) { u8 *block_ptr_1 = mmbit_get_block_ptr(bits, max_level, level, key); MMB_TYPE keymask_1 = mmb_single_bit(mmbit_get_key_val(max_level, level, key)); mmb_store(block_ptr_1, keymask_1); } return 0; } } while (level++ != max_level); return 1; } /** Internal version of \ref mmbit_set without MMB_TRACE, so it can be used by * \ref mmbit_sparse_iter_dump. */ static really_inline char mmbit_set_i(u8 *bits, u32 total_bits, u32 key) { assert(key < total_bits); if (mmbit_is_flat_model(total_bits)) { return mmbit_set_flat(bits, total_bits, key); } else { return mmbit_set_big(bits, total_bits, key); } } static really_inline char mmbit_isset(const u8 *bits, u32 total_bits, u32 key); /** \brief Sets the given key in the multibit. Returns 0 if the key was NOT * already set, 1 otherwise. */ static really_inline char mmbit_set(u8 *bits, u32 total_bits, u32 key) { MDEBUG_PRINTF("%p total_bits %u key %u\n", bits, total_bits, key); char status = mmbit_set_i(bits, total_bits, key); MMB_TRACE("SET %u (prev status: %d)\n", key, (int)status); assert(mmbit_isset(bits, total_bits, key)); return status; } /** \brief Specialisation of \ref mmbit_isset for flat models. */ static really_inline char mmbit_isset_flat(const u8 *bits, u32 total_bits, u32 key) { bits += mmbit_flat_select_byte(key, total_bits); return !!(*bits & (1U << (key % 8U))); } static really_inline char mmbit_isset_big(const u8 *bits, u32 total_bits, u32 key) { const u32 max_level = mmbit_maxlevel(total_bits); u32 level = 0; do { const u8 *block_ptr = mmbit_get_block_ptr_const(bits, max_level, level, key); MMB_TYPE block = mmb_load(block_ptr); if (!mmb_test(block, mmbit_get_key_val(max_level, level, key))) { return 0; } } while (level++ != max_level); return 1; } /** \brief Returns whether the given key is set. */ static really_inline char mmbit_isset(const u8 *bits, u32 total_bits, u32 key) { MDEBUG_PRINTF("%p total_bits %u key %u\n", bits, total_bits, key); assert(key < total_bits); if (mmbit_is_flat_model(total_bits)) { return mmbit_isset_flat(bits, total_bits, key); } else { return mmbit_isset_big(bits, total_bits, key); } } /** \brief Specialisation of \ref mmbit_unset for flat models. */ static really_inline void mmbit_unset_flat(u8 *bits, u32 total_bits, u32 key) { bits += mmbit_flat_select_byte(key, total_bits); *bits &= ~(1U << (key % 8U)); } // TODO: // build two versions of this - unset_dangerous that doesn't clear the summary // block and a regular unset that actually clears ALL the way up the levels if // possible - might make a utility function for the clear static really_inline void mmbit_unset_big(u8 *bits, u32 total_bits, u32 key) { /* This function is lazy as it does not clear the summary block * entry if the child becomes empty. This is not a correctness problem as the * summary block entries are used to mean that their children are valid * rather than that they have a set child. */ const u32 max_level = mmbit_maxlevel(total_bits); u32 level = 0; do { u8 *block_ptr = mmbit_get_block_ptr(bits, max_level, level, key); u32 key_val = mmbit_get_key_val(max_level, level, key); MMB_TYPE block = mmb_load(block_ptr); if (!mmb_test(block, key_val)) { return; } if (level == max_level) { mmb_clear(&block, key_val); mmb_store(block_ptr, block); } } while (level++ != max_level); } /** \brief Switch off a given key. */ static really_inline void mmbit_unset(u8 *bits, u32 total_bits, u32 key) { MDEBUG_PRINTF("%p total_bits %u key %u\n", bits, total_bits, key); assert(key < total_bits); MMB_TRACE("UNSET %u (prev status: %d)\n", key, (int)mmbit_isset(bits, total_bits, key)); if (mmbit_is_flat_model(total_bits)) { mmbit_unset_flat(bits, total_bits, key); } else { mmbit_unset_big(bits, total_bits, key); } } /** \brief Specialisation of \ref mmbit_iterate for flat models. */ static really_inline u32 mmbit_iterate_flat(const u8 *bits, u32 total_bits, u32 it_in) { // Short cut for single-block cases. if (total_bits <= MMB_KEY_BITS) { MMB_TYPE block = mmbit_get_flat_block(bits, total_bits); if (it_in != MMB_INVALID) { it_in++; assert(it_in < total_bits); block &= ~mmb_mask_zero_to(it_in); } if (block) { return mmb_ctz(block); } return MMB_INVALID; } const u32 last_block = total_bits / MMB_KEY_BITS; u32 start; // starting block index if (it_in != MMB_INVALID) { it_in++; assert(it_in < total_bits); start = (ROUNDUP_N(it_in, MMB_KEY_BITS) / MMB_KEY_BITS) - 1; u32 start_key = start * MMB_KEY_BITS; u32 block_size = MIN(MMB_KEY_BITS, total_bits - start_key); MMB_TYPE block = mmbit_get_flat_block(bits + (start * sizeof(MMB_TYPE)), block_size); block &= ~mmb_mask_zero_to(it_in - start_key); if (block) { return start_key + mmb_ctz(block); } else if (start_key + MMB_KEY_BITS >= total_bits) { return MMB_INVALID; // That was the final block. } start++; } else { start = 0; } // Remaining full-sized blocks. for (; start < last_block; start++) { MMB_TYPE block = mmb_load(bits + (start * sizeof(MMB_TYPE))); if (block) { return (start * MMB_KEY_BITS) + mmb_ctz(block); } } // We may have a final, smaller than full-sized, block to deal with at the // end. if (total_bits % MMB_KEY_BITS) { u32 start_key = start * MMB_KEY_BITS; u32 block_size = MIN(MMB_KEY_BITS, total_bits - start_key); MMB_TYPE block = mmbit_get_flat_block(bits + (start * sizeof(MMB_TYPE)), block_size); if (block) { return start_key + mmb_ctz(block); } } return MMB_INVALID; } static really_inline u32 mmbit_iterate_big(const u8 * bits, u32 total_bits, u32 it_in) { const u32 max_level = mmbit_maxlevel(total_bits); u32 level = 0; u32 key = 0; u32 key_rem = 0; if (it_in != MMB_INVALID) { // We're continuing a previous iteration, so we need to go // to max_level so we can pick up where we left off. // NOTE: assumes that we're valid down the whole tree key = it_in >> MMB_KEY_SHIFT; key_rem = (it_in & MMB_KEY_MASK) + 1; level = max_level; } while (1) { if (key_rem < MMB_KEY_BITS) { const u8 *block_ptr = mmbit_get_level_root_const(bits, level) + key * sizeof(MMB_TYPE); MMB_TYPE block = mmb_load(block_ptr) & ~mmb_mask_zero_to_nocheck(key_rem); if (block) { key = (key << MMB_KEY_SHIFT) + mmb_ctz(block); if (level++ == max_level) { break; } key_rem = 0; continue; // jump the rootwards step if we found a 'tree' non-zero bit } } // rootwards step (block is zero or key_rem == MMB_KEY_BITS) if (level-- == 0) { return MMB_INVALID; // if we don't find anything and we're at the top level, we're done } key_rem = (key & MMB_KEY_MASK) + 1; key >>= MMB_KEY_SHIFT; } assert(key < total_bits); assert(mmbit_isset(bits, total_bits, key)); return key; } /** \brief Unbounded iterator. Returns the index of the next set bit after \a * it_in, or MMB_INVALID. * * Note: assumes that if you pass in a value of it_in other than MMB_INVALID, * that bit must be on (assumes all its summary blocks are set). */ static really_inline u32 mmbit_iterate(const u8 *bits, u32 total_bits, u32 it_in) { MDEBUG_PRINTF("%p total_bits %u it_in %u\n", bits, total_bits, it_in); assert(it_in < total_bits || it_in == MMB_INVALID); if (!total_bits) { return MMB_INVALID; } if (it_in == total_bits - 1) { return MMB_INVALID; // it_in is the last key. } u32 key; if (mmbit_is_flat_model(total_bits)) { key = mmbit_iterate_flat(bits, total_bits, it_in); } else { key = mmbit_iterate_big(bits, total_bits, it_in); } assert(key == MMB_INVALID || mmbit_isset(bits, total_bits, key)); return key; } /** \brief Specialisation of \ref mmbit_any and \ref mmbit_any_precise for flat * models. */ static really_inline char mmbit_any_flat(const u8 *bits, u32 total_bits) { if (total_bits <= MMB_KEY_BITS) { return !!mmbit_get_flat_block(bits, total_bits); } const u8 *end = bits + mmbit_flat_size(total_bits); for (const u8 *last = end - sizeof(MMB_TYPE); bits < last; bits += sizeof(MMB_TYPE)) { if (mmb_load(bits)) { return 1; } } // Overlapping load at the end. return !!mmb_load(end - sizeof(MMB_TYPE)); } /** \brief True if any keys are (or might be) on in the given multibit. * * NOTE: mmbit_any is sloppy (may return true when only summary bits are set). * Use \ref mmbit_any_precise if you need/want a correct answer. */ static really_inline char mmbit_any(const u8 *bits, u32 total_bits) { MDEBUG_PRINTF("%p total_bits %u\n", bits, total_bits); if (!total_bits) { return 0; } if (mmbit_is_flat_model(total_bits)) { return mmbit_any_flat(bits, total_bits); } return !!mmb_load(bits); } /** \brief True if there are any keys on. Guaranteed precise. */ static really_inline char mmbit_any_precise(const u8 *bits, u32 total_bits) { MDEBUG_PRINTF("%p total_bits %u\n", bits, total_bits); if (!total_bits) { return 0; } if (mmbit_is_flat_model(total_bits)) { return mmbit_any_flat(bits, total_bits); } return mmbit_iterate_big(bits, total_bits, MMB_INVALID) != MMB_INVALID; } static really_inline char mmbit_all_flat(const u8 *bits, u32 total_bits) { while (total_bits > MMB_KEY_BITS) { if (mmb_load(bits) != MMB_ALL_ONES) { return 0; } bits += sizeof(MMB_TYPE); total_bits -= MMB_KEY_BITS; } while (total_bits > 8) { if (*bits != 0xff) { return 0; } bits++; total_bits -= 8; } u8 mask = (u8)mmb_mask_zero_to_nocheck(total_bits); return (*bits & mask) == mask; } static really_inline char mmbit_all_big(const u8 *bits, u32 total_bits) { u32 ks = mmbit_keyshift(total_bits); u32 level = 0; for (;;) { // Number of bits we expect to see switched on on this level. u32 level_bits; if (ks != 0) { u32 next_level_width = MMB_KEY_BITS << (ks - MMB_KEY_SHIFT); level_bits = ROUNDUP_N(total_bits, next_level_width) >> ks; } else { level_bits = total_bits; } const u8 *block_ptr = mmbit_get_level_root_const(bits, level); // All full-size blocks should be all-ones. while (level_bits >= MMB_KEY_BITS) { MMB_TYPE block = mmb_load(block_ptr); if (block != MMB_ALL_ONES) { return 0; } block_ptr += sizeof(MMB_TYPE); level_bits -= MMB_KEY_BITS; } // If we have bits remaining, we have a runt block on the end. if (level_bits > 0) { MMB_TYPE block = mmb_load(block_ptr); MMB_TYPE mask = mmb_mask_zero_to_nocheck(level_bits); if ((block & mask) != mask) { return 0; } } if (ks == 0) { break; } ks -= MMB_KEY_SHIFT; level++; } return 1; } /** \brief True if all keys are on. Guaranteed precise. */ static really_inline char mmbit_all(const u8 *bits, u32 total_bits) { MDEBUG_PRINTF("%p total_bits %u\n", bits, total_bits); if (mmbit_is_flat_model(total_bits)) { return mmbit_all_flat(bits, total_bits); } return mmbit_all_big(bits, total_bits); } static really_inline MMB_TYPE get_flat_masks(u32 base, u32 it_start, u32 it_end) { if (it_end <= base) { return 0; } u32 udiff = it_end - base; MMB_TYPE mask = udiff < 64 ? mmb_mask_zero_to_nocheck(udiff) : MMB_ALL_ONES; if (it_start >= base) { u32 ldiff = it_start - base; MMB_TYPE lmask = ldiff < 64 ? ~mmb_mask_zero_to_nocheck(ldiff) : 0; mask &= lmask; } return mask; } /** \brief Specialisation of \ref mmbit_iterate_bounded for flat models. */ static really_inline u32 mmbit_iterate_bounded_flat(const u8 *bits, u32 total_bits, u32 begin, u32 end) { // Short cut for single-block cases. if (total_bits <= MMB_KEY_BITS) { MMB_TYPE block = mmbit_get_flat_block(bits, total_bits); block &= get_flat_masks(0, begin, end); if (block) { return mmb_ctz(block); } return MMB_INVALID; } const u32 last_block = ROUNDDOWN_N(total_bits, MMB_KEY_BITS); // Iterate over full-sized blocks. for (u32 i = ROUNDDOWN_N(begin, MMB_KEY_BITS), e = MIN(end, last_block); i < e; i += MMB_KEY_BITS) { const u8 *block_ptr = bits + i / 8; MMB_TYPE block = mmb_load(block_ptr); block &= get_flat_masks(i, begin, end); if (block) { return i + mmb_ctz(block); } } // Final block, which is less than full-sized. if (end > last_block) { const u8 *block_ptr = bits + last_block / 8; u32 num_bits = total_bits - last_block; MMB_TYPE block = mmbit_get_flat_block(block_ptr, num_bits); block &= get_flat_masks(last_block, begin, end); if (block) { return last_block + mmb_ctz(block); } } return MMB_INVALID; } static really_inline MMB_TYPE get_lowhi_masks(u32 level, u32 max_level, u64a block_min, u64a block_max, u64a block_base) { const u32 level_shift = (max_level - level) * MMB_KEY_SHIFT; u64a lshift = (block_min - block_base) >> level_shift; u64a ushift = (block_max - block_base) >> level_shift; MMB_TYPE lmask = lshift < 64 ? ~mmb_mask_zero_to_nocheck(lshift) : 0; MMB_TYPE umask = ushift < 63 ? mmb_mask_zero_to_nocheck(ushift + 1) : MMB_ALL_ONES; return lmask & umask; } static really_inline u32 mmbit_iterate_bounded_big(const u8 *bits, u32 total_bits, u32 it_start, u32 it_end) { u64a key = 0; u32 ks = mmbit_keyshift(total_bits); const u32 max_level = mmbit_maxlevel_from_keyshift(ks); u32 level = 0; --it_end; // make end-limit inclusive for (;;) { assert(level <= max_level); u64a block_width = MMB_KEY_BITS << ks; u64a block_base = key * block_width; u64a block_min = MAX(it_start, block_base); u64a block_max = MIN(it_end, block_base + block_width - 1); const u8 *block_ptr = mmbit_get_level_root_const(bits, level) + key * sizeof(MMB_TYPE); MMB_TYPE block = mmb_load(block_ptr); block &= get_lowhi_masks(level, max_level, block_min, block_max, block_base); if (block) { // Found a bit, go down a level key = (key << MMB_KEY_SHIFT) + mmb_ctz(block); if (level++ == max_level) { return key; } ks -= MMB_KEY_SHIFT; } else { // No bit found, go up a level // we know that this block didn't have any answers, so we can push // our start iterator forward. u64a next_start = block_base + block_width; if (next_start > it_end) { break; } if (level-- == 0) { break; } it_start = next_start; key >>= MMB_KEY_SHIFT; ks += MMB_KEY_SHIFT; } } return MMB_INVALID; } /** \brief Bounded iterator. Returns the index of the first set bit between * it_start (inclusive) and it_end (exclusive) or MMB_INVALID if no bits are * set in that range. */ static really_inline u32 mmbit_iterate_bounded(const u8 *bits, u32 total_bits, u32 it_start, u32 it_end) { MDEBUG_PRINTF("%p total_bits %u it_start %u it_end %u\n", bits, total_bits, it_start, it_end); assert(it_start <= it_end); assert(it_end <= total_bits); if (!total_bits || it_end == it_start) { return MMB_INVALID; } assert(it_start < total_bits); u32 key; if (mmbit_is_flat_model(total_bits)) { key = mmbit_iterate_bounded_flat(bits, total_bits, it_start, it_end); } else { key = mmbit_iterate_bounded_big(bits, total_bits, it_start, it_end); } assert(key == MMB_INVALID || mmbit_isset(bits, total_bits, key)); return key; } /** \brief Specialisation of \ref mmbit_unset_range for flat models. */ static really_inline void mmbit_unset_range_flat(u8 *bits, u32 total_bits, u32 begin, u32 end) { const u32 last_block = ROUNDDOWN_N(total_bits, MMB_KEY_BITS); // Iterate over full-sized blocks. for (u32 i = ROUNDDOWN_N(begin, MMB_KEY_BITS), e = MIN(end, last_block); i < e; i += MMB_KEY_BITS) { u8 *block_ptr = bits + i / 8; MMB_TYPE block = mmb_load(block_ptr); MMB_TYPE mask = get_flat_masks(i, begin, end); mmb_store(block_ptr, block & ~mask); } // Final block, which is less than full-sized. if (end > last_block) { u8 *block_ptr = bits + last_block / 8; u32 num_bits = total_bits - last_block; MMB_TYPE block = mmbit_get_flat_block(block_ptr, num_bits); MMB_TYPE mask = get_flat_masks(last_block, begin, end); mmb_store_partial(block_ptr, block & ~mask, num_bits); } } static really_inline void mmbit_unset_range_big(u8 *bits, const u32 total_bits, u32 begin, u32 end) { // TODO: combine iterator and unset operation; completely replace this u32 i = begin; for (;;) { i = mmbit_iterate_bounded(bits, total_bits, i, end); if (i == MMB_INVALID) { break; } mmbit_unset_big(bits, total_bits, i); if (++i == end) { break; } } } /** \brief Unset a whole range of bits. Ensures that all bits between \a begin * (inclusive) and \a end (exclusive) are switched off. */ static really_inline void mmbit_unset_range(u8 *bits, const u32 total_bits, u32 begin, u32 end) { MDEBUG_PRINTF("%p total_bits %u begin %u end %u\n", bits, total_bits, begin, end); assert(begin <= end); assert(end <= total_bits); if (mmbit_is_flat_model(total_bits)) { mmbit_unset_range_flat(bits, total_bits, begin, end); } else { mmbit_unset_range_big(bits, total_bits, begin, end); } // No bits are on in [begin, end) once we're done. assert(MMB_INVALID == mmbit_iterate_bounded(bits, total_bits, begin, end)); } /** \brief Specialisation of \ref mmbit_init_range for flat models. */ static really_inline void mmbit_init_range_flat(u8 *bits, const u32 total_bits, u32 begin, u32 end) { const u32 last_block = ROUNDDOWN_N(total_bits, MMB_KEY_BITS); // Iterate over full-sized blocks. for (u32 i = 0; i < last_block; i += MMB_KEY_BITS) { mmb_store(bits + i / 8, get_flat_masks(i, begin, end)); } // Final block, which is less than full-sized. if (total_bits % MMB_KEY_BITS) { u32 num_bits = total_bits - last_block; MMB_TYPE block = get_flat_masks(last_block, begin, end); mmb_store_partial(bits + last_block / 8, block, num_bits); } } static really_inline void mmbit_init_range_big(u8 *bits, const u32 total_bits, u32 begin, u32 end) { u32 ks = mmbit_keyshift(total_bits); u32 level = 0; for (;;) { u8 *block = mmbit_get_level_root(bits, level); u32 k1 = begin >> ks, k2 = end >> ks; // Summary blocks need to account for the runt block on the end. if ((k2 << ks) != end) { k2++; } // Partial block to deal with beginning. block += (k1 / MMB_KEY_BITS) * sizeof(MMB_TYPE); if (k1 % MMB_KEY_BITS) { u32 idx = k1 / MMB_KEY_BITS; u32 block_end = (idx + 1) * MMB_KEY_BITS; // Because k1 % MMB_KEY_BITS != 0, we can avoid checking edge cases // here (see the branch in mmb_mask_zero_to). MMB_TYPE mask = MMB_ALL_ONES << (k1 % MMB_KEY_BITS); if (k2 < block_end) { assert(k2 % MMB_KEY_BITS); mask &= mmb_mask_zero_to_nocheck(k2 % MMB_KEY_BITS); mmb_store(block, mask); goto next_level; } else { mmb_store(block, mask); k1 = block_end; block += sizeof(MMB_TYPE); } } // Write blocks filled with ones until we get to the last block. for (; k1 < (k2 & ~MMB_KEY_MASK); k1 += MMB_KEY_BITS) { mmb_store(block, MMB_ALL_ONES); block += sizeof(MMB_TYPE); } // Final block. if (likely(k1 < k2)) { // Again, if k2 was at a block boundary, it would have been handled // by the previous loop, so we know k2 % MMB_KEY_BITS != 0 and can // avoid the branch in mmb_mask_zero_to here. assert(k2 % MMB_KEY_BITS); MMB_TYPE mask = mmb_mask_zero_to_nocheck(k2 % MMB_KEY_BITS); mmb_store(block, mask); } next_level: if (ks == 0) { break; // Last level is done, finished. } ks -= MMB_KEY_SHIFT; level++; } } /** \brief Initialises the multibit so that only the given range of bits are * set. * * Ensures that all bits between \a begin (inclusive) and \a end (exclusive) * are switched on. */ static really_inline void mmbit_init_range(u8 *bits, const u32 total_bits, u32 begin, u32 end) { MDEBUG_PRINTF("%p total_bits %u begin %u end %u\n", bits, total_bits, begin, end); assert(begin <= end); assert(end <= total_bits); if (!total_bits) { return; } // Short cut for cases where we're not actually setting any bits; just // clear the multibit. if (begin == end) { mmbit_clear(bits, total_bits); return; } if (mmbit_is_flat_model(total_bits)) { mmbit_init_range_flat(bits, total_bits, begin, end); } else { mmbit_init_range_big(bits, total_bits, begin, end); } assert(begin == end || mmbit_iterate(bits, total_bits, MMB_INVALID) == begin); assert(!end || begin == end || mmbit_iterate(bits, total_bits, end - 1) == MMB_INVALID); } /** \brief Determine the number of \ref mmbit_sparse_state elements required. * */ static really_inline u32 mmbit_sparse_iter_state_size(u32 total_bits) { if (mmbit_is_flat_model(total_bits)) { return 2; } u32 levels = mmbit_maxlevel(total_bits); return levels + 1; } #ifdef DUMP_SUPPORT // Dump function, defined in multibit.c. void mmbit_sparse_iter_dump(const struct mmbit_sparse_iter *it, u32 total_bits); #endif /** Internal: common loop used by mmbit_sparse_iter_{begin,next}_big. Returns * matching next key given starting state, or MMB_INVALID. */ static really_inline u32 mmbit_sparse_iter_exec(const u8 *bits, u32 key, u32 *idx, u32 level, const u32 max_level, struct mmbit_sparse_state *s, const struct mmbit_sparse_iter *it_root, const struct mmbit_sparse_iter *it) { for (;;) { MMB_TYPE block = s[level].mask; if (block) { u32 bit = mmb_ctz(block); key = (key << MMB_KEY_SHIFT) + bit; u32 bit_idx = mmbit_mask_index(bit, it->mask); if (level++ == max_level) { // we've found a key *idx = it->val + bit_idx; return key; } else { // iterator record is the start of the level (current it->val) // plus N, where N is the dense index of the bit in the current // level's itmask u32 iter_key = it->val + bit_idx; it = it_root + iter_key; MMB_TYPE nextblock = mmb_load(mmbit_get_level_root_const(bits, level) + key * sizeof(MMB_TYPE)); s[level].mask = nextblock & it->mask; s[level].itkey = iter_key; } } else { // No bits set in this block if (level-- == 0) { break; // no key available } key >>= MMB_KEY_SHIFT; // Update state mask and iterator s[level].mask &= (s[level].mask - 1); it = it_root + s[level].itkey; } } return MMB_INVALID; } static really_inline u32 mmbit_sparse_iter_begin_big(const u8 *bits, u32 total_bits, u32 *idx, const struct mmbit_sparse_iter *it_root, struct mmbit_sparse_state *s) { const struct mmbit_sparse_iter *it = it_root; u32 key = 0; MMB_TYPE block = mmb_load(bits) & it->mask; if (!block) { return MMB_INVALID; } // Load first block into top level state. const u32 max_level = mmbit_maxlevel(total_bits); s[0].mask = block; s[0].itkey = 0; return mmbit_sparse_iter_exec(bits, key, idx, 0, max_level, s, it_root, it); } /** \brief Specialisation of \ref mmbit_sparse_iter_begin for flat models. */ static really_inline u32 mmbit_sparse_iter_begin_flat(const u8 *bits, u32 total_bits, u32 *idx, const struct mmbit_sparse_iter *it_root, struct mmbit_sparse_state *s) { // Small cases have everything in the root iterator mask. if (total_bits <= MMB_KEY_BITS) { MMB_TYPE block = mmbit_get_flat_block(bits, total_bits); block &= it_root->mask; if (!block) { return MMB_INVALID; } s->mask = block; u32 key = mmb_ctz(block); *idx = mmbit_mask_index(key, it_root->mask); return key; } // Otherwise, the root iterator mask tells us which blocks (which we lay out // linearly in the flat model) could contain keys. assert(mmbit_maxlevel(total_bits) == 1); // Should only be two levels MMB_TYPE root = it_root->mask; for (; root; root &= (root - 1)) { u32 bit = mmb_ctz(root); u32 bit_idx = mmbit_mask_index(bit, it_root->mask); u32 iter_key = it_root->val + bit_idx; const struct mmbit_sparse_iter *it = it_root + iter_key; u32 block_key_min = bit * MMB_KEY_BITS; u32 block_key_max = block_key_min + MMB_KEY_BITS; MMB_TYPE block; if (block_key_max > total_bits) { block_key_max = total_bits; block = mmbit_get_flat_block(bits + (bit * sizeof(MMB_TYPE)), block_key_max - block_key_min); } else { block = mmb_load(bits + (bit * sizeof(MMB_TYPE))); } block &= it->mask; if (block) { s[0].mask = root; s[1].mask = block; s[1].itkey = iter_key; u32 key = mmb_ctz(block); *idx = it->val + mmbit_mask_index(key, it->mask); return key + block_key_min; } } return MMB_INVALID; } /** \brief Sparse iterator, find first key. * * Returns the first of the bits specified by the iterator \a it_root that is * on, and initialises the state \a s. If none of the bits specified by the * iterator are on, returns MMB_INVALID. */ static really_inline u32 mmbit_sparse_iter_begin(const u8 *bits, u32 total_bits, u32 *idx, const struct mmbit_sparse_iter *it_root, struct mmbit_sparse_state *s) { assert(ISALIGNED_N(it_root, alignof(struct mmbit_sparse_iter))); // Our state _may_ be on the stack assert(ISALIGNED_N(s, alignof(struct mmbit_sparse_state))); MDEBUG_PRINTF("%p total_bits %u\n", bits, total_bits); // iterator should have _something_ at the root level assert(it_root->mask != 0); u32 key; if (mmbit_is_flat_model(total_bits)) { key = mmbit_sparse_iter_begin_flat(bits, total_bits, idx, it_root, s); } else { key = mmbit_sparse_iter_begin_big(bits, total_bits, idx, it_root, s); } if (key != MMB_INVALID) { assert(key < total_bits); assert(mmbit_isset(bits, total_bits, key)); } return key; } static really_inline u32 mmbit_sparse_iter_next_big(const u8 *bits, u32 total_bits, u32 last_key, u32 *idx, const struct mmbit_sparse_iter *it_root, struct mmbit_sparse_state *s) { const u32 max_level = mmbit_maxlevel(total_bits); u32 key = last_key >> MMB_KEY_SHIFT; s[max_level].mask &= (s[max_level].mask - 1); const struct mmbit_sparse_iter *it = it_root + s[max_level].itkey; return mmbit_sparse_iter_exec(bits, key, idx, max_level, max_level, s, it_root, it); } /** \brief Specialisation of \ref mmbit_sparse_iter_next for flat models. */ static really_inline u32 mmbit_sparse_iter_next_flat(const u8 *bits, const u32 total_bits, u32 *idx, const struct mmbit_sparse_iter *it_root, struct mmbit_sparse_state *s) { if (total_bits <= MMB_KEY_BITS) { // All of our data is already in the s->mask, so we just need to scrape // off the next match. s->mask &= (s->mask - 1); if (s->mask) { u32 key = mmb_ctz(s->mask); *idx = mmbit_mask_index(key, it_root->mask); return key; } } else { assert(s[0].mask); s[1].mask &= (s[1].mask - 1); // Remove previous key from iter state. u32 bit = mmb_ctz(s[0].mask); // Flat block currently being accessed. for (;;) { if (s[1].mask) { u32 key = mmb_ctz(s[1].mask); const struct mmbit_sparse_iter *it = it_root + s[1].itkey; *idx = it->val + mmbit_mask_index(key, it->mask); key += (bit * MMB_KEY_BITS); return key; } // Otherwise, we have no keys left in this block. Consult the root // mask and find the next one. s[0].mask &= s[0].mask - 1; if (!s[0].mask) { break; } bit = mmb_ctz(s[0].mask); u32 bit_idx = mmbit_mask_index(bit, it_root->mask); u32 iter_key = it_root->val + bit_idx; const struct mmbit_sparse_iter *it = it_root + iter_key; u32 block_key_min = bit * MMB_KEY_BITS; u32 block_key_max = block_key_min + MMB_KEY_BITS; MMB_TYPE block; if (block_key_max > total_bits) { block_key_max = total_bits; block = mmbit_get_flat_block(bits + (bit * sizeof(MMB_TYPE)), block_key_max - block_key_min); } else { block = mmb_load(bits + (bit * sizeof(MMB_TYPE))); } s[1].mask = block & it->mask; s[1].itkey = iter_key; } } return MMB_INVALID; } /** \brief Sparse iterator, find next key. * * Takes in a sparse iterator tree structure \a it_root and a state array, and * finds the next on bit (from the set of bits specified in the iterator). * * NOTE: The sparse iterator stores copies of the multibit blocks in its state, * so it is not necessarily safe to set or unset bits in the multibit while * iterating: the changes you make may or may not be taken into account * by the iterator. */ static really_inline u32 mmbit_sparse_iter_next(const u8 *bits, u32 total_bits, u32 last_key, u32 *idx, const struct mmbit_sparse_iter *it_root, struct mmbit_sparse_state *s) { assert(ISALIGNED_N(it_root, alignof(struct mmbit_sparse_iter))); // Our state _may_ be on the stack assert(ISALIGNED_N(s, alignof(struct mmbit_sparse_state))); MDEBUG_PRINTF("%p total_bits %u\n", bits, total_bits); MDEBUG_PRINTF("NEXT (total_bits=%u, last_key=%u)\n", total_bits, last_key); UNUSED u32 last_idx = *idx; // for assertion at the end // our iterator should have _something_ at the root level assert(it_root->mask != 0); assert(last_key < total_bits); u32 key; if (mmbit_is_flat_model(total_bits)) { key = mmbit_sparse_iter_next_flat(bits, total_bits, idx, it_root, s); } else { key = mmbit_sparse_iter_next_big(bits, total_bits, last_key, idx, it_root, s); } if (key != MMB_INVALID) { MDEBUG_PRINTF("END NEXT: key=%u, idx=%u\n", key, *idx); assert(key < total_bits); assert(key > last_key); assert(mmbit_isset(bits, total_bits, key)); assert(*idx > last_idx); } else { MDEBUG_PRINTF("END NEXT: no more keys\n"); } return key; } /** \brief Specialisation of \ref mmbit_sparse_iter_unset for flat models. */ static really_inline void mmbit_sparse_iter_unset_flat(u8 *bits, u32 total_bits, const struct mmbit_sparse_iter *it_root) { if (total_bits <= MMB_KEY_BITS) { // Everything is in the root mask: we can just mask those bits off. MMB_TYPE block = mmbit_get_flat_block(bits, total_bits); block &= ~it_root->mask; mmb_store_partial(bits, block, total_bits); return; } // Larger case, we have two iterator levels to worry about. u32 bit_idx = 0; for (MMB_TYPE root = it_root->mask; root; root &= (root - 1), bit_idx++) { u32 bit = mmb_ctz(root); u32 block_key_min = bit * MMB_KEY_BITS; u32 block_key_max = block_key_min + MMB_KEY_BITS; u8 *block_ptr = bits + (bit * sizeof(MMB_TYPE)); u32 iter_key = it_root->val + bit_idx; const struct mmbit_sparse_iter *it = it_root + iter_key; if (block_key_max <= total_bits) { // Full-sized block. MMB_TYPE block = mmb_load(block_ptr); block &= ~it->mask; mmb_store(block_ptr, block); } else { // Runt (final) block. u32 num_bits = total_bits - block_key_min; MMB_TYPE block = mmbit_get_flat_block(block_ptr, num_bits); block &= ~it->mask; mmb_store_partial(block_ptr, block, num_bits); break; // We know this is the last block. } } } static really_inline void mmbit_sparse_iter_unset_big(u8 *bits, u32 total_bits, const struct mmbit_sparse_iter *it_root, struct mmbit_sparse_state *s) { const struct mmbit_sparse_iter *it = it_root; MMB_TYPE block = mmb_load(bits) & it->mask; if (!block) { return; } u32 key = 0; const u32 max_level = mmbit_maxlevel(total_bits); u32 level = 0; // Load first block into top level state s[level].mask = block; s[level].itkey = 0; for (;;) { block = s[level].mask; if (block) { if (level == max_level) { // bottom level block: we want to mask out the bits specified // by the iterator mask and then go back up a level. u8 *block_ptr = mmbit_get_level_root(bits, level) + key * sizeof(MMB_TYPE); MMB_TYPE real_block = mmb_load(block_ptr); real_block &= ~(it->mask); mmb_store(block_ptr, real_block); goto uplevel; // still cheap and nasty } else { u32 bit = mmb_ctz(block); key = (key << MMB_KEY_SHIFT) + bit; level++; // iterator record is the start of the level (current it->val) // plus N, where N is the dense index of the bit in the current // level's itmask u32 iter_key = it->val + mmbit_mask_index(bit, it->mask); it = it_root + iter_key; MMB_TYPE nextblock = mmb_load(mmbit_get_level_root_const(bits, level) + key * sizeof(MMB_TYPE)); s[level].mask = nextblock & it->mask; s[level].itkey = iter_key; } } else { uplevel: // No bits set in this block if (level == 0) { return; // we are done } u8 *block_ptr = mmbit_get_level_root(bits, level) + key * sizeof(MMB_TYPE); MMB_TYPE real_block = mmb_load(block_ptr); key >>= MMB_KEY_SHIFT; level--; if (real_block == 0) { // If we've zeroed our block For Real (unmasked by iterator), // we can clear the parent bit that led us to it, so that // we don't go down this particular garden path again later. u32 bit = mmb_ctz(s[level].mask); u8 *parent_ptr = mmbit_get_level_root(bits, level) + key * sizeof(MMB_TYPE); MMB_TYPE parent_block = mmb_load(parent_ptr); mmb_clear(&parent_block, bit); mmb_store(parent_ptr, parent_block); } // Update state mask and iterator s[level].mask &= (s[level].mask - 1); it = it_root + s[level].itkey; } } } /** \brief Sparse iterator, unset all bits. * * Takes in a sparse iterator tree structure and switches off any entries found * therein. */ static really_inline void mmbit_sparse_iter_unset(u8 *bits, u32 total_bits, const struct mmbit_sparse_iter *it, struct mmbit_sparse_state *s) { assert(ISALIGNED_N(it, alignof(struct mmbit_sparse_iter))); // Our state _may_ be on the stack assert(ISALIGNED_N(s, alignof(struct mmbit_sparse_state))); MDEBUG_PRINTF("%p total_bits %u\n", bits, total_bits); #ifdef MMB_TRACE_WRITES MMB_TRACE("ITER-UNSET iter=["); mmbit_sparse_iter_dump(it, total_bits); printf("] actually on=["); struct mmbit_sparse_state tmp[MAX_SPARSE_ITER_STATES]; u32 idx = 0; u32 i = mmbit_sparse_iter_begin(bits, total_bits, &idx, it, tmp); for (; i != MMB_INVALID; i = mmbit_sparse_iter_next(bits, total_bits, i, &idx, it, tmp)) { printf(" %u", i); } printf("]\n"); #endif if (mmbit_is_flat_model(total_bits)) { mmbit_sparse_iter_unset_flat(bits, total_bits, it); } else { mmbit_sparse_iter_unset_big(bits, total_bits, it, s); } } #ifdef __cplusplus } // extern "C" #endif #endif // MULTIBIT_H hyperscan-4.4.1/src/util/masked_move.c0000644000175000017500000001313513055426554020504 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ #include "ue2common.h" #include "masked_move.h" #if defined(__AVX2__) /* masks for masked moves */ /* magic mask for maskload (vmmaskmovq) - described in UE-2424 */ const ALIGN_CL_DIRECTIVE u32 mm_mask_mask[16] = { 0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U, 0x00000000U, 0xff000000U, 0xfe000000U, 0xfc000000U, 0xf8000000U, 0xf0000000U, 0xe0000000U, 0xc0000000U, 0x80000000U, }; const u32 mm_shuffle_end[32][8] = { { 0x03020100U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x02010080U, 0x80808003U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x01008080U, 0x80800302U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x00808080U, 0x80030201U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x03020100U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x02010080U, 0x80808003U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x01008080U, 0x80800302U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x00808080U, 0x80030201U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x03020100U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x02010080U, 0x80808003U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x01008080U, 0x80800302U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x00808080U, 0x80030201U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x03020100U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x02010080U, 0x80808003U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x01008080U, 0x80800302U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x00808080U, 0x80030201U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x03020100U, 0x80808080U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x02010080U, 0x80808003U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x01008080U, 0x80800302U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x00808080U, 0x80030201U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x03020100U, 0x80808080U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x02010080U, 0x80808003U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x01008080U, 0x80800302U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x00808080U, 0x80030201U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x03020100U, 0x80808080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x02010080U, 0x80808003U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x01008080U, 0x80800302U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x00808080U, 0x80030201U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x03020100U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x02010080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x01008080U, }, { 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x80808080U, 0x00808080U, }, }; #endif // AVX2 hyperscan-4.4.1/src/util/fatbit_build.h0000644000175000017500000000351213055426554020645 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Fatbit: build code */ #ifndef FATBIT_BUILD_H #define FATBIT_BUILD_H #include "ue2common.h" namespace ue2 { /** * \brief Return the size in bytes of a fatbit that can store the given * number of bits. */ u32 fatbit_size(u32 total_bits); } // namespace ue2 #endif // FATBIT_BUILD_H hyperscan-4.4.1/src/util/dump_charclass.h0000644000175000017500000000502713055426554021210 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Dump code for character classes (expressed as CharReach objects). */ #ifndef DUMP_CHARCLASS_H #define DUMP_CHARCLASS_H #include "ue2common.h" #include #include #include #include namespace ue2 { enum cc_output_t { CC_OUT_TEXT, //!< unescaped text output CC_OUT_DOT //!< escaped DOT label output }; class CharReach; void describeClass(std::ostream &os, const CharReach &cr, size_t maxLength = 16, enum cc_output_t out_type = CC_OUT_TEXT); std::string describeClass(const CharReach &cr, size_t maxLength = 16, enum cc_output_t out_type = CC_OUT_TEXT); std::string describeClasses(const std::vector &v, size_t maxClassLength = 16, enum cc_output_t out_type = CC_OUT_TEXT); void describeClass(FILE *f, const CharReach &cr, size_t maxLength, enum cc_output_t out_type); } // namespace ue2 #endif // DUMP_CHARCLASS_H hyperscan-4.4.1/src/util/unaligned.h0000644000175000017500000000651613055426554020172 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Helper functions for unaligned loads and stores. */ #ifndef UNALIGNED_H #define UNALIGNED_H #include "ue2common.h" #if !defined(_WIN32) #define PACKED__MAY_ALIAS __attribute__((packed, may_alias)) #else #define PACKED__MAY_ALIAS #pragma pack(push, 1) // pack everything until told otherwise #endif /// Perform an unaligned 16-bit load static really_inline u16 unaligned_load_u16(const void *ptr) { struct unaligned { u16 u; } PACKED__MAY_ALIAS; const struct unaligned *uptr = (const struct unaligned *)ptr; return uptr->u; } /// Perform an unaligned 32-bit load static really_inline u32 unaligned_load_u32(const void *ptr) { struct unaligned { u32 u; } PACKED__MAY_ALIAS; const struct unaligned *uptr = (const struct unaligned *)ptr; return uptr->u; } /// Perform an unaligned 64-bit load static really_inline u64a unaligned_load_u64a(const void *ptr) { struct unaligned { u64a u; } PACKED__MAY_ALIAS; const struct unaligned *uptr = (const struct unaligned *)ptr; return uptr->u; } /// Perform an unaligned 16-bit store static really_inline void unaligned_store_u16(void *ptr, u16 val) { struct unaligned { u16 u; } PACKED__MAY_ALIAS; struct unaligned *uptr = (struct unaligned *)ptr; uptr->u = val; } /// Perform an unaligned 32-bit store static really_inline void unaligned_store_u32(void *ptr, u32 val) { struct unaligned { u32 u; } PACKED__MAY_ALIAS; struct unaligned *uptr = (struct unaligned *)ptr; uptr->u = val; } /// Perform an unaligned 64-bit store static really_inline void unaligned_store_u64a(void *ptr, u64a val) { struct unaligned { u64a u; } PACKED__MAY_ALIAS; struct unaligned *uptr = (struct unaligned *)ptr; uptr->u = val; } #if defined(_WIN32) #pragma pack(pop) #endif // win32 #undef PACKED__MAY_ALIAS #endif // UNALIGNED_H hyperscan-4.4.1/src/util/multibit.c0000644000175000017500000001036313055426554020043 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Multibit: lookup tables and support code. * * This C file contains the constant tables used by multibit, so we don't end * up creating copies of them for every unit that uses it. */ #include "multibit.h" #include "ue2common.h" const u8 mmbit_keyshift_lut[32] = { 30, 30, 24, 24, 24, 24, 24, 24, 18, 18, 18, 18, 18, 18, 12, 12, 12, 12, 12, 12, 6, 6, 6, 6, 6, 6, 0, 0, 0, 0, 0, 0 }; // The only actually valid values of ks are as shown in the LUT above, but a // division is just too expensive. const u8 mmbit_maxlevel_from_keyshift_lut[32] = { 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5 }; const u8 mmbit_maxlevel_direct_lut[32] = { 5, 5, 4, 4, 4, 4, 4, 4, 3, 3, 3, 3, 3, 3, 2, 2, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0 }; #define ZERO_TO_LUT(x) ((1ULL << x) - 1) const u64a mmbit_zero_to_lut[65] = { ZERO_TO_LUT(0), ZERO_TO_LUT(1), ZERO_TO_LUT(2), ZERO_TO_LUT(3), ZERO_TO_LUT(4), ZERO_TO_LUT(5), ZERO_TO_LUT(6), ZERO_TO_LUT(7), ZERO_TO_LUT(8), ZERO_TO_LUT(9), ZERO_TO_LUT(10), ZERO_TO_LUT(11), ZERO_TO_LUT(12), ZERO_TO_LUT(13), ZERO_TO_LUT(14), ZERO_TO_LUT(15), ZERO_TO_LUT(16), ZERO_TO_LUT(17), ZERO_TO_LUT(18), ZERO_TO_LUT(19), ZERO_TO_LUT(20), ZERO_TO_LUT(21), ZERO_TO_LUT(22), ZERO_TO_LUT(23), ZERO_TO_LUT(24), ZERO_TO_LUT(25), ZERO_TO_LUT(26), ZERO_TO_LUT(27), ZERO_TO_LUT(28), ZERO_TO_LUT(29), ZERO_TO_LUT(30), ZERO_TO_LUT(31), ZERO_TO_LUT(32), ZERO_TO_LUT(33), ZERO_TO_LUT(34), ZERO_TO_LUT(35), ZERO_TO_LUT(36), ZERO_TO_LUT(37), ZERO_TO_LUT(38), ZERO_TO_LUT(39), ZERO_TO_LUT(40), ZERO_TO_LUT(41), ZERO_TO_LUT(42), ZERO_TO_LUT(43), ZERO_TO_LUT(44), ZERO_TO_LUT(45), ZERO_TO_LUT(46), ZERO_TO_LUT(47), ZERO_TO_LUT(48), ZERO_TO_LUT(49), ZERO_TO_LUT(50), ZERO_TO_LUT(51), ZERO_TO_LUT(52), ZERO_TO_LUT(53), ZERO_TO_LUT(54), ZERO_TO_LUT(55), ZERO_TO_LUT(56), ZERO_TO_LUT(57), ZERO_TO_LUT(58), ZERO_TO_LUT(59), ZERO_TO_LUT(60), ZERO_TO_LUT(61), ZERO_TO_LUT(62), ZERO_TO_LUT(63), ~0ULL }; const u32 mmbit_root_offset_from_level[7] = { 0, 1, 1 + (1 << MMB_KEY_SHIFT), 1 + (1 << MMB_KEY_SHIFT) + (1 << MMB_KEY_SHIFT * 2), 1 + (1 << MMB_KEY_SHIFT) + (1 << MMB_KEY_SHIFT * 2) + (1 << MMB_KEY_SHIFT * 3), 1 + (1 << MMB_KEY_SHIFT) + (1 << MMB_KEY_SHIFT * 2) + (1 << MMB_KEY_SHIFT * 3) + (1 << MMB_KEY_SHIFT * 4), 1 + (1 << MMB_KEY_SHIFT) + (1 << MMB_KEY_SHIFT * 2) + (1 << MMB_KEY_SHIFT * 3) + (1 << MMB_KEY_SHIFT * 4) + (1 << MMB_KEY_SHIFT * 5), }; hyperscan-4.4.1/src/util/depth.h0000644000175000017500000001607013055426554017324 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Data types used to represent depth quantities. */ #ifndef DEPTH_H #define DEPTH_H #include "ue2common.h" #ifdef DUMP_SUPPORT #include #endif #include namespace ue2 { /** * \brief Exception thrown if a depth operation overflows. */ struct DepthOverflowError {}; /** * \brief Type used to represent depth information; value is either a count, * or the special values "infinity" and "unreachable". */ class depth { public: depth() : val(val_unreachable) {} depth(u32 v) : val(v) { if (v > max_value()) { DEBUG_PRINTF("depth %u too large to represent!\n", v); throw DepthOverflowError(); } } static depth unreachable() { depth d; d.val = val_unreachable; return d; } static depth infinity() { depth d; d.val = val_infinity; return d; } /** \brief Returns the max finite value representable as a depth. */ static constexpr u32 max_value() { return val_infinity - 1; } bool is_finite() const { return val < val_infinity; } bool is_infinite() const { return val == val_infinity; } bool is_unreachable() const { return val == val_unreachable; } bool is_reachable() const { return !is_unreachable(); } /** \brief Convert a finite depth to an integer. */ operator u32() const { if (!is_finite()) { throw DepthOverflowError(); } return val; } bool operator<(const depth &d) const { return val < d.val; } bool operator>(const depth &d) const { return val > d.val; } bool operator<=(const depth &d) const { return val <= d.val; } bool operator>=(const depth &d) const { return val >= d.val; } bool operator==(const depth &d) const { return val == d.val; } bool operator!=(const depth &d) const { return val != d.val; } // The following comparison operators exist for use against integer types // that are bigger than what we can safely convert to depth (such as those // in extparam). bool operator<(u64a d) const { if (!is_finite()) { return false; } return val < d; } bool operator<=(u64a d) const { if (!is_finite()) { return false; } return val <= d; } bool operator==(u64a d) const { if (!is_finite()) { return false; } return val == d; } bool operator>(u64a d) const { return !(*this <= d); } bool operator>=(u64a d) const { return !(*this < d); } bool operator!=(u64a d) const { return !(*this == d); } depth operator+(const depth &d) const { if (is_unreachable() || d.is_unreachable()) { return unreachable(); } if (is_infinite() || d.is_infinite()) { return infinity(); } u64a rv = val + d.val; if (rv >= val_infinity) { DEBUG_PRINTF("depth %llu too large to represent!\n", rv); throw DepthOverflowError(); } return depth((u32)rv); } depth &operator+=(const depth &d) { depth rv = *this + d; *this = rv; return *this; } depth operator-(const depth &d) const { if (!d.is_finite()) { throw DepthOverflowError(); } if (is_unreachable()) { return unreachable(); } if (is_infinite()) { return infinity(); } if (val < d.val) { throw DepthOverflowError(); } u32 rv = val - d.val; return depth(rv); } depth &operator-=(const depth &d) { depth rv = *this - d; *this = rv; return *this; } depth operator+(s32 d) const { if (is_unreachable()) { return unreachable(); } if (is_infinite()) { return infinity(); } s64a rv = val + d; if (rv < 0 || (u64a)rv >= val_infinity) { DEBUG_PRINTF("depth %lld too large to represent!\n", rv); throw DepthOverflowError(); } return depth((u32)rv); } depth operator+=(s32 d) { depth rv = *this + d; *this = rv; return *this; } #ifdef DUMP_SUPPORT /** \brief Render as a string, useful for debugging. */ std::string str() const; #endif friend size_t hash_value(const depth &d) { return d.val; } private: static constexpr u32 val_infinity = (1u << 31) - 1; static constexpr u32 val_unreachable = 1u << 31; u32 val; }; /** * \brief Encapsulates a min/max pair. */ struct DepthMinMax { depth min; depth max; DepthMinMax() : min(depth::infinity()), max(depth(0)) {} DepthMinMax(const depth &mn, const depth &mx) : min(mn), max(mx) {} bool operator<(const DepthMinMax &b) const { if (min != b.min) { return min < b.min; } return max < b.max; } bool operator==(const DepthMinMax &b) const { return min == b.min && max == b.max; } bool operator!=(const DepthMinMax &b) const { return !(*this == b); } #ifdef DUMP_SUPPORT /** \brief Render as a string, useful for debugging. */ std::string str() const; #endif }; inline size_t hash_value(const DepthMinMax &d) { size_t val = 0; boost::hash_combine(val, d.min); boost::hash_combine(val, d.max); return val; } /** * \brief Merge two DepthMinMax values together to produce their union. */ DepthMinMax unionDepthMinMax(const DepthMinMax &a, const DepthMinMax &b); } // namespace ue2 #endif // DEPTH_H hyperscan-4.4.1/src/util/charreach.h0000644000175000017500000001461513055426554020143 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Class for representing character reachability. * * This is a simple (but hopefully fast) class for representing 8-bit character * reachability, along with a bunch of useful operations. */ #ifndef NG_CHARREACH_H #define NG_CHARREACH_H #include "ue2common.h" #include "util/bitfield.h" #include namespace ue2 { class CharReach { private: /// Underlying storage. ue2::bitfield<256> bits; public: static constexpr size_t npos = decltype(bits)::npos; //!< One past the max value. /// Empty constructor. CharReach() {} /// Constructor for a character class containing a single char. explicit CharReach(unsigned char c) { set(c); } /// Constructor for a character class representing a contiguous range of /// chars, inclusive. CharReach(unsigned char from, unsigned char to) { setRange(from, to); } /// Constructor for a character class based on the set of chars in a /// string. explicit CharReach(const std::string &str) { set(str); } /// Returns total capacity. static constexpr size_t size() { return npos; } /// Returns a CharReach with complete reachability (a "dot"). static CharReach dot() { return CharReach(0, 255); } /// Complete bitset equality. bool operator==(const CharReach &a) const { return bits == a.bits; } /// Inequality. bool operator!=(const CharReach &a) const { return bits != a.bits; } /// Ordering. bool operator<(const CharReach &a) const { return bits < a.bits; } /// Set all bits. void setall() { bits.setall(); } /// Clear all bits. void clear() { bits.clear(); } /// Clear bit N. void clear(unsigned char n) { bits.clear(n); } /// Set bit N. void set(unsigned char n) { bits.set(n); } /// Test bit N. bool test(unsigned char n) const { return bits.test(n); } /// Flip bit N. void flip(unsigned char n) { bits.flip(n); } /// Flip all bits. void flip() { bits.flip(); } // Switch on the bit in the range (from, to), inclusive. void setRange(unsigned char from, unsigned char to) { bits.set_range(from, to); } // Switch on the bits corresponding to the characters in \a s. void set(const std::string &s); /// Returns number of bits set on. size_t count() const { return bits.count(); } /// Are no bits set? bool none() const { return bits.none(); } /// Is any bit set? bool any() const { return bits.any(); } /// Are all bits set? bool all() const { return bits.all(); } /// Returns first bit set, or CharReach::npos if none set. size_t find_first() const { return bits.find_first(); } /// Returns last bit set, or CharReach::npos if none set. size_t find_last() const { return bits.find_last(); } /// Returns next bit set, or CharReach::npos if none set after n. size_t find_next(size_t last) const { return bits.find_next(last); } /// Returns (zero-based) N'th bit set, or CharReach::npos if fewer than /// N + 1 bits are on. size_t find_nth(size_t n) const { return bits.find_nth(n); } /// Bitwise OR. CharReach operator|(const CharReach &a) const { CharReach cr(*this); cr.bits |= a.bits; return cr; } /// Bitwise OR-equals. void operator|=(const CharReach &a) { bits |= a.bits; } /// Bitwise AND. CharReach operator&(const CharReach &a) const { CharReach cr(*this); cr.bits &= a.bits; return cr; } /// Bitwise AND-equals. void operator&=(const CharReach &a) { bits &= a.bits; } /// Bitwise XOR. CharReach operator^(const CharReach &a) const { CharReach cr(*this); cr.bits ^= a.bits; return cr; } /// Bitwise complement. CharReach operator~(void) const { CharReach cr(*this); cr.flip(); return cr; } /// Do we only contain bits representing alpha characters? bool isAlpha() const; /// Do we represent an uppercase/lowercase pair? bool isCaselessChar() const; /// Do we represent a cheapskate caseless set? bool isBit5Insensitive() const; /// Return a string containing the characters that are switched on. std::string to_string() const; /// Hash of enabled bits. size_t hash() const { return bits.hash(); } /// True if this character class is a subset of \a other. bool isSubsetOf(const CharReach &other) const; }; /** \brief True iff there is a non-empty intersection between \a and \a b */ bool overlaps(const CharReach &a, const CharReach &b); /** \brief True iff \a small is a subset of \a big. */ bool isSubsetOf(const CharReach &small, const CharReach &big); bool isutf8ascii(const CharReach &cr); bool isutf8start(const CharReach &cr); /** \brief Boost-style hash free function. */ static really_inline size_t hash_value(const CharReach &cr) { return cr.hash(); } } // namespace ue2 #endif // NG_CHARREACH_H hyperscan-4.4.1/src/util/masked_move.h0000644000175000017500000000536213055426554020514 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MASKED_MOVE_H #define MASKED_MOVE_H #if defined(__AVX2__) #include "unaligned.h" #include "simd_utils.h" #ifdef __cplusplus extern "C" { #endif extern const u32 mm_mask_mask[16]; extern const u32 mm_shuffle_end[32][8]; #ifdef __cplusplus } #endif /* load mask for len bytes from start of buffer */ static really_inline m256 _get_mm_mask_end(u32 len) { assert(len <= 32); const u8 *masky = (const u8 *)mm_mask_mask; m256 mask = load256(masky + 32); mask = _mm256_sll_epi32(mask, _mm_cvtsi32_si128(8 - (len >> 2))); return mask; } /* * masked_move256_len: Will load len bytes from *buf into m256 * _______________________________ * |0<----len---->| 32| * ------------------------------- */ static really_inline m256 masked_move256_len(const u8 *buf, const u32 len) { assert(len >= 4); m256 lmask = _get_mm_mask_end(len); u32 end = unaligned_load_u32(buf + len - 4); m256 preshufend = _mm256_broadcastq_epi64(_mm_cvtsi32_si128(end)); m256 v = _mm256_maskload_epi32((const int *)buf, lmask); m256 shufend = vpshufb(preshufend, loadu256(&mm_shuffle_end[len - 4])); m256 target = or256(v, shufend); return target; } #endif /* AVX2 */ #endif /* MASKED_MOVE_H */ hyperscan-4.4.1/src/util/simd_types.h0000644000175000017500000000510213055426554020372 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 SIMD_TYPES_H #define SIMD_TYPES_H #include "config.h" #include "ue2common.h" // more recent headers are bestest, but only if we can use them #ifdef __cplusplus # if defined(HAVE_CXX_X86INTRIN_H) # define USE_X86INTRIN_H # endif #else // C # if defined(HAVE_C_X86INTRIN_H) # define USE_X86INTRIN_H # endif #endif #ifdef __cplusplus # if defined(HAVE_CXX_INTRIN_H) # define USE_INTRIN_H # endif #else // C # if defined(HAVE_C_INTRIN_H) # define USE_INTRIN_H # endif #endif #if defined(USE_X86INTRIN_H) #include #elif defined(USE_INTRIN_H) #include #else #error no intrinsics! #endif #if defined(__SSE2__) || defined(_M_X64) || (_M_IX86_FP >= 2) typedef __m128i m128; #else typedef struct ALIGN_DIRECTIVE {u64a hi; u64a lo;} m128; #endif #if defined(__AVX2__) typedef __m256i m256; #else typedef ALIGN_AVX_DIRECTIVE struct {m128 lo; m128 hi;} m256; #endif // these should align to 16 and 32 respectively typedef struct {m128 lo; m128 mid; m128 hi;} m384; typedef struct {m256 lo; m256 hi;} m512; #endif /* SIMD_TYPES_H */ hyperscan-4.4.1/src/util/compile_context.h0000644000175000017500000000437413055426554021420 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Global compile context, describes compile environment. */ #ifndef COMPILE_CONTEXT_H #define COMPILE_CONTEXT_H #include "target_info.h" #include "grey.h" namespace ue2 { /** \brief Structure for describing the compile environment: grey box settings, * target arch, mode flags, etc. */ struct CompileContext { CompileContext(bool isStreaming, bool isVectored, const target_t &target_info, const Grey &grey); const bool streaming; /* streaming or vectored mode */ const bool vectored; /** \brief Target platform info. */ const target_t target_info; /** \brief Greybox structure, allows tuning of all sorts of behaviour. */ const Grey grey; }; } // namespace ue2 #endif hyperscan-4.4.1/src/util/dump_util.h0000644000175000017500000000334713055426554020225 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 DUMP_UTIL #define DUMP_UTIL #include /** * Same as fopen(), but on error throws an exception rather than returning NULL. */ FILE *fopen_or_throw(const char *path, const char *mode); #endif hyperscan-4.4.1/src/util/dump_charclass.cpp0000644000175000017500000001720113055426554021540 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Dump code for character classes (expressed as CharReach objects). */ #include "config.h" // Everything in this file is dump code #if defined(DUMP_SUPPORT) #include "charreach.h" #include "dump_charclass.h" #include #include #include #include using std::string; using std::ostream; namespace ue2 { static void describeChar(ostream &os, char c, enum cc_output_t out_type) { // these characters must always be escaped static const string escaped("^-[]."); static const string dot_single_escaped("\"\'"); const string backslash((out_type == CC_OUT_DOT ? 2 : 1), '\\'); if (isgraph(c) && c != '\\') { if (escaped.find(c) != string::npos) { os << backslash << c; } else if (out_type == CC_OUT_DOT && dot_single_escaped.find(c) != string::npos) { os << '\\' << c; } else { os << c; } } else if (c == 0x09) { os << backslash << 't'; } else if (c == 0x0a) { os << backslash << 'n'; } else if (c == 0x0d) { os << backslash << 'r'; } else { auto fmt(os.flags()); os << backslash << 'x' << std::hex << std::setw(2) << std::setfill('0') << (unsigned)(c & 0xff); os.flags(fmt); } } static void describeRange(ostream &os, unsigned char c1, unsigned char c2, enum cc_output_t out_type) { assert(c1 <= c2); if (c1 == c2) { describeChar(os, (char)c1, out_type); } else if (c2 - c1 < 4) { // render as individual chars do { describeChar(os, (char)c1, out_type); } while (c1++ != c2); } else { // range describeChar(os, (char)c1, out_type); os << '-'; describeChar(os, (char)c2, out_type); } } static bool extractMnemonic(ostream &os, CharReach &cr, enum cc_output_t out_type) { const string backslash((out_type == CC_OUT_DOT ? 2 : 1), '\\'); // \w (word characters: any letter, digit, or underscore) static const CharReach words(string("_0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWYXZ")); if (words == (cr & words)) { cr &= ~words; os << backslash << 'w'; return true; } // \d (digits) static const CharReach digits(string("0123456789")); if (digits == (cr & digits)) { cr &= ~digits; os << backslash << 'd'; return true; } // \s (whitespace) static const CharReach whitespace(string("\x09\x0a\x0b\x0c\x0d\x20", 6)); if (whitespace == (cr & whitespace)) { cr &= ~whitespace; os << backslash << 's'; return true; } return false; } static bool isContiguous(const CharReach &cr, size_t &first, size_t &last) { first = cr.find_first(); size_t c = first; while (c != CharReach::npos) { last = c; c = cr.find_next(c); if (c == CharReach::npos) { break; } if (c != last + 1) { return false; } } return true; } static size_t describeClassInt(ostream &os, const CharReach &incr, size_t maxLength, enum cc_output_t out_type) { // Approx size of output size_t i = 0; // one we can break CharReach cr(incr); // If we can be rendered as a single range, do it size_t first = 0, last = 0; if (isContiguous(cr, first, last)) { describeRange(os, first, last, out_type); i = 2; return i; } // Extract any mnemonics while (extractMnemonic(os, cr, out_type)) { if (++i == maxLength) { os << "...]"; return maxLength; } } if (cr.none()) { // all mnemonics, all the time return i; } // Render charclass as a series of ranges size_t c_start = cr.find_first(); size_t c = c_start, c_last = 0; while (c != CharReach::npos) { c_last = c; c = cr.find_next(c); if (c != c_last + 1 || c_last == 0xff) { describeRange(os, c_start, c_last, out_type); c_start = c; if (++i == maxLength && c != CharReach::npos) { os << "...]"; return maxLength; } } } return i; } //// //// Functions exported outside this unit. //// // C++ iostreams interface void describeClass(ostream &os, const CharReach &incr, size_t maxLength, enum cc_output_t out_type) { if (incr.all()) { os << ""; return; } if (incr.none()) { os << ""; return; } if (incr.count() == 1) { describeChar(os, (char)incr.find_first(), out_type); return; } if ((~incr).count() == 1) { os << "[^"; describeChar(os, (char)(~incr).find_first(), out_type); os << ']'; return; } // build up a normal string and a negated one, and see which is shorter std::ostringstream out; int out_count = describeClassInt(out, incr, maxLength, out_type); std::ostringstream neg; UNUSED int neg_count = describeClassInt(neg, ~incr, maxLength, out_type); if (out.tellp() <= neg.tellp()) { if (out_count > 1) { os << '[' << out.str() << ']'; } else { os << out.str(); } } else { // TODO: negated single mnemonics os << "[^" << neg.str() << ']'; } } // Version that returns a string, for convenience. string describeClass(const CharReach &cr, size_t maxLength, enum cc_output_t out_type) { std::ostringstream oss; describeClass(oss, cr, maxLength, out_type); return oss.str(); } string describeClasses(const std::vector &v, size_t maxClassLength, enum cc_output_t out_type) { std::ostringstream oss; for (const auto &cr : v) { describeClass(oss, cr, maxClassLength, out_type); } return oss.str(); } // C stdio wrapper void describeClass(FILE *f, const CharReach &cr, size_t maxLength, enum cc_output_t out_type) { fprintf(f, "%s", describeClass(cr, maxLength, out_type).c_str()); } } // namespace ue2 #endif // DUMP_SUPPORT hyperscan-4.4.1/src/util/container.h0000644000175000017500000001522313055426554020201 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Convenience template functions for containers. */ #ifndef UTIL_CONTAINER_H #define UTIL_CONTAINER_H #include "ue2common.h" #include #include #include #include #include #include #include namespace ue2 { // Existence check for associative containers. template bool contains(const C &container, const typename C::key_type &key) { return container.find(key) != container.end(); } template bool contains_any_of(const C &container, const std::pair &range) { return std::find_first_of(range.first, range.second, container.begin(), container.end()) != range.second; } template void insert(C *container, const std::pair &range) { container->insert(range.first, range.second); } template void insert(C *container, typename C::iterator pos, const std::pair &range) { container->insert(pos, range.first, range.second); } template void insert(C *container, const D &donor) { container->insert(donor.begin(), donor.end()); } template void insert(C *container, typename C::iterator pos, const D &donor) { container->insert(pos, donor.begin(), donor.end()); } /** * \brief Constructs a vector from a range bounded by the given pair of * iterators. */ template auto make_vector_from(const std::pair &range) -> std::vector { using T = decltype(*range.first); return std::vector(range.first, range.second); } /** \brief Returns a set containing the keys in the given associative * container. */ template std::set assoc_keys(const C &container) { std::set keys; for (const auto &elem : container) { keys.insert(elem.first); } return keys; } /** * \brief Return the length in bytes of the given vector of (POD) objects. */ template typename std::vector::size_type byte_length(const std::vector &vec) { static_assert(std::is_pod::value, "should be pod"); return vec.size() * sizeof(T); } /** * \brief Copy the given vector of POD objects to the given location in memory. * It is safe to give this function an empty vector. */ template void *copy_bytes(void *dest, const std::vector &vec) { static_assert(std::is_pod::value, "should be pod"); assert(dest); // Since we're generally using this function to write into the bytecode, // dest should be appropriately aligned for T. assert(ISALIGNED_N(dest, alignof(T))); if (vec.empty()) { return dest; // Protect memcpy against null pointers. } assert(vec.data() != nullptr); return std::memcpy(dest, vec.data(), byte_length(vec)); } template bool is_subset_of(const OrderedContainer1 &small, const OrderedContainer2 &big) { static_assert(std::is_same::value, "Both containers should have the same value_type"); auto sit = small.begin(); auto bit = big.begin(); if (small.size() > big.size()) { return false; } while (sit != small.end()) { if (bit == big.end()) { return false; } if (*sit == *bit) { ++sit; ++bit; continue; } if (*bit < *sit) { ++bit; continue; } return false; } return true; } template bool has_intersection(const OrderedContainer1 &a, const OrderedContainer2 &b) { static_assert(std::is_same::value, "Both containers should have the same value_type"); auto ait = a.begin(); auto bit = b.begin(); while (ait != a.end() && bit != b.end()) { if (*ait == *bit) { return true; } if (*ait < *bit) { ++ait; } else { ++bit; } } return false; } /** * \brief Erase the elements (by value) in the donor container from the given * container. */ template void erase_all(C *container, const D &donor) { for (const auto &elem : donor) { container->erase(elem); } } } // namespace ue2 #ifdef DUMP_SUPPORT #include #include namespace ue2 { /** * \brief Dump a container of stream-printable objects into a comma-separated * list in a string. */ template std::string as_string_list(const C &c) { std::ostringstream oss; for (auto it = c.begin(); it != c.end(); ++it) { if (it != c.begin()) { oss << ", "; } oss << *it; } return oss.str(); } } // namespace ue2 #endif // DUMP_SUPPORT #endif // UTIL_CONTAINER_H hyperscan-4.4.1/src/util/report_manager.cpp0000644000175000017500000001760513055426554021565 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief ReportManager: tracks Report structures, exhaustion and dedupe keys. */ #include "grey.h" #include "report_manager.h" #include "ue2common.h" #include "nfagraph/ng.h" #include "rose/rose_build.h" #include "util/compile_error.h" #include "util/container.h" #include #include #include #include using namespace std; namespace ue2 { ReportManager::ReportManager(const Grey &g) : grey(g), freeEIndex(0), global_exhaust(true) {} u32 ReportManager::getInternalId(const Report &ir) { auto it = reportIdToInternalMap.find(ir); if (it != reportIdToInternalMap.end()) { DEBUG_PRINTF("existing report %zu\n", it->second); return it->second; } // Construct a new internal report and assign it a ReportID. if (numReports() >= grey.limitReportCount) { throw ResourceLimitError(); } u32 size = reportIds.size(); reportIds.push_back(ir); reportIdToInternalMap[ir] = size; DEBUG_PRINTF("new report %u\n", size); return size; } const Report &ReportManager::getReport(u32 id) const { assert(id < reportIds.size()); return reportIds.at(id); } size_t ReportManager::numReports() const { return reportIds.size(); } u32 ReportManager::getExhaustibleKey(u32 a) { auto it = toExhaustibleKeyMap.find(a); if (it == toExhaustibleKeyMap.end()) { // get size before assigning to avoid wacky LHS shenanigans u32 size = toExhaustibleKeyMap.size(); bool inserted; tie(it, inserted) = toExhaustibleKeyMap.emplace(s64a{a}, size); assert(inserted); } DEBUG_PRINTF("%lld -> ekey %u\n", it->first, it->second); return it->second; } u32 ReportManager::getUnassociatedExhaustibleKey(void) { u32 rv = toExhaustibleKeyMap.size(); bool inserted; map::const_iterator it; tie(it, inserted) = toExhaustibleKeyMap.emplace(--freeEIndex, rv); assert(inserted); assert(it->second == rv); return rv; } u32 ReportManager::numDkeys() const { DEBUG_PRINTF("%zu dkeys\n", reportIdToDedupeKey.size()); return reportIdToDedupeKey.size(); } u32 ReportManager::numEkeys() const { return (u32) toExhaustibleKeyMap.size(); } bool ReportManager::patternSetCanExhaust() const { return global_exhaust && !toExhaustibleKeyMap.empty(); } vector ReportManager::getDkeyToReportTable() const { vector rv(reportIdToDedupeKey.size()); for (const auto &m : reportIdToDedupeKey) { assert(m.second < rv.size()); rv[m.second] = m.first; } return rv; } void ReportManager::assignDkeys(const RoseBuild *rose) { DEBUG_PRINTF("assigning...\n"); map> ext_to_int; for (u32 i = 0; i < reportIds.size(); i++) { const Report &ir = reportIds[i]; /* need to populate dkey */ if (isExternalReport(ir)) { ext_to_int[ir.onmatch].insert(i); } } auto dedupe = rose->generateDedupeAux(); for (const auto &m : ext_to_int) { u32 ext = m.first; if (!dedupe->requiresDedupeSupport(m.second)) { DEBUG_PRINTF("%u does not require dedupe\n", ext); continue; /* no dedupe required for this set */ } u32 dkey = reportIdToDedupeKey.size(); reportIdToDedupeKey[ext] = dkey; DEBUG_PRINTF("ext=%u -> dkey=%u\n", ext, dkey); } } u32 ReportManager::getDkey(const Report &r) const { if (!isExternalReport(r)) { return ~u32{0}; } auto it = reportIdToDedupeKey.find(r.onmatch); if (it == reportIdToDedupeKey.end()) { return ~u32{0}; } return it->second; } void ReportManager::registerExtReport(ReportID id, const external_report_info &ext) { if (contains(externalIdMap, id)) { const external_report_info &eri = externalIdMap.at(id); if (eri.highlander != ext.highlander) { /* we have a problem */ ostringstream out; out << "Expression (index " << ext.first_pattern_index << ") with match ID " << id << " "; if (!ext.highlander) { out << "did not specify "; } else { out << "specified "; } out << "HS_FLAG_SINGLEMATCH whereas previous expression (index " << eri.first_pattern_index << ") with the same match ID did"; if (ext.highlander) { out << " not"; } out << "."; throw CompileError(ext.first_pattern_index, out.str()); } } else { externalIdMap.emplace(id, ext); } // Any non-highlander pattern will render us not globally exhaustible. if (!ext.highlander) { global_exhaust = false; } } Report ReportManager::getBasicInternalReport(const NGWrapper &g, s32 adj) { /* validate that we are not violating highlander constraints, this will * throw a CompileError if so. */ registerExtReport(g.reportId, external_report_info(g.highlander, g.expressionIndex)); /* create the internal report */ u32 ekey = INVALID_EKEY; if (g.highlander) { /* all patterns with the same report id share an ekey */ ekey = getExhaustibleKey(g.reportId); } return makeECallback(g.reportId, adj, ekey); } void ReportManager::setProgramOffset(ReportID id, u32 programOffset) { assert(id < reportIds.size()); assert(!contains(reportIdToProgramOffset, id)); reportIdToProgramOffset.emplace(id, programOffset); } u32 ReportManager::getProgramOffset(ReportID id) const { assert(id < reportIds.size()); assert(contains(reportIdToProgramOffset, id)); return reportIdToProgramOffset.at(id); } static void ekeysUnion(std::set *ekeys, u32 more) { if (!ekeys->empty()) { if (more == INVALID_EKEY) { ekeys->clear(); } else { ekeys->insert(more); } } } set reportsToEkeys(const set &reports, const ReportManager &rm) { assert(!reports.empty()); set ekeys; for (auto it = reports.begin(), ite = reports.end(); it != ite; ++it) { u32 e = rm.getReport(*it).ekey; if (it == reports.begin()) { if (e != INVALID_EKEY) { ekeys.insert(e); } } else { ekeysUnion(&ekeys, e); } } return ekeys; } } // namespace ue2 hyperscan-4.4.1/src/util/hash.h0000644000175000017500000000452113055426554017141 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** * \file * \brief Hashing utility functions. */ #ifndef UTIL_HASH_H #define UTIL_HASH_H #include namespace ue2 { namespace hash_detail { template void hash_build(size_t &v, const T &obj) { boost::hash_combine(v, obj); } template void hash_build(size_t &v, const T &obj, Args&&... args) { hash_build(v, obj); hash_build(v, args...); // recursive } } // namespace hash_detail /** * \brief Computes the combined hash of all its arguments. * * Simply use: * * size_t hash = hash_all(a, b, c, d); * * Where a, b, c and d are hashable. */ template size_t hash_all(Args&&... args) { size_t v = 0; hash_detail::hash_build(v, args...); return v; } } // namespace ue2 #endif // UTIL_HASH_H hyperscan-4.4.1/src/util/pack_bits.h0000644000175000017500000001611213055426554020154 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Functions for packing/unpacking arrays. */ #ifndef UTIL_PACK_BITS_H #define UTIL_PACK_BITS_H #include "ue2common.h" #include "unaligned.h" #include "partial_store.h" /** * \brief Pack bits from an array of 32-bit words into \a out. * * \param out Output array. Must be large enough to store sum(bits). * \param v Input array. * \param bits Number of low bits in the corresponding element of \a v to pack. * \param elements Size of the \a v and \a bits arrays. */ static really_inline void pack_bits_32(char *out, const u32 *v, const u32 *bits, const unsigned int elements); /** * \brief Pack bits from an array of 64-bit words into \a out. * * \param out Output array. Must be large enough to store sum(bits). * \param v Input array. * \param bits Number of low bits in the corresponding element of \a v to pack. * \param elements Size of the \a v and \a bits arrays. */ static really_inline void pack_bits_64(char *out, const u64a *v, const u32 *bits, const unsigned int elements); /** * \brief Unpack bits into an array of 32-bit words according to the counts * given. * * \param v Output array. * \param in Packed input array. * \param bits Number of bits to unpack into the corresponding element of \a v. * \param elements Size of the \a v and \a bits arrays. */ static really_inline void unpack_bits_32(u32 *v, const u8 *in, const u32 *bits, const unsigned int elements); /** * \brief Unpack bits into an array of 64-bit words according to the counts * given. * * \param v Output array. * \param in Packed input array. * \param bits Number of bits to unpack into the corresponding element of \a v. * \param elements Size of the \a v and \a bits arrays. */ static really_inline void unpack_bits_64(u64a *v, const u8 *in, const u32 *bits, const unsigned int elements); /* * Inline implementations follow. */ static really_inline void pack_bits_32(char *out, const u32 *v, const u32 *bits, const unsigned int elements) { u32 write = 0; // accumulator u32 idx = 0; // acc holds this many bits for (unsigned int i = 0; i < elements; i++) { assert(bits[i] <= 32); write |= (v[i] << idx); idx += bits[i]; if (idx >= 32) { unaligned_store_u32(out, write); out += 4; idx -= 32; u32 leftover = bits[i] - idx; if (leftover == 32) { write = 0; } else { assert(leftover < 32); write = v[i] >> leftover; } } } // There might be a write left over. partial_store_u32(out, write, (idx + 7) / 8); } static really_inline void pack_bits_64(char *out, const u64a *v, const u32 *bits, const unsigned int elements) { u64a write = 0; // accumulator u32 idx = 0; // acc holds this many bits for (unsigned int i = 0; i < elements; i++) { assert(bits[i] <= 64); write |= (v[i] << idx); idx += bits[i]; if (idx >= 64) { unaligned_store_u64a(out, write); out += 8; idx -= 64; u32 leftover = bits[i] - idx; if (leftover == 64) { write = 0; } else { assert(leftover < 64); write = v[i] >> leftover; } } } // There might be a write left over. DEBUG_PRINTF("partial store of idx=%u\n", idx); partial_store_u64a(out, write, (idx + 7) / 8); } static really_inline void unpack_bits_32(u32 *v, const u8 *in, const u32 *bits, const unsigned int elements) { u32 used = 0; // bits used from *in for (unsigned int i = 0; i < elements; i++) { assert(bits[i] <= 32); u32 v_out = 0; // accumulator for v[i] u32 b = bits[i]; // bits left to read for v[i] u32 vidx = 0; // bits written to v[i] while (b) { u32 read = *in >> used; u32 bits_read = 8 - used; if (b <= bits_read) { u32 mask = read & ((1U << b) - 1); v_out |= mask << vidx; vidx += b; used += b; b = 0; if (used < 8) { continue; // more from this *in } } else { v_out |= read << vidx; vidx += bits_read; b -= bits_read; } used = 0; in++; } v[i] = v_out; } } static really_inline void unpack_bits_64(u64a *v, const u8 *in, const u32 *bits, const unsigned int elements) { u32 used = 0; // bits used from *in for (unsigned int i = 0; i < elements; i++) { assert(bits[i] <= 64); u64a v_out = 0; // accumulator for v[i] u32 b = bits[i]; // bits left to read for v[i] u32 vidx = 0; // bits written to v[i] while (b) { u64a read = *in >> used; u32 bits_read = 8 - used; if (b <= bits_read) { u64a mask = read & ((1U << b) - 1); v_out |= mask << vidx; vidx += b; used += b; b = 0; if (used < 8) { continue; // more from this *in } } else { v_out |= read << vidx; vidx += bits_read; b -= bits_read; } used = 0; in++; } v[i] = v_out; } } #endif // UTIL_PACK_BITS_H hyperscan-4.4.1/src/util/boundary_reports.h0000644000175000017500000000433513055426554021622 0ustar sleuthkidsleuthkid/* * 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 BOUNDARY_REPORTS_H #define BOUNDARY_REPORTS_H #include "ue2common.h" #include #include namespace ue2 { struct BoundaryReports : boost::noncopyable { std::set report_at_0; /* set of internal reports to fire * unconditionally at offset 0 */ std::set report_at_0_eod; /* set of internal reports to fire * unconditionally at offset 0 if it is * eod */ std::set report_at_eod; /* set of internal reports to fire * unconditionally at eod */ }; } // namespace ue2 #endif hyperscan-4.4.1/src/util/cpuid_flags.c0000644000175000017500000001554013055426554020474 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "cpuid_flags.h" #include "ue2common.h" #include "hs_compile.h" // for HS_MODE_ flags #include "hs_internal.h" #ifndef _WIN32 #include #endif // ECX #define SSE3 (1 << 0) #define SSSE3 (1 << 9) #define SSE4_1 (1 << 19) #define SSE4_2 (1 << 20) #define POPCNT (1 << 23) #define XSAVE (1 << 27) #define AVX (1 << 28) // EDX #define FXSAVE (1 << 24) #define SSE (1 << 25) #define SSE2 (1 << 26) #define HTT (1 << 28) // Structured Extended Feature Flags Enumeration Leaf ECX values #define BMI (1 << 3) #define AVX2 (1 << 5) #define BMI2 (1 << 8) // Extended Control Register 0 (XCR0) values #define XCR0_SSE (1 << 1) #define XCR0_AVX (1 << 2) static __inline void cpuid(unsigned int op, unsigned int leaf, unsigned int *eax, unsigned int *ebx, unsigned int *ecx, unsigned int *edx) { #ifndef _WIN32 __cpuid_count(op, leaf, *eax, *ebx, *ecx, *edx); #else unsigned int a[4]; __cpuidex(a, op, leaf); *eax = a[0]; *ebx = a[1]; *ecx = a[2]; *edx = a[3]; #endif } static inline u64a xgetbv(u32 op) { #if defined(_WIN32) || defined(__INTEL_COMPILER) return _xgetbv(op); #else u32 a, d; __asm__ volatile ( "xgetbv\n" : "=a"(a), "=d"(d) : "c"(op)); return ((u64a)d << 32) + a; #endif } int check_avx2(void) { #if defined(__INTEL_COMPILER) return _may_i_use_cpu_feature(_FEATURE_AVX2); #else unsigned int eax, ebx, ecx, edx; cpuid(1, 0, &eax, &ebx, &ecx, &edx); /* check AVX is supported and XGETBV is enabled by OS */ if ((ecx & (AVX | XSAVE)) != (AVX | XSAVE)) { DEBUG_PRINTF("AVX and XSAVE not supported\n"); return 0; } /* check that SSE and AVX registers are enabled by OS */ u64a xcr0 = xgetbv(0); if ((xcr0 & (XCR0_SSE | XCR0_AVX)) != (XCR0_SSE | XCR0_AVX)) { DEBUG_PRINTF("SSE and AVX registers not enabled\n"); return 0; } /* ECX and EDX contain capability flags */ ecx = 0; cpuid(7, 0, &eax, &ebx, &ecx, &edx); if (ebx & AVX2) { DEBUG_PRINTF("AVX2 enabled\n"); return 1; } return 0; #endif } u64a cpuid_flags(void) { u64a cap = 0; if (check_avx2()) { DEBUG_PRINTF("AVX2 enabled\n"); cap |= HS_CPU_FEATURES_AVX2; } #if !defined(__AVX2__) cap &= ~HS_CPU_FEATURES_AVX2; #endif return cap; } int check_ssse3(void) { unsigned int eax, ebx, ecx, edx; cpuid(1, 0, &eax, &ebx, &ecx, &edx); return !!(ecx & SSSE3); } int check_sse42(void) { unsigned int eax, ebx, ecx, edx; cpuid(1, 0, &eax, &ebx, &ecx, &edx); return !!(ecx & SSE4_2); } int check_popcnt(void) { unsigned int eax, ebx, ecx, edx; cpuid(1, 0, &eax, &ebx, &ecx, &edx); return !!(ecx & POPCNT); } struct family_id { u32 full_family; u32 full_model; u32 tune; }; /* from table 35-1 of the Intel 64 and IA32 Arch. Software Developer's Manual * and "Intel Architecture and Processor Identification With CPUID Model and * Family Numbers" */ static const struct family_id known_microarch[] = { { 0x6, 0x37, HS_TUNE_FAMILY_SLM }, /* baytrail */ { 0x6, 0x4D, HS_TUNE_FAMILY_SLM }, /* avoton, rangley */ { 0x6, 0x3C, HS_TUNE_FAMILY_HSW }, /* haswell */ { 0x6, 0x45, HS_TUNE_FAMILY_HSW }, /* haswell */ { 0x6, 0x46, HS_TUNE_FAMILY_HSW }, /* haswell */ { 0x6, 0x3F, HS_TUNE_FAMILY_HSW }, /* haswell */ { 0x6, 0x3E, HS_TUNE_FAMILY_IVB }, /* ivybridge */ { 0x6, 0x3A, HS_TUNE_FAMILY_IVB }, /* ivybridge */ { 0x6, 0x2A, HS_TUNE_FAMILY_SNB }, /* sandybridge */ { 0x6, 0x2D, HS_TUNE_FAMILY_SNB }, /* sandybridge */ { 0x6, 0x3D, HS_TUNE_FAMILY_BDW }, /* broadwell Core-M */ { 0x6, 0x4F, HS_TUNE_FAMILY_BDW }, /* broadwell xeon */ { 0x6, 0x56, HS_TUNE_FAMILY_BDW }, /* broadwell xeon-d */ // { 0x6, 0x25, HS_TUNE_FAMILY_GENERIC }, /* westmere */ // { 0x6, 0x2C, HS_TUNE_FAMILY_GENERIC }, /* westmere */ // { 0x6, 0x2F, HS_TUNE_FAMILY_GENERIC }, /* westmere */ // { 0x6, 0x1E, HS_TUNE_FAMILY_GENERIC }, /* nehalem */ // { 0x6, 0x1A, HS_TUNE_FAMILY_GENERIC }, /* nehalem */ // { 0x6, 0x2E, HS_TUNE_FAMILY_GENERIC }, /* nehalem */ // { 0x6, 0x17, HS_TUNE_FAMILY_GENERIC }, /* penryn */ // { 0x6, 0x1D, HS_TUNE_FAMILY_GENERIC }, /* penryn */ }; #ifdef DUMP_SUPPORT static UNUSED const char *dumpTune(u32 tune) { #define T_CASE(x) case x: return #x; switch (tune) { T_CASE(HS_TUNE_FAMILY_SLM); T_CASE(HS_TUNE_FAMILY_HSW); T_CASE(HS_TUNE_FAMILY_SNB); T_CASE(HS_TUNE_FAMILY_IVB); T_CASE(HS_TUNE_FAMILY_BDW); } #undef T_CASE return "unknown"; } #endif u32 cpuid_tune(void) { unsigned int eax, ebx, ecx, edx; cpuid(1, 0, &eax, &ebx, &ecx, &edx); u32 family = (eax >> 8) & 0xf; u32 model = 0; if (family == 0x6 || family == 0xf) { model = ((eax >> 4) & 0xf) | ((eax >> 12) & 0xf0); } else { model = (eax >> 4) & 0xf; } DEBUG_PRINTF("family = %xh model = %xh\n", family, model); for (u32 i = 0; i < ARRAY_LENGTH(known_microarch); i++) { if (family != known_microarch[i].full_family) { continue; } if (model != known_microarch[i].full_model) { continue; } u32 tune = known_microarch[i].tune; DEBUG_PRINTF("found tune flag %s\n", dumpTune(tune) ); return tune; } return HS_TUNE_FAMILY_GENERIC; } hyperscan-4.4.1/src/util/cpuid_flags.h0000644000175000017500000000363213055426554020500 0ustar sleuthkidsleuthkid/* * 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 CPUID_H_53FFCB14B257C2 #define CPUID_H_53FFCB14B257C2 #include "ue2common.h" #ifdef __cplusplus extern "C" { #endif /* returns HS_CPU_FEATURES_* mask. */ u64a cpuid_flags(void); u32 cpuid_tune(void); int check_avx2(void); int check_ssse3(void); int check_sse42(void); int check_popcnt(void); #ifdef __cplusplus } /* extern "C" */ #endif #endif /* CPUID_H_53FFCB14B257C2 */ hyperscan-4.4.1/src/util/dump_mask.cpp0000644000175000017500000000416413055426554020534 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Dump code for bitmasks. * * Note that these functions are only emitted in builds with DUMP_SUPPORT. */ #include "config.h" #ifdef DUMP_SUPPORT #include "ue2common.h" #include "util/dump_mask.h" #include namespace ue2 { std::string dumpMask(const u8 *mask, size_t len) { std::string s; s.reserve(len + len / 8); for (size_t i = 0; i < len; i++) { if ((i % 8) == 0 && i != 0) { s.push_back(' '); } s.push_back((mask[i / 8] >> (i % 8)) & 0x1 ? '1' : '0'); } return s; } } // namespace ue2 #endif // DUMP_SUPPORT hyperscan-4.4.1/src/util/dump_util.cpp0000644000175000017500000000345713055426554020562 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "dump_util.h" #include #include using namespace std; FILE *fopen_or_throw(const char *path, const char *mode) { FILE *f = fopen(path, mode); if (!f) { throw runtime_error(string("Unable to open file: ") + path); } return f; } hyperscan-4.4.1/src/util/scatter.h0000644000175000017500000000374613055426554017673 0ustar sleuthkidsleuthkid/* * 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 UTIL_SCATTER_H #define UTIL_SCATTER_H #include "ue2common.h" #define SCATTER_STRUCT(t) \ struct scatter_unit_##t { u32 offset; t val; }; SCATTER_STRUCT(u64a) SCATTER_STRUCT(u32) SCATTER_STRUCT(u16) SCATTER_STRUCT(u8) struct scatter_full_plan { u32 s_u64a_offset; u32 s_u64a_count; u32 s_u32_offset; u32 s_u32_count; u32 s_u16_offset; u32 s_u16_count; u32 s_u8_count; u32 s_u8_offset; }; #undef SCATTER_STRUCT #endif hyperscan-4.4.1/src/util/make_unique.h0000644000175000017500000000365113055426554020524 0ustar sleuthkidsleuthkid/* * 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 UTIL_MAKE_UNIQUE_H #define UTIL_MAKE_UNIQUE_H #if (defined(_WIN32) || defined(_WIN64)) && (_MSC_VER > 1700) // VC++ 2013 onwards has make_unique in the STL #define USE_STD #include #else #include #endif namespace ue2 { #if defined(USE_STD) using std::make_unique; #else using boost::make_unique; #endif } #undef USE_STD #endif // UTIL_MAKE_UNIQUE_H hyperscan-4.4.1/src/util/alloc.h0000644000175000017500000000774013055426554017316 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Aligned memory alloc/free. */ #ifndef UTIL_ALLOC_H #define UTIL_ALLOC_H #include #include // size_t #include #include #include // std::bad_alloc namespace ue2 { /** \brief 64-byte aligned, zeroed malloc. * * Pointers should be freed with \ref aligned_free. If we are unable to * allocate the requested number of bytes, this function will throw * std::bad_alloc. */ void *aligned_zmalloc(size_t size); /** \brief Free a pointer allocated with \ref aligned_zmalloc. */ void aligned_free(void *ptr); template struct AlignedDeleter { void operator()(T *ptr) const { aligned_free(ptr); } }; template using aligned_unique_ptr = std::unique_ptr>; /** \brief 64-byte aligned, zeroed malloc that returns an appropriately-typed * aligned_unique_ptr. * * If the requested size cannot be allocated, throws std::bad_alloc. */ template inline aligned_unique_ptr aligned_zmalloc_unique(size_t size) { T* ptr = static_cast(aligned_zmalloc(size)); assert(ptr); // Guaranteed by aligned_zmalloc. return aligned_unique_ptr(ptr); } /** \brief Internal use only, used by AlignedAllocator. */ void *aligned_malloc_internal(size_t size, size_t align); /** \brief Internal use only, used by AlignedAllocator. */ void aligned_free_internal(void *ptr); /** \brief Aligned allocator class for use with STL containers. Ensures that * your objects are aligned to N bytes. */ template class AlignedAllocator { public: using value_type = T; AlignedAllocator() noexcept {} template AlignedAllocator(const AlignedAllocator &) noexcept {} template struct rebind { using other = AlignedAllocator; }; T *allocate(std::size_t size) const { size_t alloc_size = size * sizeof(T); return static_cast(aligned_malloc_internal(alloc_size, N)); } void deallocate(T *x, std::size_t) const noexcept { aligned_free_internal(x); } }; template bool operator==(const AlignedAllocator &, const AlignedAllocator &) { return true; } template bool operator!=(const AlignedAllocator &a, const AlignedAllocator &b) { return !(a == b); } } // namespace ue2 #endif hyperscan-4.4.1/src/util/bitfield.h0000644000175000017500000002743213055426554020006 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Fast bitset class with find_first and find_next operations. */ #ifndef BITFIELD_H #define BITFIELD_H #include "ue2common.h" #include "popcount.h" #include "util/bitutils.h" #include #include #include #include namespace ue2 { /** * \brief Templated bitset class with find_first and find_next operations. * * This is a simple (but hopefully fast) class to replace our use of * std::bitset<>. * * Note: underlying storage is allocated as an array of 64-bit blocks. All * mutating operations MUST ensure that the trailer (the bits between * requested_size and the end of the array) is filled with zeroes; there's a * clear_trailer member function for this. */ template class bitfield { public: /// Empty constructor, zero initializes all bits. bitfield() : bits{{0}} { assert(none()); } bitfield(const boost::dynamic_bitset<> &a) : bits{{0}} { assert(a.size() == requested_size); assert(none()); for (auto i = a.find_first(); i != a.npos; i = a.find_next(i)) { set(i); } } /// Complete bitset equality. bool operator==(const bitfield &a) const { return bits == a.bits; } /// Inequality. bool operator!=(const bitfield &a) const { return bits != a.bits; } /// Ordering. bool operator<(const bitfield &a) const { return bits < a.bits; } /// Set all bits. void setall() { for (auto &e : bits) { e = all_ones; } clear_trailer(); } /// Set all bits (alias for bitset::setall, to match dynamic_bitset). void set() { setall(); } /// Clear all bits. void clear() { for (auto &e : bits) { e = 0; } } /// Clear all bits (alias for bitset::clear). void reset() { clear(); } /// Clear bit N. void clear(size_t n) { assert(n < size()); bits[getword(n)] &= ~maskbit(n); } /// Set bit N. void set(size_t n) { assert(n < size()); bits[getword(n)] |= maskbit(n); } /// Test bit N. bool test(size_t n) const { assert(n < size()); return bits[getword(n)] & maskbit(n); } /// Flip bit N. void flip(size_t n) { assert(n < size()); bits[getword(n)] ^= maskbit(n); } /// Flip all bits. void flip() { for (auto &e : bits) { e = ~e; } clear_trailer(); } /// Switch on the bit in the range [from, to], inclusive. void set_range(size_t from, size_t to) { assert(from <= to); assert(to < requested_size); if (from / block_size == to / block_size) { // Small case, our indices are in the same block. block_type block = all_ones << (from % block_size); if (to % block_size != block_size - 1) { block &= maskbit(to + 1) - 1; } bits[from / block_size] |= block; return; } // Large case, work in block units. Write a partial mask, then a // run of all-ones blocks, then a partial mask at the end. size_t i = from; if (i % block_size) { block_type block = all_ones << (i % block_size); bits[i / block_size] |= block; i = ROUNDUP_N(i, block_size); } for (; i + block_size <= to + 1; i += block_size) { bits[i / block_size] = all_ones; } if (i <= to) { assert(to - i + 1 < block_size); bits[i / block_size] |= (maskbit(to + 1) - 1); } } /// Returns total number of bits. static constexpr size_t size() { return requested_size; } /// Returns number of bits set on. size_t count() const { static_assert(block_size == 64, "adjust popcount for block_type"); size_t sum = 0; size_t i = 0; for (; i + 4 <= num_blocks; i += 4) { sum += popcount64(bits[i]); sum += popcount64(bits[i + 1]); sum += popcount64(bits[i + 2]); sum += popcount64(bits[i + 3]); } for (; i < num_blocks; i++) { sum += popcount64(bits[i]); } assert(sum <= size()); return sum; } /// Are no bits set? bool none() const { for (const auto &e : bits) { if (e != 0) { return false; } } return true; } /// Is any bit set? bool any() const { return !none(); } /// Are all bits set? bool all() const { for (size_t i = 0; i < bits.size() - 1; i++) { if (bits[i] != all_ones) { return false; } } size_t rem = requested_size % block_size; block_type exp = rem ? ((block_type{1} << rem) - 1) : all_ones; return *bits.rbegin() == exp; } /// Returns first bit set, or bitfield::npos if none set. size_t find_first() const { for (size_t i = 0; i < bits.size(); i++) { if (bits[i] != 0) { return (i * block_size) + word_ctz(i); } } return npos; } // Returns last bit set, or bitfield::npos if none set. size_t find_last() const { for (int i = bits.size() - 1; i >= 0; i--) { if (bits[i]) { static_assert(block_size == 64, "adjust clz for block_type"); return (i * block_size) + block_size - 1 - clz64(bits[i]); } } return npos; } /// Returns next bit set, or bitfield::npos if none set after 'last'. size_t find_next(size_t last) const { if (last >= size()) { return npos; } // check current word. size_t i = getword(last); block_type lastword = bits[i]; if ((last % block_size) != (block_size - 1)) { lastword &= (all_ones << ((last % block_size) + 1)); if (lastword) { static_assert(block_size == 64, "adjust ctz for block_type"); return (i * block_size) + ctz64(lastword); } } // check the rest. for (i++; i < bits.size(); i++) { if (bits[i]) { return (i * block_size) + word_ctz(i); } } return npos; } size_t find_nth(size_t n) const { assert(n < npos); static_assert(block_size == 64, "adjust for block_type"); size_t sum = 0; for (size_t i = 0; i < bits.size(); i++) { block_type block = bits[i]; size_t aftersum = sum + popcount64(block); if (aftersum > n) { // Block contains the nth bit. for (; sum < n; sum++) { assert(block); block &= (block - 1); } assert(block); size_t bit = (i * block_size) + ctz64(block); assert(test(bit)); return bit; } sum = aftersum; } assert(count() < n + 1); return npos; } /// Bitwise OR. bitfield operator|(bitfield a) const { a |= *this; return a; } /// Bitwise OR-equals. void operator|=(const bitfield &a) { size_t i = 0; for (; i + 4 <= num_blocks; i += 4) { bits[i] |= a.bits[i]; bits[i + 1] |= a.bits[i + 1]; bits[i + 2] |= a.bits[i + 2]; bits[i + 3] |= a.bits[i + 3]; } for (; i < num_blocks; i++) { bits[i] |= a.bits[i]; } } /// Bitwise AND. bitfield operator&(bitfield a) const { a &= *this; return a; } /// Bitwise AND-equals. void operator&=(const bitfield &a) { size_t i = 0; for (; i + 4 <= num_blocks; i += 4) { bits[i] &= a.bits[i]; bits[i + 1] &= a.bits[i + 1]; bits[i + 2] &= a.bits[i + 2]; bits[i + 3] &= a.bits[i + 3]; } for (; i < num_blocks; i++) { bits[i] &= a.bits[i]; } } /// Bitwise XOR. bitfield operator^(bitfield a) const { a ^= *this; return a; } /// Bitwise XOR-equals. void operator^=(bitfield a) { size_t i = 0; for (; i + 4 <= num_blocks; i += 4) { bits[i] ^= a.bits[i]; bits[i + 1] ^= a.bits[i + 1]; bits[i + 2] ^= a.bits[i + 2]; bits[i + 3] ^= a.bits[i + 3]; } for (; i < num_blocks; i++) { bits[i] ^= a.bits[i]; } } /// Bitwise complement. bitfield operator~(void) const { bitfield cr(*this); cr.flip(); return cr; } /// Simple hash. size_t hash() const { return boost::hash_range(std::begin(bits), std::end(bits)); } /// Sentinel value meaning "no more bits", used by find_first and /// find_next. static constexpr size_t npos = requested_size; private: /// Underlying block type. using block_type = u64a; /// A block filled with on bits. static constexpr block_type all_ones = ~block_type{0}; /// Size of a block. static constexpr size_t block_size = sizeof(block_type) * 8; static size_t getword(size_t n) { return n / block_size; } static block_type maskbit(size_t n) { return (block_type{1} << (n % block_size)); } size_t word_ctz(size_t n) const { static_assert(block_size == 64, "adjust ctz call for block type"); return ctz64(bits[n]); } /// Ensures that bits between our requested size and the end of storage are /// zero. void clear_trailer() { size_t final_bits = requested_size % block_size; if (final_bits) { bits.back() &= ((block_type{1} << final_bits) - 1); } } /// Size of storage array of blocks. static constexpr size_t num_blocks = (requested_size + block_size - 1) / block_size; /// Underlying storage. std::array bits; }; /** \brief Boost-style hash free function. */ template size_t hash_value(const bitfield &b) { return b.hash(); } } // namespace ue2 #endif // BITFIELD_H hyperscan-4.4.1/src/util/partitioned_set.h0000644000175000017500000002124113055426554021411 0ustar sleuthkidsleuthkid/* * 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 PARTITIONED_SET_H #define PARTITIONED_SET_H #include "container.h" #include "ue2_containers.h" #include "ue2common.h" #include #include #include #include namespace ue2 { static constexpr size_t INVALID_SUBSET = ~(size_t)0; /** * partition_set represents a partitioning of a set of integers [0, n) into * disjoint non-empty subsets. * * The subsets themselves are also indexed by integers. * * The underlying integer type for the set members is parameterized. */ template class partitioned_set : boost::noncopyable { public: class subset { public: typedef typename std::vector::const_iterator const_iterator; size_t size() const { assert(members.size()); return members.size(); } const_iterator begin() const { return members.begin(); } const_iterator end() const { return members.end(); } private: std::vector members; /**< sorted members of the subset */ friend class partitioned_set; }; /** returns the number of subsets in the partition */ size_t size() const { return subsets.size(); } /** returns the subset with the given index */ const subset &operator[](size_t subset_index) const { assert(subset_index < size()); return subsets[subset_index]; } /** * Splits the subset with the given subset_index based on whether its * members are also members of the splitter set. * * The smaller of the intersection and difference is placed into a new * subset, the index of which is returned. The larger part remains with the * subset index. * * If the set was not split (due to there being no overlap with splitter or * being a complete subset), INVALID_SUBSET is returned. */ size_t split(size_t subset_index, const typename ue2::flat_set &splitter) { assert(!splitter.empty()); if (splitter.empty()) { return INVALID_SUBSET; } subset &orig = subsets[subset_index]; assert(orig.size()); split_temp_diff.clear(); split_temp_inter.clear(); auto sp_it = splitter.begin(); auto sp_e = splitter.end(); /* subset members are always in sorted order. */ assert(std::is_sorted(orig.members.begin(), orig.members.end())); if (orig.members.back() < *sp_it) { /* first splitter is greater than all our members */ return INVALID_SUBSET; } if (orig.members.front() > *splitter.rbegin()) { /* last splitter is less than all our members */ return INVALID_SUBSET; } for (auto it = orig.members.begin(); it != orig.members.end(); ++it) { T member = *it; assert(member < member_to_subset.size()); while (sp_it != sp_e && *sp_it < member) { ++sp_it; } if (sp_it == sp_e) { split_temp_diff.insert(split_temp_diff.end(), it, orig.members.end()); break; } if (*sp_it > member) { split_temp_diff.push_back(member); } else { split_temp_inter.push_back(member); } } assert(split_temp_diff.size() + split_temp_inter.size() == orig.size()); if (split_temp_inter.empty()) { assert(split_temp_diff == orig.members); return INVALID_SUBSET; } if (split_temp_diff.empty()) { assert(split_temp_inter == orig.members); return INVALID_SUBSET; } assert(MIN(split_temp_inter[0], split_temp_diff[0]) == orig.members[0]); /* work out which is the bigger half */ std::vector *big; std::vector *small; if (split_temp_diff.size() > split_temp_inter.size()) { big = &split_temp_diff; small = &split_temp_inter; } else { big = &split_temp_inter; small = &split_temp_diff; } /* larger subset replaces the input subset */ std::vector temp_i; insert(&temp_i, temp_i.end(), *big); orig.members.swap(temp_i); /* smaller subset is placed in the new subset */ size_t new_index = subsets.size(); subsets.push_back(subset()); insert(&subsets.back().members, subsets.back().members.end(), *small); for (const auto &e : *small) { member_to_subset[e] = new_index; } return new_index; } /** * Returns all subsets which have a member in keys. */ void find_overlapping(const typename ue2::flat_set &keys, std::vector *containing) const { boost::dynamic_bitset<> seen(subsets.size()); // all zero by default. for (const auto &key : keys) { assert(key < member_to_subset.size()); size_t sub = member_to_subset[key]; assert(sub < subsets.size()); seen.set(sub); } for (size_t i = seen.find_first(); i != seen.npos; i = seen.find_next(i)) { containing->push_back(i); } } /** * Creates a partitioned set containing elements [0, state_to_subset.size() ) * * The initial subset that an element belongs to is given by the * corresponding entry in state_to_subset. The subsets should be identified * by a dense range of indices starting from 0. */ explicit partitioned_set(const std::vector &state_to_subset) { assert(!state_to_subset.empty()); subsets.reserve(state_to_subset.size()); member_to_subset.resize(state_to_subset.size()); split_temp_inter.reserve(state_to_subset.size()); split_temp_diff.reserve(state_to_subset.size()); size_t subset_count = 0; for (const auto &sub : state_to_subset) { assert(sub != INVALID_SUBSET); ENSURE_AT_LEAST(&subset_count, sub + 1); } assert(subset_count <= state_to_subset.size()); subsets.resize(subset_count); for (size_t i = 0; i < state_to_subset.size(); i++) { /* ensure that our underlying type is big enough to hold all our * set members */ assert(i == (size_t)(T)i); size_t sub = state_to_subset[i]; assert(sub < subsets.size()); member_to_subset[i] = sub; subsets[sub].members.push_back(i); } /* none of the subsets should be empty */ assert(std::all_of(subsets.begin(), subsets.end(), [](const subset &sub){ return sub.size() > 0; })); } private: std::vector member_to_subset; std::vector subsets; std::vector split_temp_inter; /**< used internally by split to hold the * intersection. */ std::vector split_temp_diff; /**< used internally by split to hold the * set difference. */ }; } // namespace #endif hyperscan-4.4.1/src/util/ue2_graph.h0000644000175000017500000012766713055426554020113 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 UE2_GRAPH_H #define UE2_GRAPH_H #include "ue2common.h" #include "util/graph_range.h" #include #include #include /* vertex_index_t, ... */ #include /* no_property */ #include #include #include #include #include /* tie */ #include /* pair, declval */ /* * Basic design of ue2_graph: * * Fairly standard adjacency list type graph structure. The main internal * structures are vertex_node and edge_node. * * Each vertex_node maintains lists of incoming and outgoing edge_nodes, a * serial number and the vertex properties. * * Each edge_node contains pointers to the source and target vertex as well as * the serial number and edge properties. * * Every time an edge_node or vertex_node is created in the graph, it is given a * unique serial number by increasing a private counter in the graph. * * The main thing to note is that the in and out edge lists are intrusive lists * with the edge_node containing the necessary hooks. This means that we can * easily convert the edge_node to iterators of the in_edge_list and * out_edge_list and remove them from the lists. * * vertex_descriptor and edge_descriptor structures both just wrap pointers to * the relevant node structure along with the serial number. operator<() for the * descriptors is overridden to look at the serial member of the node. * We do not use: * - the address of the node structure as this would lead to an unstable * ordering of vertices between runs. * - the index field as this would mean that the generation of new index * values (during say renumbering of vertex nodes after removing some * vertices) would potentially reorder vertices and corrupt containers * such as std::set<>. * The serial number is copied into the descriptors so that we can still have * descriptors in a container (such as set or unordered_set) after removing the * underlying node. * * Hashing of descriptors is based on the serial field for similar reasons. * * * * Main differences from boost::adjacency_list<> with listS: * * (1) Deterministic ordering for vertices and edges * boost::adjacency_list<> uses pointer ordering for vertex_descriptors. As * a result, ordering of vertices and edges between runs is * non-deterministic unless containers, etc use custom comparators. * * (2) Proper types for descriptors, etc. * No more void * for vertex_descriptors and trying to use it for the wrong * graph type. * * (3) Constant time num_edges(), num_vertices(), degree(), in_degree() and * out_degree() * std::list is meant to have constant time in C++11 ::size(), but this is * not always implemented as people want to keep ABI compatibility with * existing C++98 standard libraries (gcc 4.8). As ue2_graph_h uses * intrusive lists rather than std::list this is not an issue for us. * * (4) Constant time remove_edge(e, g) * ue2_graph uses boost::intrusive_lists internally so we can easily unlink * an edge from the in and out edgelist of its source and target. * * (5) More efficient edge(u, v, g) and remove_edge(u, v, g) * ue2_graph will check which of u and v has the smallest relevant degree * and use that to search for the edge(s). * * (6) Automatically populate the index field of vertex and edge bundles. * Saves us from doing it manually. Naturally there is nothing to prevent * the user from stuffing up the index properties later. * * (7) Different edge iteration order * ue2_graph does not maintain an explicit global edge list, so the * edge_iterator is constructed out of vertex_iterator and * out_edge_iterators by iterating the out_edges of each vertices. This * means that edge iteration order is not insertion order like for * adjacency_list. * * (8) null_edge() * Because why not? * * (9) vertex and edge properties must have an index field. * We generally need them so the effort has not been put into specialising * for when they are not present. * * * * Possible Future Work: * * (1) Improve edge(u, v, g) performance * This function sees a fair amount of use and is O(n) in the smallest of * the source out_degree or target in_degree. This could be improved by * changes on of the edge containers to be something similar to a multiset. * * (2) 'Lie' about the number of edges / vertices * * One of the main uses of num_edges() and num_vertices() is to allocate a * vector, etc so that it can be indexed by edge or vertex index. If * num_edges() and num_vertices() returned the appropriate size for such a * vector (at least one more than the largest index), we would be able to * avoid some renumbering operations. Functions would have to be provided to * get the real number of vertices and edges. Having num_vertices() and * num_edges() return an over-estimate is not without precedence in the BGL * - the filtered_graph adaptor does the same thing and is compatible with * various (all?) BGL algorithms. It is not clear that this was done * deliberately for the same reason or because it is difficult for * filtered_graph to get the true counts. * * (3) Investigate slab/pooled allocation schemes for nodes. */ namespace ue2 { namespace graph_detail { class graph_base : boost::noncopyable { }; struct default_edge_property { size_t index; }; struct default_vertex_property { size_t index; }; } template class ue2_graph : graph_detail::graph_base { private: struct in_edge_tag { }; struct out_edge_tag { }; struct vertex_node; using out_edge_hook = boost::intrusive::list_base_hook >; /* in_edge_hook does not use safe mode as during graph destruction we do not * maintain the in edge lists */ using in_edge_hook = boost::intrusive::list_base_hook, boost::intrusive::link_mode >; struct edge_node : public out_edge_hook, public in_edge_hook { explicit edge_node(u64a serial_in) : serial(serial_in) { } vertex_node *source = nullptr; vertex_node *target = nullptr; const u64a serial; /*< used to order edges. We do not use props.index so * that there is no danger of invalidating sets or * other containers by changing the index due to * renumbering */ EdgePropertyType props; }; template using vertex_edge_list = boost::intrusive::list >; struct vertex_node : public boost::intrusive::list_base_hook<> { explicit vertex_node(u64a serial_in) : serial(serial_in) { } VertexPropertyType props; const u64a serial; /*< used to order vertices. We do not use props.index * so that there is no danger of invalidating sets or * other containers by changing the index due to * renumbering */ /* The incoming edges are not considered owned by the vertex */ vertex_edge_list in_edge_list; /* The out going edges are considered owned by the vertex and * need to be freed when the graph is begin destroyed */ vertex_edge_list out_edge_list; /* The destructor only frees memory owned by the vertex and will leave * the neighbour's edges in a bad state. If a vertex is being removed * (rather than the graph being destroyed), then the more gentle clean * up of clear_vertex() is required to be called first */ ~vertex_node() { out_edge_list.clear_and_dispose(delete_disposer()); } }; struct delete_disposer { template void operator()(const T *d) const { delete d; } }; struct in_edge_disposer { void operator()(edge_node *e) const { /* remove from source's out edge list before deleting */ vertex_node *u = e->source; u->out_edge_list.erase(u->out_edge_list.iterator_to(*e)); delete e; } }; struct out_edge_disposer { void operator()(edge_node *e) const { /* remove from target's in edge list before deleting */ vertex_node *v = e->target; v->in_edge_list.erase(v->in_edge_list.iterator_to(*e)); delete e; } }; using vertices_list_type = boost::intrusive::list > >; vertices_list_type vertices_list; protected: /* to allow renumbering */ static const size_t N_SPECIAL_VERTICES = 0; /* override in derived class */ size_t next_vertex_index = 0; size_t next_edge_index = 0; private: size_t graph_edge_count = 0; /* maintained explicitly as we have no global edge list */ u64a next_serial = 0; u64a new_serial() { u64a serial = next_serial++; if (!next_serial) { /* if we have created enough graph edges/vertices to overflow a u64a * we must have spent close to an eternity adding to this graph so * something must have gone very wrong and we will not be producing * a final bytecode in a reasonable amount of time. Or, more likely, * the next_serial value has become corrupt. */ throw std::overflow_error("too many graph edges/vertices created"); } return serial; } public: using vertices_size_type = typename vertices_list_type::size_type; using degree_size_type = typename vertex_edge_list::size_type; using edges_size_type = size_t; using vertex_property_type = VertexPropertyType; using edge_property_type = EdgePropertyType; using graph_bundled = boost::no_property; using vertex_bundled = VertexPropertyType; using edge_bundled = EdgePropertyType; class vertex_descriptor : boost::totally_ordered { public: vertex_descriptor() : p(nullptr), serial(0) { } explicit vertex_descriptor(vertex_node *pp) : p(pp), serial(pp->serial) { } operator bool() const { return p; } bool operator<(const vertex_descriptor b) const { if (p && b.p) { /* no vertices in the same graph can have the same serial */ assert(p == b.p || serial != b.serial); return serial < b.serial; } else { return p < b.p; } } bool operator==(const vertex_descriptor b) const { return p == b.p; } friend size_t hash_value(vertex_descriptor v) { using boost::hash_value; return hash_value(v.serial); } private: vertex_node *raw(void) { return p; } vertex_node *p; u64a serial; friend ue2_graph; }; class edge_descriptor : boost::totally_ordered { public: edge_descriptor() : p(nullptr), serial(0) { } explicit edge_descriptor(edge_node *pp) : p(pp), serial(pp->serial) { } /* Convenice ctor to allow us to directly get an edge_descriptor from * edge() and add_edge(). As we have null_edges and we always allow * parallel edges, the bool component of the return from these functions * is not required. */ edge_descriptor(const std::pair &tup) : p(tup.first.p), serial(tup.first.serial) { assert(tup.second == (bool)tup.first); } operator bool() const { return p; } bool operator<(const edge_descriptor b) const { if (p && b.p) { /* no edges in the same graph can have the same serial */ assert(p == b.p || serial != b.serial); return serial < b.serial; } else { return p < b.p; } } bool operator==(const edge_descriptor b) const { return p == b.p; } friend size_t hash_value(edge_descriptor e) { using boost::hash_value; return hash_value(e.serial); } private: edge_node *raw(void) { return p; } edge_node *p; u64a serial; friend ue2_graph; }; private: /* Note: apparently, nested class templates cannot be fully specialised but * they can be partially specialised. Sigh, ... */ template struct bundle_key_type { }; template struct bundle_key_type { using type = vertex_descriptor; }; template struct bundle_key_type { using type = edge_descriptor; }; public: class out_edge_iterator : public boost::iterator_adaptor< out_edge_iterator, typename vertex_edge_list::const_iterator, edge_descriptor, boost::bidirectional_traversal_tag, edge_descriptor> { using super = typename out_edge_iterator::iterator_adaptor_; public: out_edge_iterator() : super() { } explicit out_edge_iterator( typename vertex_edge_list::const_iterator it) : super(it) { } edge_descriptor dereference() const { /* :( const_cast makes me sad but constness is defined by the graph * parameter of bgl api calls */ return edge_descriptor(const_cast(&*super::base())); } }; class in_edge_iterator : public boost::iterator_adaptor< in_edge_iterator, typename vertex_edge_list::const_iterator, edge_descriptor, boost::bidirectional_traversal_tag, edge_descriptor> { using super = typename in_edge_iterator::iterator_adaptor_; public: in_edge_iterator() : super() { } explicit in_edge_iterator( typename vertex_edge_list::const_iterator it) : super(it) { } edge_descriptor dereference() const { /* :( const_cast makes me sad but constness is defined by the graph * parameter of bgl api calls */ return edge_descriptor(const_cast(&*super::base())); } }; class adjacency_iterator : public boost::iterator_adaptor< adjacency_iterator, out_edge_iterator, vertex_descriptor, boost::bidirectional_traversal_tag, vertex_descriptor> { using super = typename adjacency_iterator::iterator_adaptor_; public: adjacency_iterator(out_edge_iterator a) : super(std::move(a)) { } adjacency_iterator() { } vertex_descriptor dereference() const { return vertex_descriptor(super::base()->p->target); } }; class inv_adjacency_iterator : public boost::iterator_adaptor< inv_adjacency_iterator, in_edge_iterator, vertex_descriptor, boost::bidirectional_traversal_tag, vertex_descriptor> { using super = typename inv_adjacency_iterator::iterator_adaptor_; public: inv_adjacency_iterator(in_edge_iterator a) : super(std::move(a)) { } inv_adjacency_iterator() { } vertex_descriptor dereference() const { return vertex_descriptor(super::base()->p->source); } }; class vertex_iterator : public boost::iterator_adaptor< vertex_iterator, typename vertices_list_type::const_iterator, vertex_descriptor, boost::bidirectional_traversal_tag, vertex_descriptor> { using super = typename vertex_iterator::iterator_adaptor_; public: vertex_iterator() : super() { } explicit vertex_iterator(typename vertices_list_type::const_iterator it) : super(it) { } vertex_descriptor dereference() const { /* :( const_cast makes me sad but constness is defined by the graph * parameter of bgl api calls */ return vertex_descriptor( const_cast(&*super::base())); } }; class edge_iterator : public boost::iterator_facade< edge_iterator, edge_descriptor, boost::forward_traversal_tag, /* TODO: make bidi */ edge_descriptor> { public: using main_base_iter_type = vertex_iterator; using aux_base_iter_type = out_edge_iterator; edge_iterator(main_base_iter_type b, main_base_iter_type e) : main(std::move(b)), main_end(std::move(e)) { if (main == main_end) { return; } std::tie(aux, aux_end) = out_edges_impl(*main); while (aux == aux_end) { ++main; if (main == main_end) { break; } std::tie(aux, aux_end) = out_edges_impl(*main); } } edge_iterator() { } friend class boost::iterator_core_access; void increment() { ++aux; while (aux == aux_end) { ++main; if (main == main_end) { break; } std::tie(aux, aux_end) = out_edges_impl(*main); } } bool equal(const edge_iterator &other) const { return main == other.main && (main == main_end || aux == other.aux); } edge_descriptor dereference() const { return *aux; } main_base_iter_type main; main_base_iter_type main_end; aux_base_iter_type aux; aux_base_iter_type aux_end; }; public: static vertex_descriptor null_vertex() { return vertex_descriptor(); } vertex_descriptor add_vertex_impl() { vertex_node *v = new vertex_node(new_serial()); v->props.index = next_vertex_index++; vertices_list.push_back(*v); return vertex_descriptor(v); } void remove_vertex_impl(vertex_descriptor v) { vertex_node *vv = v.raw(); assert(vv->in_edge_list.empty()); assert(vv->out_edge_list.empty()); vertices_list.erase_and_dispose(vertices_list.iterator_to(*vv), delete_disposer()); } void clear_in_edges_impl(vertex_descriptor v) { graph_edge_count -= v.raw()->in_edge_list.size(); v.raw()->in_edge_list.clear_and_dispose(in_edge_disposer()); } void clear_out_edges_impl(vertex_descriptor v) { graph_edge_count -= v.raw()->out_edge_list.size(); v.raw()->out_edge_list.clear_and_dispose(out_edge_disposer()); } /* IncidenceGraph concept functions */ static vertex_descriptor source_impl(edge_descriptor e) { return vertex_descriptor(e.raw()->source); } static vertex_descriptor target_impl(edge_descriptor e) { return vertex_descriptor(e.raw()->target); } static degree_size_type out_degree_impl(vertex_descriptor v) { return v.raw()->out_edge_list.size(); } static std::pair out_edges_impl(vertex_descriptor v) { return {out_edge_iterator(v.raw()->out_edge_list.begin()), out_edge_iterator(v.raw()->out_edge_list.end())}; } /* BidirectionalGraph concept functions */ static degree_size_type in_degree_impl(vertex_descriptor v) { return v.raw()->in_edge_list.size(); } static std::pair in_edges_impl(vertex_descriptor v) { return {in_edge_iterator(v.raw()->in_edge_list.begin()), in_edge_iterator(v.raw()->in_edge_list.end())}; } /* Note: this is defined so that self loops are counted twice - which may or * may not be what you want. Actually, you probably don't want this at * all. */ static degree_size_type degree_impl(vertex_descriptor v) { return in_degree_impl(v) + out_degree_impl(v); } /* AdjacencyList concept functions */ static std::pair adjacent_vertices_impl(vertex_descriptor v) { auto out_edge_its = out_edges_impl(v); return {adjacency_iterator(out_edge_its.first), adjacency_iterator(out_edge_its.second)}; } /* AdjacencyMatrix concept functions * (Note: complexity guarantee is not met) */ std::pair edge_impl(vertex_descriptor u, vertex_descriptor v) const { if (in_degree_impl(v) < out_degree_impl(u)) { for (const edge_descriptor &e : in_edges_range(v, *this)) { if (source_impl(e) == u) { return {e, true}; } } } else { for (const edge_descriptor &e : out_edges_range(u, *this)) { if (target_impl(e) == v) { return {e, true}; } } } return {edge_descriptor(), false}; } /* Misc functions that don't actually seem to belong to a formal BGL concept. */ static edge_descriptor null_edge() { return edge_descriptor(); } static std::pair inv_adjacent_vertices_impl(vertex_descriptor v) { auto in_edge_its = in_edges_impl(v); return {inv_adjacency_iterator(in_edge_its.first), inv_adjacency_iterator(in_edge_its.second)}; } /* MutableGraph concept functions */ std::pair add_edge_impl(vertex_descriptor u, vertex_descriptor v) { bool added = true; /* we always allow parallel edges */ edge_node *e = new edge_node(new_serial()); e->source = u.raw(); e->target = v.raw(); e->props.index = next_edge_index++; u.raw()->out_edge_list.push_back(*e); v.raw()->in_edge_list.push_back(*e); graph_edge_count++; return {edge_descriptor(e), added}; } void remove_edge_impl(edge_descriptor e) { graph_edge_count--; vertex_node *u = e.raw()->source; vertex_node *v = e.raw()->target; v->in_edge_list.erase(v->in_edge_list.iterator_to(*e.raw())); u->out_edge_list.erase(u->out_edge_list.iterator_to(*e.raw())); delete e.raw(); } template void remove_out_edge_if_impl(vertex_descriptor v, Predicate pred) { out_edge_iterator it, ite; std::tie(it, ite) = out_edges_impl(v); while (it != ite) { auto jt = it; ++it; if (pred(*jt)) { this->remove_edge_impl(*jt); } } } template void remove_in_edge_if_impl(vertex_descriptor v, Predicate pred) { in_edge_iterator it, ite; std::tie(it, ite) = in_edges_impl(v); while (it != ite) { auto jt = it; ++it; if (pred(*jt)) { remove_edge_impl(*jt); } } } template void remove_edge_if_impl(Predicate pred) { edge_iterator it, ite; std::tie(it, ite) = edges_impl(); while (it != ite) { auto jt = it; ++it; if (pred(*jt)) { remove_edge_impl(*jt); } } } private: /* GCC 4.8 has bugs with lambdas in templated friend functions, so: */ struct source_match { explicit source_match(const vertex_descriptor &uu) : u(uu) { } bool operator()(edge_descriptor e) const { return source_impl(e) == u; } const vertex_descriptor &u; }; struct target_match { explicit target_match(const vertex_descriptor &vv) : v(vv) { } bool operator()(edge_descriptor e) const { return target_impl(e) == v; } const vertex_descriptor &v; }; public: /* Note: (u,v) variant needs to remove all (parallel) edges between (u,v). * * The edge_descriptor version should be strongly preferred if the * edge_descriptor is available. */ void remove_edge_impl(const vertex_descriptor &u, const vertex_descriptor &v) { if (in_degree_impl(v) < out_degree_impl(u)) { remove_in_edge_if_impl(v, source_match(u)); } else { remove_out_edge_if_impl(u, target_match(v)); } } /* VertexListGraph concept functions */ vertices_size_type num_vertices_impl() const { return vertices_list.size(); } std::pair vertices_impl() const { return {vertex_iterator(vertices_list.begin()), vertex_iterator(vertices_list.end())}; } /* EdgeListGraph concept functions (aside from those in IncidenceGraph) */ edges_size_type num_edges_impl() const { return graph_edge_count; } std::pair edges_impl() const { vertex_iterator vi, ve; std::tie(vi, ve) = vertices_impl(); return {edge_iterator(vi, ve), edge_iterator(ve, ve)}; } /* bundled properties functions */ vertex_property_type &operator[](vertex_descriptor v) { return v.raw()->props; } const vertex_property_type &operator[](vertex_descriptor v) const { return v.raw()->props; } edge_property_type &operator[](edge_descriptor e) { return e.raw()->props; } const edge_property_type &operator[](edge_descriptor e) const { return e.raw()->props; } /* PropertyGraph concept functions & helpers */ template struct prop_map : public boost::put_get_helper > { using value_type = typename std::decay::type; using reference = R; using key_type = typename bundle_key_type::type; typedef typename boost::lvalue_property_map_tag category; prop_map(value_type P_of::*m_in) : member(m_in) { } reference operator[](key_type k) const { return k.raw()->props.*member; } reference operator()(key_type k) const { return (*this)[k]; } private: value_type P_of::*member; }; template struct prop_map_all : public boost::put_get_helper > { using value_type = typename std::decay::type; using reference = R; using key_type = typename bundle_key_type::type; typedef typename boost::lvalue_property_map_tag category; reference operator[](key_type k) const { return k.raw()->props; } reference operator()(key_type k) const { return (*this)[k]; } }; template friend prop_map get(P_type P_of::*t, Graph &) { return prop_map(t); } template friend prop_map get(P_type P_of::*t, const Graph &) { return prop_map(t); } /* We can't seem to use auto/decltype returns here as it seems that the * templated member functions are not yet visible when the compile is * evaluating the decltype for the return value. We could probably work * around it by making this a dummy templated function. */ friend prop_map get(boost::vertex_index_t, Graph &g) { return get(&VertexPropertyType::index, g); } friend prop_map get(boost::vertex_index_t, const Graph &g) { return get(&VertexPropertyType::index, g); } friend prop_map get(boost::edge_index_t, Graph &g) { return get(&EdgePropertyType::index, g); } friend prop_map get(boost::edge_index_t, const Graph &g) { return get(&EdgePropertyType::index, g); } friend prop_map_all get(boost::vertex_all_t, Graph &) { return {}; } friend prop_map_all get(boost::vertex_all_t, const Graph &) { return {}; } friend prop_map_all get(boost::edge_all_t, Graph &) { return {}; } friend prop_map_all get(boost::edge_all_t, const Graph &) { return {}; } friend prop_map_all get(boost::vertex_bundle_t, Graph &) { return {}; } friend prop_map_all get(boost::vertex_bundle_t, const Graph &) { return {}; } friend prop_map_all get(boost::edge_bundle_t, Graph &) { return {}; } friend prop_map_all get(boost::edge_bundle_t, const Graph &) { return {}; } template friend auto get(Prop p, Graph &g, K key) -> decltype(get(p, g)[key]) { return get(p, g)[key]; } template friend auto get(Prop p, const Graph &g, K key) -> decltype(get(p, g)[key]) { return get(p, g)[key]; } template friend void put(Prop p, Graph &g, K key, const V &value) { get(p, g)[key] = value; } /* MutablePropertyGraph concept functions */ /* Note: add_vertex(g, vp) allocates a next index value for the vertex * rather than using the index in vp. i.e., except for in rare coincidences: * g[add_vertex(g, vp)].index != vp.index */ vertex_descriptor add_vertex_impl(const VertexPropertyType &vp) { vertex_descriptor v = add_vertex_impl(); auto i = (*this)[v].index; (*this)[v] = vp; (*this)[v].index = i; return v; } /* Note: add_edge(u, v, g, vp) allocates a next index value for the edge * rather than using the index in ep. i.e., except for in rare coincidences: * g[add_edge(u, v, g, ep)].index != ep.index */ std::pair add_edge_impl(vertex_descriptor u, vertex_descriptor v, const EdgePropertyType &ep) { auto e = add_edge_impl(u, v); auto i = (*this)[e.first].index; (*this)[e.first] = ep; (*this)[e.first].index = i; return e; } /* End MutablePropertyGraph */ /** Pack the edge index into a contiguous range [ 0, num_edges(g) ). */ void renumber_edges_impl() { next_edge_index = 0; edge_iterator it; edge_iterator ite; for (std::tie(it, ite) = edges_impl(); it != ite; ++it) { (*this)[*it].index = next_edge_index++; } } /** Pack the vertex index into a contiguous range [ 0, num_vertices(g) ). * Vertices with indices less than N_SPECIAL_VERTICES are not renumbered. */ void renumber_vertices_impl() { DEBUG_PRINTF("renumbering above %zu\n", Graph::N_SPECIAL_VERTICES); next_vertex_index = Graph::N_SPECIAL_VERTICES; vertex_iterator it; vertex_iterator ite; for (std::tie(it, ite) = vertices_impl(); it != ite; ++it) { if ((*this)[*it].index < Graph::N_SPECIAL_VERTICES) { continue; } (*this)[*it].index = next_vertex_index++; } } /** Returns what the next allocated vertex index will be. This is an upper * on the values of index for vertices (vertex removal means that there may * be gaps). */ vertices_size_type vertex_index_upper_bound_impl() const { return next_vertex_index; } /** Returns what the next allocated edge index will be. This is an upper on * the values of index for edges (edge removal means that there may be * gaps). */ vertices_size_type edge_index_upper_bound_impl() const { return next_edge_index; } using directed_category = boost::directed_tag; using edge_parallel_category = boost::allow_parallel_edge_tag; struct traversal_category : public virtual boost::bidirectional_graph_tag, public virtual boost::adjacency_graph_tag, public virtual boost::vertex_list_graph_tag, public virtual boost::edge_list_graph_tag { }; ue2_graph() = default; ue2_graph(ue2_graph &&old) : next_vertex_index(old.next_vertex_index), next_edge_index(old.next_edge_index), graph_edge_count(old.graph_edge_count), next_serial(old.next_serial) { using std::swap; swap(vertices_list, old.vertices_list); } ue2_graph &operator=(ue2_graph &&old) { next_vertex_index = old.next_vertex_index; next_edge_index = old.next_edge_index; graph_edge_count = old.graph_edge_count; next_serial = old.next_serial; using std::swap; swap(vertices_list, old.vertices_list); return *this; } ~ue2_graph() { vertices_list.clear_and_dispose(delete_disposer()); } }; template typename std::enable_if< std::is_base_of::value, typename Graph::vertex_descriptor>::type add_vertex(Graph &g) { return g.add_vertex_impl(); } template typename std::enable_if< std::is_base_of::value>::type remove_vertex(typename Graph::vertex_descriptor v, Graph &g) { g.remove_vertex_impl(v); } template typename std::enable_if< std::is_base_of::value>::type clear_in_edges(typename Graph::vertex_descriptor v, Graph &g) { g.clear_in_edges_impl(v); } template typename std::enable_if< std::is_base_of::value>::type clear_out_edges(typename Graph::vertex_descriptor v, Graph &g) { g.clear_out_edges_impl(v); } template typename std::enable_if< std::is_base_of::value>::type clear_vertex(typename Graph::vertex_descriptor v, Graph &g) { g.clear_in_edges_impl(v); g.clear_out_edges_impl(v); } template typename std::enable_if< std::is_base_of::value, typename Graph::vertex_descriptor>::type source(typename Graph::edge_descriptor e, const Graph &) { return Graph::source_impl(e); } template typename std::enable_if< std::is_base_of::value, typename Graph::vertex_descriptor>::type target(typename Graph::edge_descriptor e, const Graph &) { return Graph::target_impl(e); } template typename std::enable_if< std::is_base_of::value, typename Graph::degree_size_type>::type out_degree(typename Graph::vertex_descriptor v, const Graph &) { return Graph::out_degree_impl(v); } template typename std::enable_if< std::is_base_of::value, std::pair>::type out_edges(typename Graph::vertex_descriptor v, const Graph &) { return Graph::out_edges_impl(v); } template typename std::enable_if< std::is_base_of::value, typename Graph::degree_size_type>::type in_degree(typename Graph::vertex_descriptor v, const Graph &) { return Graph::in_degree_impl(v); } template typename std::enable_if< std::is_base_of::value, std::pair>::type in_edges(typename Graph::vertex_descriptor v, const Graph &) { return Graph::in_edges_impl(v); } template typename std::enable_if< std::is_base_of::value, typename Graph::degree_size_type>::type degree(typename Graph::vertex_descriptor v, const Graph &) { return Graph::degree_impl(v); } template typename std::enable_if< std::is_base_of::value, std::pair>::type adjacent_vertices(typename Graph::vertex_descriptor v, const Graph &) { return Graph::adjacent_vertices_impl(v); } template typename std::enable_if< std::is_base_of::value, std::pair>::type edge(typename Graph::vertex_descriptor u, typename Graph::vertex_descriptor v, const Graph &g) { return g.edge_impl(u, v); } template typename std::enable_if< std::is_base_of::value, std::pair>::type inv_adjacent_vertices(typename Graph::vertex_descriptor v, const Graph &) { return Graph::inv_adjacent_vertices_impl(v); } template typename std::enable_if< std::is_base_of::value, std::pair>::type add_edge(typename Graph::vertex_descriptor u, typename Graph::vertex_descriptor v, Graph &g) { return g.add_edge_impl(u, v); } template typename std::enable_if< std::is_base_of::value>::type remove_edge(typename Graph::edge_descriptor e, Graph &g) { g.remove_edge_impl(e); } template typename std::enable_if< !std::is_convertible::value && std::is_base_of::value>::type remove_edge(Iter it, Graph &g) { g.remove_edge_impl(*it); } template typename std::enable_if< std::is_base_of::value>::type remove_out_edge_if(typename Graph::vertex_descriptor v, Predicate pred, Graph &g) { g.remove_out_edge_if_impl(v, pred); } template typename std::enable_if< std::is_base_of::value>::type remove_in_edge_if(typename Graph::vertex_descriptor v, Predicate pred, Graph &g) { g.remove_in_edge_if_impl(v, pred); } template typename std::enable_if< std::is_base_of::value>::type remove_edge_if(Predicate pred, Graph &g) { g.remove_edge_if_impl(pred); } template typename std::enable_if< std::is_base_of::value>::type remove_edge(const typename Graph::vertex_descriptor &u, const typename Graph::vertex_descriptor &v, Graph &g) { g.remove_edge_impl(u, v); } template typename std::enable_if< std::is_base_of::value, typename Graph::vertices_size_type>::type num_vertices(const Graph &g) { return g.num_vertices_impl(); } template typename std::enable_if< std::is_base_of::value, std::pair>::type vertices(const Graph &g) { return g.vertices_impl(); } template typename std::enable_if< std::is_base_of::value, typename Graph::edges_size_type>::type num_edges(const Graph &g) { return g.num_edges_impl(); } template typename std::enable_if< std::is_base_of::value, std::pair>::type edges(const Graph &g) { return g.edges_impl(); } template typename std::enable_if< std::is_base_of::value, typename Graph::vertex_descriptor>::type add_vertex(const typename Graph::vertex_property_type &vp, Graph &g) { return g.add_vertex_impl(vp); } template typename std::enable_if< std::is_base_of::value, std::pair>::type add_edge(typename Graph::vertex_descriptor u, typename Graph::vertex_descriptor v, const typename Graph::edge_property_type &ep, Graph &g) { return g.add_edge_impl(u, v, ep); } template typename std::enable_if< std::is_base_of::value>::type renumber_edges(Graph &g) { g.renumber_edges_impl(); } template typename std::enable_if< std::is_base_of::value>::type renumber_vertices(Graph &g) { g.renumber_vertices_impl(); } template typename std::enable_if< std::is_base_of::value, typename Graph::vertices_size_type>::type vertex_index_upper_bound(const Graph &g) { return g.vertex_index_upper_bound_impl(); } template typename std::enable_if< std::is_base_of::value, typename Graph::edges_size_type>::type edge_index_upper_bound(const Graph &g) { return g.edge_index_upper_bound_impl(); } using boost::vertex_index; using boost::edge_index; } namespace boost { /* Install partial specialisation of property_map - this is required for * adaptors (like filtered_graph) to know the type of the property maps */ template struct property_map::value >::type > { typedef decltype(get(std::declval(), std::declval())) type; typedef decltype(get(std::declval(), std::declval())) const_type; }; } #endif hyperscan-4.4.1/src/util/partial_store.h0000644000175000017500000001136013055426554021065 0ustar sleuthkidsleuthkid/* * 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 PARTIAL_STORE_H #define PARTIAL_STORE_H #include "ue2common.h" #include "unaligned.h" /* loads/stores the least significant bytes of the values. */ static really_inline void partial_store_u32(void *ptr, u32 value, u32 numBytes) { assert(numBytes <= 4); switch (numBytes) { case 4: unaligned_store_u32(ptr, value); break; case 3: unaligned_store_u16(ptr, (u16)value); *((u8 *)ptr + 2) = (u8)(value >> 16); break; case 2: unaligned_store_u16(ptr, (u16)value); break; case 1: *(u8 *)ptr = (u8)value; break; case 0: break; } } static really_inline u32 partial_load_u32(const void *ptr, u32 numBytes) { u32 value; assert(numBytes <= 4); switch (numBytes) { case 4: value = unaligned_load_u32(ptr); return value; case 3: value = unaligned_load_u16(ptr); value |= ((u32)(*((const u8 *)ptr + 2)) << 16); return value; case 2: value = unaligned_load_u16(ptr); return value; case 1: value = *(const u8 *)ptr; return value; case 0: break; } return 0; } static really_inline void partial_store_u64a(void *ptr, u64a value, u32 numBytes) { assert(numBytes <= 8); switch (numBytes) { case 8: unaligned_store_u64a(ptr, value); break; case 7: unaligned_store_u32(ptr, (u32)value); unaligned_store_u16((u8 *)ptr + 4, (u16)(value >> 32)); *((u8 *)ptr + 6) = (u8)(value >> 48); break; case 6: unaligned_store_u32(ptr, (u32)value); unaligned_store_u16((u8 *)ptr + 4, (u16)(value >> 32)); break; case 5: unaligned_store_u32(ptr, (u32)value); *((u8 *)ptr + 4) = (u8)(value >> 32); break; case 4: unaligned_store_u32(ptr, (u32)value); break; case 3: unaligned_store_u16(ptr, (u16)value); *((u8 *)ptr + 2) = (u8)(value >> 16); break; case 2: unaligned_store_u16(ptr, (u16)value); break; case 1: *(u8 *)ptr = (u8)value; break; case 0: break; } } static really_inline u64a partial_load_u64a(const void *ptr, u32 numBytes) { u64a value; assert(numBytes <= 8); switch (numBytes) { case 8: value = unaligned_load_u64a(ptr); return value; case 7: value = unaligned_load_u32(ptr); value |= (u64a)unaligned_load_u16((const u8 *)ptr + 4) << 32; value |= (u64a)(*((const u8 *)ptr + 6)) << 48; return value; case 6: value = unaligned_load_u32(ptr); value |= (u64a)unaligned_load_u16((const u8 *)ptr + 4) << 32; return value; case 5: value = unaligned_load_u32(ptr); value |= (u64a)(*((const u8 *)ptr + 4)) << 32; return value; case 4: value = unaligned_load_u32(ptr); return value; case 3: value = unaligned_load_u16(ptr); value |= (u64a)(*((const u8 *)ptr + 2)) << 16; return value; case 2: value = unaligned_load_u16(ptr); return value; case 1: value = *(const u8 *)ptr; return value; case 0: break; } return 0; } #endif hyperscan-4.4.1/src/util/multibit_build.h0000644000175000017500000000525313055426554021231 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Multibit: build code (for sparse iterators) */ #ifndef MULTIBIT_BUILD_H #define MULTIBIT_BUILD_H #include "multibit_internal.h" #include "hash.h" #include inline bool operator==(const mmbit_sparse_iter &a, const mmbit_sparse_iter &b) { return a.mask == b.mask && a.val == b.val; } inline size_t hash_value(const mmbit_sparse_iter &iter) { return ue2::hash_all(iter.mask, iter.val); } namespace ue2 { /** * \brief Return the size in bytes of a multibit that can store the given * number of bits. * * This will throw a resource limit assertion if the requested mmbit is too * large. */ u32 mmbit_size(u32 total_bits); /** \brief Construct a sparse iterator over the values in \a bits for a * multibit of size \a total_bits. */ void mmbBuildSparseIterator(std::vector &out, const std::vector &bits, u32 total_bits); struct scatter_plan_raw; void mmbBuildInitRangePlan(u32 total_bits, u32 begin, u32 end, scatter_plan_raw *out); void mmbBuildClearPlan(u32 total_bits, scatter_plan_raw *out); } // namespace ue2 #endif // MULTIBIT_BUILD_H hyperscan-4.4.1/src/util/alloc.cpp0000644000175000017500000001030013055426554017633 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Aligned memory alloc/free. */ #include "ue2common.h" #include "alloc.h" #include #include namespace ue2 { // This is one of the simplest ways to catch failure where we aren't using an // aligned_(zmalloc|_free) pair - it will force death if the wrong free is used. // We use this whenever assertions are switched on. #if !defined(NDEBUG) #define HACK_OFFSET 64 #else #define HACK_OFFSET 0 #endif /* get us a posix_memalign from somewhere */ #if !defined(HAVE_POSIX_MEMALIGN) # if defined(HAVE_MEMALIGN) #define posix_memalign(A, B, C) ((*A = (void *)memalign(B, C)) == nullptr) # elif defined(HAVE__ALIGNED_MALLOC) /* on Windows */ #include #define posix_memalign(A, B, C) ((*A = (void *)_aligned_malloc(C, B)) == nullptr) # else #error no posix_memalign or memalign aligned malloc # endif #endif void *aligned_malloc_internal(size_t size, size_t align) { void *mem; #if !defined(_WIN32) int rv = posix_memalign(&mem, align, size); if (rv != 0) { DEBUG_PRINTF("posix_memalign returned %d when asked for %zu bytes\n", rv, size); return nullptr; } #else if (nullptr == (mem = _aligned_malloc(size, align))) { DEBUG_PRINTF("_aligned_malloc failed when asked for %zu bytes\n", size); return nullptr; } #endif assert(mem); return mem; } void aligned_free_internal(void *ptr) { if (!ptr) { return; } #if defined(_WIN32) _aligned_free(ptr); #else free(ptr); #endif } /** \brief 64-byte aligned, zeroed malloc. * * Pointers should be freed with \ref aligned_free. If we are unable to * allocate the requested number of bytes, this function will throw * std::bad_alloc. */ void *aligned_zmalloc(size_t size) { // Really huge allocations are probably an indication that we've // done something wrong. assert(size < 1024 * 1024 * 1024); // 1GB const size_t alloc_size = size + HACK_OFFSET; void *mem = aligned_malloc_internal(alloc_size, 64); if (!mem) { DEBUG_PRINTF("unable to allocate %zu bytes\n", alloc_size); throw std::bad_alloc(); } DEBUG_PRINTF("alloced %p reporting %p\n", mem, (char *)mem + HACK_OFFSET); assert(ISALIGNED_N(mem, 64)); memset(mem, 0, alloc_size); return (void *)((char *)mem + HACK_OFFSET); } /** \brief Free a pointer allocated with \ref aligned_zmalloc. */ void aligned_free(void *ptr) { if (!ptr) { return; } void *addr = (void *)((char *)ptr - HACK_OFFSET); DEBUG_PRINTF("asked to free %p freeing %p\n", ptr, addr); assert(ISALIGNED_N(addr, 64)); aligned_free_internal(addr); } } // namespace ue2 hyperscan-4.4.1/src/util/queue_index_factory.h0000644000175000017500000000400713055426554022257 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief QueueIndexFactory used to hand out NFA queues at compile time. */ #ifndef UTIL_QUEUE_INDEX_FACTORY_H #define UTIL_QUEUE_INDEX_FACTORY_H #include "ue2common.h" #include namespace ue2 { class QueueIndexFactory : boost::noncopyable { public: QueueIndexFactory() : val(0) {} u32 get_queue() { return val++; } u32 allocated_count() const { return val; } private: u32 val; }; } // namespace ue2 #endif // UTIL_QUEUE_INDEX_FACTORY_H hyperscan-4.4.1/src/util/clique.h0000644000175000017500000000430213055426554017475 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief An algorithm to find cliques. */ #ifndef CLIQUE_H #define CLIQUE_H #include "ue2common.h" #include #include namespace ue2 { struct CliqueVertexProps { CliqueVertexProps() {} explicit CliqueVertexProps(u32 state_in) : stateId(state_in) {} u32 stateId = ~0U; }; typedef boost::adjacency_list CliqueGraph; typedef CliqueGraph::vertex_descriptor CliqueVertex; /** \brief Returns a vector of cliques found in a graph. */ std::vector> removeClique(CliqueGraph &cg); } // namespace ue2 #endif hyperscan-4.4.1/src/util/compile_error.cpp0000644000175000017500000000431113055426554021407 0ustar sleuthkidsleuthkid/* * 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. */ #include "compile_error.h" using namespace std; namespace ue2 { CompileError::CompileError(const string &why) : reason(why), hasIndex(false), index(0) { assert(!why.empty()); assert(*why.rbegin() == '.'); } CompileError::CompileError(unsigned int idx, const string &why) : reason(why), hasIndex(true), index(idx) { assert(!why.empty()); assert(*why.rbegin() == '.'); } void CompileError::setExpressionIndex(u32 expr_index) { hasIndex = true; index = expr_index; } CompileError::~CompileError() {} ResourceLimitError::ResourceLimitError() : CompileError("Resource limit exceeded.") {} ResourceLimitError::~ResourceLimitError() {} } // namespace ue2 hyperscan-4.4.1/src/util/charreach.cpp0000644000175000017500000001102013055426554020461 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Class for representing character reachability. * * This is a simple (but hopefully fast) class for representing 8-bit character * reachability, along with a bunch of useful operations. */ #include "ue2common.h" #include "charreach.h" #include "charreach_util.h" #include "compare.h" #include "unicode_def.h" #include #include namespace ue2 { /// Switch on the bits corresponding to the characters in \a s. void CharReach::set(const std::string &s) { for (const auto &c : s) { set(c); } } /// Do we only contain bits representing alpha characters? bool CharReach::isAlpha() const { if (none()) { return false; } for (size_t i = find_first(); i != npos; i = find_next(i)) { if (!ourisalpha((char)i)) { return false; } } return true; } /// Do we represent an uppercase/lowercase pair? bool CharReach::isCaselessChar() const { if (count() != 2) { return false; } size_t first = find_first(); size_t second = find_next(first); assert(first != npos && second != npos); return (char)first == mytoupper((char)second); } /// Do we represent a cheapskate caseless set? bool CharReach::isBit5Insensitive() const { for (size_t i = find_first(); i != npos; i = find_next(i)) { if (!test((char)i ^ 0x20)) { return false; } } return true; } /// Return a string containing the characters that are switched on. std::string CharReach::to_string() const { std::string s; for (size_t i = find_first(); i != npos; i = find_next(i)) { s += (char)i; } return s; } /** \brief True iff there is a non-empty intersection between \a and \a b */ bool overlaps(const CharReach &a, const CharReach &b) { return (a & b).any(); } /** \brief True iff \a small is a subset of \a big. */ bool isSubsetOf(const CharReach &small, const CharReach &big) { return small.isSubsetOf(big); } /// True if this character class is a subset of \a other. bool CharReach::isSubsetOf(const CharReach &other) const { return (bits & other.bits) == bits; } void make_caseless(CharReach *cr) { for (char c = 'A'; c <= 'Z'; c++) { if (cr->test(c) || cr->test(mytolower(c))) { cr->set(c); cr->set(mytolower(c)); } } } bool isutf8ascii(const CharReach &cr) { return (cr & ~CharReach(0x0, 0x7f)).none(); } bool isutf8start(const CharReach &cr) { return (cr & CharReach(0x0, UTF_CONT_MAX)).none(); } void fill_bitvector(const CharReach &cr, u8 *bits) { assert(bits); std::fill_n(bits, 32, 0); for (size_t i = cr.find_first(); i != cr.npos; i = cr.find_next(i)) { bits[i / 8U] |= (u8)1U << (i % 8U); } } void make_and_cmp_mask(const CharReach &cr, u8 *and_mask, u8 *cmp_mask) { u8 lo = 0xff; u8 hi = 0; for (size_t c = cr.find_first(); c != cr.npos; c = cr.find_next(c)) { hi |= (u8)c; lo &= (u8)c; } *and_mask = ~(lo ^ hi); *cmp_mask = lo; } } // namespace ue2 hyperscan-4.4.1/src/util/graph.h0000644000175000017500000002244313055426554017322 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Functions for graph manipulation that aren't in the base BGL toolkit. */ #ifndef UTIL_GRAPH_H #define UTIL_GRAPH_H #include "container.h" #include "ue2common.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include #include #include #include #include #include #include #include namespace ue2 { /** \brief True if the given vertex has no out-edges. */ template bool isLeafNode(const typename Graph::vertex_descriptor& v, const Graph& g) { return out_degree(v, g) == 0; } /** \brief True if vertex \a v has an edge to itself. */ template bool hasSelfLoop(const typename Graph::vertex_descriptor &v, const Graph &g) { return edge(v, v, g).second; } /** \brief True if any vertex in [it, end) has an edge to itself. */ template bool anySelfLoop(const Graph &g, Iterator it, const Iterator &end) { for (; it != end; ++it) { if (hasSelfLoop(*it, g)) { return true; } } return false; } /** \brief Returns the out-degree of vertex \a v, ignoring self-loops. */ template size_t proper_out_degree(const typename Graph::vertex_descriptor &v, const Graph &g) { return out_degree(v, g) - (edge(v, v, g).second ? 1 : 0); } /** \brief Returns the in-degree of vertex \a v, ignoring self-loops. */ template size_t proper_in_degree(const typename Graph::vertex_descriptor &v, const Graph &g) { return in_degree(v, g) - (edge(v, v, g).second ? 1 : 0); } /** \brief True if vertex \a v has at least one successor. */ template bool has_successor(const typename Graph::vertex_descriptor &v, const Graph &g) { return out_degree(v, g) > 0; } /** \brief True if vertex \a v has at least one successor other than itself. */ template bool has_proper_successor(const typename Graph::vertex_descriptor &v, const Graph &g) { typename Graph::adjacency_iterator ai, ae; std::tie(ai, ae) = adjacent_vertices(v, g); if (ai == ae) { return false; } if (*ai == v) { ++ai; // skip self-loop } return ai != ae; } /** \brief Find the set of vertices that are reachable from the vertices in \a * sources. */ template void find_reachable(const Graph &g, const SourceCont &sources, OutCont *out) { using vertex_descriptor = typename Graph::vertex_descriptor; ue2::unordered_map colours; for (auto v : sources) { boost::depth_first_visit(g, v, boost::make_dfs_visitor(boost::null_visitor()), boost::make_assoc_property_map(colours)); } for (const auto &e : colours) { out->insert(e.first); } } /** \brief Find the set of vertices that are NOT reachable from the vertices in * \a sources. */ template void find_unreachable(const Graph &g, const SourceCont &sources, OutCont *out) { using vertex_descriptor = typename Graph::vertex_descriptor; ue2::unordered_set reachable; find_reachable(g, sources, &reachable); for (const auto &v : vertices_range(g)) { if (!contains(reachable, v)) { out->insert(v); } } } template ue2::flat_set find_vertices_in_cycles(const Graph &g) { using vertex_descriptor = typename Graph::vertex_descriptor; std::map comp_map; boost::strong_components(g, boost::make_assoc_property_map(comp_map)); std::map> comps; for (const auto &e : comp_map) { comps[e.second].push_back(e.first); } ue2::flat_set rv; for (const auto &comp : comps | boost::adaptors::map_values) { /* every vertex in a strongly connected component is reachable from * every other vertex in the component. A vertex is involved in a cycle * therefore if it is in a strongly connected component with more than * one vertex or if it is the only vertex and it has a self loop. */ assert(!comp.empty()); if (comp.size() > 1) { insert(&rv, comp); } vertex_descriptor v = *comp.begin(); if (hasSelfLoop(v, g)) { rv.insert(v); } } return rv; } template bool has_parallel_edge(const Graph &g) { using vertex_descriptor = typename Graph::vertex_descriptor; ue2::unordered_set> seen; for (const auto &e : edges_range(g)) { auto u = source(e, g); auto v = target(e, g); if (!seen.emplace(u, v).second) { return true; } } return false; } struct found_back_edge {}; struct detect_back_edges : public boost::default_dfs_visitor { explicit detect_back_edges(bool ignore_self_in) : ignore_self(ignore_self_in) {} template void back_edge(const typename Graph::edge_descriptor &e, const Graph &g) const { if (ignore_self && source(e, g) == target(e, g)) { return; } throw found_back_edge(); } bool ignore_self; }; template bool is_dag(const Graph &g, bool ignore_self_loops = false) { try { depth_first_search(g, visitor(detect_back_edges(ignore_self_loops))); } catch (const found_back_edge &) { return false; } return true; } template class vertex_recorder : public boost::default_dfs_visitor { public: explicit vertex_recorder(Cont &o) : out(o) {} template void discover_vertex(typename Cont::value_type v, const G &) { out.insert(v); } Cont &out; }; template vertex_recorder make_vertex_recorder(Cont &o) { return vertex_recorder(o); } template std::pair add_edge_if_not_present(typename Graph::vertex_descriptor u, typename Graph::vertex_descriptor v, Graph &g) { std::pair e = edge(u, v, g); if (!e.second) { e = add_edge(u, v, g); } return e; } template std::pair add_edge_if_not_present( typename Graph::vertex_descriptor u, typename Graph::vertex_descriptor v, const typename Graph::edge_property_type &prop, Graph &g) { std::pair e = edge(u, v, g); if (!e.second) { e = add_edge(u, v, prop, g); } return e; } #ifndef NDEBUG template bool hasCorrectlyNumberedVertices(const Graph &g) { auto count = num_vertices(g); std::vector ids(count, false); for (auto v : vertices_range(g)) { auto id = g[v].index; if (id >= count || ids[id]) { return false; // duplicate } ids[id] = true; } return std::find(ids.begin(), ids.end(), false) == ids.end() && count == vertex_index_upper_bound(g); } template bool hasCorrectlyNumberedEdges(const Graph &g) { auto count = num_edges(g); std::vector ids(count, false); for (const auto &e : edges_range(g)) { auto id = g[e].index; if (id >= count || ids[id]) { return false; // duplicate } ids[id] = true; } return std::find(ids.begin(), ids.end(), false) == ids.end() && count == edge_index_upper_bound(g); } #endif } // namespace ue2 #endif // UTIL_GRAPH_H hyperscan-4.4.1/src/util/compile_context.cpp0000644000175000017500000000377713055426554021761 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Global compile context, describes compile environment. */ #include "compile_context.h" #include "grey.h" namespace ue2 { CompileContext::CompileContext(bool in_isStreaming, bool in_isVectored, const target_t &in_target_info, const Grey &in_grey) : streaming(in_isStreaming || in_isVectored), vectored(in_isVectored), target_info(in_target_info), grey(in_grey) { } } // namespace ue2 hyperscan-4.4.1/src/util/multibit_build.cpp0000644000175000017500000002512513055426554021564 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Multibit: build code (for sparse iterators) */ #include "multibit.h" #include "multibit_build.h" #include "scatter.h" #include "ue2common.h" #include "rose/rose_build_scatter.h" #include "util/compile_error.h" #include #include // for memset #include #include #include using namespace std; namespace ue2 { u32 mmbit_size(u32 total_bits) { if (total_bits > MMB_MAX_BITS) { throw ResourceLimitError(); } // Flat model multibit structures are just stored as a bit vector. if (total_bits <= MMB_FLAT_MAX_BITS) { return ROUNDUP_N(total_bits, 8) / 8; } u64a current_level = 1; // Number of blocks on current level. u64a total = 0; // Total number of blocks. while (current_level * MMB_KEY_BITS < total_bits) { total += current_level; current_level <<= MMB_KEY_SHIFT; } // Last level is a one-for-one bit vector. It needs room for total_bits // elements, rounded up to the nearest block. u64a last_level = ((u64a)total_bits + MMB_KEY_BITS - 1) / MMB_KEY_BITS; total += last_level; assert(total * sizeof(MMB_TYPE) <= UINT32_MAX); return (u32)(total * sizeof(MMB_TYPE)); } namespace { struct TreeNode { MMB_TYPE mask = 0; u32 depth = 0; map children; // keyed by rkey }; } // namespace static void addNode(TreeNode &tree, u32 depth, u32 key, s32 ks, u32 rkey) { u32 bit = (key >> ks) & MMB_KEY_MASK; DEBUG_PRINTF("depth=%u, key=%u, ks=%d, rkey=%u, bit=%u\n", depth, key, ks, rkey, bit); mmb_set(&tree.mask, bit); // add bit to this level tree.depth = depth; // record depth // next level rkey = (rkey << MMB_KEY_SHIFT) + bit; ks -= MMB_KEY_SHIFT; depth++; if (ks >= 0) { addNode(tree.children[rkey], depth, key, ks, rkey); } } static void bfs(vector &out, const TreeNode &tree) { queue q; q.push(&tree); vector levels; u32 depth = 0; DEBUG_PRINTF("walking q\n"); while (!q.empty()) { const TreeNode *t = q.front(); q.pop(); if (depth != t->depth) { depth = t->depth; levels.push_back(out.size()); } DEBUG_PRINTF("pop: mask=0x%08llx, depth=%u, children.size()=%zu\n", t->mask, t->depth, t->children.size()); out.push_back(mmbit_sparse_iter()); memset(&out.back(), 0, sizeof(mmbit_sparse_iter)); mmbit_sparse_iter &record = out.back(); record.mask = t->mask; record.val = 0; for (auto &e : t->children) { q.push(&e.second); } } // val for records in non-last levels is the iterator array start offset // for that iterator record's children u32 start = 0; for (size_t i = 0; i < levels.size(); i++) { u32 start_next = levels[i]; u32 population = 0; DEBUG_PRINTF("next level starts at %u\n", start_next); for (u32 j = start; j < start_next; j++) { out[j].val = start_next + population; DEBUG_PRINTF(" children of %u start at %u\n", j, out[j].val); population += mmb_popcount(out[j].mask); } start = start_next; } // val for records in the last level is the cumulative popcount u32 population = 0; for (size_t i = start; i < out.size(); i++) { DEBUG_PRINTF("last level: i=%zu, population=%u\n", i, population); out[i].val = population; population += mmb_popcount(out[i].mask); } } /** \brief Construct a sparse iterator over the values in \a bits for a * multibit of size \a total_bits. */ void mmbBuildSparseIterator(vector &out, const vector &bits, u32 total_bits) { assert(out.empty()); assert(!bits.empty()); assert(total_bits > 0); assert(total_bits <= MMB_MAX_BITS); DEBUG_PRINTF("building sparse iter for %zu of %u bits\n", bits.size(), total_bits); s32 ks = (total_bits > 1 ? mmbit_keyshift(total_bits) : 0); // Construct an intermediate tree TreeNode tree; for (const auto &bit : bits) { assert(bit < total_bits); addNode(tree, 0, bit, ks, 0); } // From our intermediate tree, lay the data out with a breadth-first walk bfs(out, tree); assert(!out.empty()); #ifdef DEBUG DEBUG_PRINTF("dump of iterator tree:\n"); for (size_t i = 0; i < out.size(); ++i) { printf(" %zu:\tmask=0x%08llx, val=%u\n", i, out[i].mask, out[i].val); } #endif DEBUG_PRINTF("iter has %zu records\n", out.size()); } template static void add_scatter(vector *out, u32 offset, u64a mask) { T su; memset(&su, 0, sizeof(su)); su.offset = offset; su.val = mask; out->push_back(su); DEBUG_PRINTF("add %llu at offset %u\n", mask, offset); } static u32 mmbit_get_level_root_offset(u32 level) { return mmbit_root_offset_from_level[level] * sizeof(MMB_TYPE); } void mmbBuildInitRangePlan(u32 total_bits, u32 begin, u32 end, scatter_plan_raw *out) { DEBUG_PRINTF("building scatter plan for [%u, %u]/%u\n", begin, end, total_bits); if (!total_bits) { return; } if (total_bits <= MMB_FLAT_MAX_BITS) { // Handle flat model cases: first a bunch of 64-bit full-sized blocks, // then a single runt block at the end. u32 dest = 0; // dest offset u32 bits = total_bits; u32 base = 0; for (; bits > 64; bits -= 64, base += 64, dest += 8) { MMB_TYPE mask = get_flat_masks(base, begin, end); add_scatter(&out->p_u64a, dest, mask); } // Last chunk. assert(bits > 0 && bits <= 64); MMB_TYPE mask = get_flat_masks(base, begin, end); if (bits <= 8) { add_scatter(&out->p_u8, dest + 0, mask); } else if (bits <= 16) { add_scatter(&out->p_u16, dest + 0, mask); } else if (bits <= 24) { add_scatter(&out->p_u16, dest + 0, mask); add_scatter(&out->p_u8, dest + 2, mask >> 16); } else if (bits <= 32) { add_scatter(&out->p_u32, dest + 0, mask); } else if (bits <= 40) { add_scatter(&out->p_u32, dest + 0, mask); add_scatter(&out->p_u8, dest + 4, mask >> 32); } else if (bits <= 48) { add_scatter(&out->p_u32, dest + 0, mask); add_scatter(&out->p_u16, dest + 4, mask >> 32); } else if (bits <= 56) { add_scatter(&out->p_u32, dest + 0, mask); add_scatter(&out->p_u16, dest + 4, mask >> 32); add_scatter(&out->p_u8, dest + 6, mask >> 48); } else { add_scatter(&out->p_u64a, dest + 0, mask); } return; } /* handle the multilevel case */ s32 ks = mmbit_keyshift(total_bits); u32 level = 0; assert(sizeof(MMB_TYPE) == sizeof(u64a)); if (begin == end) { add_scatter(&out->p_u64a, 0, 0); return; } for (;;) { u32 block_offset = mmbit_get_level_root_offset(level); u32 k1 = begin >> ks, k2 = end >> ks; // Summary blocks need to account for the runt block on the end. if ((k2 << ks) != end) { k2++; } // Partial block to deal with beginning. block_offset += k1 / MMB_KEY_BITS; if (k1 % MMB_KEY_BITS) { u32 idx = k1 / MMB_KEY_BITS; u32 block_end = (idx + 1) * MMB_KEY_BITS; // Because k1 % MMB_KEY_BITS != 0, we can avoid checking edge cases // here (see the branch in mmb_mask_zero_to). MMB_TYPE mask = (-MMB_ONE) << (k1 % MMB_KEY_BITS); if (k2 < block_end) { assert(k2 % MMB_KEY_BITS); mask &= mmb_mask_zero_to_nocheck(k2 % MMB_KEY_BITS); add_scatter(&out->p_u64a, block_offset, mask); goto next_level; } else { add_scatter(&out->p_u64a, block_offset, mask); k1 = block_end; block_offset += sizeof(MMB_TYPE); } } // Write blocks filled with ones until we get to the last block. for (; k1 < (k2 & ~MMB_KEY_MASK); k1 += MMB_KEY_BITS) { add_scatter(&out->p_u64a, block_offset, -MMB_ONE); block_offset += sizeof(MMB_TYPE); } // Final block. if (likely(k1 < k2)) { // Again, if k2 was at a block boundary, it would have been handled // by the previous loop, so we know k2 % MMB_KEY_BITS != 0 and can // avoid the branch in mmb_mask_zero_to here. assert(k2 % MMB_KEY_BITS); MMB_TYPE mask = mmb_mask_zero_to_nocheck(k2 % MMB_KEY_BITS); add_scatter(&out->p_u64a, block_offset, mask); } next_level: if (ks == 0) { break; // Last level is done, finished. } ks -= MMB_KEY_SHIFT; level++; } } void mmbBuildClearPlan(u32 total_bits, scatter_plan_raw *out) { return mmbBuildInitRangePlan(total_bits, 0, 0, out); } } // namespace ue2 hyperscan-4.4.1/src/util/compile_error.h0000644000175000017500000000501413055426554021055 0ustar sleuthkidsleuthkid/* * 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 UTIL_COMPILE_ERROR_H #define UTIL_COMPILE_ERROR_H #include #include #include #include "ue2common.h" namespace ue2 { /** \brief Error thrown by the compiler, can reference a specific expression * index. */ class CompileError { public: // Note: 'why' should describe why the error occurred and end with a // full stop, but no line break. explicit CompileError(const std::string &why); CompileError(u32 index, const std::string &why); virtual ~CompileError(); void setExpressionIndex(u32 index); std::string reason; //!< Reason for the error bool hasIndex; //!< Does it reference a specific expression? u32 index; //!< The index of the expression referred to }; /** \brief Error thrown by the compiler when an arbitrary resource limit (as * specified in the grey box) is exceeded. */ class ResourceLimitError : public CompileError { public: ResourceLimitError(); ~ResourceLimitError() override; }; } // namespace ue2 #endif hyperscan-4.4.1/src/util/target_info.cpp0000644000175000017500000000441113055426554021050 0ustar sleuthkidsleuthkid/* * 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. */ #include "hs_compile.h" // for various hs_platform_info flags #include "target_info.h" #include "util/cpuid_flags.h" namespace ue2 { target_t get_current_target(void) { hs_platform_info p; p.cpu_features = cpuid_flags(); p.tune = cpuid_tune(); return target_t(p); } bool target_t::can_run_on_code_built_for(const target_t &code_target) const { if (!has_avx2() && code_target.has_avx2()) { return false; } return true; } target_t::target_t(const hs_platform_info &p) : tune(p.tune), cpu_features(p.cpu_features) {} bool target_t::has_avx2(void) const { return (cpu_features & HS_CPU_FEATURES_AVX2); } bool target_t::is_atom_class(void) const { return tune == HS_TUNE_FAMILY_SLM; } } // namespace ue2 hyperscan-4.4.1/src/util/copybytes.h0000644000175000017500000000557513055426554020251 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 COPY_BYTES_H #define COPY_BYTES_H #include "unaligned.h" #include "simd_utils.h" static really_inline void copy_upto_32_bytes(u8 *dst, const u8 *src, unsigned int len) { switch (len) { case 0: break; case 1: *dst = *src; break; case 2: unaligned_store_u16(dst, unaligned_load_u16(src)); break; case 3: unaligned_store_u16(dst, unaligned_load_u16(src)); dst[2] = src[2]; break; case 4: unaligned_store_u32(dst, unaligned_load_u32(src)); break; case 5: case 6: case 7: unaligned_store_u32(dst + len - 4, unaligned_load_u32(src + len - 4)); unaligned_store_u32(dst, unaligned_load_u32(src)); break; case 8: unaligned_store_u64a(dst, unaligned_load_u64a(src)); break; case 9: case 10: case 11: case 12: case 13: case 14: case 15: unaligned_store_u64a(dst + len - 8, unaligned_load_u64a(src + len - 8)); unaligned_store_u64a(dst, unaligned_load_u64a(src)); break; case 16: storeu128(dst, loadu128(src)); break; case 32: storeu256(dst, loadu256(src)); break; default: assert(len < 32); storeu128(dst + len - 16, loadu128(src + len - 16)); storeu128(dst, loadu128(src)); break; } } #endif hyperscan-4.4.1/src/util/scatter_runtime.h0000644000175000017500000000574013055426554021432 0ustar sleuthkidsleuthkid/* * 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 UTIL_SCATTER_RUNTIME_H #define UTIL_SCATTER_RUNTIME_H #include "scatter.h" #include "uniform_ops.h" #define SCATTER_DEF(t) \ static really_inline \ void scatter_##t(void *out, const struct scatter_unit_##t *plan, u32 count) { \ for (u32 i = 0; i < count; i++) { \ const struct scatter_unit_##t *item = plan + i; \ DEBUG_PRINTF("storing %llu into offset %u\n", (u64a)item->val, \ item->offset); \ storeu_##t((char *)out + item->offset, item->val); \ } \ } SCATTER_DEF(u64a) SCATTER_DEF(u32) SCATTER_DEF(u16) SCATTER_DEF(u8) #undef SCATTER_DEF static really_inline void scatter(void *out, const void *base, const struct scatter_full_plan *p) { #define RUN_SUB(t) \ if (p->s_##t##_offset) { \ assert(p->s_##t##_count); \ const struct scatter_unit_##t *pp \ = (const void *)(b + p->s_##t##_offset); \ scatter_##t(out, pp, p->s_##t##_count); \ } const char *b = base; RUN_SUB(u64a); RUN_SUB(u32); RUN_SUB(u16); RUN_SUB(u8); #undef RUN_SUB } #endif hyperscan-4.4.1/src/util/simd_utils.c0000644000175000017500000000475313055426554020374 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Lookup tables to support SIMD operations. */ #include "simd_utils.h" ALIGN_CL_DIRECTIVE const char vbs_mask_data[] = { 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, 0xf0, }; #define ZEROES_8 0, 0, 0, 0, 0, 0, 0, 0 #define ZEROES_31 ZEROES_8, ZEROES_8, ZEROES_8, 0, 0, 0, 0, 0, 0, 0 #define ZEROES_32 ZEROES_8, ZEROES_8, ZEROES_8, ZEROES_8 /** \brief LUT for the mask1bit functions. */ ALIGN_CL_DIRECTIVE const u8 simd_onebit_masks[] = { ZEROES_31, 0x01, ZEROES_32, ZEROES_31, 0x02, ZEROES_32, ZEROES_31, 0x04, ZEROES_32, ZEROES_31, 0x08, ZEROES_32, ZEROES_31, 0x10, ZEROES_32, ZEROES_31, 0x20, ZEROES_32, ZEROES_31, 0x40, ZEROES_32, ZEROES_31, 0x80, ZEROES_32, }; hyperscan-4.4.1/src/util/state_compress.c0000644000175000017500000004721713055426554021255 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Mask-based state compression, used by the NFA. */ #include "config.h" #include "ue2common.h" #include "bitutils.h" #include "unaligned.h" #include "pack_bits.h" #include "partial_store.h" #include "popcount.h" #include "state_compress.h" #include /* * 32-bit store/load. */ void storecompressed32(void *ptr, const u32 *x, const u32 *m, u32 bytes) { assert(popcount32(*m) <= bytes * 8); u32 v = compress32(*x, *m); partial_store_u32(ptr, v, bytes); } void loadcompressed32(u32 *x, const void *ptr, const u32 *m, u32 bytes) { assert(popcount32(*m) <= bytes * 8); u32 v = partial_load_u32(ptr, bytes); *x = expand32(v, *m); } /* * 64-bit store/load. */ void storecompressed64(void *ptr, const u64a *x, const u64a *m, u32 bytes) { assert(popcount64(*m) <= bytes * 8); u64a v = compress64(*x, *m); partial_store_u64a(ptr, v, bytes); } void loadcompressed64(u64a *x, const void *ptr, const u64a *m, u32 bytes) { assert(popcount64(*m) <= bytes * 8); u64a v = partial_load_u64a(ptr, bytes); *x = expand64(v, *m); } /* * 128-bit store/load. */ #if defined(ARCH_32_BIT) static really_inline void storecompressed128_32bit(void *ptr, m128 xvec, m128 mvec) { // First, decompose our vectors into 32-bit chunks. u32 x[4]; memcpy(x, &xvec, sizeof(xvec)); u32 m[4]; memcpy(m, &mvec, sizeof(mvec)); // Count the number of bits of compressed state we're writing out per // chunk. u32 bits[4] = { popcount32(m[0]), popcount32(m[1]), popcount32(m[2]), popcount32(m[3]) }; // Compress each 32-bit chunk individually. u32 v[4] = { compress32(x[0], m[0]), compress32(x[1], m[1]), compress32(x[2], m[2]), compress32(x[3], m[3]) }; // Write packed data out. pack_bits_32(ptr, v, bits, 4); } #endif #if defined(ARCH_64_BIT) static really_inline void storecompressed128_64bit(void *ptr, m128 xvec, m128 mvec) { // First, decompose our vectors into 64-bit chunks. u64a x[2]; memcpy(x, &xvec, sizeof(xvec)); u64a m[2]; memcpy(m, &mvec, sizeof(mvec)); // Count the number of bits of compressed state we're writing out per // chunk. u32 bits[2] = { popcount64(m[0]), popcount64(m[1]) }; // Compress each 64-bit chunk individually. u64a v[2] = { compress64(x[0], m[0]), compress64(x[1], m[1]) }; // Write packed data out. pack_bits_64(ptr, v, bits, 2); } #endif void storecompressed128(void *ptr, const m128 *x, const m128 *m, UNUSED u32 bytes) { #if defined(ARCH_64_BIT) storecompressed128_64bit(ptr, *x, *m); #else storecompressed128_32bit(ptr, *x, *m); #endif } #if defined(ARCH_32_BIT) static really_inline m128 loadcompressed128_32bit(const void *ptr, m128 mvec) { // First, decompose our vectors into 32-bit chunks. u32 m[8]; memcpy(m, &mvec, sizeof(mvec)); u32 bits[4] = { popcount32(m[0]), popcount32(m[1]), popcount32(m[2]), popcount32(m[3]) }; u32 v[4]; unpack_bits_32(v, (const u8 *)ptr, bits, 4); u32 x[4] = { expand32(v[0], m[0]), expand32(v[1], m[1]), expand32(v[2], m[2]), expand32(v[3], m[3]) }; return _mm_set_epi32(x[3], x[2], x[1], x[0]); } #endif #if defined(ARCH_64_BIT) static really_inline m128 loadcompressed128_64bit(const void *ptr, m128 mvec) { // First, decompose our vectors into 64-bit chunks. u64a m[2] = { movq(mvec), movq(_mm_srli_si128(mvec, 8)) }; u32 bits[2] = { popcount64(m[0]), popcount64(m[1]) }; u64a v[2]; unpack_bits_64(v, (const u8 *)ptr, bits, 2); u64a x[2] = { expand64(v[0], m[0]), expand64(v[1], m[1]) }; return _mm_set_epi64x(x[1], x[0]); } #endif void loadcompressed128(m128 *x, const void *ptr, const m128 *m, UNUSED u32 bytes) { #if defined(ARCH_64_BIT) *x = loadcompressed128_64bit(ptr, *m); #else *x = loadcompressed128_32bit(ptr, *m); #endif } /* * 256-bit store/load. */ #if defined(ARCH_32_BIT) static really_inline void storecompressed256_32bit(void *ptr, m256 xvec, m256 mvec) { // First, decompose our vectors into 32-bit chunks. u32 x[8]; memcpy(x, &xvec, sizeof(xvec)); u32 m[8]; memcpy(m, &mvec, sizeof(mvec)); // Count the number of bits of compressed state we're writing out per // chunk. u32 bits[8] = { popcount32(m[0]), popcount32(m[1]), popcount32(m[2]), popcount32(m[3]), popcount32(m[4]), popcount32(m[5]), popcount32(m[6]), popcount32(m[7])}; // Compress each 32-bit chunk individually. u32 v[8] = { compress32(x[0], m[0]), compress32(x[1], m[1]), compress32(x[2], m[2]), compress32(x[3], m[3]), compress32(x[4], m[4]), compress32(x[5], m[5]), compress32(x[6], m[6]), compress32(x[7], m[7]) }; // Write packed data out. pack_bits_32(ptr, v, bits, 8); } #endif #if defined(ARCH_64_BIT) static really_really_inline void storecompressed256_64bit(void *ptr, m256 xvec, m256 mvec) { // First, decompose our vectors into 64-bit chunks. u64a x[4]; memcpy(x, &xvec, sizeof(xvec)); u64a m[4]; memcpy(m, &mvec, sizeof(mvec)); // Count the number of bits of compressed state we're writing out per // chunk. u32 bits[4] = { popcount64(m[0]), popcount64(m[1]), popcount64(m[2]), popcount64(m[3]) }; // Compress each 64-bit chunk individually. u64a v[4] = { compress64(x[0], m[0]), compress64(x[1], m[1]), compress64(x[2], m[2]), compress64(x[3], m[3]) }; // Write packed data out. pack_bits_64(ptr, v, bits, 4); } #endif void storecompressed256(void *ptr, const m256 *x, const m256 *m, UNUSED u32 bytes) { #if defined(ARCH_64_BIT) storecompressed256_64bit(ptr, *x, *m); #else storecompressed256_32bit(ptr, *x, *m); #endif } #if defined(ARCH_32_BIT) static really_inline m256 loadcompressed256_32bit(const void *ptr, m256 mvec) { // First, decompose our vectors into 32-bit chunks. u32 m[8]; memcpy(m, &mvec, sizeof(mvec)); u32 bits[8] = { popcount32(m[0]), popcount32(m[1]), popcount32(m[2]), popcount32(m[3]), popcount32(m[4]), popcount32(m[5]), popcount32(m[6]), popcount32(m[7])}; u32 v[8]; unpack_bits_32(v, (const u8 *)ptr, bits, 8); u32 x[8] = { expand32(v[0], m[0]), expand32(v[1], m[1]), expand32(v[2], m[2]), expand32(v[3], m[3]), expand32(v[4], m[4]), expand32(v[5], m[5]), expand32(v[6], m[6]), expand32(v[7], m[7]) }; #if !defined(__AVX2__) m256 xvec = { .lo = _mm_set_epi32(x[3], x[2], x[1], x[0]), .hi = _mm_set_epi32(x[7], x[6], x[5], x[4]) }; #else m256 xvec = _mm256_set_epi32(x[7], x[6], x[5], x[4], x[3], x[2], x[1], x[0]); #endif return xvec; } #endif #if defined(ARCH_64_BIT) static really_inline m256 loadcompressed256_64bit(const void *ptr, m256 mvec) { // First, decompose our vectors into 64-bit chunks. u64a m[4]; memcpy(m, &mvec, sizeof(mvec)); u32 bits[4] = { popcount64(m[0]), popcount64(m[1]), popcount64(m[2]), popcount64(m[3]) }; u64a v[4]; unpack_bits_64(v, (const u8 *)ptr, bits, 4); u64a x[4] = { expand64(v[0], m[0]), expand64(v[1], m[1]), expand64(v[2], m[2]), expand64(v[3], m[3]) }; #if !defined(__AVX2__) m256 xvec = { .lo = _mm_set_epi64x(x[1], x[0]), .hi = _mm_set_epi64x(x[3], x[2]) }; #else m256 xvec = _mm256_set_epi64x(x[3], x[2], x[1], x[0]); #endif return xvec; } #endif void loadcompressed256(m256 *x, const void *ptr, const m256 *m, UNUSED u32 bytes) { #if defined(ARCH_64_BIT) *x = loadcompressed256_64bit(ptr, *m); #else *x = loadcompressed256_32bit(ptr, *m); #endif } /* * 384-bit store/load. */ #if defined(ARCH_32_BIT) static really_inline void storecompressed384_32bit(void *ptr, m384 xvec, m384 mvec) { // First, decompose our vectors into 32-bit chunks. u32 x[12]; memcpy(x, &xvec, sizeof(xvec)); u32 m[12]; memcpy(m, &mvec, sizeof(mvec)); // Count the number of bits of compressed state we're writing out per // chunk. u32 bits[12] = { popcount32(m[0]), popcount32(m[1]), popcount32(m[2]), popcount32(m[3]), popcount32(m[4]), popcount32(m[5]), popcount32(m[6]), popcount32(m[7]), popcount32(m[8]), popcount32(m[9]), popcount32(m[10]), popcount32(m[11]) }; // Compress each 32-bit chunk individually. u32 v[12] = { compress32(x[0], m[0]), compress32(x[1], m[1]), compress32(x[2], m[2]), compress32(x[3], m[3]), compress32(x[4], m[4]), compress32(x[5], m[5]), compress32(x[6], m[6]), compress32(x[7], m[7]), compress32(x[8], m[8]), compress32(x[9], m[9]), compress32(x[10], m[10]), compress32(x[11], m[11])}; // Write packed data out. pack_bits_32(ptr, v, bits, 12); } #endif #if defined(ARCH_64_BIT) static really_inline void storecompressed384_64bit(void *ptr, m384 xvec, m384 mvec) { // First, decompose our vectors into 64-bit chunks. u64a x[6]; memcpy(x, &xvec, sizeof(xvec)); u64a m[6]; memcpy(m, &mvec, sizeof(mvec)); // Count the number of bits of compressed state we're writing out per // chunk. u32 bits[6] = { popcount64(m[0]), popcount64(m[1]), popcount64(m[2]), popcount64(m[3]), popcount64(m[4]), popcount64(m[5]) }; // Compress each 64-bit chunk individually. u64a v[6] = { compress64(x[0], m[0]), compress64(x[1], m[1]), compress64(x[2], m[2]), compress64(x[3], m[3]), compress64(x[4], m[4]), compress64(x[5], m[5]) }; // Write packed data out. pack_bits_64(ptr, v, bits, 6); } #endif void storecompressed384(void *ptr, const m384 *x, const m384 *m, UNUSED u32 bytes) { #if defined(ARCH_64_BIT) storecompressed384_64bit(ptr, *x, *m); #else storecompressed384_32bit(ptr, *x, *m); #endif } #if defined(ARCH_32_BIT) static really_inline m384 loadcompressed384_32bit(const void *ptr, m384 mvec) { // First, decompose our vectors into 32-bit chunks. u32 m[12]; memcpy(m, &mvec, sizeof(mvec)); u32 bits[12] = { popcount32(m[0]), popcount32(m[1]), popcount32(m[2]), popcount32(m[3]), popcount32(m[4]), popcount32(m[5]), popcount32(m[6]), popcount32(m[7]), popcount32(m[8]), popcount32(m[9]), popcount32(m[10]), popcount32(m[11]) }; u32 v[12]; unpack_bits_32(v, (const u8 *)ptr, bits, 12); u32 x[12] = { expand32(v[0], m[0]), expand32(v[1], m[1]), expand32(v[2], m[2]), expand32(v[3], m[3]), expand32(v[4], m[4]), expand32(v[5], m[5]), expand32(v[6], m[6]), expand32(v[7], m[7]), expand32(v[8], m[8]), expand32(v[9], m[9]), expand32(v[10], m[10]), expand32(v[11], m[11]) }; m384 xvec = { .lo = _mm_set_epi32(x[3], x[2], x[1], x[0]), .mid = _mm_set_epi32(x[7], x[6], x[5], x[4]), .hi = _mm_set_epi32(x[11], x[10], x[9], x[8]) }; return xvec; } #endif #if defined(ARCH_64_BIT) static really_inline m384 loadcompressed384_64bit(const void *ptr, m384 mvec) { // First, decompose our vectors into 64-bit chunks. u64a m[6]; memcpy(m, &mvec, sizeof(mvec)); u32 bits[6] = { popcount64(m[0]), popcount64(m[1]), popcount64(m[2]), popcount64(m[3]), popcount64(m[4]), popcount64(m[5]) }; u64a v[6]; unpack_bits_64(v, (const u8 *)ptr, bits, 6); u64a x[6] = { expand64(v[0], m[0]), expand64(v[1], m[1]), expand64(v[2], m[2]), expand64(v[3], m[3]), expand64(v[4], m[4]), expand64(v[5], m[5]) }; m384 xvec = { .lo = _mm_set_epi64x(x[1], x[0]), .mid = _mm_set_epi64x(x[3], x[2]), .hi = _mm_set_epi64x(x[5], x[4]) }; return xvec; } #endif void loadcompressed384(m384 *x, const void *ptr, const m384 *m, UNUSED u32 bytes) { #if defined(ARCH_64_BIT) *x = loadcompressed384_64bit(ptr, *m); #else *x = loadcompressed384_32bit(ptr, *m); #endif } /* * 512-bit store/load. */ #if defined(ARCH_32_BIT) static really_inline void storecompressed512_32bit(void *ptr, m512 xvec, m512 mvec) { // First, decompose our vectors into 32-bit chunks. u32 x[16]; memcpy(x, &xvec, sizeof(xvec)); u32 m[16]; memcpy(m, &mvec, sizeof(mvec)); // Count the number of bits of compressed state we're writing out per // chunk. u32 bits[16] = { popcount32(m[0]), popcount32(m[1]), popcount32(m[2]), popcount32(m[3]), popcount32(m[4]), popcount32(m[5]), popcount32(m[6]), popcount32(m[7]), popcount32(m[8]), popcount32(m[9]), popcount32(m[10]), popcount32(m[11]), popcount32(m[12]), popcount32(m[13]), popcount32(m[14]), popcount32(m[15])}; // Compress each 32-bit chunk individually. u32 v[16] = { compress32(x[0], m[0]), compress32(x[1], m[1]), compress32(x[2], m[2]), compress32(x[3], m[3]), compress32(x[4], m[4]), compress32(x[5], m[5]), compress32(x[6], m[6]), compress32(x[7], m[7]), compress32(x[8], m[8]), compress32(x[9], m[9]), compress32(x[10], m[10]), compress32(x[11], m[11]), compress32(x[12], m[12]), compress32(x[13], m[13]), compress32(x[14], m[14]), compress32(x[15], m[15]) }; // Write packed data out. pack_bits_32(ptr, v, bits, 16); } #endif #if defined(ARCH_64_BIT) static really_inline void storecompressed512_64bit(void *ptr, m512 xvec, m512 mvec) { // First, decompose our vectors into 64-bit chunks. u64a m[8]; memcpy(m, &mvec, sizeof(mvec)); u64a x[8]; memcpy(x, &xvec, sizeof(xvec)); // Count the number of bits of compressed state we're writing out per // chunk. u32 bits[8] = { popcount64(m[0]), popcount64(m[1]), popcount64(m[2]), popcount64(m[3]), popcount64(m[4]), popcount64(m[5]), popcount64(m[6]), popcount64(m[7]) }; // Compress each 64-bit chunk individually. u64a v[8] = { compress64(x[0], m[0]), compress64(x[1], m[1]), compress64(x[2], m[2]), compress64(x[3], m[3]), compress64(x[4], m[4]), compress64(x[5], m[5]), compress64(x[6], m[6]), compress64(x[7], m[7]) }; // Write packed data out. pack_bits_64(ptr, v, bits, 8); } #endif void storecompressed512(void *ptr, const m512 *x, const m512 *m, UNUSED u32 bytes) { #if defined(ARCH_64_BIT) storecompressed512_64bit(ptr, *x, *m); #else storecompressed512_32bit(ptr, *x, *m); #endif } #if defined(ARCH_32_BIT) static really_inline m512 loadcompressed512_32bit(const void *ptr, m512 mvec) { // First, decompose our vectors into 32-bit chunks. u32 m[16]; memcpy(m, &mvec, sizeof(mvec)); u32 bits[16] = { popcount32(m[0]), popcount32(m[1]), popcount32(m[2]), popcount32(m[3]), popcount32(m[4]), popcount32(m[5]), popcount32(m[6]), popcount32(m[7]), popcount32(m[8]), popcount32(m[9]), popcount32(m[10]), popcount32(m[11]), popcount32(m[12]), popcount32(m[13]), popcount32(m[14]), popcount32(m[15]) }; u32 v[16]; unpack_bits_32(v, (const u8 *)ptr, bits, 16); u32 x[16] = { expand32(v[0], m[0]), expand32(v[1], m[1]), expand32(v[2], m[2]), expand32(v[3], m[3]), expand32(v[4], m[4]), expand32(v[5], m[5]), expand32(v[6], m[6]), expand32(v[7], m[7]), expand32(v[8], m[8]), expand32(v[9], m[9]), expand32(v[10], m[10]), expand32(v[11], m[11]), expand32(v[12], m[12]), expand32(v[13], m[13]), expand32(v[14], m[14]), expand32(v[15], m[15]) }; m512 xvec; #if !defined(__AVX2__) xvec.lo.lo = _mm_set_epi32(x[3], x[2], x[1], x[0]); xvec.lo.hi = _mm_set_epi32(x[7], x[6], x[5], x[4]); xvec.hi.lo = _mm_set_epi32(x[11], x[10], x[9], x[8]); xvec.hi.hi = _mm_set_epi32(x[15], x[14], x[13], x[12]); #else xvec.lo = _mm256_set_epi32(x[7], x[6], x[5], x[4], x[3], x[2], x[1], x[0]); xvec.hi = _mm256_set_epi32(x[15], x[14], x[13], x[12], x[11], x[10], x[9], x[8]); #endif return xvec; } #endif #if defined(ARCH_64_BIT) static really_inline m512 loadcompressed512_64bit(const void *ptr, m512 mvec) { // First, decompose our vectors into 64-bit chunks. u64a m[8]; memcpy(m, &mvec, sizeof(mvec)); u32 bits[8] = { popcount64(m[0]), popcount64(m[1]), popcount64(m[2]), popcount64(m[3]), popcount64(m[4]), popcount64(m[5]), popcount64(m[6]), popcount64(m[7]) }; u64a v[8]; unpack_bits_64(v, (const u8 *)ptr, bits, 8); u64a x[8] = { expand64(v[0], m[0]), expand64(v[1], m[1]), expand64(v[2], m[2]), expand64(v[3], m[3]), expand64(v[4], m[4]), expand64(v[5], m[5]), expand64(v[6], m[6]), expand64(v[7], m[7]) }; #if !defined(__AVX2__) m512 xvec = { .lo = { _mm_set_epi64x(x[1], x[0]), _mm_set_epi64x(x[3], x[2]) }, .hi = { _mm_set_epi64x(x[5], x[4]), _mm_set_epi64x(x[7], x[6]) } }; #else m512 xvec = { .lo = _mm256_set_epi64x(x[3], x[2], x[1], x[0]), .hi = _mm256_set_epi64x(x[7], x[6], x[5], x[4])}; #endif return xvec; } #endif void loadcompressed512(m512 *x, const void *ptr, const m512 *m, UNUSED u32 bytes) { #if defined(ARCH_64_BIT) *x = loadcompressed512_64bit(ptr, *m); #else *x = loadcompressed512_32bit(ptr, *m); #endif } hyperscan-4.4.1/src/util/unicode_def.h0000644000175000017500000000630213055426554020461 0ustar sleuthkidsleuthkid/* * 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 UNICODE_DEF_H #define UNICODE_DEF_H #include "ue2common.h" #define MAX_UNICODE 0x10FFFF #define INVALID_UNICODE 0xffffffff /* unicode could never go above 2^31 */ #define UTF_2CHAR_MIN (1U << 7) #define UTF_3CHAR_MIN (1U << 11) #define UTF_4CHAR_MIN (1U << 16) #define UTF_CONT_SHIFT 6 #define UTF_CONT_BYTE_RANGE (1U << UTF_CONT_SHIFT) #define UTF_CONT_BYTE_HEADER ((u8)0x80) /* 10xx xxxx */ #define UTF_TWO_BYTE_HEADER ((u8)0xc0) /* 110x xxxx */ #define UTF_THREE_BYTE_HEADER ((u8)0xe0) /* 1110 xxxx */ #define UTF_FOUR_BYTE_HEADER ((u8)0xf0) /* 1111 0xxx */ #define UTF_CONT_BYTE_VALUE_MASK 0x3f #define UTF_CONT_MIN UTF_CONT_BYTE_HEADER #define UTF_CONT_MAX (UTF_TWO_BYTE_HEADER - 1) #define UTF_TWO_BYTE_MIN UTF_TWO_BYTE_HEADER #define UTF_TWO_BYTE_MAX (UTF_THREE_BYTE_HEADER - 1) #define UTF_THREE_BYTE_MIN UTF_THREE_BYTE_HEADER #define UTF_THREE_BYTE_MAX (UTF_FOUR_BYTE_HEADER - 1) #define UTF_FOUR_BYTE_MIN UTF_FOUR_BYTE_HEADER #define UTF_FOUR_BYTE_MAX ((u8)0xf4) #define UTF_CONT_CR CharReach(UTF_CONT_MIN, UTF_CONT_MAX) #define UTF_ASCII_CR CharReach(0, 127) #define UTF_START_CR CharReach(UTF_TWO_BYTE_MIN, UTF_FOUR_BYTE_MAX) #define UTF_TWO_START_CR CharReach(UTF_TWO_BYTE_MIN, UTF_TWO_BYTE_MAX) #define UTF_THREE_START_CR CharReach(UTF_THREE_BYTE_MIN, UTF_THREE_BYTE_MAX) #define UTF_FOUR_START_CR CharReach(UTF_FOUR_BYTE_MIN, UTF_FOUR_BYTE_MAX) #define UNICODE_SURROGATE_MIN 0xd800 #define UNICODE_SURROGATE_MAX 0xdfff #ifdef __cplusplus namespace ue2 { typedef u32 unichar; /* represents a unicode code point */ static UNUSED u8 makeContByte(u8 val) { return UTF_CONT_BYTE_HEADER | (val & UTF_CONT_BYTE_VALUE_MASK); } } // namespace #endif // __cplusplus #endif hyperscan-4.4.1/src/util/ue2string.cpp0000644000175000017500000002512113055426554020472 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Tools for string manipulation, ue2_literal definition. */ #include "charreach.h" #include "compare.h" #include "ue2string.h" #include #include #include #include using namespace std; namespace ue2 { #if defined(DUMP_SUPPORT) || defined(DEBUG) // Escape a string so that it's screen-printable string escapeString(const string &s) { ostringstream os; for (unsigned int i = 0; i < s.size(); ++i) { char c = s[i]; if (0x20 <= c && c <= 0x7e && c != '\\') { os << c; } else if (c == '\n') { os << "\\n"; } else if (c == '\r') { os << "\\r"; } else if (c == '\t') { os << "\\t"; } else { os << "\\x" << hex << setw(2) << setfill('0') << (unsigned)(c & 0xff) << dec; } } return os.str(); } string escapeString(const ue2_literal &lit) { ostringstream os; for (ue2_literal::const_iterator it = lit.begin(); it != lit.end(); ++it) { char c = it->c; if (0x20 <= c && c <= 0x7e && c != '\\') { os << c; } else if (c == '\n') { os << "\\n"; } else { os << "\\x" << hex << setw(2) << setfill('0') << (unsigned)(c & 0xff) << dec; } } return os.str(); } // escape any metacharacters in a literal string string escapeStringMeta(const string &s) { ostringstream os; for (unsigned int i = 0; i < s.size(); ++i) { char c = s[i]; switch (c) { case '#': case '$': case '(': case ')': case '*': case '+': case '.': case '/': case '?': case '[': case ']': case '^': case '|': os << "\\" << c; break; default: os << c; break; } } return os.str(); } string dotEscapeString(const string &s) { string ss = escapeString(s); string out; out.reserve(ss.size()); for (size_t i = 0; i != ss.size(); i++) { char c = ss[i]; switch (c) { case '\"': case '\\': out.push_back('\\'); // fall through default: out.push_back(c); break; } } return out; } string dumpString(const ue2_literal &lit) { string s = escapeString(lit.get_string()); if (lit.any_nocase()) { s += " (nocase)"; } return s; } #endif void upperString(string &s) { for (auto &c : s) { c = mytoupper(c); } } size_t maxStringOverlap(const string &a, const string &b, bool nocase) { size_t lena = a.length(), lenb = b.length(); const char *astart = a.c_str(); const char *bstart = b.c_str(); const char *aend = astart + lena; size_t i = lenb; for (; i > lena; i--) { if (!cmp(astart, bstart + i - lena, lena, nocase)) { return i; } } for (; i && cmp(aend - i, bstart, i, nocase); i--) { ; } return i; } size_t maxStringOverlap(const ue2_literal &a, const ue2_literal &b) { /* todo: handle nocase better */ return maxStringOverlap(a.get_string(), b.get_string(), a.any_nocase() || b.any_nocase()); } size_t maxStringSelfOverlap(const string &a, bool nocase) { size_t lena = a.length(); const char *astart = a.c_str(); const char *bstart = a.c_str(); const char *aend = astart + lena; size_t i = lena - 1; for (; i && cmp(aend - i, bstart, i, nocase); i--) { ; } return i; } u32 cmp(const char *a, const char *b, size_t len, bool nocase) { if (!nocase) { return memcmp(a, b, len); } for (const auto *a_end = a + len; a < a_end; a++, b++) { if (mytoupper(*a) != mytoupper(*b)) { return 1; } } return 0; } case_iter::case_iter(const ue2_literal &ss) : s(ss.get_string()), s_orig(ss.get_string()) { for (ue2_literal::const_iterator it = ss.begin(); it != ss.end(); ++it) { nocase.push_back(it->nocase); } } case_iter caseIterateBegin(const ue2_literal &s) { return case_iter(s); } case_iter caseIterateEnd() { return case_iter(ue2_literal()); } case_iter &case_iter::operator++ () { for (size_t i = s.length(); i != 0; i--) { char lower = mytolower(s[i - 1]); if (nocase[i - 1] && lower != s[i - 1]) { s[i - 1] = lower; copy(s_orig.begin() + i, s_orig.end(), s.begin() + i); return *this; } } s.clear(); return *this; } static string toUpperString(string s) { upperString(s); return s; } ue2_literal::elem::operator CharReach () const { if (!nocase) { return CharReach(c); } else { CharReach rv; rv.set(mytoupper(c)); rv.set(mytolower(c)); return rv; } } ue2_literal::ue2_literal(const std::string &s_in, bool nc_in) : s(nc_in ? toUpperString(s_in) : s_in), nocase(s_in.size(), nc_in) { if (nc_in) { // Quash nocase bit for non-alpha chars for (size_t i = 0; i < s.length(); i++) { if (!ourisalpha(s[i])) { nocase[i] = false; } } } } ue2_literal::ue2_literal(char c, bool nc) : s(1, nc ? mytoupper(c) : c), nocase(1, ourisalpha(c) ? nc : false) {} ue2_literal ue2_literal::substr(size_type pos, size_type n) const { ue2_literal rv; rv.s = s.substr(pos, n); size_type upper = nocase.size(); if (n != string::npos && n + pos < nocase.size()) { upper = n + pos; } rv.nocase.insert(rv.nocase.end(), nocase.begin() + pos, nocase.begin() + upper); return rv; } ue2_literal &ue2_literal::erase(size_type pos, size_type n) { s.erase(pos, n); size_type upper = nocase.size(); if (n != string::npos && n + pos < nocase.size()) { upper = n + pos; } nocase.erase(nocase.begin() + pos, nocase.begin() + upper); return *this; } void ue2_literal::push_back(char c, bool nc) { assert(!nc || ourisalpha(c)); if (nc) { c = mytoupper(c); } nocase.push_back(nc); s.push_back(c); } // Return a copy of this literal in reverse order. ue2_literal reverse_literal(const ue2_literal &in) { ue2_literal rv; if (in.empty()) { return rv; } for (ue2_literal::const_iterator it = in.end(); it != in.begin();) { --it; rv.push_back(it->c, it->nocase); } return rv; } bool ue2_literal::operator<(const ue2_literal &b) const { if (s < b.s) { return true; } if (s > b.s) { return false; } return nocase < b.nocase; } ue2_literal operator+(const ue2_literal &a, const ue2_literal &b) { ue2_literal rv; rv.s = a.s + b.s; rv.nocase = a.nocase; rv.nocase.insert(rv.nocase.end(), b.nocase.begin(), b.nocase.end()); return rv; } void ue2_literal::operator+=(const ue2_literal &b) { s += b.s; nocase.insert(nocase.end(), b.nocase.begin(), b.nocase.end()); } bool ue2_literal::any_nocase() const { return find(nocase.begin(), nocase.end(), true) != nocase.end(); } bool mixed_sensitivity(const ue2_literal &s) { bool cs = false; bool nc = false; for (ue2_literal::const_iterator it = s.begin(); it != s.end(); ++it) { if (!ourisalpha(it->c)) { continue; } if (it->nocase) { nc = true; } else { cs = true; } } return cs && nc; } void make_nocase(ue2_literal *lit) { ue2_literal rv; for (ue2_literal::const_iterator it = lit->begin(); it != lit->end(); ++it) { rv.push_back(it->c, ourisalpha(it->c)); } lit->swap(rv); } static bool testchar(char c, const CharReach &cr, bool nocase) { if (nocase) { return cr.test((unsigned char)mytolower(c)) || cr.test((unsigned char)mytoupper(c)); } else { return cr.test((unsigned char)c); } } // Returns true if the given literal contains a char in the given CharReach bool contains(const ue2_literal &s, const CharReach &cr) { for (ue2_literal::const_iterator it = s.begin(), ite = s.end(); it != ite; ++it) { if (testchar(it->c, cr, it->nocase)) { return true; } } return false; } size_t maxStringSelfOverlap(const ue2_literal &a) { /* overly conservative if only part of the string is nocase, TODO: fix */ return maxStringSelfOverlap(a.get_string(), a.any_nocase()); } size_t minStringPeriod(const ue2_literal &a) { return a.length() - maxStringSelfOverlap(a); } // Returns true if `a' is a suffix of (or equal to) `b'. bool isSuffix(const ue2_literal &a, const ue2_literal &b) { size_t alen = a.length(), blen = b.length(); if (alen > blen) { return false; } return equal(a.begin(), a.end(), b.begin() + (blen - alen)); } bool is_flood(const ue2_literal &s) { assert(!s.empty()); ue2_literal::const_iterator it = s.begin(), ite = s.end(); ue2_literal::elem f = *it; for (++it; it != ite; ++it) { if (*it != f) { return false; } } return true; } } // namespace ue2 hyperscan-4.4.1/src/util/charreach_util.h0000644000175000017500000000424413055426554021175 0ustar sleuthkidsleuthkid/* * 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 CHARREACH_UTIL_H #define CHARREACH_UTIL_H #include "ue2common.h" namespace ue2 { class CharReach; void make_caseless(CharReach *cr); /** * \brief Fill a bitvector with the contents of the given CharReach. * * \a bits should point at an array of 32 bytes. */ void fill_bitvector(const CharReach &cr, u8 *bits); /** * \brief Generate and and compare masks for checking the char reach. * * Any character c in cr will be result in (c & and_mask) == cmp_mask being true. * Note: characters not in cr may also pass the and/cmp checks. */ void make_and_cmp_mask(const CharReach &cr, u8 *and_mask, u8 *cmp_mask); } // namespace ue2 #endif hyperscan-4.4.1/src/util/report_manager.h0000644000175000017500000001325013055426554021222 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief ReportManager: tracks Report structures, exhaustion and * dedupe keys. */ #ifndef REPORT_MANAGER_H #define REPORT_MANAGER_H #include "ue2common.h" #include "util/compile_error.h" #include "util/report.h" #include #include #include #include namespace ue2 { struct Grey; class RoseBuild; class NGWrapper; struct external_report_info { external_report_info(bool h, u32 fpi) : highlander(h), first_pattern_index(fpi) { } const bool highlander; const u32 first_pattern_index; }; /** \brief Tracks Report structures, exhaustion and dedupe keys. */ class ReportManager : boost::noncopyable { public: explicit ReportManager(const Grey &g); /** \brief Fetch the ID associated with the given Report. */ u32 getInternalId(const Report &r); /** \brief Fetch the Report associated with \a id. */ const Report &getReport(u32 id) const; /** \brief Total number of reports. */ size_t numReports() const; /** \brief Return an unused exhaustion key (the next available one). */ u32 getUnassociatedExhaustibleKey(void); /** \brief Total number of dedupe keys. */ u32 numDkeys() const; /** \brief Total number of exhaustion keys. */ u32 numEkeys() const; /** \brief True if the pattern set can exhaust (i.e. all patterns are * highlander). */ bool patternSetCanExhaust() const; void assignDkeys(const RoseBuild *rose); std::vector getDkeyToReportTable() const; /** \brief Return a const reference to the table of Report * structures. */ const std::vector &reports() const { return reportIds; } /** * Get a simple internal report corresponding to the wrapper. An ekey will * be setup as required. * * Note: this function may throw a CompileError if constraints on external * match id are violated (mixed highlander status for example). */ Report getBasicInternalReport(const NGWrapper &g, s32 adj = 0); /** \brief Register an external report and validate that we are not * violating highlander constraints (which will cause an exception to be * thrown). */ void registerExtReport(ReportID id, const external_report_info &ext); /** \brief Fetch the ekey associated with the given expression index, * assigning one if necessary. */ u32 getExhaustibleKey(u32 expressionIndex); /** \brief Fetch the dedupe key associated with the given report. Returns * ~0U if no dkey is needed. */ u32 getDkey(const Report &r) const; /** \brief Register a Rose program offset with the given report. */ void setProgramOffset(ReportID id, u32 programOffset); /** \brief Fetch the program offset for a given report. It is a fatal error * for this to be called with a report for which no program offset has been * set. */ u32 getProgramOffset(ReportID id) const; private: /** \brief Grey box ref, for checking resource limits. */ const Grey &grey; /** \brief Report structures, indexed by ID. */ std::vector reportIds; /** \brief Mapping from Report to ID (inverse of \ref reportIds * vector). */ std::map reportIdToInternalMap; /** \brief Mapping from ReportID to dedupe key. */ std::map reportIdToDedupeKey; /** \brief Mapping from ReportID to Rose program offset in bytecode. */ std::map reportIdToProgramOffset; /** \brief Mapping from external match ids to information about that * id. */ std::map externalIdMap; /** \brief Mapping from expression index to exhaustion key. */ std::map toExhaustibleKeyMap; /** \brief Unallocated expression index, used for \ref * getUnassociatedExhaustibleKey. * * TODO: work out why this is signed. */ s64a freeEIndex; /** \brief True if database is globally exhaustible (all patterns must be * highlander for this to be the case). */ bool global_exhaust; }; std::set reportsToEkeys(const std::set &reports, const ReportManager &rm); } // namespace ue2 #endif hyperscan-4.4.1/src/util/fatbit_build.cpp0000644000175000017500000000343113055426554021200 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "fatbit_build.h" #include "fatbit.h" #include "multibit_build.h" #include using namespace std; namespace ue2 { u32 fatbit_size(u32 total_bits) { return max(u32{sizeof(struct fatbit)}, mmbit_size(total_bits)); } } // namespace ue2 hyperscan-4.4.1/src/util/clique.cpp0000644000175000017500000001020113055426554020023 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief An algorithm to find cliques. */ #include "clique.h" #include "container.h" #include "graph_range.h" #include "make_unique.h" #include "ue2_containers.h" #include #include #include using namespace std; namespace ue2 { static vector getNeighborInfo(const CliqueGraph &g, const CliqueVertex &cv, const set &group) { u32 id = g[cv].stateId; vector neighbor; // find neighbors for cv for (const auto &v : adjacent_vertices_range(cv, g)) { if (g[v].stateId != id && contains(group, g[v].stateId)){ neighbor.push_back(g[v].stateId); DEBUG_PRINTF("Neighbor:%u\n", g[v].stateId); } } return neighbor; } static vector findCliqueGroup(CliqueGraph &cg) { stack> gStack; // Create mapping between vertex and id map vertexMap; vector init; for (const auto &v : vertices_range(cg)) { vertexMap[cg[v].stateId] = v; init.push_back(cg[v].stateId); } gStack.push(init); // Get the vertex to start from vector clique; while (!gStack.empty()) { vector g = move(gStack.top()); gStack.pop(); // Choose a vertex from the graph u32 id = g[0]; CliqueVertex &n = vertexMap.at(id); clique.push_back(id); // Corresponding vertex in the original graph set subgraphId(g.begin(), g.end()); auto neighbor = getNeighborInfo(cg, n, subgraphId); // Get graph consisting of neighbors for left branch if (!neighbor.empty()) { gStack.push(neighbor); } } return clique; } template bool graph_empty(const Graph &g) { typename Graph::vertex_iterator vi, ve; tie(vi, ve) = vertices(g); return vi == ve; } vector> removeClique(CliqueGraph &cg) { DEBUG_PRINTF("graph size:%zu\n", num_vertices(cg)); vector> cliquesVec = {findCliqueGroup(cg)}; while (!graph_empty(cg)) { const vector &c = cliquesVec.back(); vector dead; for (const auto &v : vertices_range(cg)) { u32 id = cg[v].stateId; if (find(c.begin(), c.end(), id) != c.end()) { dead.push_back(v); } } for (const auto &v : dead) { clear_vertex(v, cg); remove_vertex(v, cg); } if (graph_empty(cg)) { break; } auto clique = findCliqueGroup(cg); cliquesVec.push_back(clique); } return cliquesVec; } } // namespace ue2 hyperscan-4.4.1/src/util/multibit_internal.h0000644000175000017500000000575113055426554021751 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Multibit: data structures. * * If all you need is the sizes of multibit's few structures, then including * this file is a much better idea than including all of multibit.h. */ #ifndef MULTIBIT_INTERNAL_H #define MULTIBIT_INTERNAL_H #include "ue2common.h" #ifdef __cplusplus extern "C" { #endif /** \brief Sentinel value meaning "no key found". */ #define MMB_INVALID 0xffffffffu typedef u64a MMB_TYPE; /**< Basic block type for mmbit operations. */ #define MMB_MAX_LEVEL 6 /**< Maximum level in the mmbit pyramid. */ /** \brief Maximum number of keys (bits) in a multibit. */ #define MMB_MAX_BITS (1U << 31) /** \brief Sparse iterator record type. * * A sparse iterator is a tree of these records, where val identifies the * offset of the result for leaf nodes and points to the next record for * intermediate nodes. Built by the code in multibit_build.cpp. */ struct mmbit_sparse_iter { MMB_TYPE mask; u32 val; }; /** \brief Sparse iterator runtime state type. * * An array of these records (one per "level" in the multibit pyramid) is used * to store the current iteration state. */ struct mmbit_sparse_state { MMB_TYPE mask; //!< \brief masked last block read at this level. u32 itkey; //!< \brief iterator offset for this level. }; /** \brief Maximum number of \ref mmbit_sparse_state that could be needed. */ #define MAX_SPARSE_ITER_STATES (6 + 1) #ifdef __cplusplus } // extern "C" #endif #endif // MULTIBIT_INTERNAL_H hyperscan-4.4.1/src/util/depth.cpp0000644000175000017500000000537113055426554017661 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Data types used to represent depth quantities. */ #include "depth.h" #include "ue2common.h" #include // std::min, std::max namespace ue2 { DepthMinMax unionDepthMinMax(const DepthMinMax &a, const DepthMinMax &b) { DepthMinMax rv; if (a.min.is_unreachable()) { rv.min = b.min; } else if (b.min.is_unreachable()) { rv.min = a.min; } else { rv.min = std::min(a.min, b.min); } if (a.max.is_infinite() || b.max.is_infinite()) { rv.max = depth::infinity(); } else if (a.max.is_unreachable()) { rv.max = b.max; } else if (b.max.is_unreachable()) { rv.max = a.max; } else { rv.max = std::max(a.max, b.max); } return rv; } } // namespace ue2 #ifdef DUMP_SUPPORT #include #include namespace ue2 { std::string depth::str() const { if (is_unreachable()) { return "unr"; } else if (is_infinite()) { return "inf"; } std::ostringstream oss; oss << val; return oss.str(); } std::string DepthMinMax::str() const { std::ostringstream oss; oss << "[" << min.str() << "," << max.str() << "]"; return oss.str(); } } // namespace ue2 #endif // DUMP_SUPPORT hyperscan-4.4.1/src/util/ue2string.h0000644000175000017500000002127413055426554020144 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Tools for string manipulation, ue2_literal definition. */ #ifndef UE2STRING_H #define UE2STRING_H #include "ue2common.h" #include "util/charreach.h" #include #include #include #include namespace ue2 { /// Force the given string to upper-case. void upperString(std::string &s); size_t maxStringOverlap(const std::string &a, const std::string &b, bool nocase); size_t maxStringSelfOverlap(const std::string &a, bool nocase); /// Compares two strings, returns non-zero if they're different. u32 cmp(const char *a, const char *b, size_t len, bool nocase); /** * \brief String type that also records whether the whole string is caseful or * caseless. * * You should use \ref ue2_literal if you need to represent a mixed-case * literal. */ struct ue2_case_string { ue2_case_string(std::string s_in, bool nocase_in) : s(std::move(s_in)), nocase(nocase_in) { if (nocase) { upperString(s); } } bool operator==(const ue2_case_string &other) const { return s == other.s && nocase == other.nocase; } std::string s; bool nocase; }; struct ue2_literal { public: /// Single element proxy, pointed to by our const_iterator. struct elem { elem() : c(0), nocase(false) {} elem(char c_in, bool nc_in) : c(c_in), nocase(nc_in) {} bool operator==(const elem &o) const { return c == o.c && nocase == o.nocase; } bool operator!=(const elem &o) const { return c != o.c || nocase != o.nocase; } operator CharReach() const; char c; bool nocase; }; /// Boost iterator_facade lets us synthesize an iterator simply. class const_iterator : public boost::iterator_facade< const_iterator, elem const, boost::random_access_traversal_tag, elem const> { public: const_iterator() {} private: friend class boost::iterator_core_access; void increment() { ++it; ++it_nc; } void decrement() { --it; --it_nc; } void advance(size_t n) { it += n; it_nc += n; } difference_type distance_to(const const_iterator &other) const { return other.it - it; } bool equal(const const_iterator &other) const { return it == other.it; } const elem dereference() const { return elem(*it, *it_nc); } friend struct ue2_literal; const_iterator(const std::string::const_iterator &it_in, const std::vector::const_iterator &it_nc_in) : it(it_in), it_nc(it_nc_in) {} std::string::const_iterator it; std::vector::const_iterator it_nc; }; using const_reverse_iterator = std::reverse_iterator; typedef std::string::size_type size_type; ue2_literal() {} ue2_literal(const std::string &s_in, bool nc_in); ue2_literal(char c, bool nc_in); ue2_literal(const ue2_literal &) = default; ue2_literal(ue2_literal &&) = default; ue2_literal &operator=(const ue2_literal &) = default; ue2_literal &operator=(ue2_literal &&) = default; template ue2_literal(InputIt b, InputIt e) { for (; b != e; ++b) { push_back(*b); } } size_type length() const { return s.length(); } bool empty() const { return s.empty(); } ue2_literal substr(size_type pos, size_type n = std::string::npos) const; const char *c_str() const { return s.c_str(); } bool any_nocase() const; const_iterator begin() const { return const_iterator(s.begin(), nocase.begin()); } const_iterator end() const { return const_iterator(s.end(), nocase.end()); } const_reverse_iterator rbegin() const { return const_reverse_iterator(end()); } const_reverse_iterator rend() const { return const_reverse_iterator(begin()); } ue2_literal &erase(size_type pos = 0, size_type n = std::string::npos); void push_back(const elem &e) { push_back(e.c, e.nocase); } void push_back(char c, bool nc); const elem back() const { return elem(*s.rbegin(), nocase.back()); } friend ue2_literal operator+(const ue2_literal &a, const ue2_literal &b); void operator+=(const ue2_literal &b); bool operator==(const ue2_literal &b) const { return s == b.s && nocase == b.nocase; } bool operator!=(const ue2_literal &b) const { return !(*this == b); } bool operator<(const ue2_literal &b) const; void clear(void) { s.clear(); nocase.clear(); } const std::string &get_string() const { return s; } void swap(ue2_literal &other) { s.swap(other.s); nocase.swap(other.nocase); } private: std::string s; std::vector nocase; /* for trolling value */ }; /// Return a reversed copy of this literal. ue2_literal reverse_literal(const ue2_literal &in); // Escape any meta characters in a string std::string escapeStringMeta(const std::string &s); /** Note: may be overly conservative if only partially nocase */ size_t maxStringSelfOverlap(const ue2_literal &a); size_t minStringPeriod(const ue2_literal &a); size_t maxStringOverlap(const ue2_literal &a, const ue2_literal &b); /** \brief True iff the literal cannot be considered entirely case-sensitive * nor entirely case-insensitive */ bool mixed_sensitivity(const ue2_literal &lit); void make_nocase(ue2_literal *lit); struct case_iter { explicit case_iter(const ue2_literal &ss); const std::string &operator*() const { return s; } /* limited lifetime */ case_iter &operator++ (); bool operator!=(const case_iter &b) const { return s != b.s; } private: std::string s; std::string s_orig; std::vector nocase; }; case_iter caseIterateBegin(const ue2_literal &lit); case_iter caseIterateEnd(); /** \brief True if there is any overlap between the characters in \a s and the * set characters in \a cr. * * Note: this means that if \a s is nocase, then \a cr only needs to have * either the lower-case or upper-case version of a letter set. */ bool contains(const ue2_literal &s, const CharReach &cr); /// Returns true if \a a is a suffix of (or equal to) \a b. bool isSuffix(const ue2_literal &a, const ue2_literal &b); static inline std::vector as_cr_seq(const ue2_literal &s) { std::vector rv; rv.reserve(s.length()); rv.insert(rv.end(), s.begin(), s.end()); return rv; } /** \brief True if the given literal consists entirely of a flood of the same * character. */ bool is_flood(const ue2_literal &s); #if defined(DUMP_SUPPORT) || defined(DEBUG) /* Utility functions for debugging/dumping */ /// Escape a string so it's dot-printable. std::string dotEscapeString(const std::string &s); std::string dumpString(const ue2_literal &lit); /// Escape a string so that it's screen-printable. std::string escapeString(const std::string &s); /// Escape a ue2_literal so that it's screen-printable. std::string escapeString(const ue2_literal &lit); #endif } // namespace ue2 #endif hyperscan-4.4.1/src/util/pqueue.h0000644000175000017500000000627113055426554017526 0ustar sleuthkidsleuthkid/* * 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 PQUEUE_H #define PQUEUE_H #include "ue2common.h" static really_inline u32 pq_left(u32 i) { return (i << 1) + 1; } static really_inline u32 pq_right(u32 i) { return (i << 1) + 2; } static really_inline u32 pq_parent(u32 i) { return (i - 1) >> 1; } static really_inline void pq_sift(PQ_T *items, u32 start, u32 end) { u32 j = start; PQ_T j_temp = items[j]; while (pq_left(j) < end) { u32 max_child; if (pq_right(j) < end && PQ_COMP(items, pq_right(j), pq_left(j))) { max_child = pq_right(j); } else { max_child = pq_left(j); } if (PQ_COMP_B(items, max_child, j_temp)) { items[j] = items[max_child]; j = max_child; } else { /* j is already less than its children. We know heap property * is already maintained for children we are done */ break; } } items[j] = j_temp; } static really_inline PQ_T *pq_top(PQ_T *items) { return items; } static really_inline void pq_pop(PQ_T *items, u32 item_count) { item_count--; items[0] = items[item_count]; pq_sift(items, 0, item_count); } static really_inline void pq_insert(PQ_T *items, u32 item_count, PQ_T new_item) { u32 pos = item_count; while (pos) { u32 parent = pq_parent(pos); if (!PQ_COMP_B(items, parent, new_item)) { items[pos] = items[parent]; pos = parent; } else { break; } } items[pos] = new_item; } static really_inline void pq_replace_top(PQ_T *items, u32 item_count, PQ_T new_item) { items[0] = new_item; pq_sift(items, 0, item_count); } #endif hyperscan-4.4.1/src/util/verify_types.h0000644000175000017500000000512013055426554020742 0ustar sleuthkidsleuthkid/* * 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 UTIL_VERIFY_TYPES #define UTIL_VERIFY_TYPES #include "ue2common.h" #include namespace ue2 { template static UNUSED u8 verify_u8(Int_T val) { assert(val == (Int_T)((u8)val)); // there and back again return (u8)(val); } template static UNUSED s8 verify_s8(Int_T val) { assert(val == (Int_T)((s8)val)); // there and back again return (s8)(val); } template static UNUSED s16 verify_s16(Int_T val) { assert(val == (Int_T)((s16)val)); // there and back again return (s16)(val); } template static UNUSED u16 verify_u16(Int_T val) { assert(val == (Int_T)((u16)val)); // there and back again return (u16)(val); } template static UNUSED s32 verify_s32(Int_T val) { assert(val == (Int_T)((s32)val)); // there and back again return (s32)(val); } template static UNUSED u32 verify_u32(Int_T val) { assert(val == (Int_T)((u32)val)); // there and back again return (u32)(val); } } // namespace ue2 #endif // UTIL_VERIFY_TYPES hyperscan-4.4.1/src/util/ue2_containers.h0000644000175000017500000004475513055426554021153 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 UTIL_UE2_CONTAINERS_H_ #define UTIL_UE2_CONTAINERS_H_ #include "ue2common.h" #include #include #include #include #include #include #include namespace ue2 { /** \brief Unordered set container implemented internally as a hash table. */ using boost::unordered_set; /** \brief Unordered map container implemented internally as a hash table. */ using boost::unordered_map; namespace flat_detail { // Iterator facade that wraps an underlying iterator, so that we get our // own iterator types. template class iter_wrapper : public boost::iterator_facade, Value, boost::random_access_traversal_tag> { public: iter_wrapper() {} explicit iter_wrapper(const WrappedIter &it_in) : it(it_in) {} // Templated copy-constructor to allow for interoperable iterator and // const_iterator. private: template friend class iter_wrapper; public: template iter_wrapper(const iter_wrapper &other, typename std::enable_if::value>::type * = nullptr) : it(other.it) {} WrappedIter get() const { return it; } private: friend class boost::iterator_core_access; WrappedIter it; void increment() { ++it; } void decrement() { --it; } void advance(size_t n) { it += n; } typename std::iterator_traits::difference_type distance_to(const iter_wrapper &other) const { return other.it - it; } bool equal(const iter_wrapper &other) const { return it == other.it; } Value &dereference() const { return *it; } }; } // namespace flat_detail /** * \brief Set container implemented internally as a sorted vector. Use this * rather than std::set for small sets as it's faster, uses less memory and * incurs less malloc time. * * Note: we used to use boost::flat_set, but have run into problems with all * the extra machinery it instantiates. */ template , class Allocator = std::allocator> class flat_set { // Underlying storage is a sorted std::vector. using StorageT = std::vector; Compare comp; StorageT data; public: // Member types. using key_type = T; using value_type = T; using size_type = typename StorageT::size_type; using difference_type = typename StorageT::difference_type; using key_compare = Compare; using value_compare = Compare; using allocator_type = Allocator; using reference = value_type &; using const_reference = const value_type &; using pointer = typename std::allocator_traits::pointer; using const_pointer = typename std::allocator_traits::const_pointer; // Iterator types. using iterator = flat_detail::iter_wrapper; using const_iterator = flat_detail::iter_wrapper; using reverse_iterator = std::reverse_iterator; using const_reverse_iterator = std::reverse_iterator; // Constructors. flat_set(const Compare &compare = Compare(), const Allocator &alloc = Allocator()) : comp(compare), data(alloc) {} template flat_set(InputIt first, InputIt last, const Compare &compare = Compare(), const Allocator &alloc = Allocator()) : comp(compare), data(alloc) { insert(first, last); } flat_set(std::initializer_list init, const Compare &compare = Compare(), const Allocator &alloc = Allocator()) : comp(compare), data(alloc) { insert(init.begin(), init.end()); } flat_set(const flat_set &) = default; flat_set(flat_set &&) = default; flat_set &operator=(const flat_set &) = default; flat_set &operator=(flat_set &&) = default; // Other members. allocator_type get_allocator() const { return data.get_allocator(); } // Iterators. iterator begin() { return iterator(data.begin()); } const_iterator cbegin() const { return const_iterator(data.cbegin()); } const_iterator begin() const { return cbegin(); } iterator end() { return iterator(data.end()); } const_iterator cend() const { return const_iterator(data.cend()); } const_iterator end() const { return cend(); } reverse_iterator rbegin() { return reverse_iterator(end()); } const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); } const_reverse_iterator rbegin() const { return crbegin(); } reverse_iterator rend() { return reverse_iterator(begin()); } const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); } const_reverse_iterator rend() const { return crend(); } // Capacity. bool empty() const { return data.empty(); } size_t size() const { return data.size(); } size_t max_size() const { return data.max_size(); } // Modifiers. void clear() { data.clear(); } std::pair insert(const value_type &value) { auto it = std::lower_bound(data.begin(), data.end(), value, comp); if (it == data.end() || comp(value, *it)) { return std::make_pair(iterator(data.insert(it, value)), true); } return std::make_pair(iterator(it), false); } iterator insert(UNUSED const_iterator hint, const value_type &value) { return insert(value).first; } std::pair insert(value_type &&value) { auto it = std::lower_bound(data.begin(), data.end(), value, comp); if (it == data.end() || comp(value, *it)) { return std::make_pair(iterator(data.insert(it, std::move(value))), true); } return std::make_pair(iterator(it), false); } iterator insert(UNUSED const_iterator hint, value_type &&value) { return insert(value).first; } template void insert(InputIt first, InputIt second) { for (; first != second; ++first) { insert(*first); } } void insert(std::initializer_list ilist) { insert(ilist.begin(), ilist.end()); } template std::pair emplace(Args&&... args) { return insert(value_type(std::forward(args)...)); } void erase(iterator pos) { data.erase(pos.get()); } void erase(iterator first, iterator last) { data.erase(first.get(), last.get()); } void erase(const key_type &key) { auto it = find(key); if (it != end()) { erase(it); } } void swap(flat_set &a) { using std::swap; swap(comp, a.comp); swap(data, a.data); } // Lookup. size_type count(const value_type &value) const { return find(value) != end() ? 1 : 0; } iterator find(const value_type &value) { auto it = std::lower_bound(data.begin(), data.end(), value, comp); if (it != data.end() && comp(value, *it)) { it = data.end(); } return iterator(it); } const_iterator find(const value_type &value) const { auto it = std::lower_bound(data.begin(), data.end(), value, comp); if (it != data.end() && comp(value, *it)) { it = data.end(); } return const_iterator(it); } // Observers. key_compare key_comp() const { return comp; } value_compare value_comp() const { return comp; } // Operators. bool operator==(const flat_set &a) const { return data == a.data; } bool operator!=(const flat_set &a) const { return data != a.data; } bool operator<(const flat_set &a) const { return data < a.data; } bool operator<=(const flat_set &a) const { return data <= a.data; } bool operator>(const flat_set &a) const { return data > a.data; } bool operator>=(const flat_set &a) const { return data >= a.data; } // Free swap function for ADL. friend void swap(flat_set &a, flat_set &b) { a.swap(b); } }; /** * \brief Map container implemented internally as a sorted vector. Use this * rather than std::map for small sets as it's faster, uses less memory and * incurs less malloc time. * * Note: we used to use boost::flat_map, but have run into problems with all * the extra machinery it instantiates. * * Note: ue2::flat_map does NOT provide mutable iterators, as (given the way * the data is stored) it is difficult to provide a real mutable iterator that * wraps std::pair. Instead, all iterators are const, and you * should use flat_map::at() or flat_map::operator[] to mutate the contents of * the container. */ template , class Allocator = std::allocator>> class flat_map { public: // Member types. using key_type = Key; using mapped_type = T; using value_type = std::pair; private: // Underlying storage is a sorted std::vector. using storage_type = std::pair; using StorageT = std::vector; Compare comp; StorageT data; public: // More Member types. using size_type = typename StorageT::size_type; using difference_type = typename StorageT::difference_type; using key_compare = Compare; using allocator_type = Allocator; using reference = value_type &; using const_reference = const value_type &; using pointer = typename std::allocator_traits::pointer; using const_pointer = typename std::allocator_traits::const_pointer; public: using const_iterator = flat_detail::iter_wrapper; using const_reverse_iterator = std::reverse_iterator; // All iterators are const for flat_map. using iterator = const_iterator; using reverse_iterator = const_reverse_iterator; // Constructors. flat_map(const Compare &compare = Compare(), const Allocator &alloc = Allocator()) : comp(compare), data(alloc) {} template flat_map(InputIt first, InputIt last, const Compare &compare = Compare(), const Allocator &alloc = Allocator()) : comp(compare), data(alloc) { insert(first, last); } flat_map(std::initializer_list init, const Compare &compare = Compare(), const Allocator &alloc = Allocator()) : comp(compare), data(alloc) { insert(init.begin(), init.end()); } flat_map(const flat_map &) = default; flat_map(flat_map &&) = default; flat_map &operator=(const flat_map &) = default; flat_map &operator=(flat_map &&) = default; // Other members. allocator_type get_allocator() const { return data.get_allocator(); } // Iterators. const_iterator cbegin() const { return const_iterator(data.cbegin()); } const_iterator begin() const { return cbegin(); } const_iterator cend() const { return const_iterator(data.cend()); } const_iterator end() const { return cend(); } const_reverse_iterator crbegin() const { return const_reverse_iterator(cend()); } const_reverse_iterator rbegin() const { return crbegin(); } const_reverse_iterator crend() const { return const_reverse_iterator(cbegin()); } const_reverse_iterator rend() const { return crend(); } // Capacity. bool empty() const { return data.empty(); } size_t size() const { return data.size(); } size_t max_size() const { return data.max_size(); } private: using storage_iterator = typename StorageT::iterator; using storage_const_iterator = typename StorageT::const_iterator; storage_iterator data_lower_bound(const key_type &key) { return std::lower_bound( data.begin(), data.end(), key, [&](const storage_type &elem, const key_type &k) { return comp(elem.first, k); }); } storage_const_iterator data_lower_bound(const key_type &key) const { return std::lower_bound( data.begin(), data.end(), key, [&](const storage_type &elem, const key_type &k) { return comp(elem.first, k); }); } std::pair data_insert(const value_type &value) { auto it = data_lower_bound(value.first); if (it == data.end() || comp(value.first, it->first)) { return std::make_pair(data.insert(it, value), true); } return std::make_pair(it, false); } std::pair data_insert(value_type &&value) { auto it = data_lower_bound(value.first); if (it == data.end() || comp(value.first, it->first)) { return std::make_pair(data.insert(it, std::move(value)), true); } return std::make_pair(it, false); } storage_iterator data_find(const key_type &key) { auto it = data_lower_bound(key); if (it != data.end() && comp(key, it->first)) { it = data.end(); } return it; } storage_const_iterator data_find(const key_type &key) const { auto it = data_lower_bound(key); if (it != data.end() && comp(key, it->first)) { it = data.end(); } return it; } public: // Modifiers. void clear() { data.clear(); } std::pair insert(const value_type &value) { auto rv = data_insert(value); return std::make_pair(iterator(rv.first), rv.second); } std::pair insert(value_type &&value) { auto rv = data_insert(std::move(value)); return std::make_pair(iterator(rv.first), rv.second); } template void insert(InputIt first, InputIt second) { for (; first != second; ++first) { insert(*first); } } void insert(std::initializer_list ilist) { insert(ilist.begin(), ilist.end()); } template std::pair emplace(Args&&... args) { return insert(value_type(std::forward(args)...)); } void erase(iterator pos) { // Convert to a non-const storage iterator via pointer arithmetic. storage_iterator it = data.begin() + distance(begin(), pos); data.erase(it); } void erase(iterator first, iterator last) { // Convert to a non-const storage iterator via pointer arithmetic. storage_iterator data_first = data.begin() + distance(begin(), first); storage_iterator data_last = data.begin() + distance(begin(), last); data.erase(data_first, data_last); } void erase(const key_type &key) { auto it = find(key); if (it != end()) { erase(it); } } void swap(flat_map &a) { using std::swap; swap(comp, a.comp); swap(data, a.data); } // Lookup. size_type count(const key_type &key) const { return find(key) != end() ? 1 : 0; } const_iterator find(const key_type &key) const { return const_iterator(data_find(key)); } // Element access. mapped_type &at(const key_type &key) { auto it = data_find(key); if (it == data.end()) { throw std::out_of_range("element not found"); } return it->second; } const mapped_type &at(const key_type &key) const { auto it = data_find(key); if (it == data.end()) { throw std::out_of_range("element not found"); } return it->second; } mapped_type &operator[](const key_type &key) { auto p = data_insert(value_type(key, mapped_type())); return p.first->second; } // Observers. key_compare key_comp() const { return comp; } // Operators. bool operator==(const flat_map &a) const { return data == a.data; } bool operator!=(const flat_map &a) const { return data != a.data; } bool operator<(const flat_map &a) const { return data < a.data; } bool operator<=(const flat_map &a) const { return data <= a.data; } bool operator>(const flat_map &a) const { return data > a.data; } bool operator>=(const flat_map &a) const { return data >= a.data; } // Free swap function for ADL. friend void swap(flat_map &a, flat_map &b) { a.swap(b); } }; } // namespace #endif // UTIL_UE2_CONTAINERS_H_ hyperscan-4.4.1/src/util/order_check.h0000644000175000017500000000354513055426554020473 0ustar sleuthkidsleuthkid/* * 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. */ /* for implementing operator<, assumes objects are a and b */ #define ORDER_CHECK(field) do { \ if (a.field < b.field) { \ return 1; \ } \ if (b.field < a.field) { \ return 0; \ } \ } while (0) hyperscan-4.4.1/src/util/fatbit.h0000644000175000017500000000577413055426554017502 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 FATBIT_H #define FATBIT_H /** \file * \brief Multibit: fast bitset structure for use in scratch. * Uses more space than mmbit, to avoid partial words for hopefully a taddy more * performance. * * API is also trimmed down. */ #include "multibit.h" #include "ue2common.h" #ifdef __cplusplus extern "C" { #endif #define MIN_FAT_SIZE 32 struct fatbit { union { u64a flat[MIN_FAT_SIZE / sizeof(u64a)]; u8 raw[MIN_FAT_SIZE]; } fb_int; u64a tail[]; }; static really_inline void fatbit_clear(struct fatbit *bits) { assert(ISALIGNED(bits)); memset(bits, 0, sizeof(struct fatbit)); } static really_inline char fatbit_set(struct fatbit *bits, u32 total_bits, u32 key) { assert(ISALIGNED(bits)); return mmbit_set(bits->fb_int.raw, total_bits, key); } static really_inline void fatbit_unset(struct fatbit *bits, u32 total_bits, u32 key) { assert(ISALIGNED(bits)); mmbit_unset(bits->fb_int.raw, total_bits, key); } static really_inline char fatbit_isset(const struct fatbit *bits, u32 total_bits, u32 key) { assert(ISALIGNED(bits)); return mmbit_isset(bits->fb_int.raw, total_bits, key); } static really_inline u32 fatbit_iterate(const struct fatbit *bits, u32 total_bits, u32 it_in) { assert(ISALIGNED(bits)); /* TODO: iterate_flat could be specialised as we don't have to worry about * partial blocks. */ return mmbit_iterate(bits->fb_int.raw, total_bits, it_in); } #ifdef __cplusplus } // extern "C" #endif #endif hyperscan-4.4.1/src/util/uniform_ops.h0000644000175000017500000002215713055426554020563 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Uniformly-named primitives named by target type. * * The following are a set of primitives named by target type, so that we can * macro the hell out of all our NFA implementations. Hurrah! */ #ifndef UNIFORM_OPS_H #define UNIFORM_OPS_H #include "ue2common.h" #include "simd_utils.h" #include "unaligned.h" // Aligned loads #define load_u8(a) (*(const u8 *)(a)) #define load_u16(a) (*(const u16 *)(a)) #define load_u32(a) (*(const u32 *)(a)) #define load_u64a(a) (*(const u64a *)(a)) #define load_m128(a) load128(a) #define load_m256(a) load256(a) #define load_m384(a) load384(a) #define load_m512(a) load512(a) // Unaligned loads #define loadu_u8(a) (*(const u8 *)(a)) #define loadu_u16(a) unaligned_load_u16((const u8 *)(a)) #define loadu_u32(a) unaligned_load_u32((const u8 *)(a)) #define loadu_u64a(a) unaligned_load_u64a((const u8 *)(a)) #define loadu_m128(a) loadu128(a) #define loadu_m256(a) loadu256(a) #define loadu_m384(a) loadu384(a) #define loadu_m512(a) loadu512(a) // Aligned stores #define store_u8(ptr, a) do { *(u8 *)(ptr) = (a); } while(0) #define store_u16(ptr, a) do { *(u16 *)(ptr) = (a); } while(0) #define store_u32(ptr, a) do { *(u32 *)(ptr) = (a); } while(0) #define store_u64a(ptr, a) do { *(u64a *)(ptr) = (a); } while(0) #define store_m128(ptr, a) store128(ptr, a) #define store_m256(ptr, a) store256(ptr, a) #define store_m384(ptr, a) store384(ptr, a) #define store_m512(ptr, a) store512(ptr, a) // Unaligned stores #define storeu_u8(ptr, a) do { *(u8 *)(ptr) = (a); } while(0) #define storeu_u16(ptr, a) unaligned_store_u16(ptr, a) #define storeu_u32(ptr, a) unaligned_store_u32(ptr, a) #define storeu_u64a(ptr, a) unaligned_store_u64a(ptr, a) #define storeu_m128(ptr, a) storeu128(ptr, a) #define zero_u8 0 #define zero_u32 0 #define zero_u64a 0 #define zero_m128 zeroes128() #define zero_m256 zeroes256() #define zero_m384 zeroes384() #define zero_m512 zeroes512() #define ones_u8 0xff #define ones_u32 0xfffffffful #define ones_u64a 0xffffffffffffffffull #define ones_m128 ones128() #define ones_m256 ones256() #define ones_m384 ones384() #define ones_m512 ones512() #define or_u8(a, b) ((a) | (b)) #define or_u32(a, b) ((a) | (b)) #define or_u64a(a, b) ((a) | (b)) #define or_m128(a, b) (or128(a, b)) #define or_m256(a, b) (or256(a, b)) #define or_m384(a, b) (or384(a, b)) #define or_m512(a, b) (or512(a, b)) #define and_u8(a, b) ((a) & (b)) #define and_u32(a, b) ((a) & (b)) #define and_u64a(a, b) ((a) & (b)) #define and_m128(a, b) (and128(a, b)) #define and_m256(a, b) (and256(a, b)) #define and_m384(a, b) (and384(a, b)) #define and_m512(a, b) (and512(a, b)) #define not_u8(a) (~(a)) #define not_u32(a) (~(a)) #define not_u64a(a) (~(a)) #define not_m128(a) (not128(a)) #define not_m256(a) (not256(a)) #define not_m384(a) (not384(a)) #define not_m512(a) (not512(a)) #define andnot_u8(a, b) ((~(a)) & (b)) #define andnot_u32(a, b) ((~(a)) & (b)) #define andnot_u64a(a, b) ((~(a)) & (b)) #define andnot_m128(a, b) (andnot128(a, b)) #define andnot_m256(a, b) (andnot256(a, b)) #define andnot_m384(a, b) (andnot384(a, b)) #define andnot_m512(a, b) (andnot512(a, b)) #define lshift_u32(a, b) ((a) << (b)) #define lshift_u64a(a, b) ((a) << (b)) #define lshift_m128(a, b) (lshift64_m128(a, b)) #define lshift_m256(a, b) (lshift64_m256(a, b)) #define lshift_m384(a, b) (lshift64_m384(a, b)) #define lshift_m512(a, b) (lshift64_m512(a, b)) #define isZero_u8(a) ((a) == 0) #define isZero_u32(a) ((a) == 0) #define isZero_u64a(a) ((a) == 0) #define isZero_m128(a) (!isnonzero128(a)) #define isZero_m256(a) (!isnonzero256(a)) #define isZero_m384(a) (!isnonzero384(a)) #define isZero_m512(a) (!isnonzero512(a)) #define isNonZero_u8(a) ((a) != 0) #define isNonZero_u32(a) ((a) != 0) #define isNonZero_u64a(a) ((a) != 0) #define isNonZero_m128(a) (isnonzero128(a)) #define isNonZero_m256(a) (isnonzero256(a)) #define isNonZero_m384(a) (isnonzero384(a)) #define isNonZero_m512(a) (isnonzero512(a)) #define diffrich_u32(a, b) ((a) != (b)) #define diffrich_u64a(a, b) ((a) != (b) ? 3 : 0) //TODO: impl 32bit granularity #define diffrich_m128(a, b) (diffrich128(a, b)) #define diffrich_m256(a, b) (diffrich256(a, b)) #define diffrich_m384(a, b) (diffrich384(a, b)) #define diffrich_m512(a, b) (diffrich512(a, b)) #define diffrich64_u32(a, b) ((a) != (b)) #define diffrich64_u64a(a, b) ((a) != (b) ? 1 : 0) #define diffrich64_m128(a, b) (diffrich64_128(a, b)) #define diffrich64_m256(a, b) (diffrich64_256(a, b)) #define diffrich64_m384(a, b) (diffrich64_384(a, b)) #define diffrich64_m512(a, b) (diffrich64_512(a, b)) #define noteq_u8(a, b) ((a) != (b)) #define noteq_u32(a, b) ((a) != (b)) #define noteq_u64a(a, b) ((a) != (b)) #define noteq_m128(a, b) (diff128(a, b)) #define noteq_m256(a, b) (diff256(a, b)) #define noteq_m384(a, b) (diff384(a, b)) #define noteq_m512(a, b) (diff512(a, b)) #define partial_store_m128(ptr, v, sz) storebytes128(ptr, v, sz) #define partial_store_m256(ptr, v, sz) storebytes256(ptr, v, sz) #define partial_store_m384(ptr, v, sz) storebytes384(ptr, v, sz) #define partial_store_m512(ptr, v, sz) storebytes512(ptr, v, sz) #define partial_load_m128(ptr, sz) loadbytes128(ptr, sz) #define partial_load_m256(ptr, sz) loadbytes256(ptr, sz) #define partial_load_m384(ptr, sz) loadbytes384(ptr, sz) #define partial_load_m512(ptr, sz) loadbytes512(ptr, sz) #define store_compressed_u32(ptr, x, m, len) storecompressed32(ptr, x, m, len) #define store_compressed_u64a(ptr, x, m, len) storecompressed64(ptr, x, m, len) #define store_compressed_m128(ptr, x, m, len) storecompressed128(ptr, x, m, len) #define store_compressed_m256(ptr, x, m, len) storecompressed256(ptr, x, m, len) #define store_compressed_m384(ptr, x, m, len) storecompressed384(ptr, x, m, len) #define store_compressed_m512(ptr, x, m, len) storecompressed512(ptr, x, m, len) #define load_compressed_u32(x, ptr, m, len) loadcompressed32(x, ptr, m, len) #define load_compressed_u64a(x, ptr, m, len) loadcompressed64(x, ptr, m, len) #define load_compressed_m128(x, ptr, m, len) loadcompressed128(x, ptr, m, len) #define load_compressed_m256(x, ptr, m, len) loadcompressed256(x, ptr, m, len) #define load_compressed_m384(x, ptr, m, len) loadcompressed384(x, ptr, m, len) #define load_compressed_m512(x, ptr, m, len) loadcompressed512(x, ptr, m, len) static really_inline void clearbit_u32(u32 *p, u32 n) { assert(n < sizeof(*p) * 8); *p &= ~(1U << n); } static really_inline void clearbit_u64a(u64a *p, u32 n) { assert(n < sizeof(*p) * 8); *p &= ~(1ULL << n); } #define clearbit_m128(ptr, n) (clearbit128(ptr, n)) #define clearbit_m256(ptr, n) (clearbit256(ptr, n)) #define clearbit_m384(ptr, n) (clearbit384(ptr, n)) #define clearbit_m512(ptr, n) (clearbit512(ptr, n)) static really_inline char testbit_u32(u32 val, u32 n) { assert(n < sizeof(val) * 8); return !!(val & (1U << n)); } static really_inline char testbit_u64a(u64a val, u32 n) { assert(n < sizeof(val) * 8); return !!(val & (1ULL << n)); } #define testbit_m128(val, n) (testbit128(val, n)) #define testbit_m256(val, n) (testbit256(val, n)) #define testbit_m384(val, n) (testbit384(val, n)) #define testbit_m512(val, n) (testbit512(val, n)) #endif hyperscan-4.4.1/src/util/state_compress.h0000644000175000017500000000535113055426554021253 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Mask-based state compression, used by the NFA. */ #ifndef STATE_COMPRESS_H #define STATE_COMPRESS_H #include "simd_utils.h" #include "ue2common.h" #ifdef __cplusplus extern "C" { #endif /* Note: bytes is not used by implementations >= 128 */ void storecompressed32(void *ptr, const u32 *x, const u32 *m, u32 bytes); void loadcompressed32(u32 *x, const void *ptr, const u32 *m, u32 bytes); void storecompressed64(void *ptr, const u64a *x, const u64a *m, u32 bytes); void loadcompressed64(u64a *x, const void *ptr, const u64a *m, u32 bytes); void storecompressed128(void *ptr, const m128 *x, const m128 *m, u32 bytes); void loadcompressed128(m128 *x, const void *ptr, const m128 *m, u32 bytes); void storecompressed256(void *ptr, const m256 *x, const m256 *m, u32 bytes); void loadcompressed256(m256 *x, const void *ptr, const m256 *m, u32 bytes); void storecompressed384(void *ptr, const m384 *x, const m384 *m, u32 bytes); void loadcompressed384(m384 *x, const void *ptr, const m384 *m, u32 bytes); void storecompressed512(void *ptr, const m512 *x, const m512 *m, u32 bytes); void loadcompressed512(m512 *x, const void *ptr, const m512 *m, u32 bytes); #ifdef __cplusplus } /* extern "C" */ #endif #endif hyperscan-4.4.1/src/util/simd_utils.h0000644000175000017500000006763213055426554020406 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief SIMD types and primitive operations. */ #ifndef SIMD_UTILS #define SIMD_UTILS #if !defined(_WIN32) && !defined(__SSSE3__) #error SSSE3 instructions must be enabled #endif #include "config.h" #include // for memcpy // more recent headers are bestest, but only if we can use them #ifdef __cplusplus # if defined(HAVE_CXX_X86INTRIN_H) # define USE_X86INTRIN_H # endif #else // C # if defined(HAVE_C_X86INTRIN_H) # define USE_X86INTRIN_H # endif #endif #ifdef __cplusplus # if defined(HAVE_CXX_INTRIN_H) # define USE_INTRIN_H # endif #else // C # if defined(HAVE_C_INTRIN_H) # define USE_INTRIN_H # endif #endif #if defined(USE_X86INTRIN_H) #include #elif defined(USE_INTRIN_H) #include #else #error no intrins! #endif #include "ue2common.h" #include "simd_types.h" #include "unaligned.h" // Define a common assume_aligned using an appropriate compiler built-in, if // it's available. Note that we need to handle C or C++ compilation. #ifdef __cplusplus # ifdef HAVE_CXX_BUILTIN_ASSUME_ALIGNED # define assume_aligned(x, y) __builtin_assume_aligned((x), (y)) # endif #else # ifdef HAVE_CC_BUILTIN_ASSUME_ALIGNED # define assume_aligned(x, y) __builtin_assume_aligned((x), (y)) # endif #endif // Fallback to identity case. #ifndef assume_aligned #define assume_aligned(x, y) (x) #endif #ifdef __cplusplus extern "C" { #endif extern const char vbs_mask_data[]; #ifdef __cplusplus } #endif static really_inline m128 ones128(void) { #if defined(__GNUC__) || defined(__INTEL_COMPILER) /* gcc gets this right */ return _mm_set1_epi8(0xFF); #else /* trick from Intel's optimization guide to generate all-ones. * ICC converts this to the single cmpeq instruction */ return _mm_cmpeq_epi8(_mm_setzero_si128(), _mm_setzero_si128()); #endif } static really_inline m128 zeroes128(void) { return _mm_setzero_si128(); } /** \brief Bitwise not for m128*/ static really_inline m128 not128(m128 a) { return _mm_xor_si128(a, ones128()); } /** \brief Return 1 if a and b are different otherwise 0 */ static really_inline int diff128(m128 a, m128 b) { return (_mm_movemask_epi8(_mm_cmpeq_epi8(a, b)) ^ 0xffff); } static really_inline int isnonzero128(m128 a) { return !!diff128(a, zeroes128()); } /** * "Rich" version of diff128(). Takes two vectors a and b and returns a 4-bit * mask indicating which 32-bit words contain differences. */ static really_inline u32 diffrich128(m128 a, m128 b) { a = _mm_cmpeq_epi32(a, b); return ~(_mm_movemask_ps(_mm_castsi128_ps(a))) & 0xf; } /** * "Rich" version of diff128(), 64-bit variant. Takes two vectors a and b and * returns a 4-bit mask indicating which 64-bit words contain differences. */ static really_inline u32 diffrich64_128(m128 a, m128 b) { #if defined(__SSE_41__) a = _mm_cmpeq_epi64(a, b); return ~(_mm_movemask_ps(_mm_castsi128_ps(a))) & 0x5; #else u32 d = diffrich128(a, b); return (d | (d >> 1)) & 0x5; #endif } #define lshift64_m128(a, b) _mm_slli_epi64((a), (b)) #define rshift64_m128(a, b) _mm_srli_epi64((a), (b)) #define eq128(a, b) _mm_cmpeq_epi8((a), (b)) #define movemask128(a) ((u32)_mm_movemask_epi8((a))) static really_inline m128 set16x8(u8 c) { return _mm_set1_epi8(c); } static really_inline m128 set4x32(u32 c) { return _mm_set1_epi32(c); } static really_inline u32 movd(const m128 in) { return _mm_cvtsi128_si32(in); } static really_inline u64a movq(const m128 in) { #if defined(ARCH_X86_64) return _mm_cvtsi128_si64(in); #else // 32-bit - this is horrific u32 lo = movd(in); u32 hi = movd(_mm_srli_epi64(in, 32)); return (u64a)hi << 32 | lo; #endif } /* another form of movq */ static really_inline m128 load_m128_from_u64a(const u64a *p) { #if defined(__GNUC__) && !defined(__INTEL_COMPILER) /* unfortunately _mm_loadl_epi64() is best avoided as it seems to cause * trouble on some older compilers, possibly because it is misdefined to * take an m128 as its parameter */ return _mm_set_epi64((__m64)0ULL, (__m64)*p); #else /* ICC doesn't like casting to __m64 */ return _mm_loadl_epi64((const m128 *)p); #endif } #define rshiftbyte_m128(a, count_immed) _mm_srli_si128(a, count_immed) #define lshiftbyte_m128(a, count_immed) _mm_slli_si128(a, count_immed) #if !defined(__AVX2__) // TODO: this entire file needs restructuring - this carveout is awful #define extractlow64from256(a) movq(a.lo) #define extractlow32from256(a) movd(a.lo) #if defined(__SSE4_1__) #define extract32from256(a, imm) _mm_extract_epi32((imm >> 2) ? a.hi : a.lo, imm % 4) #define extract64from256(a, imm) _mm_extract_epi64((imm >> 2) ? a.hi : a.lo, imm % 2) #else #define extract32from256(a, imm) movd(_mm_srli_si128((imm >> 2) ? a.hi : a.lo, (imm % 4) * 8)) #define extract64from256(a, imm) movq(_mm_srli_si128((imm >> 2) ? a.hi : a.lo, (imm % 2) * 8)) #endif #endif // !AVX2 static really_inline m128 and128(m128 a, m128 b) { return _mm_and_si128(a,b); } static really_inline m128 xor128(m128 a, m128 b) { return _mm_xor_si128(a,b); } static really_inline m128 or128(m128 a, m128 b) { return _mm_or_si128(a,b); } static really_inline m128 andnot128(m128 a, m128 b) { return _mm_andnot_si128(a, b); } // aligned load static really_inline m128 load128(const void *ptr) { assert(ISALIGNED_N(ptr, alignof(m128))); ptr = assume_aligned(ptr, 16); return _mm_load_si128((const m128 *)ptr); } // aligned store static really_inline void store128(void *ptr, m128 a) { assert(ISALIGNED_N(ptr, alignof(m128))); ptr = assume_aligned(ptr, 16); *(m128 *)ptr = a; } // unaligned load static really_inline m128 loadu128(const void *ptr) { return _mm_loadu_si128((const m128 *)ptr); } // unaligned store static really_inline void storeu128(void *ptr, m128 a) { _mm_storeu_si128 ((m128 *)ptr, a); } // packed unaligned store of first N bytes static really_inline void storebytes128(void *ptr, m128 a, unsigned int n) { assert(n <= sizeof(a)); memcpy(ptr, &a, n); } // packed unaligned load of first N bytes, pad with zero static really_inline m128 loadbytes128(const void *ptr, unsigned int n) { m128 a = zeroes128(); assert(n <= sizeof(a)); memcpy(&a, ptr, n); return a; } #ifdef __cplusplus extern "C" { #endif extern const u8 simd_onebit_masks[]; #ifdef __cplusplus } #endif static really_inline m128 mask1bit128(unsigned int n) { assert(n < sizeof(m128) * 8); u32 mask_idx = ((n % 8) * 64) + 31; mask_idx -= n / 8; return loadu128(&simd_onebit_masks[mask_idx]); } // switches on bit N in the given vector. static really_inline void setbit128(m128 *ptr, unsigned int n) { *ptr = or128(mask1bit128(n), *ptr); } // switches off bit N in the given vector. static really_inline void clearbit128(m128 *ptr, unsigned int n) { *ptr = andnot128(mask1bit128(n), *ptr); } // tests bit N in the given vector. static really_inline char testbit128(m128 val, unsigned int n) { const m128 mask = mask1bit128(n); #if defined(__SSE4_1__) return !_mm_testz_si128(mask, val); #else return isnonzero128(and128(mask, val)); #endif } // offset must be an immediate #define palignr(r, l, offset) _mm_alignr_epi8(r, l, offset) static really_inline m128 pshufb(m128 a, m128 b) { m128 result; result = _mm_shuffle_epi8(a, b); return result; } static really_inline m256 vpshufb(m256 a, m256 b) { #if defined(__AVX2__) return _mm256_shuffle_epi8(a, b); #else m256 rv; rv.lo = pshufb(a.lo, b.lo); rv.hi = pshufb(a.hi, b.hi); return rv; #endif } static really_inline m128 variable_byte_shift_m128(m128 in, s32 amount) { assert(amount >= -16 && amount <= 16); m128 shift_mask = loadu128(vbs_mask_data + 16 - amount); return pshufb(in, shift_mask); } static really_inline m128 max_u8_m128(m128 a, m128 b) { return _mm_max_epu8(a, b); } static really_inline m128 min_u8_m128(m128 a, m128 b) { return _mm_min_epu8(a, b); } static really_inline m128 sadd_u8_m128(m128 a, m128 b) { return _mm_adds_epu8(a, b); } static really_inline m128 sub_u8_m128(m128 a, m128 b) { return _mm_sub_epi8(a, b); } /**** **** 256-bit Primitives ****/ #if defined(__AVX2__) #define lshift64_m256(a, b) _mm256_slli_epi64((a), (b)) #define rshift64_m256(a, b) _mm256_srli_epi64((a), (b)) static really_inline m256 set32x8(u32 in) { return _mm256_set1_epi8(in); } #define eq256(a, b) _mm256_cmpeq_epi8((a), (b)) #define movemask256(a) ((u32)_mm256_movemask_epi8((a))) static really_inline m256 set2x128(m128 a) { return _mm256_broadcastsi128_si256(a); } #else static really_inline m256 lshift64_m256(m256 a, int b) { m256 rv = a; rv.lo = lshift64_m128(rv.lo, b); rv.hi = lshift64_m128(rv.hi, b); return rv; } static really_inline m256 rshift64_m256(m256 a, int b) { m256 rv = a; rv.lo = rshift64_m128(rv.lo, b); rv.hi = rshift64_m128(rv.hi, b); return rv; } static really_inline m256 set32x8(u32 in) { m256 rv; rv.lo = set16x8((u8) in); rv.hi = rv.lo; return rv; } static really_inline m256 eq256(m256 a, m256 b) { m256 rv; rv.lo = eq128(a.lo, b.lo); rv.hi = eq128(a.hi, b.hi); return rv; } static really_inline u32 movemask256(m256 a) { u32 lo_mask = movemask128(a.lo); u32 hi_mask = movemask128(a.hi); return lo_mask | (hi_mask << 16); } static really_inline m256 set2x128(m128 a) { m256 rv = {a, a}; return rv; } #endif static really_inline m256 zeroes256(void) { #if defined(__AVX2__) return _mm256_setzero_si256(); #else m256 rv = {zeroes128(), zeroes128()}; return rv; #endif } static really_inline m256 ones256(void) { #if defined(__AVX2__) m256 rv = _mm256_set1_epi8(0xFF); #else m256 rv = {ones128(), ones128()}; #endif return rv; } #if defined(__AVX2__) static really_inline m256 and256(m256 a, m256 b) { return _mm256_and_si256(a, b); } #else static really_inline m256 and256(m256 a, m256 b) { m256 rv; rv.lo = and128(a.lo, b.lo); rv.hi = and128(a.hi, b.hi); return rv; } #endif #if defined(__AVX2__) static really_inline m256 or256(m256 a, m256 b) { return _mm256_or_si256(a, b); } #else static really_inline m256 or256(m256 a, m256 b) { m256 rv; rv.lo = or128(a.lo, b.lo); rv.hi = or128(a.hi, b.hi); return rv; } #endif #if defined(__AVX2__) static really_inline m256 xor256(m256 a, m256 b) { return _mm256_xor_si256(a, b); } #else static really_inline m256 xor256(m256 a, m256 b) { m256 rv; rv.lo = xor128(a.lo, b.lo); rv.hi = xor128(a.hi, b.hi); return rv; } #endif #if defined(__AVX2__) static really_inline m256 not256(m256 a) { return _mm256_xor_si256(a, ones256()); } #else static really_inline m256 not256(m256 a) { m256 rv; rv.lo = not128(a.lo); rv.hi = not128(a.hi); return rv; } #endif #if defined(__AVX2__) static really_inline m256 andnot256(m256 a, m256 b) { return _mm256_andnot_si256(a, b); } #else static really_inline m256 andnot256(m256 a, m256 b) { m256 rv; rv.lo = andnot128(a.lo, b.lo); rv.hi = andnot128(a.hi, b.hi); return rv; } #endif static really_inline int diff256(m256 a, m256 b) { #if defined(__AVX2__) return !!(_mm256_movemask_epi8(_mm256_cmpeq_epi8(a, b)) ^ (int)-1); #else return diff128(a.lo, b.lo) || diff128(a.hi, b.hi); #endif } static really_inline int isnonzero256(m256 a) { #if defined(__AVX2__) return !!diff256(a, zeroes256()); #else return isnonzero128(or128(a.lo, a.hi)); #endif } /** * "Rich" version of diff256(). Takes two vectors a and b and returns an 8-bit * mask indicating which 32-bit words contain differences. */ static really_inline u32 diffrich256(m256 a, m256 b) { #if defined(__AVX2__) a = _mm256_cmpeq_epi32(a, b); return ~(_mm256_movemask_ps(_mm256_castsi256_ps(a))) & 0xFF; #else m128 z = zeroes128(); a.lo = _mm_cmpeq_epi32(a.lo, b.lo); a.hi = _mm_cmpeq_epi32(a.hi, b.hi); m128 packed = _mm_packs_epi16(_mm_packs_epi32(a.lo, a.hi), z); return ~(_mm_movemask_epi8(packed)) & 0xff; #endif } /** * "Rich" version of diff256(), 64-bit variant. Takes two vectors a and b and * returns an 8-bit mask indicating which 64-bit words contain differences. */ static really_inline u32 diffrich64_256(m256 a, m256 b) { u32 d = diffrich256(a, b); return (d | (d >> 1)) & 0x55555555; } // aligned load static really_inline m256 load256(const void *ptr) { assert(ISALIGNED_N(ptr, alignof(m256))); #if defined(__AVX2__) return _mm256_load_si256((const m256 *)ptr); #else m256 rv = { load128(ptr), load128((const char *)ptr + 16) }; return rv; #endif } // aligned load of 128-bit value to low and high part of 256-bit value static really_inline m256 load2x128(const void *ptr) { #if defined(__AVX2__) return set2x128(load128(ptr)); #else assert(ISALIGNED_N(ptr, alignof(m128))); m256 rv; rv.hi = rv.lo = load128(ptr); return rv; #endif } static really_inline m256 loadu2x128(const void *ptr) { return set2x128(loadu128(ptr)); } // aligned store static really_inline void store256(void *ptr, m256 a) { assert(ISALIGNED_N(ptr, alignof(m256))); #if defined(__AVX2__) _mm256_store_si256((m256 *)ptr, a); #else ptr = assume_aligned(ptr, 16); *(m256 *)ptr = a; #endif } // unaligned load static really_inline m256 loadu256(const void *ptr) { #if defined(__AVX2__) return _mm256_loadu_si256((const m256 *)ptr); #else m256 rv = { loadu128(ptr), loadu128((const char *)ptr + 16) }; return rv; #endif } // unaligned store static really_inline void storeu256(void *ptr, m256 a) { #if defined(__AVX2__) _mm256_storeu_si256((m256 *)ptr, a); #else storeu128(ptr, a.lo); storeu128((char *)ptr + 16, a.hi); #endif } // packed unaligned store of first N bytes static really_inline void storebytes256(void *ptr, m256 a, unsigned int n) { assert(n <= sizeof(a)); memcpy(ptr, &a, n); } // packed unaligned load of first N bytes, pad with zero static really_inline m256 loadbytes256(const void *ptr, unsigned int n) { m256 a = zeroes256(); assert(n <= sizeof(a)); memcpy(&a, ptr, n); return a; } static really_inline m256 mask1bit256(unsigned int n) { assert(n < sizeof(m256) * 8); u32 mask_idx = ((n % 8) * 64) + 31; mask_idx -= n / 8; return loadu256(&simd_onebit_masks[mask_idx]); } #if !defined(__AVX2__) // switches on bit N in the given vector. static really_inline void setbit256(m256 *ptr, unsigned int n) { assert(n < sizeof(*ptr) * 8); m128 *sub; if (n < 128) { sub = &ptr->lo; } else { sub = &ptr->hi; n -= 128; } setbit128(sub, n); } // switches off bit N in the given vector. static really_inline void clearbit256(m256 *ptr, unsigned int n) { assert(n < sizeof(*ptr) * 8); m128 *sub; if (n < 128) { sub = &ptr->lo; } else { sub = &ptr->hi; n -= 128; } clearbit128(sub, n); } // tests bit N in the given vector. static really_inline char testbit256(m256 val, unsigned int n) { assert(n < sizeof(val) * 8); m128 sub; if (n < 128) { sub = val.lo; } else { sub = val.hi; n -= 128; } return testbit128(sub, n); } static really_really_inline m128 movdq_hi(m256 x) { return x.hi; } static really_really_inline m128 movdq_lo(m256 x) { return x.lo; } static really_inline m256 combine2x128(m128 hi, m128 lo) { m256 rv = {lo, hi}; return rv; } #else // AVX2 // switches on bit N in the given vector. static really_inline void setbit256(m256 *ptr, unsigned int n) { *ptr = or256(mask1bit256(n), *ptr); } static really_inline void clearbit256(m256 *ptr, unsigned int n) { *ptr = andnot256(mask1bit256(n), *ptr); } // tests bit N in the given vector. static really_inline char testbit256(m256 val, unsigned int n) { const m256 mask = mask1bit256(n); return !_mm256_testz_si256(mask, val); } static really_really_inline m128 movdq_hi(m256 x) { return _mm256_extracti128_si256(x, 1); } static really_really_inline m128 movdq_lo(m256 x) { return _mm256_extracti128_si256(x, 0); } #define cast256to128(a) _mm256_castsi256_si128(a) #define cast128to256(a) _mm256_castsi128_si256(a) #define swap128in256(a) _mm256_permute4x64_epi64(a, 0x4E) #define insert128to256(a, b, imm) _mm256_inserti128_si256(a, b, imm) #define rshift128_m256(a, count_immed) _mm256_srli_si256(a, count_immed) #define lshift128_m256(a, count_immed) _mm256_slli_si256(a, count_immed) #define extract64from256(a, imm) _mm_extract_epi64(_mm256_extracti128_si256(a, imm >> 1), imm % 2) #define extract32from256(a, imm) _mm_extract_epi32(_mm256_extracti128_si256(a, imm >> 2), imm % 4) #define extractlow64from256(a) _mm_cvtsi128_si64(cast256to128(a)) #define extractlow32from256(a) movd(cast256to128(a)) #define interleave256hi(a, b) _mm256_unpackhi_epi8(a, b); #define interleave256lo(a, b) _mm256_unpacklo_epi8(a, b); #define vpalignr(r, l, offset) _mm256_alignr_epi8(r, l, offset) static really_inline m256 combine2x128(m128 hi, m128 lo) { #if defined(_mm256_set_m128i) return _mm256_set_m128i(hi, lo); #else return insert128to256(cast128to256(lo), hi, 1); #endif } #endif //AVX2 /**** **** 384-bit Primitives ****/ static really_inline m384 and384(m384 a, m384 b) { m384 rv; rv.lo = and128(a.lo, b.lo); rv.mid = and128(a.mid, b.mid); rv.hi = and128(a.hi, b.hi); return rv; } static really_inline m384 or384(m384 a, m384 b) { m384 rv; rv.lo = or128(a.lo, b.lo); rv.mid = or128(a.mid, b.mid); rv.hi = or128(a.hi, b.hi); return rv; } static really_inline m384 xor384(m384 a, m384 b) { m384 rv; rv.lo = xor128(a.lo, b.lo); rv.mid = xor128(a.mid, b.mid); rv.hi = xor128(a.hi, b.hi); return rv; } static really_inline m384 not384(m384 a) { m384 rv; rv.lo = not128(a.lo); rv.mid = not128(a.mid); rv.hi = not128(a.hi); return rv; } static really_inline m384 andnot384(m384 a, m384 b) { m384 rv; rv.lo = andnot128(a.lo, b.lo); rv.mid = andnot128(a.mid, b.mid); rv.hi = andnot128(a.hi, b.hi); return rv; } // The shift amount is an immediate static really_really_inline m384 lshift64_m384(m384 a, unsigned b) { m384 rv; rv.lo = lshift64_m128(a.lo, b); rv.mid = lshift64_m128(a.mid, b); rv.hi = lshift64_m128(a.hi, b); return rv; } static really_inline m384 zeroes384(void) { m384 rv = {zeroes128(), zeroes128(), zeroes128()}; return rv; } static really_inline m384 ones384(void) { m384 rv = {ones128(), ones128(), ones128()}; return rv; } static really_inline int diff384(m384 a, m384 b) { return diff128(a.lo, b.lo) || diff128(a.mid, b.mid) || diff128(a.hi, b.hi); } static really_inline int isnonzero384(m384 a) { return isnonzero128(or128(or128(a.lo, a.mid), a.hi)); } /** * "Rich" version of diff384(). Takes two vectors a and b and returns a 12-bit * mask indicating which 32-bit words contain differences. */ static really_inline u32 diffrich384(m384 a, m384 b) { m128 z = zeroes128(); a.lo = _mm_cmpeq_epi32(a.lo, b.lo); a.mid = _mm_cmpeq_epi32(a.mid, b.mid); a.hi = _mm_cmpeq_epi32(a.hi, b.hi); m128 packed = _mm_packs_epi16(_mm_packs_epi32(a.lo, a.mid), _mm_packs_epi32(a.hi, z)); return ~(_mm_movemask_epi8(packed)) & 0xfff; } /** * "Rich" version of diff384(), 64-bit variant. Takes two vectors a and b and * returns a 12-bit mask indicating which 64-bit words contain differences. */ static really_inline u32 diffrich64_384(m384 a, m384 b) { u32 d = diffrich384(a, b); return (d | (d >> 1)) & 0x55555555; } // aligned load static really_inline m384 load384(const void *ptr) { assert(ISALIGNED_16(ptr)); m384 rv = { load128(ptr), load128((const char *)ptr + 16), load128((const char *)ptr + 32) }; return rv; } // aligned store static really_inline void store384(void *ptr, m384 a) { assert(ISALIGNED_16(ptr)); ptr = assume_aligned(ptr, 16); *(m384 *)ptr = a; } // unaligned load static really_inline m384 loadu384(const void *ptr) { m384 rv = { loadu128(ptr), loadu128((const char *)ptr + 16), loadu128((const char *)ptr + 32)}; return rv; } // packed unaligned store of first N bytes static really_inline void storebytes384(void *ptr, m384 a, unsigned int n) { assert(n <= sizeof(a)); memcpy(ptr, &a, n); } // packed unaligned load of first N bytes, pad with zero static really_inline m384 loadbytes384(const void *ptr, unsigned int n) { m384 a = zeroes384(); assert(n <= sizeof(a)); memcpy(&a, ptr, n); return a; } // switches on bit N in the given vector. static really_inline void setbit384(m384 *ptr, unsigned int n) { assert(n < sizeof(*ptr) * 8); m128 *sub; if (n < 128) { sub = &ptr->lo; } else if (n < 256) { sub = &ptr->mid; } else { sub = &ptr->hi; } setbit128(sub, n % 128); } // switches off bit N in the given vector. static really_inline void clearbit384(m384 *ptr, unsigned int n) { assert(n < sizeof(*ptr) * 8); m128 *sub; if (n < 128) { sub = &ptr->lo; } else if (n < 256) { sub = &ptr->mid; } else { sub = &ptr->hi; } clearbit128(sub, n % 128); } // tests bit N in the given vector. static really_inline char testbit384(m384 val, unsigned int n) { assert(n < sizeof(val) * 8); m128 sub; if (n < 128) { sub = val.lo; } else if (n < 256) { sub = val.mid; } else { sub = val.hi; } return testbit128(sub, n % 128); } /**** **** 512-bit Primitives ****/ static really_inline m512 and512(m512 a, m512 b) { m512 rv; rv.lo = and256(a.lo, b.lo); rv.hi = and256(a.hi, b.hi); return rv; } static really_inline m512 or512(m512 a, m512 b) { m512 rv; rv.lo = or256(a.lo, b.lo); rv.hi = or256(a.hi, b.hi); return rv; } static really_inline m512 xor512(m512 a, m512 b) { m512 rv; rv.lo = xor256(a.lo, b.lo); rv.hi = xor256(a.hi, b.hi); return rv; } static really_inline m512 not512(m512 a) { m512 rv; rv.lo = not256(a.lo); rv.hi = not256(a.hi); return rv; } static really_inline m512 andnot512(m512 a, m512 b) { m512 rv; rv.lo = andnot256(a.lo, b.lo); rv.hi = andnot256(a.hi, b.hi); return rv; } // The shift amount is an immediate static really_really_inline m512 lshift64_m512(m512 a, unsigned b) { m512 rv; rv.lo = lshift64_m256(a.lo, b); rv.hi = lshift64_m256(a.hi, b); return rv; } static really_inline m512 zeroes512(void) { m512 rv = {zeroes256(), zeroes256()}; return rv; } static really_inline m512 ones512(void) { m512 rv = {ones256(), ones256()}; return rv; } static really_inline int diff512(m512 a, m512 b) { return diff256(a.lo, b.lo) || diff256(a.hi, b.hi); } static really_inline int isnonzero512(m512 a) { #if !defined(__AVX2__) m128 x = or128(a.lo.lo, a.lo.hi); m128 y = or128(a.hi.lo, a.hi.hi); return isnonzero128(or128(x, y)); #else m256 x = or256(a.lo, a.hi); return !!diff256(x, zeroes256()); #endif } /** * "Rich" version of diff512(). Takes two vectors a and b and returns a 16-bit * mask indicating which 32-bit words contain differences. */ static really_inline u32 diffrich512(m512 a, m512 b) { #if defined(__AVX2__) return diffrich256(a.lo, b.lo) | (diffrich256(a.hi, b.hi) << 8); #else a.lo.lo = _mm_cmpeq_epi32(a.lo.lo, b.lo.lo); a.lo.hi = _mm_cmpeq_epi32(a.lo.hi, b.lo.hi); a.hi.lo = _mm_cmpeq_epi32(a.hi.lo, b.hi.lo); a.hi.hi = _mm_cmpeq_epi32(a.hi.hi, b.hi.hi); m128 packed = _mm_packs_epi16(_mm_packs_epi32(a.lo.lo, a.lo.hi), _mm_packs_epi32(a.hi.lo, a.hi.hi)); return ~(_mm_movemask_epi8(packed)) & 0xffff; #endif } /** * "Rich" version of diffrich(), 64-bit variant. Takes two vectors a and b and * returns a 16-bit mask indicating which 64-bit words contain differences. */ static really_inline u32 diffrich64_512(m512 a, m512 b) { u32 d = diffrich512(a, b); return (d | (d >> 1)) & 0x55555555; } // aligned load static really_inline m512 load512(const void *ptr) { assert(ISALIGNED_N(ptr, alignof(m256))); m512 rv = { load256(ptr), load256((const char *)ptr + 32) }; return rv; } // aligned store static really_inline void store512(void *ptr, m512 a) { assert(ISALIGNED_N(ptr, alignof(m256))); #if defined(__AVX2__) m512 *x = (m512 *)ptr; store256(&x->lo, a.lo); store256(&x->hi, a.hi); #else ptr = assume_aligned(ptr, 16); *(m512 *)ptr = a; #endif } // unaligned load static really_inline m512 loadu512(const void *ptr) { m512 rv = { loadu256(ptr), loadu256((const char *)ptr + 32) }; return rv; } // packed unaligned store of first N bytes static really_inline void storebytes512(void *ptr, m512 a, unsigned int n) { assert(n <= sizeof(a)); memcpy(ptr, &a, n); } // packed unaligned load of first N bytes, pad with zero static really_inline m512 loadbytes512(const void *ptr, unsigned int n) { m512 a = zeroes512(); assert(n <= sizeof(a)); memcpy(&a, ptr, n); return a; } // switches on bit N in the given vector. static really_inline void setbit512(m512 *ptr, unsigned int n) { assert(n < sizeof(*ptr) * 8); #if !defined(__AVX2__) m128 *sub; if (n < 128) { sub = &ptr->lo.lo; } else if (n < 256) { sub = &ptr->lo.hi; } else if (n < 384) { sub = &ptr->hi.lo; } else { sub = &ptr->hi.hi; } setbit128(sub, n % 128); #else m256 *sub; if (n < 256) { sub = &ptr->lo; } else { sub = &ptr->hi; n -= 256; } setbit256(sub, n); #endif } // switches off bit N in the given vector. static really_inline void clearbit512(m512 *ptr, unsigned int n) { assert(n < sizeof(*ptr) * 8); #if !defined(__AVX2__) m128 *sub; if (n < 128) { sub = &ptr->lo.lo; } else if (n < 256) { sub = &ptr->lo.hi; } else if (n < 384) { sub = &ptr->hi.lo; } else { sub = &ptr->hi.hi; } clearbit128(sub, n % 128); #else m256 *sub; if (n < 256) { sub = &ptr->lo; } else { sub = &ptr->hi; n -= 256; } clearbit256(sub, n); #endif } // tests bit N in the given vector. static really_inline char testbit512(m512 val, unsigned int n) { assert(n < sizeof(val) * 8); #if !defined(__AVX2__) m128 sub; if (n < 128) { sub = val.lo.lo; } else if (n < 256) { sub = val.lo.hi; } else if (n < 384) { sub = val.hi.lo; } else { sub = val.hi.hi; } return testbit128(sub, n % 128); #else m256 sub; if (n < 256) { sub = val.lo; } else { sub = val.hi; n -= 256; } return testbit256(sub, n); #endif } #endif hyperscan-4.4.1/src/util/unicode_set.h0000644000175000017500000001005413055426554020515 0ustar sleuthkidsleuthkid/* * 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 UNICODE_SET #define UNICODE_SET #include "unicode_def.h" #include namespace ue2 { class CodePointSet { public: typedef boost::icl::closed_interval interval; typedef boost::icl::interval_set implT; typedef implT::const_iterator const_iterator; CodePointSet(void) {} explicit CodePointSet(const interval &st) : impl(st) {} bool none(void) const { return impl.empty(); } void set(unichar c) { assert(c <= MAX_UNICODE); impl.insert(c); } void unset(unichar c) { assert(c <= MAX_UNICODE); impl.subtract(c); } void setRange(unichar from, unichar to) { /* inclusive */ assert(from <= to); assert(to <= MAX_UNICODE); impl.insert(interval(from, to)); } void unsetRange(unichar from, unichar to) { /* inclusive */ assert(from <= to); assert(to <= MAX_UNICODE); impl.subtract(interval(from, to)); } void flip(void) { impl = implT(interval(0, MAX_UNICODE)) - impl; } void operator|=(const CodePointSet &a) { impl += a.impl; } const_iterator begin(void) const { return impl.begin(); } const_iterator end(void) const { return impl.end(); } size_t count(void) const { return cardinality(impl); } CodePointSet operator~(void) const { CodePointSet rv = *this; rv.flip(); return rv; } bool operator==(const CodePointSet &a) const { return is_element_equal(impl, a.impl); } bool operator!=(const CodePointSet &a) const { return !is_element_equal(impl, a.impl); } bool isSubset(const CodePointSet &a) const { // Check that adding an interval set has no effect return ((impl + a.impl) == impl); } void operator-=(const CodePointSet &a) { impl -= a.impl; } /* finds the nth set codepoint, returns INVALID_UNICODE on failure */ unichar at(size_t pos) const { for (const_iterator i = begin(), e = end(); i != e; ++i) { size_t int_count = cardinality(*i); if (int_count <= pos) { /* not in this interval, check next */ pos -= int_count; continue; } else { return lower(*i) + pos; } } return INVALID_UNICODE; } void swap(CodePointSet &other) { impl.swap(other.impl); } private: implT impl; }; } // namespace ue2 #endif hyperscan-4.4.1/src/util/bitutils.h0000644000175000017500000003040513055426554020055 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Bit-twiddling primitives (ctz, compress etc) */ #ifndef BITUTILS_H #define BITUTILS_H #include "ue2common.h" #include "popcount.h" #ifdef __cplusplus # if defined(HAVE_CXX_X86INTRIN_H) # define USE_X86INTRIN_H # endif #else // C, baby # if defined(HAVE_C_X86INTRIN_H) # define USE_X86INTRIN_H # endif #endif #ifdef __cplusplus # if defined(HAVE_CXX_INTRIN_H) # define USE_INTRIN_H # endif #else // C, baby # if defined(HAVE_C_INTRIN_H) # define USE_INTRIN_H # endif #endif #if defined(USE_X86INTRIN_H) #include #elif defined(USE_INTRIN_H) #include #endif // MSVC has a different form of inline asm #ifdef _WIN32 #define NO_ASM #endif #define CASE_BIT 0x20 #define CASE_CLEAR 0xdf #define DOUBLE_CASE_CLEAR 0xdfdf #define OCTO_CASE_CLEAR 0xdfdfdfdfdfdfdfdfULL static really_inline u32 clz32(u32 x) { assert(x); // behaviour not defined for x == 0 #if defined(_WIN32) unsigned long r; _BitScanReverse(&r, x); return 31 - r; #else return (u32)__builtin_clz(x); #endif } static really_inline u32 clz64(u64a x) { assert(x); // behaviour not defined for x == 0 #if defined(_WIN64) unsigned long r; _BitScanReverse64(&r, x); return 63 - r; #elif defined(_WIN32) unsigned long x1 = (u32)x; unsigned long x2 = (u32)(x >> 32); unsigned long r; if (x2) { _BitScanReverse(&r, x2); return (u32)(31 - r); } _BitScanReverse(&r, (u32)x1); return (u32)(63 - r); #else return (u32)__builtin_clzll(x); #endif } // CTZ (count trailing zero) implementations. static really_inline u32 ctz32(u32 x) { assert(x); // behaviour not defined for x == 0 #if defined(_WIN32) unsigned long r; _BitScanForward(&r, x); return r; #else return (u32)__builtin_ctz(x); #endif } static really_inline u32 ctz64(u64a x) { assert(x); // behaviour not defined for x == 0 #if defined(_WIN64) unsigned long r; _BitScanForward64(&r, x); return r; #elif defined(_WIN32) unsigned long r; if (_BitScanForward(&r, (u32)x)) { return (u32)r; } _BitScanForward(&r, x >> 32); return (u32)(r + 32); #else return (u32)__builtin_ctzll(x); #endif } static really_inline u32 lg2(u32 x) { if (!x) { return 0; } return 31 - clz32(x); } static really_inline u64a lg2_64(u64a x) { if (!x) { return 0; } return 63 - clz64(x); } static really_inline u32 findAndClearLSB_32(u32 *v) { assert(*v != 0); // behaviour not defined in this case #ifndef NO_ASM u32 val = *v, offset; __asm__ ("bsf %1, %0\n" "btr %0, %1\n" : "=r" (offset), "=r" (val) : "1" (val)); *v = val; #else u32 val = *v; u32 offset = ctz32(val); *v = val & (val - 1); #endif assert(offset < 32); return offset; } static really_inline u32 findAndClearLSB_64(u64a *v) { assert(*v != 0); // behaviour not defined in this case #ifdef ARCH_64_BIT #if defined(ARCH_X86_64) && !defined(NO_ASM) u64a val = *v, offset; __asm__ ("bsfq %1, %0\n" "btrq %0, %1\n" : "=r" (offset), "=r" (val) : "1" (val)); *v = val; #else // generic variant using gcc's builtin on 64-bit u64a val = *v, offset; offset = ctz64(val); *v = val & (val - 1); #endif // ARCH_X86_64 #else // fall back to doing things with two 32-bit cases, since gcc-4.1 doesn't // inline calls to __builtin_ctzll u32 v1 = (u32)*v; u32 v2 = (u32)(*v >> 32); u32 offset; if (v1) { offset = findAndClearLSB_32(&v1); *v = (u64a)v1 | ((u64a)v2 << 32); } else { offset = findAndClearLSB_32(&v2) + 32; *v = (u64a)v2 << 32; } #endif assert(offset < 64); return (u32)offset; } static really_inline u32 findAndClearMSB_32(u32 *v) { assert(*v != 0); // behaviour not defined in this case #ifndef NO_ASM u32 val = *v, offset; __asm__ ("bsr %1, %0\n" "btr %0, %1\n" : "=r" (offset), "=r" (val) : "1" (val)); *v = val; #else u32 val = *v; u32 offset = 31 - clz32(val); *v = val & ~(1 << offset); #endif assert(offset < 32); return offset; } static really_inline u32 findAndClearMSB_64(u64a *v) { assert(*v != 0); // behaviour not defined in this case #ifdef ARCH_64_BIT #if defined(ARCH_X86_64) && !defined(NO_ASM) u64a val = *v, offset; __asm__ ("bsrq %1, %0\n" "btrq %0, %1\n" : "=r" (offset), "=r" (val) : "1" (val)); *v = val; #else // generic variant using gcc's builtin on 64-bit u64a val = *v, offset; offset = 63 - clz64(val); *v = val & ~(1ULL << offset); #endif // ARCH_X86_64 #else // fall back to doing things with two 32-bit cases, since gcc-4.1 doesn't // inline calls to __builtin_ctzll u32 v1 = (u32)*v; u32 v2 = (*v >> 32); u32 offset; if (v2) { offset = findAndClearMSB_32(&v2) + 32; *v = ((u64a)v2 << 32) | (u64a)v1; } else { offset = findAndClearMSB_32(&v1); *v = (u64a)v1; } #endif assert(offset < 64); return (u32)offset; } static really_inline u32 compress32(u32 x, u32 m) { #if defined(__BMI2__) // BMI2 has a single instruction for this operation. return _pext_u32(x, m); #else // Return zero quickly on trivial cases if ((x & m) == 0) { return 0; } u32 mk, mp, mv, t; x &= m; // clear irrelevant bits mk = ~m << 1; // we will count 0's to right for (u32 i = 0; i < 5; i++) { mp = mk ^ (mk << 1); mp ^= mp << 2; mp ^= mp << 4; mp ^= mp << 8; mp ^= mp << 16; mv = mp & m; // bits to move m = (m ^ mv) | (mv >> (1 << i)); // compress m t = x & mv; x = (x ^ t) | (t >> (1 << i)); // compress x mk = mk & ~mp; } return x; #endif } static really_inline u64a compress64(u64a x, u64a m) { #if defined(ARCH_X86_64) && defined(__BMI2__) // BMI2 has a single instruction for this operation. return _pext_u64(x, m); #else // Return zero quickly on trivial cases if ((x & m) == 0) { return 0; } u64a mk, mp, mv, t; x &= m; // clear irrelevant bits mk = ~m << 1; // we will count 0's to right for (u32 i = 0; i < 6; i++) { mp = mk ^ (mk << 1); mp ^= mp << 2; mp ^= mp << 4; mp ^= mp << 8; mp ^= mp << 16; mp ^= mp << 32; mv = mp & m; // bits to move m = (m ^ mv) | (mv >> (1 << i)); // compress m t = x & mv; x = (x ^ t) | (t >> (1 << i)); // compress x mk = mk & ~mp; } return x; #endif } static really_inline u32 expand32(u32 x, u32 m) { #if defined(__BMI2__) // BMI2 has a single instruction for this operation. return _pdep_u32(x, m); #else // Return zero quickly on trivial cases if (!x || !m) { return 0; } u32 m0, mk, mp, mv, t; u32 array[5]; m0 = m; // save original mask mk = ~m << 1; // we will count 0's to right for (int i = 0; i < 5; i++) { mp = mk ^ (mk << 1); // parallel suffix mp = mp ^ (mp << 2); mp = mp ^ (mp << 4); mp = mp ^ (mp << 8); mp = mp ^ (mp << 16); mv = mp & m; // bits to move array[i] = mv; m = (m ^ mv) | (mv >> (1 << i)); // compress m mk = mk & ~mp; } for (int i = 4; i >= 0; i--) { mv = array[i]; t = x << (1 << i); x = (x & ~mv) | (t & mv); } return x & m0; // clear out extraneous bits #endif } static really_inline u64a expand64(u64a x, u64a m) { #if defined(ARCH_X86_64) && defined(__BMI2__) // BMI2 has a single instruction for this operation. return _pdep_u64(x, m); #else // Return zero quickly on trivial cases if (!x || !m) { return 0; } u64a m0, mk, mp, mv, t; u64a array[6]; m0 = m; // save original mask mk = ~m << 1; // we will count 0's to right for (int i = 0; i < 6; i++) { mp = mk ^ (mk << 1); // parallel suffix mp = mp ^ (mp << 2); mp = mp ^ (mp << 4); mp = mp ^ (mp << 8); mp = mp ^ (mp << 16); mp = mp ^ (mp << 32); mv = mp & m; // bits to move array[i] = mv; m = (m ^ mv) | (mv >> (1 << i)); // compress m mk = mk & ~mp; } for (int i = 5; i >= 0; i--) { mv = array[i]; t = x << (1 << i); x = (x & ~mv) | (t & mv); } return x & m0; // clear out extraneous bits #endif } /* returns the first set bit after begin (if not ~0U). If no bit is set after * begin returns ~0U */ static really_inline u32 bf64_iterate(u64a bitfield, u32 begin) { if (begin != ~0U) { /* switch off all bits at or below begin. Note: not legal to shift by * by size of the datatype or larger. */ assert(begin <= 63); bitfield &= ~((2ULL << begin) - 1); } if (!bitfield) { return ~0U; } return ctz64(bitfield); } static really_inline char bf64_set(u64a *bitfield, u32 i) { assert(i < 64); u64a mask = 1ULL << i; char was_set = !!(*bitfield & mask); *bitfield |= mask; return was_set; } static really_inline void bf64_unset(u64a *bitfield, u32 i) { assert(i < 64); *bitfield &= ~(1ULL << i); } static really_inline u32 rank_in_mask32(u32 mask, u32 bit) { assert(bit < sizeof(u32) * 8); assert(mask & (u32)(1U << bit)); mask &= (u32)(1U << bit) - 1; return popcount32(mask); } static really_inline u32 rank_in_mask64(u64a mask, u32 bit) { assert(bit < sizeof(u64a) * 8); assert(mask & (u64a)(1ULL << bit)); mask &= (u64a)(1ULL << bit) - 1; return popcount64(mask); } #if defined(__BMI2__) || (defined(_WIN32) && defined(__AVX2__)) #define HAVE_PEXT #endif static really_inline u32 pext32(u32 x, u32 mask) { #if defined(HAVE_PEXT) // Intel BMI2 can do this operation in one instruction. return _pext_u32(x, mask); #else u32 result = 0, num = 1; while (mask != 0) { u32 bit = findAndClearLSB_32(&mask); if (x & (1U << bit)) { assert(num != 0); // more than 32 bits! result |= num; } num <<= 1; } return result; #endif } static really_inline u64a pext64(u64a x, u64a mask) { #if defined(HAVE_PEXT) && defined(ARCH_64_BIT) // Intel BMI2 can do this operation in one instruction. return _pext_u64(x, mask); #else u32 result = 0, num = 1; while (mask != 0) { u32 bit = findAndClearLSB_64(&mask); if (x & (1ULL << bit)) { assert(num != 0); // more than 32 bits! result |= num; } num <<= 1; } return result; #endif } #if defined(HAVE_PEXT) && defined(ARCH_64_BIT) static really_inline u64a pdep64(u64a x, u64a mask) { return _pdep_u64(x, mask); } #endif #endif // BITUTILS_H hyperscan-4.4.1/src/util/determinise.h0000644000175000017500000001604313055426554020530 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief DFA determinisation code. */ #ifndef DETERMINISE_H #define DETERMINISE_H #include "nfagraph/ng_holder.h" #include "charreach.h" #include "container.h" #include "ue2common.h" #include #include #include namespace ue2 { #define DETERMINISE_RESERVE_SIZE 10 /* Automaton details: * * const vector initial() * returns initial states to start determinising from. StateSets in the * initial() vector will given consecutive ids starting from 1, in the order * that they appear. * * void reports(StateSet s, flat_set *out) * fills out with any reports that need to be raised for stateset. * * void reportsEod(StateSet s, flat_set *out) * fills out with any reports that need to be raised for stateset at EOD. * * void transition(const StateSet &in, StateSet *next) * fills the next array such next[i] is the stateset that in transitions to * on seeing symbol i (i is in the compressed alphabet of the automaton). * * u16 alphasize * size of the compressed alphabet */ /** \brief determinises some sort of nfa * \param n the automaton to determinise * \param dstates_out output dfa states * \param state_limit limit on the number of dfa states to construct * \param statesets_out a mapping from DFA state to the set of NFA states in * the automaton * \return zero on success */ template never_inline int determinise(Auto &n, std::vector &dstates_out, dstate_id_t state_limit, std::vector *statesets_out = nullptr) { DEBUG_PRINTF("the determinator\n"); typedef typename Auto::StateSet StateSet; typedef typename Auto::StateMap DstateIdMap; DstateIdMap dstate_ids; std::vector statesets; const size_t alphabet_size = n.alphasize; std::vector dstates; dstates.reserve(DETERMINISE_RESERVE_SIZE); statesets.reserve(DETERMINISE_RESERVE_SIZE); dstate_ids[n.dead] = DEAD_STATE; dstates.push_back(ds(alphabet_size)); std::fill_n(dstates[0].next.begin(), alphabet_size, DEAD_STATE); statesets.push_back(n.dead); const std::vector &init = n.initial(); for (u32 i = 0; i < init.size(); i++) { statesets.push_back(init[i]); assert(!contains(dstate_ids, init[i])); dstate_ids[init[i]] = dstates.size(); dstates.push_back(ds(alphabet_size)); } std::vector succs(alphabet_size, n.dead); for (dstate_id_t curr_id = DEAD_STATE; curr_id < dstates.size(); curr_id++) { StateSet &curr = statesets[curr_id]; DEBUG_PRINTF("curr: %hu\n", curr_id); /* fill in accepts */ n.reports(curr, dstates[curr_id].reports); n.reportsEod(curr, dstates[curr_id].reports_eod); if (!dstates[curr_id].reports.empty()) { DEBUG_PRINTF("curr: %hu: is accept\n", curr_id); } if (!dstates[curr_id].reports.empty()) { /* only external reports set ekeys */ if (n.canPrune(dstates[curr_id].reports)) { /* we only transition to dead on characters, TOPs leave us * alone */ std::fill_n(dstates[curr_id].next.begin(), alphabet_size, DEAD_STATE); dstates[curr_id].next[n.alpha[TOP]] = curr_id; continue; } } /* fill in successor states */ n.transition(curr, &succs[0]); for (symbol_t s = 0; s < n.alphasize; s++) { dstate_id_t succ_id; if (s && succs[s] == succs[s - 1]) { succ_id = dstates[curr_id].next[s - 1]; } else { typename DstateIdMap::const_iterator dstate_id_iter; dstate_id_iter = dstate_ids.find(succs[s]); if (dstate_id_iter != dstate_ids.end()) { succ_id = dstate_id_iter->second; if (succ_id > curr_id && !dstates[succ_id].daddy && n.unalpha[s] < N_CHARS) { dstates[succ_id].daddy = curr_id; } } else { statesets.push_back(succs[s]); succ_id = dstates.size(); dstate_ids[succs[s]] = succ_id; dstates.push_back(ds(alphabet_size)); dstates.back().daddy = n.unalpha[s] < N_CHARS ? curr_id : 0; } DEBUG_PRINTF("-->%hu on %02hx\n", succ_id, n.unalpha[s]); } if (succ_id >= state_limit) { DEBUG_PRINTF("succ_id %hu >= state_limit %hu\n", succ_id, state_limit); return -2; } dstates[curr_id].next[s] = succ_id; } } dstates_out = dstates; if (statesets_out) { statesets_out->swap(statesets); } DEBUG_PRINTF("ok\n"); return 0; } static inline std::vector populateCR(const NGHolder &g, const std::vector &v_by_index, const std::array &alpha) { std::vector cr_by_index(v_by_index.size()); for (size_t i = 0; i < v_by_index.size(); i++) { const CharReach &cr = g[v_by_index[i]].char_reach; CharReach &cr_out = cr_by_index[i]; for (size_t s = cr.find_first(); s != cr.npos; s = cr.find_next(s)) { cr_out.set(alpha[s]); } } return cr_by_index; } } // namespace ue2 #endif hyperscan-4.4.1/src/util/compare.h0000644000175000017500000001237313055426554017650 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 COMPARE_H #define COMPARE_H #include "unaligned.h" #include "ue2common.h" /* Our own definitions of tolower, toupper and isalpha are provided to prevent * us from going out to libc for these tests. */ static really_inline char myisupper(const char c) { return ((c >= 'A') && (c <= 'Z')); } static really_inline char myislower(const char c) { return ((c >= 'a') && (c <= 'z')); } static really_inline char mytolower(const char c) { if (myisupper(c)) { return c + 0x20; } return c; } static really_inline char mytoupper(const char c) { if (myislower(c)) { return c - 0x20; } return c; } /* this is a slightly warped definition of `alpha'. What we really * mean is: does this character have different uppercase and lowercase forms? */ static really_inline char ourisalpha(const char c) { return mytolower(c) != mytoupper(c); } static really_inline char ourisprint(const char c) { return c >= 0x20 && c <= 0x7e; } // Paul Hsieh's SWAR toupper; used because it doesn't // matter whether we go toupper or tolower. We should // probably change the other one static really_inline u32 theirtoupper32(const u32 x) { u32 b = 0x80808080ul | x; u32 c = b - 0x61616161ul; u32 d = ~(b - 0x7b7b7b7bul); u32 e = (c & d) & (~x & 0x80808080ul); return x - (e >> 2); } // 64-bit variant. static really_inline u64a theirtoupper64(const u64a x) { u64a b = 0x8080808080808080ull | x; u64a c = b - 0x6161616161616161ull; u64a d = ~(b - 0x7b7b7b7b7b7b7b7bull); u64a e = (c & d) & (~x & 0x8080808080808080ull); u64a v = x - (e >> 2); return v; } static really_inline int cmpNocaseNaive(const u8 *p1, const u8 *p2, size_t len) { const u8 *pEnd = p1 + len; for (; p1 < pEnd; p1++, p2++) { assert(!ourisalpha(*p2) || myisupper(*p2)); // Already upper-case. if ((u8)mytoupper(*p1) != *p2) { return 1; } } return 0; } static really_inline int cmpCaseNaive(const u8 *p1, const u8 *p2, size_t len) { const u8 *pEnd = p1 + len; for (; p1 < pEnd; p1++, p2++) { if (*p1 != *p2) { return 1; } } return 0; } #ifdef ARCH_64_BIT # define CMP_T u64a # define ULOAD(x) unaligned_load_u64a(x) # define TOUPPER(x) theirtoupper64(x) #else # define CMP_T u32 # define ULOAD(x) unaligned_load_u32(x) # define TOUPPER(x) theirtoupper32(x) #endif #define CMP_SIZE sizeof(CMP_T) /** * \brief Compare two strings, optionally caselessly. * * Note: If nocase is true, p2 is assumed to be already upper-case. */ #if defined(ARCH_IA32) static UNUSED never_inline #else static really_inline #endif int cmpForward(const u8 *p1, const u8 *p2, size_t len, char nocase) { if (len < CMP_SIZE) { return nocase ? cmpNocaseNaive(p1, p2, len) : cmpCaseNaive(p1, p2, len); } const u8 *p1_end = p1 + len - CMP_SIZE; const u8 *p2_end = p2 + len - CMP_SIZE; if (nocase) { // Case-insensitive version. for (; p1 < p1_end; p1 += CMP_SIZE, p2 += CMP_SIZE) { assert(ULOAD(p2) == TOUPPER(ULOAD(p2))); // Already upper-case. if (TOUPPER(ULOAD(p1)) != ULOAD(p2)) { return 1; } } assert(ULOAD(p2_end) == TOUPPER(ULOAD(p2_end))); // Already upper-case. if (TOUPPER(ULOAD(p1_end)) != ULOAD(p2_end)) { return 1; } } else { // Case-sensitive version. for (; p1 < p1_end; p1 += CMP_SIZE, p2 += CMP_SIZE) { if (ULOAD(p1) != ULOAD(p2)) { return 1; } } if (ULOAD(p1_end) != ULOAD(p2_end)) { return 1; } } return 0; } #undef CMP_T #undef ULOAD #undef TOUPPER #undef CMP_SIZE #endif hyperscan-4.4.1/src/grey.h0000644000175000017500000001603013055426554016205 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 GREY_H #define GREY_H #include #include #include "ue2common.h" namespace ue2 { struct Grey { Grey(void); bool optimiseComponentTree; bool performGraphSimplification; bool prefilterReductions; bool removeEdgeRedundancy; bool allowGough; bool allowHaigLit; bool allowLitHaig; bool allowLbr; bool allowMcClellan; bool allowSheng; bool allowMcSheng; bool allowPuff; bool allowLiteral; bool allowRose; bool allowViolet; bool allowExtendedNFA; bool allowLimExNFA; bool allowAnchoredAcyclic; bool allowSmallLiteralSet; bool allowCastle; bool allowDecoratedLiteral; bool allowNoodle; bool fdrAllowTeddy; u32 violetAvoidSuffixes; /* 0=never, 1=sometimes, 2=always */ bool violetAvoidWeakInfixes; bool violetDoubleCut; bool violetExtractStrongLiterals; bool violetLiteralChains; u32 violetDoubleCutLiteralLen; u32 violetEarlyCleanLiteralLen; bool puffImproveHead; bool castleExclusive; // enable castle mutual exclusion analysis bool mergeSEP; bool mergeRose; bool mergeSuffixes; bool mergeOutfixes; bool onlyOneOutfix; // if > 1 outfix, fail compile bool allowShermanStates; bool allowMcClellan8; bool highlanderPruneDFA; bool minimizeDFA; bool accelerateDFA; bool accelerateNFA; bool reverseAccelerate; bool squashNFA; bool compressNFAState; bool numberNFAStatesWrong; bool highlanderSquash; bool allowZombies; bool floodAsPuffette; u32 nfaForceSize; u32 maxHistoryAvailable; u32 minHistoryAvailable; u32 maxAnchoredRegion; u32 minRoseLiteralLength; u32 minRoseNetflowLiteralLength; u32 maxRoseNetflowEdges; u32 minExtBoundedRepeatSize; /* to be considered for ng_repeat */ bool goughCopyPropagate; bool goughRegisterAllocate; bool shortcutLiterals; bool roseGraphReduction; bool roseRoleAliasing; bool roseMasks; u32 roseMaxBadLeafLength; bool roseConvertInfBadLeaves; bool roseConvertFloodProneSuffixes; bool roseMergeRosesDuringAliasing; bool roseMultiTopRoses; bool roseHamsterMasks; bool roseLookaroundMasks; u32 roseMcClellanPrefix; /* 0 = off, 1 = only if large nfa, 2 = always */ u32 roseMcClellanSuffix; /* 0 = off, 1 = only if very large nfa, 2 = * always */ u32 roseMcClellanOutfix; /* 0 = off, 1 = sometimes, 2 = almost always */ bool roseTransformDelay; u32 roseDesiredSplit; bool earlyMcClellanPrefix; bool earlyMcClellanInfix; bool earlyMcClellanSuffix; bool allowCountingMiracles; bool allowSomChain; u32 somMaxRevNfaLength; bool hamsterAccelForward; bool hamsterAccelReverse; // currently not implemented u32 miracleHistoryBonus; /* cheap hack to make miracles better, TODO * something dignified */ bool equivalenceEnable; // SmallWrite engine bool allowSmallWrite; bool allowSmallWriteSheng; u32 smallWriteLargestBuffer; // largest buffer that can be small write u32 smallWriteLargestBufferBad;// largest buffer that can be small write u32 limitSmallWriteOutfixSize; //!< max total size of outfix DFAs u32 smallWriteMaxPatterns; // only try small writes if fewer patterns u32 smallWriteMaxLiterals; // only try small writes if fewer literals // Tamarama engine bool allowTamarama; u32 tamaChunkSize; //!< max chunk size for exclusivity analysis in Tamarama enum DumpFlags { DUMP_NONE = 0, DUMP_BASICS = 1 << 0, // Dump basic textual data DUMP_PARSE = 1 << 1, // Dump component tree to .txt DUMP_INT_GRAPH = 1 << 2, // Dump non-implementation graphs DUMP_IMPL = 1 << 3 // Dump implementation graphs }; u32 dumpFlags; std::string dumpPath; /* Resource limits. These are somewhat arbitrary, but are intended to bound * the input to many of our internal structures. Exceeding one of these * limits will cause an error to be returned to the user. * * NOTE: Raising these limitations make cause smoke to come out of parts of * the runtime. */ u32 limitPatternCount; //!< max number of patterns u32 limitPatternLength; //!< max number of characters in a regex u32 limitGraphVertices; //!< max number of states in built NFA graph u32 limitGraphEdges; //!< max number of edges in build NFA graph u32 limitReportCount; //!< max number of ReportIDs allocated internally // HWLM literal matcher limits. u32 limitLiteralCount; //!< max number of literals in an HWLM table u32 limitLiteralLength; //!< max number of characters in a literal u32 limitLiteralMatcherChars; //!< max characters in an HWLM literal matcher u32 limitLiteralMatcherSize; //!< max size of an HWLM matcher (in bytes) // Rose limits. u32 limitRoseRoleCount; //!< max number of Rose roles u32 limitRoseEngineCount; //!< max prefix/infix/suffix/outfix engines u32 limitRoseAnchoredSize; //!< max total size of anchored DFAs (bytes) // Engine (DFA/NFA/etc) limits. u32 limitEngineSize; //!< max size of an engine (in bytes) u32 limitDFASize; //!< max size of a DFA (in bytes) u32 limitNFASize; //!< max size of an NFA (in bytes) u32 limitLBRSize; //!< max size of an LBR engine (in bytes) }; #ifndef RELEASE_BUILD #include void applyGreyOverrides(Grey *g, const std::string &overrides); #endif } // namespace ue2 #endif hyperscan-4.4.1/src/fdr/0000755000175000017500000000000013055426554015641 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/fdr/teddy_avx2.c0000644000175000017500000016033613055426554020067 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Teddy literal matcher: AVX2 engine runtime. */ #include "fdr_internal.h" #include "flood_runtime.h" #include "teddy.h" #include "teddy_internal.h" #include "teddy_runtime_common.h" #include "util/simd_utils.h" #if defined(__AVX2__) static const u8 ALIGN_AVX_DIRECTIVE p_mask_arr256[33][64] = { {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} }; #ifdef ARCH_64_BIT #define CONFIRM_FAT_TEDDY(var, bucket, offset, reason, conf_fn) \ do { \ if (unlikely(isnonzero256(var))) { \ m256 swap = swap128in256(var); \ m256 r = interleave256lo(var, swap); \ u64a part1 = extractlow64from256(r); \ u64a part2 = extract64from256(r, 1); \ r = interleave256hi(var, swap); \ u64a part3 = extractlow64from256(r); \ u64a part4 = extract64from256(r, 1); \ if (unlikely(part1)) { \ conf_fn(&part1, bucket, offset, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part2)) { \ conf_fn(&part2, bucket, offset + 4, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part3)) { \ conf_fn(&part3, bucket, offset + 8, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part4)) { \ conf_fn(&part4, bucket, offset + 12, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ } \ } while (0); #else #define CONFIRM_FAT_TEDDY(var, bucket, offset, reason, conf_fn) \ do { \ if (unlikely(isnonzero256(var))) { \ m256 swap = swap128in256(var); \ m256 r = interleave256lo(var, swap); \ u32 part1 = extractlow32from256(r); \ u32 part2 = extract32from256(r, 1); \ u32 part3 = extract32from256(r, 2); \ u32 part4 = extract32from256(r, 3); \ r = interleave256hi(var, swap); \ u32 part5 = extractlow32from256(r); \ u32 part6 = extract32from256(r, 1); \ u32 part7 = extract32from256(r, 2); \ u32 part8 = extract32from256(r, 3); \ if (unlikely(part1)) { \ conf_fn(&part1, bucket, offset, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part2)) { \ conf_fn(&part2, bucket, offset + 2, confBase, reason, a, ptr, \ &control, &last_match); \ } \ if (unlikely(part3)) { \ conf_fn(&part3, bucket, offset + 4, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part4)) { \ conf_fn(&part4, bucket, offset + 6, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part5)) { \ conf_fn(&part5, bucket, offset + 8, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part6)) { \ conf_fn(&part6, bucket, offset + 10, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part7)) { \ conf_fn(&part7, bucket, offset + 12, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part8)) { \ conf_fn(&part8, bucket, offset + 14, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ } \ } while (0); #endif #define CONFIRM_FAST_TEDDY(var, offset, reason, conf_fn) \ do { \ if (unlikely(isnonzero256(var))) { \ u32 arrCnt = 0; \ m128 lo = cast256to128(var); \ m128 hi = movdq_hi(var); \ bit_array_fast_teddy(lo, bitArr, &arrCnt, offset); \ bit_array_fast_teddy(hi, bitArr, &arrCnt, offset + 2); \ for (u32 i = 0; i < arrCnt; i++) { \ conf_fn(bitArr[i], confBase, reason, a, ptr, &control, \ &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ } \ } while (0); static really_inline m256 vectoredLoad2x128(m256 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi, const u8 *buf_history, size_t len_history, const u32 nMasks) { m128 p_mask128; m256 ret = set2x128(vectoredLoad128(&p_mask128, ptr, lo, hi, buf_history, len_history, nMasks)); *p_mask = set2x128(p_mask128); return ret; } /* * \brief Copy a block of [0,31] bytes efficiently. * * This function is a workaround intended to stop some compilers from * synthesizing a memcpy function call out of the copy of a small number of * bytes that we do in vectoredLoad128. */ static really_inline void copyRuntBlock256(u8 *dst, const u8 *src, size_t len) { switch (len) { case 0: break; case 1: *dst = *src; break; case 2: unaligned_store_u16(dst, unaligned_load_u16(src)); break; case 3: unaligned_store_u16(dst, unaligned_load_u16(src)); dst[2] = src[2]; break; case 4: unaligned_store_u32(dst, unaligned_load_u32(src)); break; case 5: case 6: case 7: /* Perform copy with two overlapping 4-byte chunks. */ unaligned_store_u32(dst + len - 4, unaligned_load_u32(src + len - 4)); unaligned_store_u32(dst, unaligned_load_u32(src)); break; case 8: unaligned_store_u64a(dst, unaligned_load_u64a(src)); break; case 9: case 10: case 11: case 12: case 13: case 14: case 15: /* Perform copy with two overlapping 8-byte chunks. */ unaligned_store_u64a(dst + len - 8, unaligned_load_u64a(src + len - 8)); unaligned_store_u64a(dst, unaligned_load_u64a(src)); break; case 16: storeu128(dst, loadu128(src)); break; default: /* Perform copy with two overlapping 16-byte chunks. */ assert(len < 32); storeu128(dst + len - 16, loadu128(src + len - 16)); storeu128(dst, loadu128(src)); break; } } static really_inline m256 vectoredLoad256(m256 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi, const u8 *buf_history, size_t len_history) { union { u8 val8[32]; m256 val256; } u; uintptr_t copy_start; uintptr_t copy_len; if (ptr >= lo) { uintptr_t avail = (uintptr_t)(hi - ptr); if (avail >= 32) { *p_mask = load256(p_mask_arr256[32] + 32); return loadu256(ptr); } *p_mask = load256(p_mask_arr256[avail] + 32); copy_start = 0; copy_len = avail; } else { // need contains "how many chars to pull from history" // calculate based on what we need, what we have in the buffer // and only what we need to make primary confirm work uintptr_t start = (uintptr_t)(lo - ptr); uintptr_t i; for (i = start; ptr + i < lo; i++) { u.val8[i] = buf_history[len_history - (lo - (ptr + i))]; } uintptr_t end = MIN(32, (uintptr_t)(hi - ptr)); *p_mask = loadu256(p_mask_arr256[end - start] + 32 - start); copy_start = i; copy_len = end - i; } // Runt block from the buffer. copyRuntBlock256(&u.val8[copy_start], &ptr[copy_start], copy_len); return u.val256; } static really_inline void do_confWithBit1_fast_teddy(u16 bits, const u32 *confBase, CautionReason reason, const struct FDR_Runtime_Args *a, const u8 *ptr, hwlmcb_rv_t *control, u32 *last_match) { u32 byte = bits / 8; u32 cf = confBase[bits % 8]; const struct FDRConfirm *fdrc = (const struct FDRConfirm *) ((const u8 *)confBase + cf); u64a confVal = getConfVal(a, ptr, byte, reason); confWithBit1(fdrc, a, ptr - a->buf + byte, control, last_match, confVal); } static really_inline void do_confWithBit_fast_teddy(u16 bits, const u32 *confBase, CautionReason reason, const struct FDR_Runtime_Args *a, const u8 *ptr, hwlmcb_rv_t *control, u32 *last_match) { u32 byte = bits / 8; u32 bitRem = bits % 8; u32 confSplit = *(ptr+byte) & 0x1f; u32 idx = confSplit * 8 + bitRem; u32 cf = confBase[idx]; if (!cf) { return; } const struct FDRConfirm *fdrc = (const struct FDRConfirm *) ((const u8 *)confBase + cf); if (!(fdrc->groups & *control)) { return; } u64a confVal = getConfVal(a, ptr, byte, reason); confWithBit(fdrc, a, ptr - a->buf + byte, 0, control, last_match, confVal); } static really_inline void bit_array_fast_teddy(m128 var, u16 *bitArr, u32 *arrCnt, u32 offset) { if (unlikely(isnonzero128(var))) { #ifdef ARCH_64_BIT u64a part_0 = movq(var); while (unlikely(part_0)) { bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_0) + 64 * (offset); *arrCnt += 1; } u64a part_1 = movq(rshiftbyte_m128(var, 8)); while (unlikely(part_1)) { bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_1) + 64 * (offset + 1); *arrCnt += 1; } #else u32 part_0 = movd(var); while (unlikely(part_0)) { bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_0) + 32 * (offset * 2); *arrCnt += 1; } u32 part_1 = movd(rshiftbyte_m128(var, 4)); while (unlikely(part_1)) { bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_1) + 32 * (offset * 2 + 1); *arrCnt += 1; } u32 part_2 = movd(rshiftbyte_m128(var, 8)); while (unlikely(part_2)) { bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_2) + 32 * (offset * 2 + 2); *arrCnt += 1; } u32 part_3 = movd(rshiftbyte_m128(var, 12)); while (unlikely(part_3)) { bitArr[*arrCnt] = (u16) TEDDY_FIND_AND_CLEAR_LSB(&part_3) + 32 * (offset * 2 + 3); *arrCnt += 1; } #endif } } static really_inline m256 prep_conf_fat_teddy_m1(const m256 *maskBase, m256 val) { m256 mask = set32x8(0xf); m256 lo = and256(val, mask); m256 hi = and256(rshift64_m256(val, 4), mask); return and256(vpshufb(maskBase[0*2], lo), vpshufb(maskBase[0*2+1], hi)); } static really_inline m256 prep_conf_fat_teddy_m2(const m256 *maskBase, m256 *old_1, m256 val) { m256 mask = set32x8(0xf); m256 lo = and256(val, mask); m256 hi = and256(rshift64_m256(val, 4), mask); m256 r = prep_conf_fat_teddy_m1(maskBase, val); m256 res_1 = and256(vpshufb(maskBase[1*2], lo), vpshufb(maskBase[1*2+1], hi)); m256 res_shifted_1 = vpalignr(res_1, *old_1, 16-1); *old_1 = res_1; return and256(r, res_shifted_1); } static really_inline m256 prep_conf_fat_teddy_m3(const m256 *maskBase, m256 *old_1, m256 *old_2, m256 val) { m256 mask = set32x8(0xf); m256 lo = and256(val, mask); m256 hi = and256(rshift64_m256(val, 4), mask); m256 r = prep_conf_fat_teddy_m2(maskBase, old_1, val); m256 res_2 = and256(vpshufb(maskBase[2*2], lo), vpshufb(maskBase[2*2+1], hi)); m256 res_shifted_2 = vpalignr(res_2, *old_2, 16-2); *old_2 = res_2; return and256(r, res_shifted_2); } static really_inline m256 prep_conf_fat_teddy_m4(const m256 *maskBase, m256 *old_1, m256 *old_2, m256 *old_3, m256 val) { m256 mask = set32x8(0xf); m256 lo = and256(val, mask); m256 hi = and256(rshift64_m256(val, 4), mask); m256 r = prep_conf_fat_teddy_m3(maskBase, old_1, old_2, val); m256 res_3 = and256(vpshufb(maskBase[3*2], lo), vpshufb(maskBase[3*2+1], hi)); m256 res_shifted_3 = vpalignr(res_3, *old_3, 16-3); *old_3 = res_3; return and256(r, res_shifted_3); } static really_inline m256 prep_conf_fast_teddy_m1(m256 val, m256 mask, m256 maskLo, m256 maskHi) { m256 lo = and256(val, mask); m256 hi = and256(rshift64_m256(val, 4), mask); return and256(vpshufb(maskLo, lo), vpshufb(maskHi, hi)); } static really_inline const m256 * getMaskBase_avx2(const struct Teddy *teddy) { return (const m256 *)((const u8 *)teddy + sizeof(struct Teddy)); } static really_inline const u32 * getConfBase_avx2(const struct Teddy *teddy, u8 numMask) { return (const u32 *)((const u8 *)teddy + sizeof(struct Teddy) + (numMask*32*2)); } hwlm_error_t fdr_exec_teddy_avx2_msks1_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m256 *maskBase = getMaskBase_avx2(teddy); const u32 *confBase = getConfBase_avx2(teddy, 1); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 1); m256 r_0 = prep_conf_fat_teddy_m1(maskBase, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit1_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m256 r_0 = prep_conf_fat_teddy_m1(maskBase, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit1_teddy); ptr += 16; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 r_0 = prep_conf_fat_teddy_m1(maskBase, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit1_teddy); m256 r_1 = prep_conf_fat_teddy_m1(maskBase, load2x128(ptr + 16)); CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit1_teddy); } for (; ptr < buf_end; ptr += 16) { m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 1); m256 r_0 = prep_conf_fat_teddy_m1(maskBase, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit1_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks1_pck_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m256 *maskBase = getMaskBase_avx2(teddy); const u32 *confBase = getConfBase_avx2(teddy, 1); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 1); m256 r_0 = prep_conf_fat_teddy_m1(maskBase, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m256 r_0 = prep_conf_fat_teddy_m1(maskBase, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 r_0 = prep_conf_fat_teddy_m1(maskBase, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit_teddy); m256 r_1 = prep_conf_fat_teddy_m1(maskBase, load2x128(ptr + 16)); CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit_teddy); } for (; ptr < buf_end; ptr += 16) { m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 1); m256 r_0 = prep_conf_fat_teddy_m1(maskBase, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks2_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m256 *maskBase = getMaskBase_avx2(teddy); const u32 *confBase = getConfBase_avx2(teddy, 2); m256 res_old_1 = ones256(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 2); m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy); m256 r_1 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, load2x128(ptr + 16)); CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy); } for (; ptr < buf_end; ptr += 16) { m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 2); m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks2_pck_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m256 *maskBase = getMaskBase_avx2(teddy); const u32 *confBase = getConfBase_avx2(teddy, 2); m256 res_old_1 = ones256(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 2); m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit_teddy); m256 r_1 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, load2x128(ptr + 16)); CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit_teddy); } for (; ptr < buf_end; ptr += 16) { m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 2); m256 r_0 = prep_conf_fat_teddy_m2(maskBase, &res_old_1, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks3_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m256 *maskBase = getMaskBase_avx2(teddy); const u32 *confBase = getConfBase_avx2(teddy, 3); m256 res_old_1 = ones256(); m256 res_old_2 = ones256(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 3); m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy); m256 r_1 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, load2x128(ptr + 16)); CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy); } for (; ptr < buf_end; ptr += 16) { m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 3); m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks3_pck_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m256 *maskBase = getMaskBase_avx2(teddy); const u32 *confBase = getConfBase_avx2(teddy, 3); m256 res_old_1 = ones256(); m256 res_old_2 = ones256(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 3); m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit_teddy); m256 r_1 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, load2x128(ptr + 16)); CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit_teddy); } for (; ptr < buf_end; ptr += 16) { m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 3); m256 r_0 = prep_conf_fat_teddy_m3(maskBase, &res_old_1, &res_old_2, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks4_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m256 *maskBase = getMaskBase_avx2(teddy); const u32 *confBase = getConfBase_avx2(teddy, 4); m256 res_old_1 = ones256(); m256 res_old_2 = ones256(); m256 res_old_3 = ones256(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 4); m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy); m256 r_1 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load2x128(ptr + 16)); CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy); } for (; ptr < buf_end; ptr += 16) { m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 4); m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBitMany_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks4_pck_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m256 *maskBase = getMaskBase_avx2(teddy); const u32 *confBase = getConfBase_avx2(teddy, 4); m256 res_old_1 = ones256(); m256 res_old_2 = ones256(); m256 res_old_3 = ones256(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 4); m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load2x128(ptr)); CONFIRM_FAT_TEDDY(r_0, 16, 0, NOT_CAUTIOUS, do_confWithBit_teddy); m256 r_1 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load2x128(ptr + 16)); CONFIRM_FAT_TEDDY(r_1, 16, 16, NOT_CAUTIOUS, do_confWithBit_teddy); } for (; ptr < buf_end; ptr += 16) { m256 p_mask; m256 val_0 = vectoredLoad2x128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 4); m256 r_0 = prep_conf_fat_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, val_0); r_0 = and256(r_0, p_mask); CONFIRM_FAT_TEDDY(r_0, 16, 0, VECTORING, do_confWithBit_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks1_fast(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 64; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 1); const m256 maskLo = set2x128(maskBase[0]); const m256 maskHi = set2x128(maskBase[1]); const m256 mask = set32x8(0xf); u16 bitArr[512]; const u8 *mainStart = ROUNDUP_PTR(ptr, 32); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 32; m256 p_mask; m256 val_0 = vectoredLoad256(&p_mask, ptr, a->buf + a->start_offset, buf_end, a->buf_history, a->len_history); m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi); res_0 = and256(res_0, p_mask); CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit1_fast_teddy); ptr += 32; } if (ptr + 32 < buf_end) { m256 val_0 = load256(ptr + 0); m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi); CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit1_fast_teddy); ptr += 32; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 val_0 = load256(ptr + 0); m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi); CONFIRM_FAST_TEDDY(res_0, 0, NOT_CAUTIOUS, do_confWithBit1_fast_teddy); m256 val_1 = load256(ptr + 32); m256 res_1 = prep_conf_fast_teddy_m1(val_1, mask, maskLo, maskHi); CONFIRM_FAST_TEDDY(res_1, 4, NOT_CAUTIOUS, do_confWithBit1_fast_teddy); } for (; ptr < buf_end; ptr += 32) { m256 p_mask; m256 val_0 = vectoredLoad256(&p_mask, ptr, a->buf + a->start_offset, buf_end, a->buf_history, a->len_history); m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi); res_0 = and256(res_0, p_mask); CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit1_fast_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_avx2_msks1_pck_fast(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 64; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 1); const m256 maskLo = set2x128(maskBase[0]); const m256 maskHi = set2x128(maskBase[1]); const m256 mask = set32x8(0xf); u16 bitArr[512]; const u8 *mainStart = ROUNDUP_PTR(ptr, 32); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 32; m256 p_mask; m256 val_0 = vectoredLoad256(&p_mask, ptr, a->buf + a->start_offset, buf_end, a->buf_history, a->len_history); m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi); res_0 = and256(res_0, p_mask); CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit_fast_teddy); ptr += 32; } if (ptr + 32 < buf_end) { m256 val_0 = load256(ptr + 0); m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi); CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit_fast_teddy); ptr += 32; } for ( ; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m256 val_0 = load256(ptr + 0); m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi); CONFIRM_FAST_TEDDY(res_0, 0, NOT_CAUTIOUS, do_confWithBit_fast_teddy); m256 val_1 = load256(ptr + 32); m256 res_1 = prep_conf_fast_teddy_m1(val_1, mask, maskLo, maskHi); CONFIRM_FAST_TEDDY(res_1, 4, NOT_CAUTIOUS, do_confWithBit_fast_teddy); } for (; ptr < buf_end; ptr += 32) { m256 p_mask; m256 val_0 = vectoredLoad256(&p_mask, ptr, a->buf + a->start_offset, buf_end, a->buf_history, a->len_history); m256 res_0 = prep_conf_fast_teddy_m1(val_0, mask, maskLo, maskHi); res_0 = and256(res_0, p_mask); CONFIRM_FAST_TEDDY(res_0, 0, VECTORING, do_confWithBit_fast_teddy); } return HWLM_SUCCESS; } #endif // __AVX2__ hyperscan-4.4.1/src/fdr/teddy_engine_description.cpp0000644000175000017500000001733213055426554023414 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "fdr_internal.h" #include "fdr_compile_internal.h" #include "fdr_confirm.h" #include "ue2common.h" #include "hs_internal.h" #include "fdr_engine_description.h" #include "teddy_internal.h" #include "teddy_engine_description.h" #include "util/make_unique.h" #include using namespace std; namespace ue2 { TeddyEngineDescription::TeddyEngineDescription(const TeddyEngineDef &def) : EngineDescription(def.id, targetByArchFeatures(def.cpu_features), def.numBuckets, def.confirmPullBackDistance, def.confirmTopLevelSplit), numMasks(def.numMasks), packed(def.packed) {} u32 TeddyEngineDescription::getDefaultFloodSuffixLength() const { return numMasks; } bool TeddyEngineDescription::needConfirm(const vector &lits) const { if (packed || lits.size() > getNumBuckets()) { return true; } for (const auto &lit : lits) { if (lit.s.size() > numMasks || !lit.msk.empty()) { return true; } } return false; } void getTeddyDescriptions(vector *out) { static const TeddyEngineDef defns[] = { { 1, 0 | HS_CPU_FEATURES_AVX2, 1, 8, false, 0, 1 }, { 2, 0 | HS_CPU_FEATURES_AVX2, 1, 8, true, 0, 32 }, { 3, 0 | HS_CPU_FEATURES_AVX2, 1, 16, false, 0, 1 }, { 4, 0 | HS_CPU_FEATURES_AVX2, 1, 16, true, 0, 32 }, { 5, 0 | HS_CPU_FEATURES_AVX2, 2, 16, false, 0, 1 }, { 6, 0 | HS_CPU_FEATURES_AVX2, 2, 16, true, 0, 32 }, { 7, 0 | HS_CPU_FEATURES_AVX2, 3, 16, false, 0, 1 }, { 8, 0 | HS_CPU_FEATURES_AVX2, 3, 16, true, 0, 32 }, { 9, 0 | HS_CPU_FEATURES_AVX2, 4, 16, false, 0, 1 }, { 10, 0 | HS_CPU_FEATURES_AVX2, 4, 16, true, 0, 32 }, { 11, 0, 1, 8, false, 0, 1 }, { 12, 0, 1, 8, true, 0, 32 }, { 13, 0, 2, 8, false, 0, 1 }, { 14, 0, 2, 8, true, 0, 32 }, { 15, 0, 3, 8, false, 0, 1 }, { 16, 0, 3, 8, true, 0, 32 }, { 17, 0, 4, 8, false, 0, 1 }, { 18, 0, 4, 8, true, 0, 32 }, }; out->clear(); for (const auto &def : defns) { out->emplace_back(def); } } static size_t maxFloodTailLen(const vector &vl) { size_t max_flood_tail = 0; for (const auto &lit : vl) { const string &s = lit.s; assert(!s.empty()); size_t j; for (j = 1; j < s.length(); j++) { if (s[s.length() - j - 1] != s[s.length() - 1]) { break; } } max_flood_tail = max(max_flood_tail, j); } return max_flood_tail; } /** * \brief True if this Teddy engine is qualified to handle this set of literals * on this target. */ static bool isAllowed(const vector &vl, const TeddyEngineDescription &eng, const size_t max_lit_len, const target_t &target) { if (!eng.isValidOnTarget(target)) { DEBUG_PRINTF("%u disallowed: not valid on target\n", eng.getID()); return false; } if (eng.getNumBuckets() < vl.size() && !eng.packed) { DEBUG_PRINTF("%u disallowed: num buckets < num lits and not packed\n", eng.getID()); return false; } if (eng.getNumBuckets() * TEDDY_BUCKET_LOAD < vl.size()) { DEBUG_PRINTF("%u disallowed: too many lits for num buckets\n", eng.getID()); return false; } if (eng.numMasks > max_lit_len) { DEBUG_PRINTF("%u disallowed: more masks than max lit len (%zu)\n", eng.getID(), max_lit_len); return false; } if (vl.size() > 40) { u32 n_small_lits = 0; for (const auto &lit : vl) { if (lit.s.length() < eng.numMasks) { n_small_lits++; } } if (n_small_lits * 5 > vl.size()) { DEBUG_PRINTF("too many short literals (%u)\n", n_small_lits); return false; } } return true; } unique_ptr chooseTeddyEngine(const target_t &target, const vector &vl) { vector descs; getTeddyDescriptions(&descs); const TeddyEngineDescription *best = nullptr; const size_t max_lit_len = maxLen(vl); const size_t max_flood_tail = maxFloodTailLen(vl); DEBUG_PRINTF("%zu lits, max_lit_len=%zu, max_flood_tail=%zu\n", vl.size(), max_lit_len, max_flood_tail); u32 best_score = 0; for (size_t engineID = 0; engineID < descs.size(); engineID++) { const TeddyEngineDescription &eng = descs[engineID]; if (!isAllowed(vl, eng, max_lit_len, target)) { continue; } u32 score = 0; // We prefer unpacked Teddy models. if (!eng.packed) { score += 100; } // If we're heavily loaded, we prefer to have more masks. if (vl.size() > 4 * eng.getNumBuckets()) { score += eng.numMasks * 4; } else { // Lightly loaded cases are great. score += 100; } // We want enough masks to avoid becoming flood-prone. if (eng.numMasks > max_flood_tail) { score += 50; } // We prefer having 3 masks. 3 is just right. score += 6 / (abs(3 - (int)eng.numMasks) + 1); // We prefer cheaper, smaller Teddy models. score += 16 / eng.getNumBuckets(); DEBUG_PRINTF("teddy %u: masks=%u, buckets=%u, packed=%u " "-> score=%u\n", eng.getID(), eng.numMasks, eng.getNumBuckets(), eng.packed ? 1U : 0U, score); if (!best || score > best_score) { best = ŋ best_score = score; } } if (!best) { DEBUG_PRINTF("failed to find engine\n"); return nullptr; } DEBUG_PRINTF("using engine %u\n", best->getID()); return ue2::make_unique(*best); } unique_ptr getTeddyDescription(u32 engineID) { vector descs; getTeddyDescriptions(&descs); for (const auto &desc : descs) { if (desc.getID() == engineID) { return ue2::make_unique(desc); } } return nullptr; } } // namespace ue2 hyperscan-4.4.1/src/fdr/fdr_compile_util.cpp0000644000175000017500000000436113055426554021671 0ustar sleuthkidsleuthkid/* * 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. */ #include "fdr_compile_internal.h" #include "hwlm/hwlm_literal.h" #include #include using namespace std; namespace ue2 { size_t maxLen(const vector &lits) { size_t rv = 0; for (const auto &lit : lits) { rv = max(rv, lit.s.size()); } return rv; } size_t minLenCount(const vector &lits, size_t *count) { size_t rv = (size_t)-1; *count = 0; for (const auto &lit : lits) { if (lit.s.size() < rv) { rv = lit.s.size(); *count = 1; } else if (lit.s.size() == rv) { (*count)++; } } return rv; } u32 absdiff(u32 i, u32 j) { return (i > j) ? (i - j) : (j - i); } } // namespace ue2 hyperscan-4.4.1/src/fdr/fdr_confirm_compile.cpp0000644000175000017500000004323513055426554022354 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "fdr_internal.h" #include "fdr_compile_internal.h" #include "fdr_confirm.h" #include "engine_description.h" #include "teddy_engine_description.h" #include "ue2common.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/compare.h" #include "util/verify_types.h" #include #include #include using namespace std; namespace ue2 { using ConfSplitType = u8; using BucketSplitPair = pair; using BC2CONF = map, size_t>>; // return the number of bytes beyond a length threshold in all strings in lits static size_t thresholdedSize(const vector &lits, size_t threshold) { size_t tot = 0; for (const auto &lit : lits) { size_t sz = lit.s.size(); if (sz > threshold) { tot += ROUNDUP_N(sz - threshold, 8); } } return tot; } static u64a make_u64a_mask(const vector &v) { assert(v.size() <= sizeof(u64a)); if (v.size() > sizeof(u64a)) { throw std::exception(); } u64a mask = 0; size_t vlen = v.size(); size_t len = std::min(vlen, sizeof(mask)); unsigned char *m = (unsigned char *)&mask; memcpy(m + sizeof(mask) - len, &v[vlen - len], len); return mask; } /** * Build a temporary vector of LitInfo structures (without the corresponding * pointers to the actual strings; these cannot be laid out yet). These * stay in 1:1 correspondence with the lits[] vector as that's the only * place we have to obtain our full strings. */ static void fillLitInfo(const vector &lits, vector &tmpLitInfo, CONF_TYPE &andmsk) { const CONF_TYPE all_ones = ~(u64a)0; andmsk = all_ones; // fill in with 'and' of all literal masks for (LiteralIndex i = 0; i < lits.size(); i++) { const hwlmLiteral &lit = lits[i]; LitInfo &info = tmpLitInfo[i]; memset(&info, 0, sizeof(info)); info.id = lit.id; u8 flags = NoFlags; if (lit.nocase) { flags |= Caseless; } if (lit.noruns) { flags |= NoRepeat; } if (lit.msk.size() > lit.s.size()) { flags |= ComplexConfirm; info.extended_size = verify_u8(lit.msk.size()); } info.flags = flags; info.size = verify_u8(lit.s.size()); info.groups = lit.groups; // these are built up assuming a LE machine CONF_TYPE msk = all_ones; CONF_TYPE val = 0; for (u32 j = 0; j < sizeof(CONF_TYPE); j++) { u32 shiftLoc = (sizeof(CONF_TYPE) - j - 1) * 8; if (j >= lit.s.size()) { msk &= ~((CONF_TYPE)0xff << shiftLoc); } else { u8 c = lit.s[lit.s.size() - j - 1]; if (lit.nocase && ourisalpha(c)) { msk &= ~((CONF_TYPE)CASE_BIT << shiftLoc); val |= (CONF_TYPE)(c & CASE_CLEAR) << shiftLoc; } else { val |= (CONF_TYPE)c << shiftLoc; } } } info.v = val; info.msk = msk; if (!lit.msk.empty()) { u64a l_msk = make_u64a_mask(lit.msk); u64a l_cmp = make_u64a_mask(lit.cmp); // test for consistency - if there's intersection, then v and msk // values must line up UNUSED u64a intersection = l_msk & info.msk; assert((info.v & intersection) == (l_cmp & intersection)); // incorporate lit.msk, lit.cmp into v and msk info.msk |= l_msk; info.v |= l_cmp; } andmsk &= info.msk; } } //#define FDR_CONFIRM_DUMP 1 static pair, size_t> getFDRConfirm(const vector &lits, bool applyOneCharOpt, bool make_small, bool make_confirm) { vector tmpLitInfo(lits.size()); CONF_TYPE andmsk; fillLitInfo(lits, tmpLitInfo, andmsk); #ifdef FDR_CONFIRM_DUMP printf("-------------------\n"); #endif // just magic numbers and crude measures for now u32 nBits; if (make_small) { nBits = min(10U, lg2(lits.size()) + 1); } else { nBits = min(13U, lg2(lits.size()) + 4); } CONF_TYPE mult = (CONF_TYPE)0x0b4e0ef37bc32127ULL; u32 flags = 0; // we use next three variables for 'confirmless' case to speed-up // confirmation process u32 soleLitSize = 0; u32 soleLitCmp = 0; u32 soleLitMsk = 0; if ((applyOneCharOpt && lits.size() == 1 && lits[0].s.size() == 0 && lits[0].msk.empty()) || make_confirm == false) { flags = FDRC_FLAG_NO_CONFIRM; if (lits[0].noruns) { flags |= NoRepeat; // messy - need to clean this up later as flags is sorta kinda obsoleted } mult = 0; soleLitSize = lits[0].s.size() - 1; // we can get to this point only in confirmless case; // it means that we have only one literal per FDRConfirm (no packing), // with no literal mask and size of literal is less or equal // to the number of masks of Teddy engine; // maximum number of masks for Teddy is 4, so the size of // literal is definitely less or equal to size of u32 assert(lits[0].s.size() <= sizeof(u32)); for (u32 i = 0; i < lits[0].s.size(); i++) { u32 shiftLoc = (sizeof(u32) - i - 1) * 8; u8 c = lits[0].s[lits[0].s.size() - i - 1]; if (lits[0].nocase && ourisalpha(c)) { soleLitCmp |= (u32)(c & CASE_CLEAR) << shiftLoc; soleLitMsk |= (u32)CASE_CLEAR << shiftLoc; } else { soleLitCmp |= (u32)c << shiftLoc; soleLitMsk |= (u32)0xff << shiftLoc; } } } // we can walk the vector and assign elements from the vectors to a // map by hash value map > res2lits; hwlm_group_t gm = 0; for (LiteralIndex i = 0; i < lits.size(); i++) { LitInfo & li = tmpLitInfo[i]; u32 hash = CONF_HASH_CALL(li.v, andmsk, mult, nBits); DEBUG_PRINTF("%016llx --> %u\n", li.v, hash); res2lits[hash].push_back(i); gm |= li.groups; } #ifdef FDR_CONFIRM_DUMP // print out the literals reversed - makes it easier to line up analyses // that are end-offset based for (const auto &m : res2lits) { const u32 &hash = m.first; const vector &vlidx = m.second; if (vlidx.size() <= 1) { continue; } printf("%x -> %zu literals\n", hash, vlidx.size()); size_t min_len = lits[vlidx.front()].s.size(); vector> vsl; // contains the set of chars at each location // reversed from the end for (const auto &litIdx : vlidx) { const auto &lit = lits[litIdx]; if (lit.s.size() > vsl.size()) { vsl.resize(lit.s.size()); } for (size_t j = lit.s.size(); j != 0; j--) { vsl[lit.s.size() - j].insert(lit.s[j - 1]); } min_len = min(min_len, lit.s.size()); } printf("common "); for (size_t j = 0; j < min_len; j++) { if (vsl[j].size() == 1) { printf("%02x", *vsl[j].begin()); } else { printf("__"); } } printf("\n"); for (const auto &litIdx : vlidx) { const auto &lit = lits[litIdx]; printf("%8x %c", lit.id, lit.nocase ? '!' : ' '); for (size_t j = lit.s.size(); j != 0; j--) { size_t dist_from_end = lit.s.size() - j; if (dist_from_end < min_len && vsl[dist_from_end].size() == 1) { printf("__"); } else { printf("%02x", lit.s[j - 1]); } } printf("\n"); } size_t total_compares = 0; for (const auto &v : vsl) { total_compares += v.size(); } size_t total_string_size = 0; for (const auto &litIdx : vlidx) { const auto &lit = lits[litIdx]; total_string_size += lit.s.size(); } printf("Total compare load: %zu Total string size: %zu\n\n", total_compares, total_string_size); } #endif const size_t bitsToLitIndexSize = (1U << nBits) * sizeof(u32); const size_t totalLitSize = thresholdedSize(lits, sizeof(CONF_TYPE)); // this size can now be a worst-case as we can always be a bit smaller size_t size = ROUNDUP_N(sizeof(FDRConfirm), alignof(u32)) + ROUNDUP_N(bitsToLitIndexSize, alignof(LitInfo)) + sizeof(LitInfo) * lits.size() + totalLitSize; size = ROUNDUP_N(size, alignof(FDRConfirm)); auto fdrc = aligned_zmalloc_unique(size); assert(fdrc); // otherwise would have thrown std::bad_alloc fdrc->andmsk = andmsk; fdrc->mult = mult; fdrc->nBitsOrSoleID = (flags & FDRC_FLAG_NO_CONFIRM) ? lits[0].id : nBits; fdrc->flags = flags; fdrc->soleLitSize = soleLitSize; fdrc->soleLitCmp = soleLitCmp; fdrc->soleLitMsk = soleLitMsk; fdrc->groups = gm; // After the FDRConfirm, we have the lit index array. u8 *fdrc_base = (u8 *)fdrc.get(); u8 *ptr = fdrc_base + sizeof(*fdrc); ptr = ROUNDUP_PTR(ptr, alignof(u32)); u32 *bitsToLitIndex = (u32 *)ptr; ptr += bitsToLitIndexSize; // After the lit index array, we have the LitInfo structures themselves, // which vary in size (as each may have a variable-length string after it). ptr = ROUNDUP_PTR(ptr, alignof(LitInfo)); // Walk the map by hash value assigning indexes and laying out the // elements (and their associated string confirm material) in memory. for (const auto &m : res2lits) { const u32 hash = m.first; const vector &vlidx = m.second; bitsToLitIndex[hash] = verify_u32(ptr - fdrc_base); for (auto i = vlidx.begin(), e = vlidx.end(); i != e; ++i) { LiteralIndex litIdx = *i; // Write LitInfo header. u8 *oldPtr = ptr; LitInfo &finalLI = *(LitInfo *)ptr; finalLI = tmpLitInfo[litIdx]; ptr += sizeof(LitInfo); // String starts directly after LitInfo. // Write literal prefix (everything before the last N characters, // as the last N are already confirmed). const string &t = lits[litIdx].s; if (t.size() > sizeof(CONF_TYPE)) { size_t prefix_len = t.size() - sizeof(CONF_TYPE); memcpy(ptr, t.c_str(), prefix_len); ptr += prefix_len; } ptr = ROUNDUP_PTR(ptr, alignof(LitInfo)); if (next(i) == e) { finalLI.next = 0; } else { // our next field represents an adjustment on top of // current address + the actual size of the literal // so we track any rounding up done for alignment and // add this in - that way we don't have to use bigger // than a u8 (for now) assert((size_t)(ptr - oldPtr) > t.size()); finalLI.next = verify_u8(ptr - oldPtr - t.size()); } } assert((size_t)(ptr - fdrc_base) <= size); } // Return actual used size, not worst-case size. Must be rounded up to // FDRConfirm alignment so that the caller can lay out a sequence of these. size_t actual_size = ROUNDUP_N((size_t)(ptr - fdrc_base), alignof(FDRConfirm)); assert(actual_size <= size); return {move(fdrc), actual_size}; } static u32 setupMultiConfirms(const vector &lits, const EngineDescription &eng, BC2CONF &bc2Conf, map > &bucketToLits, bool make_small) { u32 pullBack = eng.getConfirmPullBackDistance(); u32 splitMask = eng.getConfirmTopLevelSplit() - 1; bool splitHasCase = splitMask & 0x20; bool makeConfirm = true; unique_ptr teddyDescr = getTeddyDescription(eng.getID()); if (teddyDescr) { makeConfirm = teddyDescr->needConfirm(lits); } u32 totalConfirmSize = 0; for (BucketIndex b = 0; b < eng.getNumBuckets(); b++) { if (!bucketToLits[b].empty()) { vector> vl(eng.getConfirmTopLevelSplit()); for (const LiteralIndex &lit_idx : bucketToLits[b]) { hwlmLiteral lit = lits[lit_idx]; // copy // c is last char of this literal u8 c = *(lit.s.rbegin()); bool suppressSplit = false; if (pullBack) { // make a shorter string to work over if we're pulling back // getFDRConfirm doesn't know about that stuff assert(lit.s.size() >= pullBack); lit.s.resize(lit.s.size() - pullBack); u8 c_sub, c_sub_msk; if (lit.msk.empty()) { c_sub = 0; c_sub_msk = 0; } else { c_sub = *(lit.cmp.rbegin()); c_sub_msk = *(lit.msk.rbegin()); size_t len = lit.msk.size() - min(lit.msk.size(), (size_t)pullBack); lit.msk.resize(len); lit.cmp.resize(len); } // if c_sub_msk is 0xff and lit.nocase // resteer 'c' to an exact value and set suppressSplit if ((c_sub_msk == 0xff) && (lit.nocase)) { suppressSplit = true; c = c_sub; } } if (!suppressSplit && splitHasCase && lit.nocase && ourisalpha(c)) { vl[(u8)(mytoupper(c) & splitMask)].push_back(lit); vl[(u8)(mytolower(c) & splitMask)].push_back(lit); } else { vl[c & splitMask].push_back(lit); } } for (u32 c = 0; c < eng.getConfirmTopLevelSplit(); c++) { if (vl[c].empty()) { continue; } DEBUG_PRINTF("b %d c %02x sz %zu\n", b, c, vl[c].size()); auto key = make_pair(b, c); auto fc = getFDRConfirm(vl[c], eng.typicallyHoldsOneCharLits(), make_small, makeConfirm); totalConfirmSize += fc.second; assert(bc2Conf.find(key) == end(bc2Conf)); bc2Conf.emplace(key, move(fc)); } } } return totalConfirmSize; } pair, size_t> setupFullMultiConfs(const vector &lits, const EngineDescription &eng, map> &bucketToLits, bool make_small) { BC2CONF bc2Conf; u32 totalConfirmSize = setupMultiConfirms(lits, eng, bc2Conf, bucketToLits, make_small); u32 primarySwitch = eng.getConfirmTopLevelSplit(); u32 nBuckets = eng.getNumBuckets(); u32 totalConfSwitchSize = primarySwitch * nBuckets * sizeof(u32); u32 totalSize = ROUNDUP_16(totalConfSwitchSize + totalConfirmSize); auto buf = aligned_zmalloc_unique(totalSize); assert(buf); // otherwise would have thrown std::bad_alloc u32 *confBase = (u32 *)buf.get(); u8 *ptr = buf.get() + totalConfSwitchSize; for (const auto &m : bc2Conf) { const BucketIndex &b = m.first.first; const u8 &c = m.first.second; const pair, size_t> &p = m.second; // confirm offset is relative to the base of this structure, now u32 confirm_offset = verify_u32(ptr - buf.get()); memcpy(ptr, p.first.get(), p.second); ptr += p.second; u32 idx = c * nBuckets + b; confBase[idx] = confirm_offset; } return {move(buf), totalSize}; } } // namespace ue2 hyperscan-4.4.1/src/fdr/fdr_compile.h0000644000175000017500000000464513055426554020306 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief FDR literal matcher: build API. */ #ifndef FDR_COMPILE_H #define FDR_COMPILE_H #include "ue2common.h" #include "util/alloc.h" #include struct FDR; namespace ue2 { struct hwlmLiteral; struct hwlmStreamingControl; struct Grey; struct target_t; ue2::aligned_unique_ptr fdrBuildTable(const std::vector &lits, bool make_small, const target_t &target, const Grey &grey, hwlmStreamingControl *stream_control = nullptr); #if !defined(RELEASE_BUILD) ue2::aligned_unique_ptr fdrBuildTableHinted(const std::vector &lits, bool make_small, u32 hint, const target_t &target, const Grey &grey, hwlmStreamingControl *stream_control = nullptr); #endif /** \brief Returns size in bytes of the given FDR engine. */ size_t fdrSize(const struct FDR *fdr); } // namespace ue2 #endif hyperscan-4.4.1/src/fdr/fdr_engine_description.cpp0000644000175000017500000001703413055426554023055 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "fdr_compile_internal.h" #include "fdr_engine_description.h" #include "hs_compile.h" #include "util/target_info.h" #include "util/compare.h" // for ourisalpha() #include "util/make_unique.h" #include #include #include #include using namespace std; namespace ue2 { FDREngineDescription::FDREngineDescription(const FDREngineDef &def) : EngineDescription(def.id, targetByArchFeatures(def.cpu_features), def.numBuckets, def.confirmPullBackDistance, def.confirmTopLevelSplit), schemeWidth(def.schemeWidth), stride(0), bits(0) {} u32 FDREngineDescription::getDefaultFloodSuffixLength() const { // rounding up, so that scheme width 32 and 6 buckets is 6 not 5! // the +1 avoids pain due to various reach choices return ((getSchemeWidth() + getNumBuckets() - 1) / getNumBuckets()) + 1; } void getFdrDescriptions(vector *out) { static const FDREngineDef def = {0, 128, 8, 0, 1, 256}; out->clear(); out->emplace_back(def); } static u32 findDesiredStride(size_t num_lits, size_t min_len, size_t min_len_count) { u32 desiredStride = 1; // always our safe fallback if (min_len > 1) { if (num_lits < 250) { // small cases we just go for it desiredStride = min_len; } else if (num_lits < 800) { // intermediate cases desiredStride = min_len - 1; } else if (num_lits < 5000) { // for larger but not huge sizes, go to stride 2 only if we have at // least minlen 3 desiredStride = MIN(min_len - 1, 2); } } // patch if count is quite large - a ton of length 2 literals can // break things #ifdef TRY_THIS_LATER if ((min_len == 2) && (desiredStride == 2) && (min_len_count > 20)) { desiredStride = 1; } #endif // patch stuff just for the stride 4 case; don't let min_len=4, // desiredStride=4 through as even a few length 4 literals can break things // (far more fragile) if ((min_len == 4) && (desiredStride == 4) && (min_len_count > 2)) { desiredStride = 2; } return desiredStride; } unique_ptr chooseEngine(const target_t &target, const vector &vl, bool make_small) { vector allDescs; getFdrDescriptions(&allDescs); // find desired stride size_t count; size_t msl = minLenCount(vl, &count); u32 desiredStride = findDesiredStride(vl.size(), msl, count); DEBUG_PRINTF("%zu lits, msl=%zu, desiredStride=%u\n", vl.size(), msl, desiredStride); FDREngineDescription *best = nullptr; u32 best_score = 0; FDREngineDescription &eng = allDescs[0]; for (u32 domain = 9; domain <= 15; domain++) { for (size_t stride = 1; stride <= 4; stride *= 2) { // to make sure that domains >=14 have stride 1 according to origin if (domain > 13 && stride > 1) { continue; } if (!eng.isValidOnTarget(target)) { continue; } if (msl < stride) { continue; } u32 score = 100; score -= absdiff(desiredStride, stride); if (stride <= desiredStride) { score += stride; } u32 effLits = vl.size(); /* * desiredStride;*/ u32 ideal; if (effLits < eng.getNumBuckets()) { if (stride == 1) { ideal = 8; } else { ideal = 10; } } else if (effLits < 20) { ideal = 10; } else if (effLits < 100) { ideal = 11; } else if (effLits < 1000) { ideal = 12; } else if (effLits < 10000) { ideal = 13; } else { ideal = 15; } if (ideal != 8 && eng.schemeWidth == 32) { ideal += 1; } if (make_small) { ideal -= 2; } if (stride > 1) { ideal++; } DEBUG_PRINTF("effLits %u\n", effLits); if (target.is_atom_class() && !make_small && effLits < 4000) { /* Unless it is a very heavy case, we want to build smaller * tables on lightweight machines due to their small caches. */ ideal -= 2; } score -= absdiff(ideal, domain); DEBUG_PRINTF("fdr %u: width=%u, domain=%u, buckets=%u, stride=%zu " "-> score=%u\n", eng.getID(), eng.schemeWidth, domain, eng.getNumBuckets(), stride, score); if (!best || score > best_score) { eng.bits = domain; eng.stride = stride; best = ŋ best_score = score; } } } if (!best) { DEBUG_PRINTF("failed to find engine\n"); return nullptr; } DEBUG_PRINTF("using engine %u\n", best->getID()); return ue2::make_unique(*best); } SchemeBitIndex FDREngineDescription::getSchemeBit(BucketIndex b, PositionInBucket p) const { assert(p < getBucketWidth(b)); SchemeBitIndex sbi = p * getNumBuckets() + b; assert(sbi < getSchemeWidth()); return sbi; } u32 FDREngineDescription::getBucketWidth(BucketIndex) const { u32 sw = getSchemeWidth(); u32 nm = getNumBuckets(); assert(sw % nm == 0); return sw/nm; } unique_ptr getFdrDescription(u32 engineID) { vector allDescs; getFdrDescriptions(&allDescs); if (engineID >= allDescs.size()) { return nullptr; } return ue2::make_unique(allDescs[engineID]); } } // namespace ue2 hyperscan-4.4.1/src/fdr/fdr_dump.h0000644000175000017500000000346413055426554017621 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief FDR literal matcher: dump API. */ #ifndef FDR_DUMP_H #define FDR_DUMP_H #if defined(DUMP_SUPPORT) #include struct FDR; namespace ue2 { void fdrPrintStats(const struct FDR *fdr, FILE *f); } // namespace ue2 #endif // DUMP_SUPPORT #endif // FDR_DUMP_H hyperscan-4.4.1/src/fdr/flood_compile.cpp0000644000175000017500000002026413055426554021164 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "fdr_internal.h" #include "fdr_confirm.h" #include "fdr_compile_internal.h" #include "fdr_engine_description.h" #include "ue2common.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/compare.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include #include using namespace std; namespace ue2 { namespace { struct FloodComparator { bool operator()(const FDRFlood &f1, const FDRFlood &f2) const { return std::memcmp(&f1, &f2, sizeof(f1)) < 0; } }; } static bool isDifferent(u8 oldC, u8 c, bool caseless) { if (caseless) { return mytolower(oldC) != mytolower(c); } else { return oldC != c; } } static void updateFloodSuffix(vector &tmpFlood, u8 c, u32 suffix) { FDRFlood &fl = tmpFlood[c]; fl.suffix = MAX(fl.suffix, suffix + 1); DEBUG_PRINTF("Updated Flood Suffix for char 0x%02x to %u\n", c, fl.suffix); } static void addFlood(vector &tmpFlood, u8 c, const hwlmLiteral &lit, u32 suffix) { FDRFlood &fl = tmpFlood[c]; fl.suffix = MAX(fl.suffix, suffix + 1); if (fl.idCount < FDR_FLOOD_MAX_IDS) { fl.ids[fl.idCount] = lit.id; fl.allGroups |= lit.groups; fl.groups[fl.idCount] = lit.groups; fl.len[fl.idCount] = suffix; // when idCount gets to max_ids this flood no longer happens // only incremented one more time to avoid arithmetic overflow DEBUG_PRINTF("Added Flood for char '%c' suffix=%u len[%hu]=%u\n", c, fl.suffix, fl.idCount, suffix); fl.idCount++; } } pair, size_t> setupFDRFloodControl(const vector &lits, const EngineDescription &eng) { vector tmpFlood(N_CHARS); u32 default_suffix = eng.getDefaultFloodSuffixLength(); // zero everything to avoid spurious distinctions in the compares memset(&tmpFlood[0], 0, N_CHARS * sizeof(FDRFlood)); for (u32 c = 0; c < N_CHARS; c++) { tmpFlood[c].suffix = default_suffix; } for (const auto &lit : lits) { DEBUG_PRINTF("lit: '%s'%s\n", escapeString(lit.s).c_str(), lit.nocase ? " (nocase)" : ""); u32 litSize = verify_u32(lit.s.size()); u32 maskSize = (u32)lit.msk.size(); u8 c = lit.s[litSize - 1]; bool nocase = ourisalpha(c) ? lit.nocase : false; if (nocase && maskSize && (lit.msk[maskSize - 1] & CASE_BIT)) { c = (lit.cmp[maskSize - 1] & CASE_BIT) ? mytolower(c) : mytoupper(c); nocase = false; } u32 iEnd = MAX(litSize, maskSize); u32 upSuffix = iEnd; // upSuffix is used as an upper case suffix length // for case-less, or as a suffix length for case-sensitive; u32 loSuffix = iEnd; // loSuffix used only for case-less as a lower case suffix // length; for (u32 i = 0; i < iEnd; i++) { if (i < litSize) { if (isDifferent(c, lit.s[litSize - i - 1], lit.nocase)) { DEBUG_PRINTF("non-flood char in literal[%u]: " "0x%02x != 0x%02x\n", i, c, lit.s[litSize - i - 1]); upSuffix = MIN(upSuffix, i); loSuffix = MIN(loSuffix, i); // makes sense only for case-less break; } } if (i < maskSize) { u8 m = lit.msk[maskSize - i - 1]; u8 cm = lit.cmp[maskSize - i - 1] & m; if(nocase) { if ((mytoupper(c) & m) != cm) { DEBUG_PRINTF("non-flood char in mask[%u] %c != %c\n", i, mytoupper(c), cm); upSuffix = MIN(upSuffix, i); } if ((mytolower(c) & m) != cm) { DEBUG_PRINTF("non-flood char in mask[%u] %c != %c\n", i, mytolower(c), cm); loSuffix = MIN(loSuffix, i); } if (loSuffix != iEnd && upSuffix != iEnd) { break; } } else if ((c & m) != cm) { DEBUG_PRINTF("non-flood char in mask[%u] %c != %c\n", i, c, cm); upSuffix = MIN(upSuffix, i); break; } } } if(upSuffix != iEnd) { updateFloodSuffix(tmpFlood, nocase ? mytoupper(c) : c, upSuffix); } else { addFlood(tmpFlood, nocase ? mytoupper(c) : c, lit, upSuffix); } if (nocase) { if(loSuffix != iEnd) { updateFloodSuffix(tmpFlood, mytolower(c), loSuffix); } else { addFlood(tmpFlood, mytolower(c), lit, loSuffix); } } } #ifdef DEBUG for (u32 i = 0; i < N_CHARS; i++) { FDRFlood &fl = tmpFlood[i]; if (!fl.idCount) { continue; } printf("i is %02x fl->idCount is %hd fl->suffix is %d fl->allGroups is " "%016llx\n", i, fl.idCount, fl.suffix, fl.allGroups); for (u32 j = 0; j < fl.idCount; j++) { printf("j is %d fl.groups[j] %016llx fl.len[j] %d \n", j, fl.groups[j], fl.len[j]); } } #endif map flood2chars; for (u32 i = 0; i < N_CHARS; i++) { FDRFlood fl = tmpFlood[i]; flood2chars[fl].set(i); } u32 nDistinctFloods = flood2chars.size(); size_t floodHeaderSize = sizeof(u32) * N_CHARS; size_t floodStructSize = sizeof(FDRFlood) * nDistinctFloods; size_t totalSize = ROUNDUP_16(floodHeaderSize + floodStructSize); auto buf = aligned_zmalloc_unique(totalSize); assert(buf); // otherwise would have thrown std::bad_alloc u32 *floodHeader = (u32 *)buf.get(); FDRFlood *layoutFlood = (FDRFlood *)(buf.get() + floodHeaderSize); u32 currentFloodIndex = 0; for (const auto &m : flood2chars) { const FDRFlood &fl = m.first; const CharReach &cr = m.second; layoutFlood[currentFloodIndex] = fl; for (size_t c = cr.find_first(); c != cr.npos; c = cr.find_next(c)) { floodHeader[c] = currentFloodIndex; } currentFloodIndex++; } DEBUG_PRINTF("made a flood structure with %zu + %zu = %zu\n", floodHeaderSize, floodStructSize, totalSize); return {move(buf), totalSize}; } } // namespace ue2 hyperscan-4.4.1/src/fdr/fdr_compile.cpp0000644000175000017500000004531513055426554020640 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief FDR literal matcher: build API. */ #include "fdr_internal.h" #include "fdr_compile.h" #include "fdr_confirm.h" #include "fdr_compile_internal.h" #include "fdr_engine_description.h" #include "teddy_compile.h" #include "teddy_engine_description.h" #include "grey.h" #include "ue2common.h" #include "hwlm/hwlm_build.h" #include "util/alloc.h" #include "util/compare.h" #include "util/dump_mask.h" #include "util/target_info.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; namespace ue2 { namespace { class FDRCompiler : boost::noncopyable { private: const FDREngineDescription ŋ vector tab; const vector &lits; map > bucketToLits; bool make_small; u8 *tabIndexToMask(u32 indexInTable); void assignStringToBucket(LiteralIndex l, BucketIndex b); void assignStringsToBuckets(); #ifdef DEBUG void dumpMasks(const u8 *defaultMask); #endif void setupTab(); aligned_unique_ptr setupFDR(pair, size_t> &link); void createInitialState(FDR *fdr); public: FDRCompiler(const vector &lits_in, const FDREngineDescription &eng_in, bool make_small_in) : eng(eng_in), tab(eng_in.getTabSizeBytes()), lits(lits_in), make_small(make_small_in) {} aligned_unique_ptr build(pair, size_t> &link); }; u8 *FDRCompiler::tabIndexToMask(u32 indexInTable) { assert(indexInTable < tab.size()); return &tab[0] + (indexInTable * (eng.getSchemeWidth() / 8)); } static void setbit(u8 *msk, u32 bit) { msk[bit / 8] |= 1U << (bit % 8); } static void clearbit(u8 *msk, u32 bit) { msk[bit / 8] &= ~(1U << (bit % 8)); } static void andMask(u8 *dest, const u8 *a, const u8 *b, u32 num_bytes) { for (u32 i = 0; i < num_bytes; i++) { dest[i] = a[i] & b[i]; } } void FDRCompiler::createInitialState(FDR *fdr) { u8 *start = (u8 *)&fdr->start; /* initial state should to be 1 in each slot in the bucket up to bucket * minlen - 1, and 0 thereafter */ for (BucketIndex b = 0; b < eng.getNumBuckets(); b++) { // Find the minimum length for the literals in this bucket. const vector &bucket_lits = bucketToLits[b]; u32 min_len = ~0U; for (const LiteralIndex &lit_idx : bucket_lits) { min_len = min(min_len, verify_u32(lits[lit_idx].s.length())); } DEBUG_PRINTF("bucket %u has min_len=%u\n", b, min_len); assert(min_len); for (PositionInBucket i = 0; i < eng.getBucketWidth(b); i++) { if (i < min_len - 1) { setbit(start, eng.getSchemeBit(b, i)); } } } } aligned_unique_ptr FDRCompiler::setupFDR(pair, size_t> &link) { size_t tabSize = eng.getTabSizeBytes(); auto floodControlTmp = setupFDRFloodControl(lits, eng); auto confirmTmp = setupFullMultiConfs(lits, eng, bucketToLits, make_small); assert(ISALIGNED_16(tabSize)); assert(ISALIGNED_16(confirmTmp.second)); assert(ISALIGNED_16(floodControlTmp.second)); assert(ISALIGNED_16(link.second)); size_t headerSize = ROUNDUP_16(sizeof(FDR)); size_t size = ROUNDUP_16(headerSize + tabSize + confirmTmp.second + floodControlTmp.second + link.second); DEBUG_PRINTF("sizes base=%zu tabSize=%zu confirm=%zu floodControl=%zu " "total=%zu\n", headerSize, tabSize, confirmTmp.second, floodControlTmp.second, size); aligned_unique_ptr fdr = aligned_zmalloc_unique(size); assert(fdr); // otherwise would have thrown std::bad_alloc fdr->size = size; fdr->engineID = eng.getID(); fdr->maxStringLen = verify_u32(maxLen(lits)); createInitialState(fdr.get()); u8 *fdr_base = (u8 *)fdr.get(); u8 * ptr = fdr_base + ROUNDUP_16(sizeof(FDR)); copy(tab.begin(), tab.end(), ptr); ptr += tabSize; memcpy(ptr, confirmTmp.first.get(), confirmTmp.second); ptr += confirmTmp.second; fdr->floodOffset = verify_u32(ptr - fdr_base); memcpy(ptr, floodControlTmp.first.get(), floodControlTmp.second); ptr += floodControlTmp.second; /* we are allowing domains 9 to 15 only */ assert(eng.bits > 8 && eng.bits < 16); fdr->domain = eng.bits; fdr->domainMask = (1 << eng.bits) - 1; fdr->tabSize = (1 << eng.bits) * (eng.schemeWidth / 8); fdr->stride = eng.stride; if (link.first) { fdr->link = verify_u32(ptr - fdr_base); memcpy(ptr, link.first.get(), link.second); } else { fdr->link = 0; } return fdr; } void FDRCompiler::assignStringToBucket(LiteralIndex l, BucketIndex b) { bucketToLits[b].push_back(l); } struct LitOrder { explicit LitOrder(const vector &vl_) : vl(vl_) {} bool operator()(const u32 &i1, const u32 &i2) const { const string &i1s = vl[i1].s; const string &i2s = vl[i2].s; size_t len1 = i1s.size(), len2 = i2s.size(); if (len1 != len2) { return len1 < len2; } else { auto p = std::mismatch(i1s.rbegin(), i1s.rend(), i2s.rbegin()); if (p.first == i1s.rend()) { return false; } return *p.first < *p.second; } } private: const vector &vl; }; static u64a getScoreUtil(u32 len, u32 count) { if (len == 0) { return (u64a)-1; } const u32 LEN_THRESH = 128; const u32 elen = (len > LEN_THRESH) ? LEN_THRESH : len; const u64a lenScore = (LEN_THRESH * LEN_THRESH * LEN_THRESH) / (elen * elen * elen); return count * lenScore; // deemphasize count - possibly more than needed // this might be overkill in the other direction } //#define DEBUG_ASSIGNMENT void FDRCompiler::assignStringsToBuckets() { typedef u64a SCORE; // 'Score' type const SCORE MAX_SCORE = (SCORE)-1; const u32 CHUNK_MAX = 512; const u32 BUCKET_MAX = 16; typedef pair SCORE_INDEX_PAIR; u32 ls = verify_u32(lits.size()); assert(ls); // Shouldn't be called with no literals. // make a vector that contains our literals as pointers or u32 LiteralIndex values vector vli; vli.resize(ls); map lenCounts; for (LiteralIndex l = 0; l < ls; l++) { vli[l] = l; lenCounts[lits[l].s.size()]++; } // sort vector by literal length + if tied on length, 'magic' criteria of some kind (tbd) stable_sort(vli.begin(), vli.end(), LitOrder(lits)); #ifdef DEBUG_ASSIGNMENT for (const auto &m : lenCounts) { printf("l<%u>:%u ", m.first, m.second); } printf("\n"); #endif // TODO: detailed early stage literal analysis for v. small cases (actually look at lits) // yes - after we factor this out and merge in the Teddy style of building we can look // at this, although the teddy merge modelling is quite different. It's still probably // adaptable to some extent for this class of problem u32 firstIds[CHUNK_MAX]; // how many are in this chunk (CHUNK_MAX - 1 contains 'last' bound) u32 count[CHUNK_MAX]; // how many are in this chunk u32 length[CHUNK_MAX]; // how long things in the chunk are const u32 MAX_CONSIDERED_LENGTH = 16; u32 currentChunk = 0; u32 currentSize = 0; u32 chunkStartID = 0; u32 maxPerChunk = ls/(CHUNK_MAX - MIN(MAX_CONSIDERED_LENGTH, lenCounts.size())) + 1; for (u32 i = 0; i < ls && currentChunk < CHUNK_MAX - 1; i++) { LiteralIndex l = vli[i]; if ((currentSize < MAX_CONSIDERED_LENGTH && (lits[l].s.size() != currentSize)) || (currentSize != 1 && ((i - chunkStartID) >= maxPerChunk))) { currentSize = lits[l].s.size(); if (currentChunk) { count[currentChunk - 1 ] = i - chunkStartID; } chunkStartID = firstIds[currentChunk] = i; length[currentChunk] = currentSize; currentChunk++; } } assert(currentChunk > 0); count[currentChunk - 1] = ls - chunkStartID; // close off chunks with an empty row firstIds[currentChunk] = ls; length[currentChunk] = 0; count[currentChunk] = 0; u32 nChunks = currentChunk + 1; #ifdef DEBUG_ASSIGNMENT for (u32 j = 0; j < nChunks; j++) { printf("%d %d %d %d\n", j, firstIds[j], count[j], length[j]); } #endif SCORE_INDEX_PAIR t[CHUNK_MAX][BUCKET_MAX]; // pair of score, index u32 nb = eng.getNumBuckets(); for (u32 j = 0; j < nChunks; j++) { u32 cnt = 0; for (u32 k = j; k < nChunks; ++k) { cnt += count[k]; } t[j][0] = {getScoreUtil(length[j], cnt), 0}; } for (u32 i = 1; i < nb; i++) { for (u32 j = 0; j < nChunks - 1; j++) { // don't process last, empty row SCORE_INDEX_PAIR best = {MAX_SCORE, 0}; u32 cnt = count[j]; for (u32 k = j + 1; k < nChunks - 1; k++, cnt += count[k]) { SCORE score = getScoreUtil(length[j], cnt); if (score > best.first) { break; // if we're now worse locally than our best score, give up } score += t[k][i-1].first; if (score < best.first) { best = {score, k}; } } t[j][i] = best; } t[nChunks - 1][i] = {0,0}; // fill in empty final row for next iteration } #ifdef DEBUG_ASSIGNMENT for (u32 j = 0; j < nChunks; j++) { for (u32 i = 0; i < nb; i++) { SCORE_INDEX_PAIR v = t[j][i]; printf("<%7lld,%3d>", v.first, v.second); } printf("\n"); } #endif // our best score is in best[0][N_BUCKETS-1] and we can follow the links // to find where our buckets should start and what goes into them for (u32 i = 0, n = nb; n && (i != nChunks - 1); n--) { u32 j = t[i][n - 1].second; if (j == 0) { j = nChunks - 1; } // put chunks between i - j into bucket (NBUCKETS-1) - n #ifdef DEBUG_ASSIGNMENT printf("placing from %d to %d in bucket %d\n", firstIds[i], firstIds[j], nb - n); #endif for (u32 k = firstIds[i]; k < firstIds[j]; k++) { assignStringToBucket((LiteralIndex)vli[k], nb - n); } i = j; } } #ifdef DEBUG void FDRCompiler::dumpMasks(const u8 *defaultMask) { const size_t width = eng.getSchemeWidth(); printf("default mask: %s\n", dumpMask(defaultMask, width).c_str()); for (u32 i = 0; i < eng.getNumTableEntries(); i++) { u8 *m = tabIndexToMask(i); if (memcmp(m, defaultMask, width / 8)) { printf("tab %04x: %s\n", i, dumpMask(m, width).c_str()); } } } #endif static bool getMultiEntriesAtPosition(const FDREngineDescription &eng, const vector &vl, const vector &lits, SuffixPositionInString pos, std::map > &m2) { assert(eng.bits < 32); u32 distance = 0; if (eng.bits <= 8) { distance = 1; } else if (eng.bits <= 16) { distance = 2; } else { distance = 4; } for (auto i = vl.begin(), e = vl.end(); i != e; ++i) { if (e - i > 5) { __builtin_prefetch(&lits[*(i + 5)]); } const hwlmLiteral &lit = lits[*i]; const size_t sz = lit.s.size(); u32 mask = 0; u32 dontCares = 0; for (u32 cnt = 0; cnt < distance; cnt++) { int newPos = pos - cnt; u8 dontCareByte = 0x0; u8 maskByte = 0x0; if (newPos < 0 || ((u32)newPos >= sz)) { dontCareByte = 0xff; } else { u8 c = lit.s[sz - newPos - 1]; maskByte = c; u32 remainder = eng.bits - cnt * 8; assert(remainder != 0); if (remainder < 8) { u8 cmask = (1U << remainder) - 1; maskByte &= cmask; dontCareByte |= ~cmask; } if (lit.nocase && ourisalpha(c)) { maskByte &= 0xdf; dontCareByte |= 0x20; } } u32 loc = cnt * 8; mask |= maskByte << loc; dontCares |= dontCareByte << loc; } // truncate m and dc down to nBits mask &= (1U << eng.bits) - 1; dontCares &= (1U << eng.bits) - 1; if (dontCares == ((1U << eng.bits) - 1)) { return true; } m2[dontCares].insert(mask); } return false; } void FDRCompiler::setupTab() { const size_t mask_size = eng.getSchemeWidth() / 8; assert(mask_size); vector defaultMask(mask_size, 0xff); for (u32 i = 0; i < eng.getNumTableEntries(); i++) { memcpy(tabIndexToMask(i), &defaultMask[0], mask_size); } for (BucketIndex b = 0; b < eng.getNumBuckets(); b++) { const vector &vl = bucketToLits[b]; SuffixPositionInString pLimit = eng.getBucketWidth(b); for (SuffixPositionInString pos = 0; pos < pLimit; pos++) { u32 bit = eng.getSchemeBit(b, pos); map> m2; bool done = getMultiEntriesAtPosition(eng, vl, lits, pos, m2); if (done) { clearbit(&defaultMask[0], bit); continue; } for (const auto &elem : m2) { u32 dc = elem.first; const ue2::unordered_set &mskSet = elem.second; u32 v = ~dc; do { u32 b2 = v & dc; for (const u32 &mskVal : mskSet) { u32 val = (mskVal & ~dc) | b2; clearbit(tabIndexToMask(val), bit); } v = (v + (dc & -dc)) | ~dc; } while (v != ~dc); } } } for (u32 i = 0; i < eng.getNumTableEntries(); i++) { u8 *m = tabIndexToMask(i); andMask(m, m, &defaultMask[0], mask_size); } #ifdef DEBUG dumpMasks(&defaultMask[0]); #endif } aligned_unique_ptr FDRCompiler::build(pair, size_t> &link) { assignStringsToBuckets(); setupTab(); return setupFDR(link); } } // namespace static size_t maxMaskLen(const vector &lits) { size_t rv = 0; for (const auto &lit : lits) { rv = max(rv, lit.msk.size()); } return rv; } static void setHistoryRequired(hwlmStreamingControl &stream_ctl, const vector &lits) { size_t max_mask_len = maxMaskLen(lits); // we want enough history to manage the longest literal and the longest // mask. stream_ctl.literal_history_required = max(maxLen(lits), max_mask_len) - 1; } static aligned_unique_ptr fdrBuildTableInternal(const vector &lits, bool make_small, const target_t &target, const Grey &grey, u32 hint, hwlmStreamingControl *stream_control) { pair, size_t> link(nullptr, 0); if (stream_control) { setHistoryRequired(*stream_control, lits); } DEBUG_PRINTF("cpu has %s\n", target.has_avx2() ? "avx2" : "no-avx2"); if (grey.fdrAllowTeddy) { auto fdr = teddyBuildTableHinted(lits, make_small, hint, target, link); if (fdr) { DEBUG_PRINTF("build with teddy succeeded\n"); return fdr; } else { DEBUG_PRINTF("build with teddy failed, will try with FDR\n"); } } const unique_ptr des = (hint == HINT_INVALID) ? chooseEngine(target, lits, make_small) : getFdrDescription(hint); if (!des) { return nullptr; } // temporary hack for unit testing if (hint != HINT_INVALID) { des->bits = 9; des->stride = 1; } FDRCompiler fc(lits, *des, make_small); return fc.build(link); } aligned_unique_ptr fdrBuildTable(const vector &lits, bool make_small, const target_t &target, const Grey &grey, hwlmStreamingControl *stream_control) { return fdrBuildTableInternal(lits, make_small, target, grey, HINT_INVALID, stream_control); } #if !defined(RELEASE_BUILD) aligned_unique_ptr fdrBuildTableHinted(const vector &lits, bool make_small, u32 hint, const target_t &target, const Grey &grey, hwlmStreamingControl *stream_control) { pair link(nullptr, 0); return fdrBuildTableInternal(lits, make_small, target, grey, hint, stream_control); } #endif size_t fdrSize(const FDR *fdr) { assert(fdr); return fdr->size; } } // namespace ue2 hyperscan-4.4.1/src/fdr/engine_description.h0000644000175000017500000000561413055426554021670 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ENGINE_DESCRIPTION_H #define ENGINE_DESCRIPTION_H #include "ue2common.h" #include "util/target_info.h" namespace ue2 { class EngineDescription { u32 id; target_t code_target; // the target that we built this code for u32 numBuckets; u32 confirmPullBackDistance; u32 confirmTopLevelSplit; public: EngineDescription(u32 id_in, const target_t &code_target_in, u32 numBuckets_in, u32 confirmPullBackDistance_in, u32 confirmTopLevelSplit_in) : id(id_in), code_target(code_target_in), numBuckets(numBuckets_in), confirmPullBackDistance(confirmPullBackDistance_in), confirmTopLevelSplit(confirmTopLevelSplit_in) {} virtual ~EngineDescription(); u32 getID() const { return id; } u32 getNumBuckets() const { return numBuckets; } u32 getConfirmPullBackDistance() const { return confirmPullBackDistance; } u32 getConfirmTopLevelSplit() const { return confirmTopLevelSplit; } void setConfirmTopLevelSplit(u32 split) { confirmTopLevelSplit = split; } bool isValidOnTarget(const target_t &target_in) const; virtual u32 getDefaultFloodSuffixLength() const = 0; virtual bool typicallyHoldsOneCharLits() const { return true; } }; /** Returns a target given a CPU feature set value. */ target_t targetByArchFeatures(u64a cpu_features); } // namespace ue2 #endif hyperscan-4.4.1/src/fdr/fdr_confirm.h0000644000175000017500000000622713055426554020311 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 FDR_CONFIRM_H #define FDR_CONFIRM_H #include "ue2common.h" #include "hwlm/hwlm.h" static really_inline u32 mul_hash_64(u64a lv, u64a andmsk, u64a mult, u32 nBits) { return ((lv & andmsk) * mult) >> (sizeof(u64a)*8 - nBits); } // data structures // TODO: fix this hard-coding #define CONF_TYPE u64a #define CONF_HASH_CALL mul_hash_64 typedef enum LitInfoFlags { NoFlags = 0, Caseless = 1, NoRepeat = 2, ComplexConfirm = 4 } LitInfoFlags; /** * \brief Structure describing a literal, linked to by FDRConfirm. * * This structure is followed in memory by a variable-sized string prefix, for * strings that are longer than CONF_TYPE. */ struct LitInfo { CONF_TYPE v; CONF_TYPE msk; hwlm_group_t groups; u32 id; // literal ID as passed in u8 size; u8 flags; /* LitInfoFlags */ u8 next; u8 extended_size; }; #define FDRC_FLAG_NO_CONFIRM 1 /** * \brief FDR confirm header. * * This structure is followed in memory by: * * -# lit index mapping (array of u32) * -# list of LitInfo structures */ struct FDRConfirm { CONF_TYPE andmsk; CONF_TYPE mult; u32 nBitsOrSoleID; // if flags is NO_CONFIRM then this is soleID u32 flags; // sole meaning is 'non-zero means no-confirm' (that is all) hwlm_group_t groups; u32 soleLitSize; u32 soleLitCmp; u32 soleLitMsk; }; static really_inline const u32 *getConfirmLitIndex(const struct FDRConfirm *fdrc) { const u8 *base = (const u8 *)fdrc; const u32 *litIndex = (const u32 *)(base + ROUNDUP_N(sizeof(*fdrc), alignof(u32))); assert(ISALIGNED(litIndex)); return litIndex; } #endif // FDR_CONFIRM_H hyperscan-4.4.1/src/fdr/fdr_confirm_runtime.h0000644000175000017500000001703513055426554022053 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 FDR_CONFIRM_RUNTIME_H #define FDR_CONFIRM_RUNTIME_H #include "fdr_internal.h" #include "fdr_loadval.h" #include "hwlm/hwlm.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/compare.h" // this is ordinary confirmation function which runs through // the whole confirmation procedure static really_inline void confWithBit(const struct FDRConfirm *fdrc, const struct FDR_Runtime_Args *a, size_t i, u32 pullBackAmount, hwlmcb_rv_t *control, u32 *last_match, u64a conf_key) { assert(i < a->len); assert(ISALIGNED(fdrc)); const u8 * buf = a->buf; u32 c = CONF_HASH_CALL(conf_key, fdrc->andmsk, fdrc->mult, fdrc->nBitsOrSoleID); u32 start = getConfirmLitIndex(fdrc)[c]; if (likely(!start)) { return; } const struct LitInfo *li = (const struct LitInfo *)((const u8 *)fdrc + start); u8 oldNext; // initialized in loop do { assert(ISALIGNED(li)); if (unlikely((conf_key & li->msk) != li->v)) { goto out; } if ((*last_match == li->id) && (li->flags & NoRepeat)) { goto out; } const u8 *loc = buf + i - li->size + 1 - pullBackAmount; u8 caseless = li->flags & Caseless; if (loc < buf) { u32 full_overhang = buf - loc; const u8 *history = a->buf_history; size_t len_history = a->len_history; // can't do a vectored confirm either if we don't have // the bytes if (full_overhang > len_history) { goto out; } // as for the regular case, no need to do a full confirm if // we're a short literal if (unlikely(li->size > sizeof(CONF_TYPE))) { const u8 *s1 = (const u8 *)li + sizeof(*li); const u8 *s2 = s1 + full_overhang; const u8 *loc1 = history + len_history - full_overhang; const u8 *loc2 = buf; size_t size1 = MIN(full_overhang, li->size - sizeof(CONF_TYPE)); size_t wind_size2_back = sizeof(CONF_TYPE) + full_overhang; size_t size2 = wind_size2_back > li->size ? 0 : li->size - wind_size2_back; if (cmpForward(loc1, s1, size1, caseless)) { goto out; } if (cmpForward(loc2, s2, size2, caseless)) { goto out; } } } else { // NON-VECTORING PATH // if string < conf_type we don't need regular string cmp if (unlikely(li->size > sizeof(CONF_TYPE))) { const u8 *s = (const u8 *)li + sizeof(*li); if (cmpForward(loc, s, li->size - sizeof(CONF_TYPE), caseless)) { goto out; } } } if (unlikely(!(li->groups & *control))) { goto out; } if (unlikely(li->flags & ComplexConfirm)) { const u8 *loc2 = buf + i - li->extended_size + 1 - pullBackAmount; if (loc2 < buf) { u32 full_overhang = buf - loc2; size_t len_history = a->len_history; if (full_overhang > len_history) { goto out; } } } *last_match = li->id; *control = a->cb(loc - buf, i, li->id, a->ctxt); out: oldNext = li->next; // oldNext is either 0 or an 'adjust' value li = (const struct LitInfo *)((const u8 *)li + oldNext + li->size); } while (oldNext); } // 'light-weight' confirmation function which is used by 1-mask Teddy; // in the 'confirmless' case it simply calls callback function, // otherwise it calls 'confWithBit' function for the full confirmation procedure static really_inline void confWithBit1(const struct FDRConfirm *fdrc, const struct FDR_Runtime_Args *a, size_t i, hwlmcb_rv_t *control, u32 *last_match, u64a conf_key) { assert(i < a->len); assert(ISALIGNED(fdrc)); if (unlikely(fdrc->mult)) { confWithBit(fdrc, a, i, 0, control, last_match, conf_key); return; } else { u32 id = fdrc->nBitsOrSoleID; if ((*last_match == id) && (fdrc->flags & NoRepeat)) { return; } *last_match = id; *control = a->cb(i, i, id, a->ctxt); } } // This is 'light-weight' confirmation function which is used by 2-3-4-mask Teddy // In the 'confirmless' case it makes fast 32-bit comparison, // otherwise it calls 'confWithBit' function for the full confirmation procedure static really_inline void confWithBitMany(const struct FDRConfirm *fdrc, const struct FDR_Runtime_Args *a, size_t i, CautionReason r, hwlmcb_rv_t *control, u32 *last_match, u64a conf_key) { assert(i < a->len); assert(ISALIGNED(fdrc)); if (i < a->start_offset) { return; } if (unlikely(fdrc->mult)) { confWithBit(fdrc, a, i, 0, control, last_match, conf_key); return; } else { const u32 id = fdrc->nBitsOrSoleID; const u32 len = fdrc->soleLitSize; if ((*last_match == id) && (fdrc->flags & NoRepeat)) { return; } if (r == VECTORING && len > i - a->start_offset) { if (len > i + a->len_history) { return; } u32 cmp = (u32)a->buf[i] << 24; if (len <= i) { for (u32 j = 1; j <= len; j++) { cmp |= (u32)a->buf[i - j] << (24 - (j * 8)); } } else { for (u32 j = 1; j <= i; j++) { cmp |= (u32)a->buf[i - j] << (24 - (j * 8)); } cmp |= (u32)(a->histBytes >> (40 + i * 8)); } if ((fdrc->soleLitMsk & cmp) != fdrc->soleLitCmp) { return; } } *last_match = id; *control = a->cb(i - len, i, id, a->ctxt); } } #endif hyperscan-4.4.1/src/fdr/fdr_internal.h0000644000175000017500000000775413055426554020476 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief FDR literal matcher: data structures. */ #ifndef FDR_INTERNAL_H #define FDR_INTERNAL_H #include "ue2common.h" #include "hwlm/hwlm.h" // for hwlm_group_t, HWLMCallback typedef enum { NOT_CAUTIOUS, //!< not near a boundary (quantify?) VECTORING //!< potentially vectoring } CautionReason; /** \brief number of different ids that can be triggered by floods of any given * character. */ #define FDR_FLOOD_MAX_IDS 16 struct FDRFlood { hwlm_group_t allGroups; //!< all the groups or'd together u32 suffix; /** \brief 0 to FDR_FLOOD_MAX_IDS-1 ids that are generated once per char on * a flood. * If larger we won't handle this through the flood path at all. */ u16 idCount; u32 ids[FDR_FLOOD_MAX_IDS]; //!< the ids hwlm_group_t groups[FDR_FLOOD_MAX_IDS]; //!< group ids to go with string ids u32 len[FDR_FLOOD_MAX_IDS]; //!< lengths to go with the string ids }; /** \brief FDR structure. * * 1. struct as-is * 2. primary matching table * 3. confirm stuff */ struct FDR { u32 engineID; u32 size; u32 maxStringLen; u32 floodOffset; /** link is the relative offset of a secondary included FDR table for * stream handling if we're a primary FDR table or the subsidiary tertiary * structures (spillover strings and hash table) if we're a secondary * structure. */ u32 link; u8 stride; /* stride - how frequeuntly the data is consulted by the first * stage matcher */ u8 domain; /* number of bits used to index into main FDR table. This value * is used only of debugging/asserts. */ u16 domainMask; /* pre-computed domain mask */ u32 tabSize; /* pre-computed hashtable size in bytes */ u32 pad; m128 start; /* initial start state to use at offset 0. The state has been set * up based on the min length of buckets to reduce the need for * pointless confirms. */ }; /** \brief FDR runtime arguments. * * This structure handles read-only things that are passed extensively around * the FDR run-time functions. They are set by the API, passed by value into * the main function, then a pointer is passed around to all the various * sub-functions (confirm & flood). */ struct FDR_Runtime_Args { const u8 *buf; size_t len; const u8 *buf_history; size_t len_history; size_t start_offset; HWLMCallback cb; void *ctxt; const u8 *firstFloodDetect; const u64a histBytes; }; #endif hyperscan-4.4.1/src/fdr/fdr.c0000644000175000017500000007720713055426554016575 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "fdr.h" #include "fdr_confirm.h" #include "fdr_confirm_runtime.h" #include "fdr_internal.h" #include "fdr_loadval.h" #include "flood_runtime.h" #include "teddy.h" #include "teddy_internal.h" #include "util/simd_utils.h" /** \brief number of bytes processed in each iteration */ #define ITER_BYTES 16 /** \brief total zone buffer size */ #define ZONE_TOTAL_SIZE 64 /** \brief maximum number of allowed zones */ #define ZONE_MAX 3 /** \brief zone information. * * Zone represents a region of data to scan in FDR. * * The incoming buffer is to split in multiple zones to ensure two properties: * 1: that we can read 8? bytes behind to generate a hash safely * 2: that we can read the byte after the current byte (domain > 8) */ struct zone { /** \brief copied buffer, used only when it is a boundary zone. */ u8 ALIGN_CL_DIRECTIVE buf[ZONE_TOTAL_SIZE]; /** \brief shift amount for fdr state to avoid unwanted match. */ u8 shift; /** \brief if boundary zone, start points into the zone buffer after the * pre-padding. Otherwise, points to the main buffer, appropriately. */ const u8 *start; /** \brief if boundary zone, end points to the end of zone. Otherwise, * pointer to the main buffer, appropriately. */ const u8 *end; /** \brief the amount to adjust to go from a pointer in the zones region * (between start and end) to a pointer in the original data buffer. */ ptrdiff_t zone_pointer_adjust; /** \brief firstFloodDetect from FDR_Runtime_Args for non-boundary zones, * otherwise end of the zone buf. floodPtr always points inside the same * buffer as the start pointe. */ const u8 *floodPtr; }; static const ALIGN_CL_DIRECTIVE u8 zone_or_mask[ITER_BYTES+1][ITER_BYTES] = { { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00 }, { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00 }, { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 } }; /* generates an initial state mask based on the last byte-ish of history rather * than being all accepting. If there is no history to consider, the state is * generated based on the minimum length of each bucket in order to prevent * confirms. */ static really_inline m128 getInitState(const struct FDR *fdr, u8 len_history, const u8 *ft, const struct zone *z) { m128 s; if (len_history) { /* +1: the zones ensure that we can read the byte at z->end */ u32 tmp = lv_u16(z->start + z->shift - 1, z->buf, z->end + 1); tmp &= fdr->domainMask; s = *((const m128 *)ft + tmp); s = rshiftbyte_m128(s, 1); } else { s = fdr->start; } return s; } static really_inline void get_conf_stride_1(const u8 *itPtr, const u8 *start_ptr, const u8 *end_ptr, u64a domain_mask_adjusted, const u8 *ft, u64a *conf0, u64a *conf8, m128 *s) { /* +1: the zones ensure that we can read the byte at z->end */ u64a current_data_0; u64a current_data_8; current_data_0 = lv_u64a(itPtr + 0, start_ptr, end_ptr); u64a v7 = (lv_u16(itPtr + 7, start_ptr, end_ptr + 1) << 1) & domain_mask_adjusted; u64a v0 = (current_data_0 << 1) & domain_mask_adjusted; u64a v1 = (current_data_0 >> 7) & domain_mask_adjusted; u64a v2 = (current_data_0 >> 15) & domain_mask_adjusted; u64a v3 = (current_data_0 >> 23) & domain_mask_adjusted; u64a v4 = (current_data_0 >> 31) & domain_mask_adjusted; u64a v5 = (current_data_0 >> 39) & domain_mask_adjusted; u64a v6 = (current_data_0 >> 47) & domain_mask_adjusted; current_data_8 = lv_u64a(itPtr + 8, start_ptr, end_ptr); u64a v15 = (lv_u16(itPtr + 15, start_ptr, end_ptr + 1) << 1) & domain_mask_adjusted; u64a v8 = (current_data_8 << 1) & domain_mask_adjusted; u64a v9 = (current_data_8 >> 7) & domain_mask_adjusted; u64a v10 = (current_data_8 >> 15) & domain_mask_adjusted; u64a v11 = (current_data_8 >> 23) & domain_mask_adjusted; u64a v12 = (current_data_8 >> 31) & domain_mask_adjusted; u64a v13 = (current_data_8 >> 39) & domain_mask_adjusted; u64a v14 = (current_data_8 >> 47) & domain_mask_adjusted; m128 st0 = *(const m128 *)(ft + v0*8); m128 st1 = *(const m128 *)(ft + v1*8); m128 st2 = *(const m128 *)(ft + v2*8); m128 st3 = *(const m128 *)(ft + v3*8); m128 st4 = *(const m128 *)(ft + v4*8); m128 st5 = *(const m128 *)(ft + v5*8); m128 st6 = *(const m128 *)(ft + v6*8); m128 st7 = *(const m128 *)(ft + v7*8); m128 st8 = *(const m128 *)(ft + v8*8); m128 st9 = *(const m128 *)(ft + v9*8); m128 st10 = *(const m128 *)(ft + v10*8); m128 st11 = *(const m128 *)(ft + v11*8); m128 st12 = *(const m128 *)(ft + v12*8); m128 st13 = *(const m128 *)(ft + v13*8); m128 st14 = *(const m128 *)(ft + v14*8); m128 st15 = *(const m128 *)(ft + v15*8); st1 = lshiftbyte_m128(st1, 1); st2 = lshiftbyte_m128(st2, 2); st3 = lshiftbyte_m128(st3, 3); st4 = lshiftbyte_m128(st4, 4); st5 = lshiftbyte_m128(st5, 5); st6 = lshiftbyte_m128(st6, 6); st7 = lshiftbyte_m128(st7, 7); st9 = lshiftbyte_m128(st9, 1); st10 = lshiftbyte_m128(st10, 2); st11 = lshiftbyte_m128(st11, 3); st12 = lshiftbyte_m128(st12, 4); st13 = lshiftbyte_m128(st13, 5); st14 = lshiftbyte_m128(st14, 6); st15 = lshiftbyte_m128(st15, 7); *s = or128(*s, st0); *s = or128(*s, st1); *s = or128(*s, st2); *s = or128(*s, st3); *s = or128(*s, st4); *s = or128(*s, st5); *s = or128(*s, st6); *s = or128(*s, st7); *conf0 = movq(*s); *s = rshiftbyte_m128(*s, 8); *conf0 ^= ~0ULL; *s = or128(*s, st8); *s = or128(*s, st9); *s = or128(*s, st10); *s = or128(*s, st11); *s = or128(*s, st12); *s = or128(*s, st13); *s = or128(*s, st14); *s = or128(*s, st15); *conf8 = movq(*s); *s = rshiftbyte_m128(*s, 8); *conf8 ^= ~0ULL; } static really_inline void get_conf_stride_2(const u8 *itPtr, const u8 *start_ptr, const u8 *end_ptr, u64a domain_mask_adjusted, const u8 *ft, u64a *conf0, u64a *conf8, m128 *s) { u64a current_data_0; u64a current_data_8; current_data_0 = lv_u64a(itPtr + 0, start_ptr, end_ptr); u64a v0 = (current_data_0 << 1) & domain_mask_adjusted; u64a v2 = (current_data_0 >> 15) & domain_mask_adjusted; u64a v4 = (current_data_0 >> 31) & domain_mask_adjusted; u64a v6 = (current_data_0 >> 47) & domain_mask_adjusted; current_data_8 = lv_u64a(itPtr + 8, start_ptr, end_ptr); u64a v8 = (current_data_8 << 1) & domain_mask_adjusted; u64a v10 = (current_data_8 >> 15) & domain_mask_adjusted; u64a v12 = (current_data_8 >> 31) & domain_mask_adjusted; u64a v14 = (current_data_8 >> 47) & domain_mask_adjusted; m128 st0 = *(const m128 *)(ft + v0*8); m128 st2 = *(const m128 *)(ft + v2*8); m128 st4 = *(const m128 *)(ft + v4*8); m128 st6 = *(const m128 *)(ft + v6*8); m128 st8 = *(const m128 *)(ft + v8*8); m128 st10 = *(const m128 *)(ft + v10*8); m128 st12 = *(const m128 *)(ft + v12*8); m128 st14 = *(const m128 *)(ft + v14*8); st2 = lshiftbyte_m128(st2, 2); st4 = lshiftbyte_m128(st4, 4); st6 = lshiftbyte_m128(st6, 6); st10 = lshiftbyte_m128(st10, 2); st12 = lshiftbyte_m128(st12, 4); st14 = lshiftbyte_m128(st14, 6); *s = or128(*s, st0); *s = or128(*s, st2); *s = or128(*s, st4); *s = or128(*s, st6); *conf0 = movq(*s); *s = rshiftbyte_m128(*s, 8); *conf0 ^= ~0ULL; *s = or128(*s, st8); *s = or128(*s, st10); *s = or128(*s, st12); *s = or128(*s, st14); *conf8 = movq(*s); *s = rshiftbyte_m128(*s, 8); *conf8 ^= ~0ULL; } static really_inline void get_conf_stride_4(const u8 *itPtr, const u8 *start_ptr, const u8 *end_ptr, u64a domain_mask_adjusted, const u8 *ft, u64a *conf0, u64a *conf8, m128 *s) { u64a current_data_0; u64a current_data_8; current_data_0 = lv_u64a(itPtr + 0, start_ptr, end_ptr); u64a v0 = (current_data_0 << 1) & domain_mask_adjusted; u64a v4 = (current_data_0 >> 31) & domain_mask_adjusted; current_data_8 = lv_u64a(itPtr + 8, start_ptr, end_ptr); u64a v8 = (current_data_8 << 1) & domain_mask_adjusted; u64a v12 = (current_data_8 >> 31) & domain_mask_adjusted; m128 st0 = *(const m128 *)(ft + v0*8); m128 st4 = *(const m128 *)(ft + v4*8); m128 st8 = *(const m128 *)(ft + v8*8); m128 st12 = *(const m128 *)(ft + v12*8); st4 = lshiftbyte_m128(st4, 4); st12 = lshiftbyte_m128(st12, 4); *s = or128(*s, st0); *s = or128(*s, st4); *conf0 = movq(*s); *s = rshiftbyte_m128(*s, 8); *conf0 ^= ~0ULL; *s = or128(*s, st8); *s = or128(*s, st12); *conf8 = movq(*s); *s = rshiftbyte_m128(*s, 8); *conf8 ^= ~0ULL; } static really_inline void do_confirm_fdr(u64a *conf, u8 offset, hwlmcb_rv_t *control, const u32 *confBase, const struct FDR_Runtime_Args *a, const u8 *ptr, u32 *last_match_id, struct zone *z) { const u8 bucket = 8; const u8 pullback = 1; if (likely(!*conf)) { return; } /* ptr is currently referring to a location in the zone's buffer, we also * need a pointer in the original, main buffer for the final string compare. */ const u8 *ptr_main = (const u8 *)((uintptr_t)ptr + z->zone_pointer_adjust); const u8 *confLoc = ptr; do { u32 bit = findAndClearLSB_64(conf); u32 byte = bit / bucket + offset; u32 bitRem = bit % bucket; u32 confSplit = *(ptr + byte); u32 idx = confSplit * bucket + bitRem; u32 cf = confBase[idx]; if (!cf) { continue; } const struct FDRConfirm *fdrc = (const struct FDRConfirm *) ((const u8 *)confBase + cf); if (!(fdrc->groups & *control)) { continue; } if (!fdrc->mult) { u32 id = fdrc->nBitsOrSoleID; if ((*last_match_id == id) && (fdrc->flags & NoRepeat)) { continue; } *last_match_id = id; *control = a->cb(ptr_main + byte - a->buf, ptr_main + byte - a->buf, id, a->ctxt); continue; } u64a confVal = unaligned_load_u64a(confLoc + byte - sizeof(u64a)); confWithBit(fdrc, a, ptr_main - a->buf + byte, pullback, control, last_match_id, confVal); } while (unlikely(!!*conf)); } static really_inline void dumpZoneInfo(UNUSED struct zone *z, UNUSED size_t zone_id) { #ifdef DEBUG DEBUG_PRINTF("zone: zone=%zu, bufPtr=%p\n", zone_id, z->buf); DEBUG_PRINTF("zone: startPtr=%p, endPtr=%p, shift=%u\n", z->start, z->end, z->shift); DEBUG_PRINTF("zone: zone_pointer_adjust=%zd, floodPtr=%p\n", z->zone_pointer_adjust, z->floodPtr); DEBUG_PRINTF("zone buf:"); for (size_t i = 0; i < ZONE_TOTAL_SIZE; i++) { if (i % 8 == 0) { printf("_"); } if (z->buf[i]) { printf("%02x", z->buf[i]); } else { printf(".."); } } printf("\n"); #endif }; /** * \brief Updates attributes for non-boundary region zone. */ static really_inline void createMainZone(const u8 *flood, const u8 *begin, const u8 *end, struct zone *z) { z->zone_pointer_adjust = 0; /* zone buffer is the main buffer */ z->start = begin; z->end = end; z->floodPtr = flood; z->shift = 0; } /** * \brief Create zone for short cases (<= ITER_BYTES). * * For this case we need to copy everything into the zone's internal buffer. * * We need to ensure that we run over real data if it exists (in history or * before zone begin). We also need to ensure 8 bytes before any data being * matched can be read (to perform a conf hash). * * We also need to ensure that the data at z->end can be read. * * Hence, the zone consists of: * 16 bytes of history, * 1 - 24 bytes of data form the buffer (ending at end), * 1 byte of final padding */ static really_inline void createShortZone(const u8 *buf, const u8 *hend, const u8 *begin, const u8 *end, struct zone *z) { /* the floodPtr for BOUNDARY zones are maximum of end of zone buf to avoid * the checks in boundary zone. */ z->floodPtr = z->buf + ZONE_TOTAL_SIZE; ptrdiff_t z_len = end - begin; assert(z_len > 0); assert(z_len <= ITER_BYTES); z->shift = ITER_BYTES - z_len; /* ignore bytes outside region specified */ static const size_t ZONE_SHORT_DATA_OFFSET = 16; /* after history */ /* we are guaranteed to always have 16 initialised bytes at the end of * the history buffer (they may be garbage coming from the stream state * preceding hbuf, but bytes that don't correspond to actual history * shouldn't affect computations). */ *(m128 *)z->buf = loadu128(hend - sizeof(m128)); /* The amount of data we have to copy from main buffer. */ size_t copy_len = MIN((size_t)(end - buf), ITER_BYTES + sizeof(CONF_TYPE)); u8 *zone_data = z->buf + ZONE_SHORT_DATA_OFFSET; switch (copy_len) { case 1: *zone_data = *(end - 1); break; case 2: *(u16 *)zone_data = unaligned_load_u16(end - 2); break; case 3: *(u16 *)zone_data = unaligned_load_u16(end - 3); *(zone_data + 2) = *(end - 1); break; case 4: *(u32 *)zone_data = unaligned_load_u32(end - 4); break; case 5: case 6: case 7: /* perform copy with 2 overlapping 4-byte chunks from buf. */ *(u32 *)zone_data = unaligned_load_u32(end - copy_len); unaligned_store_u32(zone_data + copy_len - sizeof(u32), unaligned_load_u32(end - sizeof(u32))); break; case 8: *(u64a *)zone_data = unaligned_load_u64a(end - 8); break; case 9: case 10: case 11: case 12: case 13: case 14: case 15: /* perform copy with 2 overlapping 8-byte chunks from buf. */ *(u64a *)zone_data = unaligned_load_u64a(end - copy_len); unaligned_store_u64a(zone_data + copy_len - sizeof(u64a), unaligned_load_u64a(end - sizeof(u64a))); break; case 16: /* copy 16-bytes from buf. */ *(m128 *)zone_data = loadu128(end - 16); break; default: assert(copy_len <= sizeof(m128) + sizeof(u64a)); /* perform copy with (potentially overlapping) 8-byte and 16-byte chunks. */ *(u64a *)zone_data = unaligned_load_u64a(end - copy_len); storeu128(zone_data + copy_len - sizeof(m128), loadu128(end - sizeof(m128))); break; } /* set the start and end location of the zone buf * to be scanned */ u8 *z_end = z->buf + ZONE_SHORT_DATA_OFFSET + copy_len; assert(ZONE_SHORT_DATA_OFFSET + copy_len >= ITER_BYTES); /* copy the post-padding byte; this is required for domain > 8 due to * overhang */ *z_end = 0; z->end = z_end; z->start = z_end - ITER_BYTES; z->zone_pointer_adjust = (ptrdiff_t)((uintptr_t)end - (uintptr_t)z_end); assert(z->start + z->shift == z_end - z_len); } /** * \brief Create a zone for the start region. * * This function requires that there is > ITER_BYTES of data in the buffer to * scan. The start zone itself is always responsible for scanning exactly * ITER_BYTES of data - there are no warmup/junk bytes scanned. * * This zone ensures that the byte at z->end can be read and corresponds to * the next byte of data. * * 8 bytes of history data are provided before z->start to allow proper hash * generation in streaming mode. If buf != begin, upto 8 bytes of data * prior to begin is also provided. * * Although we are not interested in bare literals which start before begin * if buf != begin, lookarounds associated with the literal may require * the data prior to begin for hash purposes. */ static really_inline void createStartZone(const u8 *buf, const u8 *hend, const u8 *begin, struct zone *z) { assert(ITER_BYTES == sizeof(m128)); assert(sizeof(CONF_TYPE) == 8); static const size_t ZONE_START_BEGIN = sizeof(CONF_TYPE); const u8 *end = begin + ITER_BYTES; /* set floodPtr to the end of zone buf to avoid checks in start zone */ z->floodPtr = z->buf + ZONE_TOTAL_SIZE; z->shift = 0; /* we are processing ITER_BYTES of real data */ /* we are guaranteed to always have 16 initialised bytes at the end of the * history buffer (they may be garbage coming from the stream state * preceding hbuf, but bytes that don't correspond to actual history * shouldn't affect computations). However, for start zones, history is only * required for conf hash purposes so we only need 8 bytes */ unaligned_store_u64a(z->buf, unaligned_load_u64a(hend - sizeof(u64a))); /* The amount of data we have to copy from main buffer. */ size_t copy_len = MIN((size_t)(end - buf), ITER_BYTES + sizeof(CONF_TYPE)); assert(copy_len >= 16); /* copy the post-padding byte; this is required for domain > 8 due to * overhang. The start requires that there is data after the zone so it * it safe to dereference end */ z->buf[ZONE_START_BEGIN + copy_len] = *end; /* set the start and end location of the zone buf to be scanned */ u8 *z_end = z->buf + ZONE_START_BEGIN + copy_len; z->end = z_end; z->start = z_end - ITER_BYTES; /* copy the first 8 bytes of the valid region */ unaligned_store_u64a(z->buf + ZONE_START_BEGIN, unaligned_load_u64a(end - copy_len)); /* copy the last 16 bytes, may overlap with the previous 8 byte write */ storeu128(z_end - sizeof(m128), loadu128(end - sizeof(m128))); z->zone_pointer_adjust = (ptrdiff_t)((uintptr_t)end - (uintptr_t)z_end); } /** * \brief Create a zone for the end region. * * This function requires that there is > ITER_BYTES of data in the buffer to * scan. The end zone, however, is only responsible for a scanning the <= * ITER_BYTES rump of data. The end zone is required to handle a full ITER_BYTES * iteration as the main loop cannot handle the last byte of the buffer. * * This zone ensures that the byte at z->end can be read by filling it with a * padding character. * * Upto 8 bytes of data prior to begin is also provided for the purposes of * generating hashes. History is not copied, as all locations which require * history for generating a hash are the responsiblity of the start zone. */ static really_inline void createEndZone(const u8 *buf, const u8 *begin, const u8 *end, struct zone *z) { /* the floodPtr for BOUNDARY zones are maximum of end of zone buf to avoid * the checks in boundary zone. */ z->floodPtr = z->buf + ZONE_TOTAL_SIZE; ptrdiff_t z_len = end - begin; assert(z_len > 0); assert(z_len <= ITER_BYTES); z->shift = ITER_BYTES - z_len; /* The amount of data we have to copy from main buffer. */ size_t copy_len = MIN((size_t)(end - buf), ITER_BYTES + sizeof(CONF_TYPE)); assert(copy_len >= 16); /* copy the post-padding byte; this is required for domain > 8 due to * overhang */ z->buf[copy_len] = 0; /* set the start and end location of the zone buf * to be scanned */ u8 *z_end = z->buf + copy_len; z->end = z_end; z->start = z_end - ITER_BYTES; assert(z->start + z->shift == z_end - z_len); /* copy the first 8 bytes of the valid region */ unaligned_store_u64a(z->buf, unaligned_load_u64a(end - copy_len)); /* copy the last 16 bytes, may overlap with the previous 8 byte write */ storeu128(z_end - sizeof(m128), loadu128(end - sizeof(m128))); z->zone_pointer_adjust = (ptrdiff_t)((uintptr_t)end - (uintptr_t)z_end); } /** * \brief Prepare zones. * * This function prepares zones with actual buffer and some padded bytes. * The actual ITER_BYTES bytes in zone is preceded by main buf and/or * history buf and succeeded by padded bytes possibly from main buf, * if available. */ static really_inline size_t prepareZones(const u8 *buf, size_t len, const u8 *hend, size_t start, const u8 *flood, struct zone *zoneArr) { const u8 *ptr = buf + start; size_t remaining = len - start; if (remaining <= ITER_BYTES) { /* enough bytes to make only one zone */ createShortZone(buf, hend, ptr, buf + len, &zoneArr[0]); return 1; } /* enough bytes to make more than one zone */ size_t numZone = 0; createStartZone(buf, hend, ptr, &zoneArr[numZone++]); ptr += ITER_BYTES; assert(ptr < buf + len); /* find maximum buffer location that the main zone can scan * - must be a multiple of ITER_BYTES, and * - cannot contain the last byte (due to overhang) */ const u8 *main_end = buf + start + ROUNDDOWN_N(len - start - 1, ITER_BYTES); assert(main_end >= ptr); /* create a zone if multiple of ITER_BYTES are found */ if (main_end != ptr) { createMainZone(flood, ptr, main_end, &zoneArr[numZone++]); ptr = main_end; } /* create a zone with rest of the data from the main buffer */ createEndZone(buf, ptr, buf + len, &zoneArr[numZone++]); return numZone; } #define INVALID_MATCH_ID (~0U) #define FDR_MAIN_LOOP(zz, s, get_conf_fn) \ do { \ const u8 *tryFloodDetect = zz->floodPtr; \ const u8 *start_ptr = zz->start; \ const u8 *end_ptr = zz->end; \ \ for (const u8 *itPtr = start_ptr; itPtr + ITER_BYTES <= end_ptr; \ itPtr += ITER_BYTES) { \ if (unlikely(itPtr > tryFloodDetect)) { \ tryFloodDetect = floodDetect(fdr, a, &itPtr, tryFloodDetect,\ &floodBackoff, &control, \ ITER_BYTES); \ if (unlikely(control == HWLM_TERMINATE_MATCHING)) { \ return HWLM_TERMINATED; \ } \ } \ __builtin_prefetch(itPtr + (ITER_BYTES*4)); \ u64a conf0; \ u64a conf8; \ get_conf_fn(itPtr, start_ptr, end_ptr, domain_mask_adjusted, \ ft, &conf0, &conf8, &s); \ do_confirm_fdr(&conf0, 0, &control, confBase, a, itPtr, \ &last_match_id, zz); \ do_confirm_fdr(&conf8, 8, &control, confBase, a, itPtr, \ &last_match_id, zz); \ if (unlikely(control == HWLM_TERMINATE_MATCHING)) { \ return HWLM_TERMINATED; \ } \ } /* end for loop */ \ } while (0) \ static never_inline hwlm_error_t fdr_engine_exec(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { u32 floodBackoff = FLOOD_BACKOFF_START; u32 last_match_id = INVALID_MATCH_ID; u64a domain_mask_adjusted = fdr->domainMask << 1; u8 stride = fdr->stride; const u8 *ft = (const u8 *)fdr + ROUNDUP_16(sizeof(struct FDR)); const u32 *confBase = (const u32 *)(ft + fdr->tabSize); struct zone zones[ZONE_MAX]; assert(fdr->domain > 8 && fdr->domain < 16); size_t numZone = prepareZones(a->buf, a->len, a->buf_history + a->len_history, a->start_offset, a->firstFloodDetect, zones); assert(numZone <= ZONE_MAX); m128 state = getInitState(fdr, a->len_history, ft, &zones[0]); for (size_t curZone = 0; curZone < numZone; curZone++) { struct zone *z = &zones[curZone]; dumpZoneInfo(z, curZone); /* When a zone contains less data than is processed in an iteration * of FDR_MAIN_LOOP(), we need to scan over some extra data. * * We have chosen to scan this extra data at the start of the * iteration. The extra data is either data we have already scanned or * garbage (if it is earlier than offset 0), * * As a result we need to shift the incoming state back so that it will * properly line up with the data being scanned. * * We also need to forbid reporting any matches in the data being * rescanned as they have already been reported (or are over garbage but * later stages should also provide that safety guarantee). */ u8 shift = z->shift; state = variable_byte_shift_m128(state, shift); state = or128(state, load128(zone_or_mask[shift])); switch (stride) { case 1: FDR_MAIN_LOOP(z, state, get_conf_stride_1); break; case 2: FDR_MAIN_LOOP(z, state, get_conf_stride_2); break; case 4: FDR_MAIN_LOOP(z, state, get_conf_stride_4); break; default: break; } } return HWLM_SUCCESS; } #if defined(__AVX2__) #define ONLY_AVX2(func) func #else #define ONLY_AVX2(func) NULL #endif typedef hwlm_error_t (*FDRFUNCTYPE)(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); static const FDRFUNCTYPE funcs[] = { fdr_engine_exec, ONLY_AVX2(fdr_exec_teddy_avx2_msks1_fast), ONLY_AVX2(fdr_exec_teddy_avx2_msks1_pck_fast), ONLY_AVX2(fdr_exec_teddy_avx2_msks1_fat), ONLY_AVX2(fdr_exec_teddy_avx2_msks1_pck_fat), ONLY_AVX2(fdr_exec_teddy_avx2_msks2_fat), ONLY_AVX2(fdr_exec_teddy_avx2_msks2_pck_fat), ONLY_AVX2(fdr_exec_teddy_avx2_msks3_fat), ONLY_AVX2(fdr_exec_teddy_avx2_msks3_pck_fat), ONLY_AVX2(fdr_exec_teddy_avx2_msks4_fat), ONLY_AVX2(fdr_exec_teddy_avx2_msks4_pck_fat), fdr_exec_teddy_msks1, fdr_exec_teddy_msks1_pck, fdr_exec_teddy_msks2, fdr_exec_teddy_msks2_pck, fdr_exec_teddy_msks3, fdr_exec_teddy_msks3_pck, fdr_exec_teddy_msks4, fdr_exec_teddy_msks4_pck, }; #define FAKE_HISTORY_SIZE 16 static const u8 fake_history[FAKE_HISTORY_SIZE]; hwlm_error_t fdrExec(const struct FDR *fdr, const u8 *buf, size_t len, size_t start, HWLMCallback cb, void *ctxt, hwlm_group_t groups) { // We guarantee (for safezone construction) that it is safe to read 16 // bytes before the end of the history buffer. const u8 *hbuf = fake_history + FAKE_HISTORY_SIZE; const struct FDR_Runtime_Args a = { buf, len, hbuf, 0, start, cb, ctxt, nextFloodDetect(buf, len, FLOOD_BACKOFF_START), 0 }; if (unlikely(a.start_offset >= a.len)) { return HWLM_SUCCESS; } else { assert(funcs[fdr->engineID]); return funcs[fdr->engineID](fdr, &a, groups); } } hwlm_error_t fdrExecStreaming(const struct FDR *fdr, const u8 *hbuf, size_t hlen, const u8 *buf, size_t len, size_t start, HWLMCallback cb, void *ctxt, hwlm_group_t groups) { struct FDR_Runtime_Args a = { buf, len, hbuf, hlen, start, cb, ctxt, nextFloodDetect(buf, len, FLOOD_BACKOFF_START), /* we are guaranteed to always have 16 initialised bytes at the end of * the history buffer (they may be garbage). */ hbuf ? unaligned_load_u64a(hbuf + hlen - sizeof(u64a)) : (u64a)0 }; hwlm_error_t ret; if (unlikely(a.start_offset >= a.len)) { ret = HWLM_SUCCESS; } else { assert(funcs[fdr->engineID]); ret = funcs[fdr->engineID](fdr, &a, groups); } return ret; } hyperscan-4.4.1/src/fdr/teddy.c0000644000175000017500000007267213055426554017134 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Teddy literal matcher: SSSE3 engine runtime. */ #include "fdr_internal.h" #include "flood_runtime.h" #include "teddy.h" #include "teddy_internal.h" #include "teddy_runtime_common.h" #include "util/simd_utils.h" const u8 ALIGN_DIRECTIVE p_mask_arr[17][32] = { {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0x00}, {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff} }; #ifdef ARCH_64_BIT #define CONFIRM_TEDDY(var, bucket, offset, reason, conf_fn) \ do { \ if (unlikely(isnonzero128(var))) { \ u64a lo = movq(var); \ u64a hi = movq(rshiftbyte_m128(var, 8)); \ if (unlikely(lo)) { \ conf_fn(&lo, bucket, offset, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(hi)) { \ conf_fn(&hi, bucket, offset + 8, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ } \ } while (0); #else #define CONFIRM_TEDDY(var, bucket, offset, reason, conf_fn) \ do { \ if (unlikely(isnonzero128(var))) { \ u32 part1 = movd(var); \ u32 part2 = movd(rshiftbyte_m128(var, 4)); \ u32 part3 = movd(rshiftbyte_m128(var, 8)); \ u32 part4 = movd(rshiftbyte_m128(var, 12)); \ if (unlikely(part1)) { \ conf_fn(&part1, bucket, offset, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part2)) { \ conf_fn(&part2, bucket, offset + 4, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part3)) { \ conf_fn(&part3, bucket, offset + 8, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ if (unlikely(part4)) { \ conf_fn(&part4, bucket, offset + 12, confBase, reason, a, ptr, \ &control, &last_match); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ } \ } while (0); #endif static really_inline m128 prep_conf_teddy_m1(const m128 *maskBase, m128 val) { m128 mask = set16x8(0xf); m128 lo = and128(val, mask); m128 hi = and128(rshift64_m128(val, 4), mask); return and128(pshufb(maskBase[0*2], lo), pshufb(maskBase[0*2+1], hi)); } static really_inline m128 prep_conf_teddy_m2(const m128 *maskBase, m128 *old_1, m128 val) { m128 mask = set16x8(0xf); m128 lo = and128(val, mask); m128 hi = and128(rshift64_m128(val, 4), mask); m128 r = prep_conf_teddy_m1(maskBase, val); m128 res_1 = and128(pshufb(maskBase[1*2], lo), pshufb(maskBase[1*2+1], hi)); m128 res_shifted_1 = palignr(res_1, *old_1, 16-1); *old_1 = res_1; return and128(r, res_shifted_1); } static really_inline m128 prep_conf_teddy_m3(const m128 *maskBase, m128 *old_1, m128 *old_2, m128 val) { m128 mask = set16x8(0xf); m128 lo = and128(val, mask); m128 hi = and128(rshift64_m128(val, 4), mask); m128 r = prep_conf_teddy_m2(maskBase, old_1, val); m128 res_2 = and128(pshufb(maskBase[2*2], lo), pshufb(maskBase[2*2+1], hi)); m128 res_shifted_2 = palignr(res_2, *old_2, 16-2); *old_2 = res_2; return and128(r, res_shifted_2); } static really_inline m128 prep_conf_teddy_m4(const m128 *maskBase, m128 *old_1, m128 *old_2, m128 *old_3, m128 val) { m128 mask = set16x8(0xf); m128 lo = and128(val, mask); m128 hi = and128(rshift64_m128(val, 4), mask); m128 r = prep_conf_teddy_m3(maskBase, old_1, old_2, val); m128 res_3 = and128(pshufb(maskBase[3*2], lo), pshufb(maskBase[3*2+1], hi)); m128 res_shifted_3 = palignr(res_3, *old_3, 16-3); *old_3 = res_3; return and128(r, res_shifted_3); } hwlm_error_t fdr_exec_teddy_msks1(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 1); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 1); m128 r_0 = prep_conf_teddy_m1(maskBase, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit1_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m128 r_0 = prep_conf_teddy_m1(maskBase, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit1_teddy); ptr += 16; } for (; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m128 r_0 = prep_conf_teddy_m1(maskBase, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit1_teddy); m128 r_1 = prep_conf_teddy_m1(maskBase, load128(ptr + 16)); CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit1_teddy); } for (; ptr < buf_end; ptr += 16) { m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 1); m128 r_0 = prep_conf_teddy_m1(maskBase, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit1_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_msks1_pck(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 1); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 1); m128 r_0 = prep_conf_teddy_m1(maskBase, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m128 r_0 = prep_conf_teddy_m1(maskBase, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } for (; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m128 r_0 = prep_conf_teddy_m1(maskBase, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit_teddy); m128 r_1 = prep_conf_teddy_m1(maskBase, load128(ptr + 16)); CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit_teddy); } for (; ptr < buf_end; ptr += 16) { m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 1); m128 r_0 = prep_conf_teddy_m1(maskBase, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_msks2(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 2); m128 res_old_1 = ones128(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 2); m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } for (; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy); m128 r_1 = prep_conf_teddy_m2(maskBase, &res_old_1, load128(ptr + 16)); CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy); } for (; ptr < buf_end; ptr += 16) { m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 2); m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_msks2_pck(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 2); m128 res_old_1 = ones128(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 2); m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } for (; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit_teddy); m128 r_1 = prep_conf_teddy_m2(maskBase, &res_old_1, load128(ptr + 16)); CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit_teddy); } for (; ptr < buf_end; ptr += 16) { m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 2); m128 r_0 = prep_conf_teddy_m2(maskBase, &res_old_1, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_msks3(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 3); m128 res_old_1 = ones128(); m128 res_old_2 = ones128(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 3); m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } for (; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy); m128 r_1 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, load128(ptr + 16)); CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy); } for (; ptr < buf_end; ptr += 16) { m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 3); m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_msks3_pck(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 3); m128 res_old_1 = ones128(); m128 res_old_2 = ones128(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 3); m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } for (; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit_teddy); m128 r_1 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, load128(ptr + 16)); CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit_teddy); } for (; ptr < buf_end; ptr += 16) { m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 3); m128 r_0 = prep_conf_teddy_m3(maskBase, &res_old_1, &res_old_2, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_msks4(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 4); m128 res_old_1 = ones128(); m128 res_old_2 = ones128(); m128 res_old_3 = ones128(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 4); m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); ptr += 16; } for (; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBitMany_teddy); m128 r_1 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load128(ptr + 16)); CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBitMany_teddy); } for (; ptr < buf_end; ptr += 16) { m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 4); m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBitMany_teddy); } return HWLM_SUCCESS; } hwlm_error_t fdr_exec_teddy_msks4_pck(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control) { const u8 *buf_end = a->buf + a->len; const u8 *ptr = a->buf + a->start_offset; u32 floodBackoff = FLOOD_BACKOFF_START; const u8 *tryFloodDetect = a->firstFloodDetect; u32 last_match = (u32)-1; const struct Teddy *teddy = (const struct Teddy *)fdr; const size_t iterBytes = 32; DEBUG_PRINTF("params: buf %p len %zu start_offset %zu\n", a->buf, a->len, a->start_offset); const m128 *maskBase = getMaskBase(teddy); const u32 *confBase = getConfBase(teddy, 4); m128 res_old_1 = ones128(); m128 res_old_2 = ones128(); m128 res_old_3 = ones128(); const u8 *mainStart = ROUNDUP_PTR(ptr, 16); DEBUG_PRINTF("derive: ptr: %p mainstart %p\n", ptr, mainStart); if (ptr < mainStart) { ptr = mainStart - 16; m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 4); m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } if (ptr + 16 < buf_end) { m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); ptr += 16; } for (; ptr + iterBytes <= buf_end; ptr += iterBytes) { __builtin_prefetch(ptr + (iterBytes*4)); CHECK_FLOOD; m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load128(ptr)); CONFIRM_TEDDY(r_0, 8, 0, NOT_CAUTIOUS, do_confWithBit_teddy); m128 r_1 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, load128(ptr + 16)); CONFIRM_TEDDY(r_1, 8, 16, NOT_CAUTIOUS, do_confWithBit_teddy); } for (; ptr < buf_end; ptr += 16) { m128 p_mask; m128 val_0 = vectoredLoad128(&p_mask, ptr, a->buf, buf_end, a->buf_history, a->len_history, 4); m128 r_0 = prep_conf_teddy_m4(maskBase, &res_old_1, &res_old_2, &res_old_3, val_0); r_0 = and128(r_0, p_mask); CONFIRM_TEDDY(r_0, 8, 0, VECTORING, do_confWithBit_teddy); } return HWLM_SUCCESS; } hyperscan-4.4.1/src/fdr/fdr.h0000644000175000017500000000605013055426554016566 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief FDR literal matcher: runtime API. */ #ifndef FDR_H #define FDR_H #include "ue2common.h" #include "hwlm/hwlm.h" // C linkage in the API #ifdef __cplusplus extern "C" { #endif struct FDR; /** * \brief Block-mode scan. * * \param fdr FDR matcher engine. * \param buf Buffer to scan. * \param len Length of buffer to scan. * \param start First offset in buf at which a match may end. * \param cb Callback to call when a match is found. * \param ctxt Caller-provided context pointer supplied to callback on match. * \param groups Initial groups mask. */ hwlm_error_t fdrExec(const struct FDR *fdr, const u8 *buf, size_t len, size_t start, HWLMCallback cb, void *ctxt, hwlm_group_t groups); /** * \brief Streaming-mode scan. * * \param fdr FDR matcher engine. * \param hbuf History buffer. * \param hlen Length of history buffer (hbuf). * \param buf Buffer to scan. * \param len Length of buffer to scan (buf). * \param start First offset in buf at which a match may end. * \param cb Callback to call when a match is found. * \param ctxt Caller-provided context pointer supplied to callback on match. * \param groups Initial groups mask. */ hwlm_error_t fdrExecStreaming(const struct FDR *fdr, const u8 *hbuf, size_t hlen, const u8 *buf, size_t len, size_t start, HWLMCallback cb, void *ctxt, hwlm_group_t groups); #ifdef __cplusplus } #endif // __cplusplus #endif // FDR_H hyperscan-4.4.1/src/fdr/teddy_compile.cpp0000644000175000017500000003513013055426554021170 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "fdr.h" #include "fdr_internal.h" #include "fdr_compile_internal.h" #include "fdr_confirm.h" #include "fdr_engine_description.h" #include "ue2common.h" #include "util/alloc.h" #include "util/compare.h" #include "util/popcount.h" #include "util/target_info.h" #include "util/verify_types.h" #include "teddy_compile.h" #include "teddy_internal.h" #include "teddy_engine_description.h" #include #include #include #include #include #include #include #include #include #include #include #include using namespace std; namespace ue2 { namespace { //#define TEDDY_DEBUG class TeddyCompiler : boost::noncopyable { const TeddyEngineDescription ŋ const vector &lits; bool make_small; public: TeddyCompiler(const vector &lits_in, const TeddyEngineDescription &eng_in, bool make_small_in) : eng(eng_in), lits(lits_in), make_small(make_small_in) {} aligned_unique_ptr build(pair, size_t> &link); bool pack(map > &bucketToLits); }; class TeddySet { u32 len; // nibbleSets is a series of bitfields over 16 predicates // that represent the whether shufti nibble set // so for num_masks = 4 we will represent our strings by // 8 u16s in the vector that indicate what a shufti bucket // would have to look like vector nibbleSets; set litIds; public: explicit TeddySet(u32 len_in) : len(len_in), nibbleSets(len_in * 2, 0) {} const set & getLits() const { return litIds; } size_t litCount() const { return litIds.size(); } bool operator<(const TeddySet & s) const { return litIds < s.litIds; } #ifdef TEDDY_DEBUG void dump() const { printf("TS: "); for (u32 i = 0; i < nibbleSets.size(); i++) { printf("%04x ", (u32)nibbleSets[i]); } printf("\nnlits: %zu\nLit ids: ", litCount()); printf("Prob: %llu\n", probability()); for (const auto &id : litIds) { printf("%u ", id); } printf("\n"); printf("Flood prone : %s\n", isRunProne()?"yes":"no"); } #endif bool identicalTail(const TeddySet & ts) const { return nibbleSets == ts.nibbleSets; } void addLiteral(u32 lit_id, const hwlmLiteral &lit) { const string &s = lit.s; for (u32 i = 0; i < len; i++) { if (i < s.size()) { u8 c = s[s.size() - i - 1]; u8 c_hi = (c >> 4) & 0xf; u8 c_lo = c & 0xf; nibbleSets[i*2] = 1 << c_lo; if (lit.nocase && ourisalpha(c)) { nibbleSets[i*2+1] = (1 << (c_hi&0xd)) | (1 << (c_hi|0x2)); } else { nibbleSets[i*2+1] = 1 << c_hi; } } else { nibbleSets[i*2] = nibbleSets[i*2+1] = 0xffff; } } litIds.insert(lit_id); } void merge(const TeddySet &ts) { for (u32 i = 0; i < nibbleSets.size(); i++) { nibbleSets[i] |= ts.nibbleSets[i]; } litIds.insert(ts.litIds.begin(), ts.litIds.end()); } // return a value p from 0 .. MAXINT64 that gives p/MAXINT64 // likelihood of this TeddySet firing a first-stage accept // if it was given a bucket of its own and random data were // to be passed in u64a probability() const { u64a val = 1; for (size_t i = 0; i < nibbleSets.size(); i++) { val *= popcount32((u32)nibbleSets[i]); } return val; } // return a score based around the chance of this hitting times // a small fixed cost + the cost of traversing some sort of followup // (assumption is that the followup is linear) u64a heuristic() const { return probability() * (2+litCount()); } bool isRunProne() const { u16 lo_and = 0xffff; u16 hi_and = 0xffff; for (u32 i = 0; i < len; i++) { lo_and &= nibbleSets[i*2]; hi_and &= nibbleSets[i*2+1]; } // we're not flood-prone if there's no way to get // through with a flood if (!lo_and || !hi_and) { return false; } return true; } }; bool TeddyCompiler::pack(map > &bucketToLits) { set sts; for (u32 i = 0; i < lits.size(); i++) { TeddySet ts(eng.numMasks); ts.addLiteral(i, lits[i]); sts.insert(ts); } while (1) { #ifdef TEDDY_DEBUG printf("Size %zu\n", sts.size()); for (const TeddySet &ts : sts) { printf("\n"); ts.dump(); } printf("\n===============================================\n"); #endif auto m1 = sts.end(), m2 = sts.end(); u64a best = 0xffffffffffffffffULL; for (auto i1 = sts.begin(), e1 = sts.end(); i1 != e1; ++i1) { const TeddySet &s1 = *i1; for (auto i2 = next(i1), e2 = sts.end(); i2 != e2; ++i2) { const TeddySet &s2 = *i2; // be more conservative if we don't absolutely need to // keep packing if ((sts.size() <= eng.getNumBuckets()) && !s1.identicalTail(s2)) { continue; } TeddySet tmpSet(eng.numMasks); tmpSet.merge(s1); tmpSet.merge(s2); u64a newScore = tmpSet.heuristic(); u64a oldScore = s1.heuristic() + s2.heuristic(); if (newScore < oldScore) { m1 = i1; m2 = i2; break; } else { u64a score = newScore - oldScore; bool oldRunProne = s1.isRunProne() && s2.isRunProne(); bool newRunProne = tmpSet.isRunProne(); if (newRunProne && !oldRunProne) { continue; } if (score < best) { best = score; m1 = i1; m2 = i2; } } } } // if we didn't find a merge candidate, bail out if ((m1 == sts.end()) || (m2 == sts.end())) { break; } // do the merge TeddySet nts(eng.numMasks); nts.merge(*m1); nts.merge(*m2); #ifdef TEDDY_DEBUG printf("Merging\n"); printf("m1 = \n"); m1->dump(); printf("m2 = \n"); m2->dump(); printf("nts = \n"); nts.dump(); printf("\n===============================================\n"); #endif sts.erase(m1); sts.erase(m2); sts.insert(nts); } if (sts.size() > eng.getNumBuckets()) { return false; } u32 bucket_id = 0; for (const TeddySet &ts : sts) { const auto &ts_lits = ts.getLits(); auto &bucket_lits = bucketToLits[bucket_id]; bucket_lits.insert(end(bucket_lits), begin(ts_lits), end(ts_lits)); bucket_id++; } return true; } aligned_unique_ptr TeddyCompiler::build(pair, size_t> &link) { if (lits.size() > eng.getNumBuckets() * TEDDY_BUCKET_LOAD) { DEBUG_PRINTF("too many literals: %zu\n", lits.size()); return nullptr; } #ifdef TEDDY_DEBUG for (size_t i = 0; i < lits.size(); i++) { printf("lit %zu (len = %zu, %s) is ", i, lits[i].s.size(), lits[i].nocase ? "caseless" : "caseful"); for (size_t j = 0; j < lits[i].s.size(); j++) { printf("%02x", ((u32)lits[i].s[j])&0xff); } printf("\n"); } #endif map > bucketToLits; if(eng.needConfirm(lits)) { if (!pack(bucketToLits)) { DEBUG_PRINTF("more lits (%zu) than buckets (%u), can't pack.\n", lits.size(), eng.getNumBuckets()); return nullptr; } } else { for (u32 i = 0; i < lits.size(); i++) { bucketToLits[i].push_back(i); } } u32 maskWidth = eng.getNumBuckets() / 8; size_t maskLen = eng.numMasks * 16 * 2 * maskWidth; auto floodControlTmp = setupFDRFloodControl(lits, eng); auto confirmTmp = setupFullMultiConfs(lits, eng, bucketToLits, make_small); size_t size = ROUNDUP_N(sizeof(Teddy) + maskLen + confirmTmp.second + floodControlTmp.second + link.second, 16 * maskWidth); aligned_unique_ptr fdr = aligned_zmalloc_unique(size); assert(fdr); // otherwise would have thrown std::bad_alloc Teddy *teddy = (Teddy *)fdr.get(); // ugly u8 *teddy_base = (u8 *)teddy; teddy->size = size; teddy->engineID = eng.getID(); teddy->maxStringLen = verify_u32(maxLen(lits)); u8 *ptr = teddy_base + sizeof(Teddy) + maskLen; memcpy(ptr, confirmTmp.first.get(), confirmTmp.second); ptr += confirmTmp.second; teddy->floodOffset = verify_u32(ptr - teddy_base); memcpy(ptr, floodControlTmp.first.get(), floodControlTmp.second); ptr += floodControlTmp.second; if (link.first) { teddy->link = verify_u32(ptr - teddy_base); memcpy(ptr, link.first.get(), link.second); } else { teddy->link = 0; } u8 *baseMsk = teddy_base + sizeof(Teddy); for (const auto &b2l : bucketToLits) { const u32 &bucket_id = b2l.first; const vector &ids = b2l.second; const u8 bmsk = 1U << (bucket_id % 8); for (const LiteralIndex &lit_id : ids) { const hwlmLiteral &l = lits[lit_id]; DEBUG_PRINTF("putting lit %u into bucket %u\n", lit_id, bucket_id); const u32 sz = verify_u32(l.s.size()); // fill in masks for (u32 j = 0; j < eng.numMasks; j++) { u32 msk_id_lo = j * 2 * maskWidth + (bucket_id / 8); u32 msk_id_hi = (j * 2 + 1) * maskWidth + (bucket_id / 8); // if we don't have a char at this position, fill in i // locations in these masks with '1' if (j >= sz) { for (u32 n = 0; n < 16; n++) { baseMsk[msk_id_lo * 16 + n] |= bmsk; baseMsk[msk_id_hi * 16 + n] |= bmsk; } } else { u8 c = l.s[sz - 1 - j]; // if we do have a char at this position const u32 hiShift = 4; u32 n_hi = (c >> hiShift) & 0xf; u32 n_lo = c & 0xf; if (j < l.msk.size() && l.msk[l.msk.size() - 1 - j]) { u8 m = l.msk[l.msk.size() - 1 - j]; u8 m_hi = (m >> hiShift) & 0xf; u8 m_lo = m & 0xf; u8 cmp = l.cmp[l.msk.size() - 1 - j]; u8 cmp_lo = cmp & 0xf; u8 cmp_hi = (cmp >> hiShift) & 0xf; for (u8 cm = 0; cm < 0x10; cm++) { if ((cm & m_lo) == (cmp_lo & m_lo)) { baseMsk[msk_id_lo * 16 + cm] |= bmsk; } if ((cm & m_hi) == (cmp_hi & m_hi)) { baseMsk[msk_id_hi * 16 + cm] |= bmsk; } } } else{ if (l.nocase && ourisalpha(c)) { u32 cmHalfClear = (0xdf >> hiShift) & 0xf; u32 cmHalfSet = (0x20 >> hiShift) & 0xf; baseMsk[msk_id_hi * 16 + (n_hi & cmHalfClear)] |= bmsk; baseMsk[msk_id_hi * 16 + (n_hi | cmHalfSet )] |= bmsk; } else { baseMsk[msk_id_hi * 16 + n_hi] |= bmsk; } baseMsk[msk_id_lo * 16 + n_lo] |= bmsk; } } } } } #ifdef TEDDY_DEBUG for (u32 i = 0; i < eng.numMasks * 2; i++) { for (u32 j = 0; j < 16; j++) { u8 val = baseMsk[i * 16 + j]; for (u32 k = 0; k < 8; k++) { printf("%s", ((val >> k) & 0x1) ? "1" : "0"); } printf(" "); } printf("\n"); } #endif return fdr; } } // namespace aligned_unique_ptr teddyBuildTableHinted(const vector &lits, bool make_small, u32 hint, const target_t &target, pair, size_t> &link) { unique_ptr des; if (hint == HINT_INVALID) { des = chooseTeddyEngine(target, lits); } else { des = getTeddyDescription(hint); } if (!des) { return nullptr; } TeddyCompiler tc(lits, *des, make_small); return tc.build(link); } } // namespace ue2 hyperscan-4.4.1/src/fdr/teddy_compile.h0000644000175000017500000000411113055426554020630 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief FDR literal matcher: Teddy build API. */ #ifndef TEDDY_COMPILE_H #define TEDDY_COMPILE_H #include "ue2common.h" #include "util/alloc.h" #include #include // std::pair struct FDR; struct target_t; namespace ue2 { struct hwlmLiteral; ue2::aligned_unique_ptr teddyBuildTableHinted(const std::vector &lits, bool make_small, u32 hint, const target_t &target, std::pair, size_t> &link); } // namespace ue2 #endif // TEDDY_COMPILE_H hyperscan-4.4.1/src/fdr/engine_description.cpp0000644000175000017500000000401513055426554022215 0ustar sleuthkidsleuthkid/* * 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. */ #include "engine_description.h" #include "hs_compile.h" // for hs_platform_info #include "util/target_info.h" namespace ue2 { EngineDescription::~EngineDescription() {} bool EngineDescription::isValidOnTarget(const target_t &target_in) const { return target_in.can_run_on_code_built_for(code_target); } target_t targetByArchFeatures(u64a cpu_features) { hs_platform_info p; p.tune = HS_TUNE_FAMILY_GENERIC; p.cpu_features = cpu_features; return target_t(p); } } // namespace ue2 hyperscan-4.4.1/src/fdr/teddy.h0000644000175000017500000001260313055426554017125 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Teddy literal matcher: function declarations. */ #ifndef TEDDY_H_ #define TEDDY_H_ #include "hwlm/hwlm.h" // for hwlm_group_t struct FDR; // forward declaration from fdr_internal.h struct FDR_Runtime_Args; hwlm_error_t fdr_exec_teddy_msks1(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_msks1_pck(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_msks2(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_msks2_pck(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_msks3(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_msks3_pck(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_msks4(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_msks4_pck(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); #if defined(__AVX2__) hwlm_error_t fdr_exec_teddy_avx2_msks1_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks1_pck_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks2_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks2_pck_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks3_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks3_pck_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks4_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks4_pck_fat(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks1_fast(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); hwlm_error_t fdr_exec_teddy_avx2_msks1_pck_fast(const struct FDR *fdr, const struct FDR_Runtime_Args *a, hwlm_group_t control); #endif /* __AVX2__ */ #endif /* TEDDY_H_ */ hyperscan-4.4.1/src/fdr/flood_runtime.h0000644000175000017500000003252213055426554020664 0ustar sleuthkidsleuthkid/* * 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 FLOOD_RUNTIME #define FLOOD_RUNTIME #if defined(ARCH_64_BIT) #define FLOOD_64 #else #define FLOOD_32 #endif #define FLOOD_MINIMUM_SIZE 256 #define FLOOD_BACKOFF_START 32 static really_inline const u8 * nextFloodDetect(const u8 * buf, size_t len, u32 floodBackoff) { // if we don't have a flood at either the start or end, // or have a very small buffer, don't bother with flood detection if (len < FLOOD_MINIMUM_SIZE) { return buf + len; } /* entry points in runtime.c prefetch relevant data */ #ifndef FLOOD_32 u64a x11 = *(const u64a *)ROUNDUP_PTR(buf, 8); u64a x12 = *(const u64a *)ROUNDUP_PTR(buf+8, 8); if (x11 == x12) { return buf + floodBackoff; } u64a x21 = *(const u64a *)ROUNDUP_PTR(buf + len/2, 8); u64a x22 = *(const u64a *)ROUNDUP_PTR(buf + len/2 + 8, 8); if (x21 == x22) { return buf + floodBackoff; } u64a x31 = *(const u64a *)ROUNDUP_PTR(buf + len - 24, 8); u64a x32 = *(const u64a *)ROUNDUP_PTR(buf + len - 16, 8); if (x31 == x32) { return buf + floodBackoff; } #else u32 x11 = *(const u32 *)ROUNDUP_PTR(buf, 4); u32 x12 = *(const u32 *)ROUNDUP_PTR(buf+4, 4); if (x11 == x12) { return buf + floodBackoff; } u32 x21 = *(const u32 *)ROUNDUP_PTR(buf + len/2, 4); u32 x22 = *(const u32 *)ROUNDUP_PTR(buf + len/2 + 4, 4); if (x21 == x22) { return buf + floodBackoff; } u32 x31 = *(const u32 *)ROUNDUP_PTR(buf + len - 12, 4); u32 x32 = *(const u32 *)ROUNDUP_PTR(buf + len - 8, 4); if (x31 == x32) { return buf + floodBackoff; } #endif return buf + len; } static really_inline const u8 * floodDetect(const struct FDR * fdr, const struct FDR_Runtime_Args * a, const u8 ** ptrPtr, const u8 * tryFloodDetect, u32 * floodBackoffPtr, hwlmcb_rv_t * control, u32 iterBytes) { DEBUG_PRINTF("attempting flood detection at %p\n", tryFloodDetect); const u8 * buf = a->buf; const size_t len = a->len; HWLMCallback cb = a->cb; void * ctxt = a->ctxt; const u8 * ptr = *ptrPtr; // tryFloodDetect is never put in places where unconditional // reads a short distance forward or backward here // TODO: rationale for this line needs to be rediscovered!! size_t mainLoopLen = len > iterBytes ? len - iterBytes : 0; const u32 i = ptr - buf; u32 j = i; // go from c to our FDRFlood structure u8 c = buf[i]; const u8 * fBase = ((const u8 *)fdr) + fdr->floodOffset; u32 fIdx = ((const u32 *)fBase)[c]; const struct FDRFlood * fsb = (const struct FDRFlood *)(fBase + sizeof(u32) * 256); const struct FDRFlood * fl = &fsb[fIdx]; #ifndef FLOOD_32 u64a cmpVal = c; cmpVal |= cmpVal << 8; cmpVal |= cmpVal << 16; cmpVal |= cmpVal << 32; u64a probe = *(const u64a *)ROUNDUP_PTR(buf+i, 8); #else u32 cmpVal = c; cmpVal |= cmpVal << 8; cmpVal |= cmpVal << 16; u32 probe = *(const u32 *)ROUNDUP_PTR(buf+i, 4); #endif if ((probe != cmpVal) || (fl->idCount >= FDR_FLOOD_MAX_IDS)) { *floodBackoffPtr *= 2; goto floodout; } if (i < fl->suffix + 7) { *floodBackoffPtr *= 2; goto floodout; } j = i - fl->suffix; #ifndef FLOOD_32 j -= (u32)((uintptr_t)buf + j) & 0x7; // push j back to yield 8-aligned addrs for (; j + 32 < mainLoopLen; j += 32) { u64a v = *(const u64a *)(buf + j); u64a v2 = *(const u64a *)(buf + j + 8); u64a v3 = *(const u64a *)(buf + j + 16); u64a v4 = *(const u64a *)(buf + j + 24); if ((v4 != cmpVal) || (v3 != cmpVal) || (v2 != cmpVal) || (v != cmpVal)) { break; } } for (; j + 8 < mainLoopLen; j += 8) { u64a v = *(const u64a *)(buf + j); if (v != cmpVal) { break; } } #else j -= (u32)((size_t)buf + j) & 0x3; // push j back to yield 4-aligned addrs for (; j + 16 < mainLoopLen; j += 16) { u32 v = *(const u32 *)(buf + j); u32 v2 = *(const u32 *)(buf + j + 4); u32 v3 = *(const u32 *)(buf + j + 8); u32 v4 = *(const u32 *)(buf + j + 12); if ((v4 != cmpVal) || (v3 != cmpVal) || (v2 != cmpVal) || (v != cmpVal)) { break; } } for (; j + 4 < mainLoopLen; j += 4) { u32 v = *(const u32 *)(buf + j); if (v != cmpVal) { break; } } #endif for (; j < mainLoopLen; j++) { u8 v = *(const u8 *)(buf + j); if (v != c) { break; } } if (j > i ) { j--; // needed for some reaches u32 itersAhead = (j-i)/iterBytes; u32 floodSize = itersAhead*iterBytes; DEBUG_PRINTF("flooding %u size j %u i %u fl->idCount %hu " "*control %016llx fl->allGroups %016llx\n", floodSize, j, i, fl->idCount, *control, fl->allGroups); DEBUG_PRINTF("mainloopLen %zu mainStart ??? mainEnd ??? len %zu\n", mainLoopLen, len); if (fl->idCount && (*control & fl->allGroups)) { switch (fl->idCount) { #if !defined(FLOOD_DEBUG) // Carefully unrolled code case 1: for (u32 t = 0; t < floodSize && (*control & fl->allGroups); t += 4) { DEBUG_PRINTF("aaa %u %llx\n", t, fl->groups[0]); u32 len0 = fl->len[0] - 1; if (*control & fl->groups[0]) { *control = cb(i + t + 0 - len0, i + t + 0, fl->ids[0], ctxt); } if (*control & fl->groups[0]) { *control = cb(i + t + 1 - len0, i + t + 1, fl->ids[0], ctxt); } if (*control & fl->groups[0]) { *control = cb(i + t + 2 - len0, i + t + 2, fl->ids[0], ctxt); } if (*control & fl->groups[0]) { *control = cb(i + t + 3 - len0, i + t + 3, fl->ids[0], ctxt); } } break; case 2: for (u32 t = 0; t < floodSize && (*control & fl->allGroups); t += 4) { u32 len0 = fl->len[0] - 1; u32 len1 = fl->len[1] - 1; if (*control & fl->groups[0]) { *control = cb(i + t - len0, i + t, fl->ids[0], ctxt); } if (*control & fl->groups[1]) { *control = cb(i + t - len1, i + t, fl->ids[1], ctxt); } if (*control & fl->groups[0]) { *control = cb(i + t + 1 - len0, i + t + 1, fl->ids[0], ctxt); } if (*control & fl->groups[1]) { *control = cb(i + t + 1 - len1, i + t + 1, fl->ids[1], ctxt); } if (*control & fl->groups[0]) { *control = cb(i + t + 2 - len0, i + t + 2, fl->ids[0], ctxt); } if (*control & fl->groups[1]) { *control = cb(i + t + 2 - len1, i + t + 2, fl->ids[1], ctxt); } if (*control & fl->groups[0]) { *control = cb(i + t + 3 - len0, i + t + 3, fl->ids[0], ctxt); } if (*control & fl->groups[1]) { *control = cb(i + t + 3 - len1, i + t + 3, fl->ids[1], ctxt); } } break; case 3: for (u32 t = 0; t < floodSize && (*control & fl->allGroups); t += 2) { u32 len0 = fl->len[0] - 1; u32 len1 = fl->len[1] - 1; u32 len2 = fl->len[2] - 1; if (*control & fl->groups[0]) { *control = cb(i + t - len0, i + t, fl->ids[0], ctxt); } if (*control & fl->groups[1]) { *control = cb(i + t - len1, i + t, fl->ids[1], ctxt); } if (*control & fl->groups[2]) { *control = cb(i + t - len2, i + t, fl->ids[2], ctxt); } if (*control & fl->groups[0]) { *control = cb(i + t + 1 - len0, i + t + 1, fl->ids[0], ctxt); } if (*control & fl->groups[1]) { *control = cb(i + t + 1 - len1, i + t + 1, fl->ids[1], ctxt); } if (*control & fl->groups[2]) { *control = cb(i + t + 1 - len2, i + t + 1, fl->ids[2], ctxt); } } break; default: // slow generalized loop for (u32 t = 0; t < floodSize && (*control & fl->allGroups); t += 2) { u32 len0 = fl->len[0] - 1; u32 len1 = fl->len[1] - 1; u32 len2 = fl->len[2] - 1; u32 len3 = fl->len[3] - 1; if (*control & fl->groups[0]) { *control = cb(i + t - len0, i + t, fl->ids[0], ctxt); } if (*control & fl->groups[1]) { *control = cb(i + t - len1, i + t, fl->ids[1], ctxt); } if (*control & fl->groups[2]) { *control = cb(i + t - len2, i + t, fl->ids[2], ctxt); } if (*control & fl->groups[3]) { *control = cb(i + t - len3, i + t, fl->ids[3], ctxt); } for (u32 t2 = 4; t2 < fl->idCount; t2++) { if (*control & fl->groups[t2]) { *control = cb(i + t - (fl->len[t2] - 1), i + t, fl->ids[t2], ctxt); } } if (*control & fl->groups[0]) { *control = cb(i + t + 1 - len0, i + t + 1, fl->ids[0], ctxt); } if (*control & fl->groups[1]) { *control = cb(i + t + 1 - len1, i + t + 1, fl->ids[1], ctxt); } if (*control & fl->groups[2]) { *control = cb(i + t + 1 - len2, i + t + 1, fl->ids[2], ctxt); } if (*control & fl->groups[3]) { *control = cb(i + t + 1 - len3, i + t + 1, fl->ids[3], ctxt); } for (u32 t2 = 4; t2 < fl->idCount; t2++) { if (*control & fl->groups[t2]) { *control = cb(i + t + 1 - (fl->len[t2] - 1), i + t + 1, fl->ids[t2], ctxt); } } } break; #else // Fallback for debugging default: for (u32 t = 0; t < floodSize && (*control & fl->allGroups); t++) { for (u32 t2 = 0; t2 < fl->idCount; t2++) { if (*control & fl->groups[t2]) { *control = cb(i + t - (fl->len[t2] - 1), i + t, fl->ids[t2], ctxt); } } } #endif } } ptr += floodSize; } else { *floodBackoffPtr *= 2; } floodout: if (j + *floodBackoffPtr < mainLoopLen - 128) { tryFloodDetect = buf + MAX(i,j) + *floodBackoffPtr; } else { tryFloodDetect = buf + mainLoopLen; // set so we never do another flood detect } *ptrPtr = ptr; DEBUG_PRINTF("finished flood detection at %p (next check %p)\n", ptr, tryFloodDetect); return tryFloodDetect; } #endif hyperscan-4.4.1/src/fdr/fdr_dump.cpp0000644000175000017500000000614313055426554020151 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "fdr_compile.h" #include "fdr_compile_internal.h" #include "fdr_dump.h" #include "fdr_engine_description.h" #include "fdr_internal.h" #include "teddy_engine_description.h" #include "ue2common.h" #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using std::unique_ptr; namespace ue2 { static bool fdrIsTeddy(const FDR *fdr) { assert(fdr); u32 engine = fdr->engineID; /* teddys don't have an fdr engine description (which is why the dump code * is so broken). */ return !getFdrDescription(engine); } void fdrPrintStats(const FDR *fdr, FILE *f) { const bool isTeddy = fdrIsTeddy(fdr); if (isTeddy) { fprintf(f, "TEDDY: %u\n", fdr->engineID); } else { fprintf(f, "FDR: %u\n", fdr->engineID); } if (isTeddy) { auto des = getTeddyDescription(fdr->engineID); if (des) { fprintf(f, " masks %u\n", des->numMasks); fprintf(f, " buckets %u\n", des->getNumBuckets()); fprintf(f, " packed %s\n", des->packed ? "true" : "false"); } else { fprintf(f, " \n"); } } else { fprintf(f, " domain %u\n", fdr->domain); fprintf(f, " stride %u\n", fdr->stride); } fprintf(f, " strings ???\n"); fprintf(f, " size %zu bytes\n", fdrSize(fdr)); fprintf(f, " max length %u\n", fdr->maxStringLen); fprintf(f, " floodoff %u (%x)\n", fdr->floodOffset, fdr->floodOffset); } } // namespace ue2 hyperscan-4.4.1/src/fdr/fdr_loadval.h0000644000175000017500000000604713055426554020276 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 FDR_LOADVAL_H #define FDR_LOADVAL_H #include "ue2common.h" #include "util/unaligned.h" #define MAKE_LOADVAL(type, name) \ static really_inline \ type name(const u8 *ptr, UNUSED const u8 *lo, UNUSED const u8 *hi) #define NORMAL_SAFE(type) \ do { \ assert(ptr >= lo); \ assert(ptr + sizeof(type) - 1 < hi); \ } while(0) #define MAKE_LOOP_CE(TYPE) \ TYPE v = 0; \ for (TYPE i = 0; i < sizeof(TYPE); i++) { \ if ((lo <= ptr + i) && (ptr + i < hi)) { \ v += (TYPE)ptr[i] << (i*8); \ } \ } \ return v; // no suffix = normal (unaligned) // _ce = cautious everywhere (in both directions); test against hi and lo MAKE_LOADVAL(u16, lv_u16) { NORMAL_SAFE(u16); return unaligned_load_u16(ptr); } MAKE_LOADVAL(u64a, lv_u64a) { NORMAL_SAFE(u32); return unaligned_load_u64a(ptr); } MAKE_LOADVAL(u16, lv_u16_ce) { MAKE_LOOP_CE(u16); } MAKE_LOADVAL(u64a, lv_u64a_ce) { MAKE_LOOP_CE(u64a); } #endif hyperscan-4.4.1/src/fdr/teddy_internal.h0000644000175000017500000000344413055426554021024 0ustar sleuthkidsleuthkid/* * 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 TEDDY_INTERNAL_H #define TEDDY_INTERNAL_H #include "ue2common.h" // first part is compatible with an FDR struct Teddy { u32 engineID; u32 size; u32 maxStringLen; u32 floodOffset; u32 link; u32 pad1; u32 pad2; u32 pad3; }; #endif hyperscan-4.4.1/src/fdr/fdr_compile_internal.h0000644000175000017500000000652013055426554022174 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 FDR_COMPILE_INTERNAL_H #define FDR_COMPILE_INTERNAL_H #include "ue2common.h" #include "hwlm/hwlm_literal.h" #include "util/alloc.h" #include #include #include struct FDRConfirm; struct LitInfo; namespace ue2 { // a pile of decorative typedefs // good for documentation purposes more than anything else typedef u32 LiteralIndex; typedef u32 SuffixPositionInString; // zero is last byte, counting back // into the string typedef u32 BucketIndex; typedef u32 SchemeBitIndex; typedef u32 PositionInBucket; // zero is 'we are matching right now!", // counting towards future matches class EngineDescription; class FDREngineDescription; struct hwlmStreamingControl; std::pair, size_t> setupFullMultiConfs( const std::vector &lits, const EngineDescription &eng, std::map> &bucketToLits, bool make_small); // all suffixes include an implicit max_bucket_width suffix to ensure that // we always read a full-scale flood "behind" us in terms of what's in our // state; if we don't have a flood that's long enough we won't be in the // right state yet to allow blindly advancing std::pair, size_t> setupFDRFloodControl(const std::vector &lits, const EngineDescription &eng); std::pair, size_t> fdrBuildTableStreaming(const std::vector &lits, hwlmStreamingControl &stream_control); static constexpr u32 HINT_INVALID = 0xffffffff; // fdr_compile_util.cpp utilities size_t maxLen(const std::vector &lits); size_t minLenCount(const std::vector &lits, size_t *count); u32 absdiff(u32 i, u32 j); } // namespace ue2 #endif hyperscan-4.4.1/src/fdr/teddy_engine_description.h0000644000175000017500000000475413055426554023065 0ustar sleuthkidsleuthkid/* * 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 TEDDY_ENGINE_DESCRIPTION_H #define TEDDY_ENGINE_DESCRIPTION_H #include "engine_description.h" #include "fdr_compile_internal.h" #include #include namespace ue2 { #define TEDDY_BUCKET_LOAD 6 struct TeddyEngineDef { u32 id; u64a cpu_features; u32 numMasks; u32 numBuckets; bool packed; u32 confirmPullBackDistance; u32 confirmTopLevelSplit; }; class TeddyEngineDescription : public EngineDescription { public: u32 numMasks; bool packed; explicit TeddyEngineDescription(const TeddyEngineDef &def); u32 getDefaultFloodSuffixLength() const override; bool needConfirm(const std::vector &lits) const; }; std::unique_ptr chooseTeddyEngine(const target_t &target, const std::vector &vl); std::unique_ptr getTeddyDescription(u32 engineID); void getTeddyDescriptions(std::vector *out); } // namespace ue2 #endif hyperscan-4.4.1/src/fdr/teddy_runtime_common.h0000644000175000017500000002263213055426554022243 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Teddy literal matcher: common runtime procedures. */ #ifndef TEDDY_RUNTIME_COMMON_H_ #define TEDDY_RUNTIME_COMMON_H_ #include "fdr_confirm.h" #include "fdr_confirm_runtime.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" extern const u8 ALIGN_DIRECTIVE p_mask_arr[17][32]; #ifdef ARCH_64_BIT #define TEDDY_CONF_TYPE u64a #define TEDDY_FIND_AND_CLEAR_LSB(conf) findAndClearLSB_64(conf) #else #define TEDDY_CONF_TYPE u32 #define TEDDY_FIND_AND_CLEAR_LSB(conf) findAndClearLSB_32(conf) #endif #define CHECK_HWLM_TERMINATE_MATCHING \ do { \ if (unlikely(control == HWLM_TERMINATE_MATCHING)) { \ return HWLM_TERMINATED; \ } \ } while (0); #define CHECK_FLOOD \ do { \ if (unlikely(ptr > tryFloodDetect)) { \ tryFloodDetect = floodDetect(fdr, a, &ptr, tryFloodDetect, \ &floodBackoff, &control, iterBytes); \ CHECK_HWLM_TERMINATE_MATCHING; \ } \ } while (0); /* * \brief Copy a block of [0,15] bytes efficiently. * * This function is a workaround intended to stop some compilers from * synthesizing a memcpy function call out of the copy of a small number of * bytes that we do in vectoredLoad128. */ static really_inline void copyRuntBlock128(u8 *dst, const u8 *src, size_t len) { switch (len) { case 0: break; case 1: *dst = *src; break; case 2: unaligned_store_u16(dst, unaligned_load_u16(src)); break; case 3: unaligned_store_u16(dst, unaligned_load_u16(src)); dst[2] = src[2]; break; case 4: unaligned_store_u32(dst, unaligned_load_u32(src)); break; case 5: case 6: case 7: /* Perform copy with two overlapping 4-byte chunks. */ unaligned_store_u32(dst + len - 4, unaligned_load_u32(src + len - 4)); unaligned_store_u32(dst, unaligned_load_u32(src)); break; case 8: unaligned_store_u64a(dst, unaligned_load_u64a(src)); break; default: /* Perform copy with two overlapping 8-byte chunks. */ assert(len < 16); unaligned_store_u64a(dst + len - 8, unaligned_load_u64a(src + len - 8)); unaligned_store_u64a(dst, unaligned_load_u64a(src)); break; } } // Note: p_mask is an output param that initialises a poison mask. static really_inline m128 vectoredLoad128(m128 *p_mask, const u8 *ptr, const u8 *lo, const u8 *hi, const u8 *buf_history, size_t len_history, const u32 nMasks) { union { u8 val8[16]; m128 val128; } u; u.val128 = zeroes128(); uintptr_t copy_start; uintptr_t copy_len; if (ptr >= lo) { uintptr_t avail = (uintptr_t)(hi - ptr); if (avail >= 16) { *p_mask = load128(p_mask_arr[16] + 16); return loadu128(ptr); } *p_mask = load128(p_mask_arr[avail] + 16); copy_start = 0; copy_len = avail; } else { uintptr_t need = MIN((uintptr_t)(lo - ptr), MIN(len_history, nMasks - 1)); uintptr_t start = (uintptr_t)(lo - ptr); uintptr_t i; for (i = start - need; ptr + i < lo; i++) { u.val8[i] = buf_history[len_history - (lo - (ptr + i))]; } uintptr_t end = MIN(16, (uintptr_t)(hi - ptr)); *p_mask = loadu128(p_mask_arr[end - start] + 16 - start); copy_start = i; copy_len = end - i; } // Runt block from the buffer. copyRuntBlock128(&u.val8[copy_start], &ptr[copy_start], copy_len); return u.val128; } static really_inline u64a getConfVal(const struct FDR_Runtime_Args *a, const u8 *ptr, u32 byte, CautionReason reason) { u64a confVal = 0; const u8 *buf = a->buf; size_t len = a->len; const u8 *confirm_loc = ptr + byte - 7; if (likely(reason == NOT_CAUTIOUS || confirm_loc >= buf)) { confVal = lv_u64a(confirm_loc, buf, buf + len); } else { // r == VECTORING, confirm_loc < buf u64a histBytes = a->histBytes; confVal = lv_u64a_ce(confirm_loc, buf, buf + len); // stitch together confVal and history u32 overhang = buf - confirm_loc; histBytes >>= 64 - (overhang * 8); confVal |= histBytes; } return confVal; } static really_inline void do_confWithBit_teddy(TEDDY_CONF_TYPE *conf, u8 bucket, u8 offset, const u32 *confBase, CautionReason reason, const struct FDR_Runtime_Args *a, const u8 *ptr, hwlmcb_rv_t *control, u32 *last_match) { do { u32 bit = TEDDY_FIND_AND_CLEAR_LSB(conf); u32 byte = bit / bucket + offset; u32 bitRem = bit % bucket; u32 confSplit = *(ptr+byte) & 0x1f; u32 idx = confSplit * bucket + bitRem; u32 cf = confBase[idx]; if (!cf) { continue; } const struct FDRConfirm *fdrc = (const struct FDRConfirm *) ((const u8 *)confBase + cf); if (!(fdrc->groups & *control)) { continue; } u64a confVal = getConfVal(a, ptr, byte, reason); confWithBit(fdrc, a, ptr - a->buf + byte, 0, control, last_match, confVal); } while (unlikely(*conf)); } static really_inline void do_confWithBit1_teddy(TEDDY_CONF_TYPE *conf, u8 bucket, u8 offset, const u32 *confBase, CautionReason reason, const struct FDR_Runtime_Args *a, const u8 *ptr, hwlmcb_rv_t *control, u32 *last_match) { do { u32 bit = TEDDY_FIND_AND_CLEAR_LSB(conf); u32 byte = bit / bucket + offset; u32 idx = bit % bucket; u32 cf = confBase[idx]; const struct FDRConfirm *fdrc = (const struct FDRConfirm *) ((const u8 *)confBase + cf); if (!(fdrc->groups & *control)) { continue; } u64a confVal = getConfVal(a, ptr, byte, reason); confWithBit1(fdrc, a, ptr - a->buf + byte, control, last_match, confVal); } while (unlikely(*conf)); } static really_inline void do_confWithBitMany_teddy(TEDDY_CONF_TYPE *conf, u8 bucket, u8 offset, const u32 *confBase, CautionReason reason, const struct FDR_Runtime_Args *a, const u8 *ptr, hwlmcb_rv_t *control, u32 *last_match) { do { u32 bit = TEDDY_FIND_AND_CLEAR_LSB(conf); u32 byte = bit / bucket + offset; u32 idx = bit % bucket; u32 cf = confBase[idx]; const struct FDRConfirm *fdrc = (const struct FDRConfirm *) ((const u8 *)confBase + cf); if (!(fdrc->groups & *control)) { continue; } u64a confVal = getConfVal(a, ptr, byte, reason); confWithBitMany(fdrc, a, ptr - a->buf + byte, reason, control, last_match, confVal); } while (unlikely(*conf)); } static really_inline const m128 * getMaskBase(const struct Teddy *teddy) { return (const m128 *)((const u8 *)teddy + sizeof(struct Teddy)); } static really_inline const u32 * getConfBase(const struct Teddy *teddy, u8 numMask) { return (const u32 *)((const u8 *)teddy + sizeof(struct Teddy) + (numMask*32)); } #endif /* TEDDY_RUNTIME_COMMON_H_ */ hyperscan-4.4.1/src/fdr/fdr_engine_description.h0000644000175000017500000000546713055426554022531 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 FDR_ENGINE_DESCRIPTION_H #define FDR_ENGINE_DESCRIPTION_H #include "engine_description.h" #include "util/ue2_containers.h" #include #include #include namespace ue2 { struct FDREngineDef { u32 id; u32 schemeWidth; u32 numBuckets; u64a cpu_features; u32 confirmPullBackDistance; u32 confirmTopLevelSplit; }; class FDREngineDescription : public EngineDescription { public: u32 schemeWidth; u32 stride; u32 bits; u32 getSchemeWidth() const { return schemeWidth; } u32 getBucketWidth(BucketIndex b) const; SchemeBitIndex getSchemeBit(BucketIndex b, PositionInBucket p) const; u32 getNumTableEntries() const { return 1 << bits; } u32 getTabSizeBytes() const { return schemeWidth / 8 * getNumTableEntries(); } explicit FDREngineDescription(const FDREngineDef &def); u32 getDefaultFloodSuffixLength() const override; bool typicallyHoldsOneCharLits() const override { return stride == 1; } }; std::unique_ptr chooseEngine(const target_t &target, const std::vector &vl, bool make_small); std::unique_ptr getFdrDescription(u32 engineID); void getFdrDescriptions(std::vector *out); } // namespace ue2 #endif hyperscan-4.4.1/src/database.h0000644000175000017500000000653113055426554017010 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Runtime code for hs_database manipulation. */ #ifndef DATABASE_H_D467FD6F343DDE #define DATABASE_H_D467FD6F343DDE #ifdef __cplusplus extern "C" { #endif #include "hs_compile.h" // for HS_MODE_ flags #include "hs_version.h" #include "ue2common.h" #define HS_DB_VERSION HS_VERSION_32BIT #define HS_DB_MAGIC (0xdbdbdbdbU) // Values in here cannot (easily) change - add new ones! // CPU type is the low 6 bits (we can't need more than 64, surely!) #define HS_PLATFORM_INTEL 1 #define HS_PLATFORM_CPU_MASK 0x3F #define HS_PLATFORM_NOAVX2 (4<<13) /** \brief Platform features bitmask. */ typedef u64a platform_t; static UNUSED const platform_t hs_current_platform = { #if !defined(__AVX2__) HS_PLATFORM_NOAVX2 | #endif 0, }; static UNUSED const platform_t hs_current_platform_no_avx2 = { HS_PLATFORM_NOAVX2 | 0, }; /* * a header to enclose the actual bytecode - useful for keeping info about the * compiled data. */ struct hs_database { u32 magic; u32 version; u32 length; u64a platform; u32 crc32; u32 reserved0; u32 reserved1; u32 bytecode; // offset relative to db start u32 padding[16]; char bytes[]; }; static really_inline const void *hs_get_bytecode(const struct hs_database *db) { return ((const char *)db + db->bytecode); } /** * Cheap database sanity checks used in block mode scan calls and streaming * mode open calls. */ static really_inline hs_error_t validDatabase(const hs_database_t *db) { if (!db || db->magic != HS_DB_MAGIC) { return HS_INVALID; } if (db->version != HS_DB_VERSION) { return HS_DB_VERSION_ERROR; } return HS_SUCCESS; } hs_error_t dbIsValid(const struct hs_database *db); #ifdef __cplusplus } /* extern "C" */ #endif #endif /* DATABASE_H_D467FD6F343DDE */ hyperscan-4.4.1/src/dispatcher.c0000644000175000017500000001506613055426554017370 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "hs_common.h" #include "hs_runtime.h" #include "ue2common.h" #include "util/cpuid_flags.h" #include "util/join.h" #define CREATE_DISPATCH(RTYPE, NAME, ...) \ /* create defns */ \ RTYPE JOIN(avx2_, NAME)(__VA_ARGS__); \ RTYPE JOIN(corei7_, NAME)(__VA_ARGS__); \ RTYPE JOIN(core2_, NAME)(__VA_ARGS__); \ \ /* error func */ \ static inline RTYPE JOIN(error_, NAME)(__VA_ARGS__) { \ return (RTYPE)HS_ARCH_ERROR; \ } \ \ /* resolver */ \ static void(*JOIN(resolve_, NAME)(void)) { \ if (check_avx2()) { \ return JOIN(avx2_, NAME); \ } \ if (check_sse42() && check_popcnt()) { \ return JOIN(corei7_, NAME); \ } \ if (check_ssse3()) { \ return JOIN(core2_, NAME); \ } \ /* anything else is fail */ \ return JOIN(error_, NAME); \ } \ \ /* function */ \ HS_PUBLIC_API \ RTYPE NAME(__VA_ARGS__) __attribute__((ifunc("resolve_" #NAME))) CREATE_DISPATCH(hs_error_t, hs_scan, const hs_database_t *db, const char *data, unsigned length, unsigned flags, hs_scratch_t *scratch, match_event_handler onEvent, void *userCtx); CREATE_DISPATCH(hs_error_t, hs_stream_size, const hs_database_t *database, size_t *stream_size); CREATE_DISPATCH(hs_error_t, hs_database_size, const hs_database_t *db, size_t *size); CREATE_DISPATCH(hs_error_t, dbIsValid, const hs_database_t *db); CREATE_DISPATCH(hs_error_t, hs_free_database, hs_database_t *db); CREATE_DISPATCH(hs_error_t, hs_open_stream, const hs_database_t *db, unsigned int flags, hs_stream_t **stream); CREATE_DISPATCH(hs_error_t, 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); CREATE_DISPATCH(hs_error_t, hs_close_stream, hs_stream_t *id, hs_scratch_t *scratch, match_event_handler onEvent, void *ctxt); CREATE_DISPATCH(hs_error_t, 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); CREATE_DISPATCH(hs_error_t, hs_database_info, const hs_database_t *db, char **info); CREATE_DISPATCH(hs_error_t, hs_copy_stream, hs_stream_t **to_id, const hs_stream_t *from_id); CREATE_DISPATCH(hs_error_t, hs_reset_stream, hs_stream_t *id, unsigned int flags, hs_scratch_t *scratch, match_event_handler onEvent, void *context); CREATE_DISPATCH(hs_error_t, 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); CREATE_DISPATCH(hs_error_t, hs_serialize_database, const hs_database_t *db, char **bytes, size_t *length); CREATE_DISPATCH(hs_error_t, hs_deserialize_database, const char *bytes, const size_t length, hs_database_t **db); CREATE_DISPATCH(hs_error_t, hs_deserialize_database_at, const char *bytes, const size_t length, hs_database_t *db); CREATE_DISPATCH(hs_error_t, hs_serialized_database_info, const char *bytes, size_t length, char **info); CREATE_DISPATCH(hs_error_t, hs_serialized_database_size, const char *bytes, const size_t length, size_t *deserialized_size); /** INTERNALS **/ CREATE_DISPATCH(u32, Crc32c_ComputeBuf, u32 inCrc32, const void *buf, size_t bufLen); hyperscan-4.4.1/src/scratch.h0000644000175000017500000002320013055426554016663 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Scratch and associated data structures. * * This header gets pulled into many places (many deep, slow to compile * places). Try to keep the included headers under control. */ #ifndef SCRATCH_H_DA6D4FC06FF410 #define SCRATCH_H_DA6D4FC06FF410 #include "ue2common.h" #include "rose/rose_types.h" #ifdef __cplusplus extern "C" { #endif UNUSED static const u32 SCRATCH_MAGIC = 0x544F4259; #define FDR_TEMP_BUF_SIZE 222 struct fatbit; struct hs_scratch; struct RoseEngine; struct mq; struct queue_match { /** \brief used to store the current location of an (suf|out)fix match in * the current buffer. * * As (suf|out)fixes always run in the main buffer and never in history * this number will always be positive (matches at 0 belong to previous * write). Hence we can get away with a size_t rather than the usual s64a * for a location. */ size_t loc; u32 queue; /**< queue index. */ }; struct catchup_pq { struct queue_match *qm; u32 qm_size; /**< current size of the priority queue */ }; /** \brief Status flag: user requested termination. */ #define STATUS_TERMINATED (1U << 0) /** \brief Status flag: all possible matches on this stream have * been raised (i.e. all its exhaustion keys are on.) */ #define STATUS_EXHAUSTED (1U << 1) /** \brief Status flag: Rose requires rebuild as delay literal matched in * history. */ #define STATUS_DELAY_DIRTY (1U << 2) /** \brief Core information about the current scan, used everywhere. */ struct core_info { void *userContext; /**< user-supplied context */ /** \brief user-supplied match callback */ int (*userCallback)(unsigned int id, unsigned long long from, unsigned long long to, unsigned int flags, void *ctx); const struct RoseEngine *rose; char *state; /**< full stream state */ char *exhaustionVector; /**< pointer to evec for this stream */ const u8 *buf; /**< main scan buffer */ size_t len; /**< length of main scan buffer in bytes */ const u8 *hbuf; /**< history buffer */ size_t hlen; /**< length of history buffer in bytes. */ u64a buf_offset; /**< stream offset, for the base of the buffer */ u8 status; /**< stream status bitmask, using STATUS_ flags above */ }; /** \brief Rose state information. */ struct RoseContext { u8 mpv_inactive; u64a groups; u64a lit_offset_adjust; /**< offset to add to matches coming from hwlm */ u64a delayLastEndOffset; /**< end of the last match from FDR used by delay * code */ u64a lastEndOffset; /**< end of the last match from FDR/anchored DFAs used * by history code. anchored DFA matches update this * when they are inserted into the literal match * stream */ u64a lastMatchOffset; /**< last match offset report up out of rose; * used _only_ for debugging, asserts */ u64a minMatchOffset; /**< the earliest offset that we are still allowed to * report */ u64a minNonMpvMatchOffset; /**< the earliest offset that non-mpv engines are * still allowed to report */ u64a next_mpv_offset; /**< earliest offset that the MPV can next report a * match, cleared if top events arrive */ u32 filledDelayedSlots; u32 curr_qi; /**< currently executing main queue index during * \ref nfaQueueExec */ /** * \brief Buffer for caseful long literal support, used in streaming mode * only. * * If a long literal prefix was at the end of the buffer at the end of a * stream write, then the long lit table hashes it and stores the result in * stream state. At the start of the next write, this value is used to set * this buffer to the matching prefix string (stored in the bytecode. */ const u8 *ll_buf; /** \brief Length in bytes of the string pointed to by ll_buf. */ size_t ll_len; /** \brief Caseless version of ll_buf. */ const u8 *ll_buf_nocase; /** \brief Length in bytes of the string pointed to by ll_buf_nocase. */ size_t ll_len_nocase; }; struct match_deduper { struct fatbit *log[2]; /**< even, odd logs */ struct fatbit *som_log[2]; /**< even, odd fatbit logs for som */ u64a *som_start_log[2]; /**< even, odd start offset logs for som */ u32 dkey_count; u32 log_size; u64a current_report_offset; u8 som_log_dirty; }; /** \brief Hyperscan scratch region header. * * NOTE: there is no requirement that scratch is 16-byte aligned, as it is * allocated by a malloc equivalent, possibly supplied by the user. */ struct ALIGN_CL_DIRECTIVE hs_scratch { u32 magic; u8 in_use; /**< non-zero when being used by an API call. */ u32 queueCount; u32 activeQueueArraySize; /**< size of active queue array fatbit in bytes */ u32 bStateSize; /**< sizeof block mode states */ u32 tStateSize; /**< sizeof transient rose states */ u32 fullStateSize; /**< size of uncompressed nfa state */ struct RoseContext tctxt; char *bstate; /**< block mode states */ char *tstate; /**< state for transient roses */ char *fullState; /**< uncompressed NFA state */ struct mq *queues; struct fatbit *aqa; /**< active queue array; fatbit of queues that are valid * & active */ struct fatbit **delay_slots; struct fatbit **al_log; u64a al_log_sum; struct catchup_pq catchup_pq; struct core_info core_info; struct match_deduper deduper; u32 anchored_literal_region_len; u32 anchored_literal_fatbit_size; /**< size of each anch fatbit in bytes */ struct fatbit *handled_roles; /**< fatbit of ROLES (not states) already * handled by this literal */ u64a *som_store; /**< array of som locations */ u64a *som_attempted_store; /**< array of som locations for fail stores */ struct fatbit *som_set_now; /**< fatbit, true if the som location was set * based on a match at the current offset */ struct fatbit *som_attempted_set; /**< fatbit, true if the som location * would have been set at the current offset if the * location had been writable */ u64a som_set_now_offset; /**< offset at which som_set_now represents */ u32 som_store_count; u32 som_fatbit_size; /**< size of som location fatbit structures in bytes */ u32 handledKeyFatbitSize; /**< size of handled_keys fatbit in bytes */ u32 delay_fatbit_size; /**< size of each delay fatbit in bytes */ u32 scratchSize; char *scratch_alloc; /* user allocated scratch object */ u8 ALIGN_DIRECTIVE fdr_temp_buf[FDR_TEMP_BUF_SIZE]; }; /* array of fatbit ptr; TODO: why not an array of fatbits? */ static really_inline struct fatbit **getAnchoredLiteralLog(struct hs_scratch *scratch) { return scratch->al_log; } static really_inline struct fatbit **getDelaySlots(struct hs_scratch *scratch) { return scratch->delay_slots; } static really_inline char told_to_stop_matching(const struct hs_scratch *scratch) { return scratch->core_info.status & STATUS_TERMINATED; } static really_inline char can_stop_matching(const struct hs_scratch *scratch) { return scratch->core_info.status & (STATUS_TERMINATED | STATUS_EXHAUSTED); } /** * \brief Mark scratch as in use. * * Returns non-zero if it was already in use, zero otherwise. */ static really_inline char markScratchInUse(struct hs_scratch *scratch) { DEBUG_PRINTF("marking scratch as in use\n"); assert(scratch && scratch->magic == SCRATCH_MAGIC); if (scratch->in_use) { DEBUG_PRINTF("scratch already in use!\n"); return 1; } scratch->in_use = 1; return 0; } /** * \brief Mark scratch as no longer in use. */ static really_inline void unmarkScratchInUse(struct hs_scratch *scratch) { DEBUG_PRINTF("marking scratch as not in use\n"); assert(scratch && scratch->magic == SCRATCH_MAGIC); assert(scratch->in_use == 1); scratch->in_use = 0; } #ifdef __cplusplus } /* extern "C" */ #endif #endif /* SCRATCH_H_DA6D4FC06FF410 */ hyperscan-4.4.1/src/scratch_dump.h0000644000175000017500000000342213055426554017714 0ustar sleuthkidsleuthkid/* * 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 SCRATCH_DUMP_H #define SCRATCH_DUMP_H #if defined(DUMP_SUPPORT) #include struct hs_scratch; namespace ue2 { void dumpScratch(const struct hs_scratch *s, FILE *f); } // namespace ue2 #endif // DUMP_SUPPORT #endif // SCRATCH_DUMP_H hyperscan-4.4.1/src/hs_common.h0000644000175000017500000004547213055426554017235 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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_COMMON_H_ #define HS_COMMON_H_ #include /** * @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 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 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 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 @a 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 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 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 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 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 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 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_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_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 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 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 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 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 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 *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 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. */ #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) /** @} */ #ifdef __cplusplus } /* extern "C" */ #endif #endif /* HS_COMMON_H_ */ hyperscan-4.4.1/src/state.h0000644000175000017500000000476713055426554016375 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Stream state data structures. */ #ifndef STATE_H #define STATE_H #include "hs_runtime.h" /* match_event_handler */ #include "ue2common.h" #ifdef __cplusplus extern "C" { #endif struct RoseEngine; /** \brief Stream context: allocated for each stream. * * struct hs_stream is followed in memory by the main Rose state: history, * exhaustion, individual states, etc. The RoseEngine has the offsets required * to correctly index into the main state structure. The offsets used by the * RoseEngine are based on the end of the hs_stream struct as its size may * vary from platform to platform. */ struct hs_stream { /** \brief The RoseEngine that this stream is matching against. */ const struct RoseEngine *rose; /** \brief The current stream offset. */ u64a offset; }; #define getMultiState(hs_s) ((char *)(hs_s) + sizeof(*(hs_s))) #define getMultiStateConst(hs_s) ((const char *)(hs_s) + sizeof(*(hs_s))) #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/hwlm/0000755000175000017500000000000013055426554016035 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/hwlm/hwlm.c0000644000175000017500000002135413055426554017155 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: runtime. */ #include "hwlm.h" #include "hwlm_internal.h" #include "noodle_engine.h" #include "scratch.h" #include "ue2common.h" #include "fdr/fdr.h" #include "nfa/accel.h" #include "nfa/shufti.h" #include "nfa/truffle.h" #include "nfa/vermicelli.h" #include #define MIN_ACCEL_LEN_BLOCK 16 #define MIN_ACCEL_LEN_STREAM 16 static really_inline const u8 *run_hwlm_accel(const union AccelAux *aux, const u8 *ptr, const u8 *end) { switch (aux->accel_type) { case ACCEL_VERM: DEBUG_PRINTF("single vermicelli for 0x%02hhx\n", aux->verm.c); return vermicelliExec(aux->verm.c, 0, ptr, end); case ACCEL_VERM_NOCASE: DEBUG_PRINTF("single vermicelli-nocase for 0x%02hhx\n", aux->verm.c); return vermicelliExec(aux->verm.c, 1, ptr, end); case ACCEL_DVERM: DEBUG_PRINTF("double vermicelli for 0x%02hhx%02hhx\n", aux->dverm.c1, aux->dverm.c2); return vermicelliDoubleExec(aux->dverm.c1, aux->dverm.c2, 0, ptr, end); case ACCEL_DVERM_NOCASE: DEBUG_PRINTF("double vermicelli-nocase for 0x%02hhx%02hhx\n", aux->dverm.c1, aux->dverm.c2); return vermicelliDoubleExec(aux->dverm.c1, aux->dverm.c2, 1, ptr, end); case ACCEL_SHUFTI: DEBUG_PRINTF("single shufti\n"); return shuftiExec(aux->shufti.lo, aux->shufti.hi, ptr, end); case ACCEL_TRUFFLE: DEBUG_PRINTF("truffle\n"); return truffleExec(aux->truffle.mask1, aux->truffle.mask2, ptr, end); default: /* no acceleration, fall through and return current ptr */ DEBUG_PRINTF("no accel; %u\n", (int)aux->accel_type); assert(aux->accel_type == ACCEL_NONE); return ptr; } } static really_inline void do_accel_block(const union AccelAux *aux, const u8 *buf, size_t len, size_t *start) { if (len - *start < MIN_ACCEL_LEN_BLOCK) { return; } const u8 *ptr = buf + *start; const u8 *end = buf + len; const u8 offset = aux->generic.offset; ptr = run_hwlm_accel(aux, ptr, end); if (offset) { ptr -= offset; if (ptr < buf) { ptr = buf; } } assert(ptr >= buf); *start = ptr - buf; } static really_inline int inaccurate_accel(u8 type) { /* accels which don't always catch up to the boundary * DSHUFTI is also inaccurate but it is not used by the hamsters */ return type == ACCEL_DVERM_NOCASE || type == ACCEL_DVERM; } static never_inline void do_accel_streaming(const union AccelAux *aux, const u8 *hbuf, size_t hlen, const u8 *buf, size_t len, size_t *start) { if (aux->accel_type == ACCEL_NONE || len - *start < MIN_ACCEL_LEN_STREAM) { return; } const u8 offset = aux->generic.offset; DEBUG_PRINTF("using accel %hhu offset %hhu\n", aux->accel_type, offset); // Scan history buffer, but only if the start offset (which always refers to // buf) is zero. if (!*start && hlen) { const u8 *ptr1 = hbuf; const u8 *end1 = hbuf + hlen; if (hlen >= 16) { ptr1 = run_hwlm_accel(aux, ptr1, end1); } if ((hlen <= 16 || inaccurate_accel(aux->accel_type)) && end1 != ptr1 && end1 - ptr1 <= 16) { DEBUG_PRINTF("already scanned %zu/%zu\n", ptr1 - hbuf, hlen); /* see if we can finish off the history buffer completely */ u8 ALIGN_DIRECTIVE temp[17]; ptrdiff_t tlen = end1 - ptr1; memcpy(temp, ptr1, tlen); memset(temp + tlen, 0, 17 - tlen); if (len) { /* for dverm */ temp[end1 - ptr1] = *buf; } const u8 *tempp = run_hwlm_accel(aux, temp, temp + 17); if (tempp - temp >= tlen) { ptr1 = end1; } DEBUG_PRINTF("got %zu\n", tempp - temp); } if (ptr1 != end1) { DEBUG_PRINTF("bailing in history\n"); return; } } DEBUG_PRINTF("scanning main buffer, start=%zu, len=%zu\n", *start, len); const u8 *ptr2 = buf + *start; const u8 *end2 = buf + len; const u8 *found = run_hwlm_accel(aux, ptr2, end2); if (found >= ptr2 + offset) { size_t delta = found - offset - ptr2; DEBUG_PRINTF("got %zu/%zu in 2nd buffer\n", delta, len); *start += delta; } else if (hlen) { UNUSED size_t remaining = offset + ptr2 - found; DEBUG_PRINTF("got %zu/%zu remaining in 1st buffer\n", remaining, hlen); } } hwlm_error_t hwlmExec(const struct HWLM *t, const u8 *buf, size_t len, size_t start, HWLMCallback cb, void *ctxt, hwlm_group_t groups) { DEBUG_PRINTF("buf len=%zu, start=%zu, groups=%llx\n", len, start, groups); if (!groups) { DEBUG_PRINTF("groups all off\n"); return HWLM_SUCCESS; } assert(start < len); if (t->type == HWLM_ENGINE_NOOD) { DEBUG_PRINTF("calling noodExec\n"); return noodExec(HWLM_C_DATA(t), buf + start, len - start, start, cb, ctxt); } else { assert(t->type == HWLM_ENGINE_FDR); const union AccelAux *aa = &t->accel0; if ((groups & ~t->accel1_groups) == 0) { DEBUG_PRINTF("using hq accel %hhu\n", t->accel1.accel_type); aa = &t->accel1; } do_accel_block(aa, buf, len, &start); DEBUG_PRINTF("calling frankie (groups=%08llx, start=%zu)\n", groups, start); return fdrExec(HWLM_C_DATA(t), buf, len, start, cb, ctxt, groups); } } hwlm_error_t hwlmExecStreaming(const struct HWLM *t, struct hs_scratch *scratch, size_t len, size_t start, HWLMCallback cb, void *ctxt, hwlm_group_t groups) { const u8 *hbuf = scratch->core_info.hbuf; const size_t hlen = scratch->core_info.hlen; const u8 *buf = scratch->core_info.buf; DEBUG_PRINTF("hbuf len=%zu, buf len=%zu, start=%zu, groups=%llx\n", hlen, len, start, groups); if (!groups) { return HWLM_SUCCESS; } assert(start < len); if (t->type == HWLM_ENGINE_NOOD) { DEBUG_PRINTF("calling noodExec\n"); // If we've been handed a start offset, we can use a block mode scan at // that offset. if (start) { return noodExec(HWLM_C_DATA(t), buf + start, len - start, start, cb, ctxt); } else { return noodExecStreaming(HWLM_C_DATA(t), hbuf, hlen, buf, len, cb, ctxt, scratch->fdr_temp_buf, FDR_TEMP_BUF_SIZE); } } else { // t->type == HWLM_ENGINE_FDR const union AccelAux *aa = &t->accel0; if ((groups & ~t->accel1_groups) == 0) { DEBUG_PRINTF("using hq accel %hhu\n", t->accel1.accel_type); aa = &t->accel1; } do_accel_streaming(aa, hbuf, hlen, buf, len, &start); DEBUG_PRINTF("calling frankie (groups=%08llx, start=%zu)\n", groups, start); return fdrExecStreaming(HWLM_C_DATA(t), hbuf, hlen, buf, len, start, cb, ctxt, groups); } } hyperscan-4.4.1/src/hwlm/hwlm_literal.cpp0000644000175000017500000001040413055426554021223 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: literal representation at build time. */ #include "hwlm_literal.h" #include "util/bitutils.h" // for CASE_BIT #include "util/compare.h" // for ourisalpha #include "util/ue2string.h" // for escapeString #include #include #include using namespace std; namespace ue2 { #ifdef DEBUG static UNUSED std::string dumpMask(const vector &v) { ostringstream oss; vector::const_iterator it, ite; for (it = v.begin(), ite = v.end(); it != ite; ++it) { oss << setfill('0') << setw(2) << hex << (unsigned int)*it; } return oss.str(); } #endif bool maskIsConsistent(const std::string &s, bool nocase, const vector &msk, const vector &cmp) { string::const_reverse_iterator si = s.rbegin(); vector::const_reverse_iterator mi = msk.rbegin(), ci = cmp.rbegin(); for (; si != s.rend() && mi != msk.rend(); ++si, ++mi, ++ci) { u8 c = *si, m = *mi, v = *ci; if (nocase && ourisalpha(c)) { m &= ~CASE_BIT; v &= ~CASE_BIT; } assert(ci != cmp.rend()); if ((c & m) != v) { DEBUG_PRINTF("c = %02hhx; *ci = %02hhx m =%02hhx\n", c, *ci, m); DEBUG_PRINTF("s = %s; dist = %zd\n", s.c_str(), si - s.rbegin()); return false; } } return true; } /** \brief Complete constructor, takes group information and msk/cmp. * * This constructor takes a msk/cmp pair. Both must be vectors of length <= * \ref HWLM_MASKLEN. */ hwlmLiteral::hwlmLiteral(const std::string &s_in, bool nocase_in, bool noruns_in, u32 id_in, hwlm_group_t groups_in, const vector &msk_in, const vector &cmp_in) : s(s_in), id(id_in), nocase(nocase_in), noruns(noruns_in), groups(groups_in), msk(msk_in), cmp(cmp_in) { assert(s.size() <= HWLM_LITERAL_MAX_LEN); assert(msk.size() <= HWLM_MASKLEN); assert(msk.size() == cmp.size()); // If we've been handled a nocase literal, all letter characters must be // upper-case. if (nocase) { upperString(s); } DEBUG_PRINTF("literal '%s'%s, msk=%s, cmp=%s\n", escapeString(s).c_str(), nocase ? " (nocase)" : "", dumpMask(msk).c_str(), dumpMask(cmp).c_str()); // Mask and compare vectors MUST be the same size. assert(msk.size() == cmp.size()); // We must have been passed a msk/cmp that can be applied to s. assert(maskIsConsistent(s, nocase, msk, cmp)); // In the name of good hygiene, zap msk/cmp if msk is all zeroes. if (all_of(begin(msk), end(msk), [](u8 val) { return val == 0; })) { msk.clear(); cmp.clear(); } } } // namespace ue2 hyperscan-4.4.1/src/hwlm/noodle_build.h0000644000175000017500000000422113055426554020644 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Noodle literal matcher: build code. */ #ifndef NOODLE_BUILD_H_048A1A6D585A9A #define NOODLE_BUILD_H_048A1A6D585A9A #include "ue2common.h" #include "util/alloc.h" struct noodTable; namespace ue2 { struct hwlmLiteral; /** \brief Construct a Noodle matcher for the given literal. */ ue2::aligned_unique_ptr noodBuildTable(const hwlmLiteral &lit); size_t noodSize(const noodTable *n); } // namespace ue2 #ifdef DUMP_SUPPORT #include namespace ue2 { void noodPrintStats(const noodTable *n, FILE *f); } // namespace ue2 #endif // DUMP_SUPPORT #endif /* NOODLE_BUILD_H_048A1A6D585A9A */ hyperscan-4.4.1/src/hwlm/hwlm_build.h0000644000175000017500000000707213055426554020342 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: build API. */ #ifndef HWLM_BUILD_H #define HWLM_BUILD_H #include "hwlm.h" #include "hwlm_literal.h" #include "ue2common.h" #include "util/alloc.h" #include #include struct HWLM; namespace ue2 { struct CompileContext; struct Grey; struct target_t; /** \brief Structure gathering together the input/output parameters related to * streaming mode operation. */ struct hwlmStreamingControl { /** \brief IN parameter: Upper limit on the amount of history that can be * requested. */ size_t history_max; /** \brief IN parameter: History already known to be used before literal * analysis. */ size_t history_min; /** \brief OUT parameter: History required by the literal matcher to * correctly match all literals. */ size_t literal_history_required; }; /** \brief Build an \ref HWLM literal matcher runtime structure for a group of * literals. * * \param lits The group of literals. * \param stream_control Streaming control parameters. If the matcher will * operate in non-streaming (block) mode, this pointer should be NULL. * \param make_small Optimise matcher for small size. * \param cc Compile context. * \param expected_groups FIXME: document me! * * Build failures are generally a result of memory allocation failure. These * may result in a nullptr return value, or a std::bad_alloc exception being * thrown. */ aligned_unique_ptr hwlmBuild(const std::vector &lits, hwlmStreamingControl *stream_control, bool make_small, const CompileContext &cc, hwlm_group_t expected_groups = HWLM_ALL_GROUPS); /** * Returns an estimate of the number of repeated characters on the end of a * literal that will make a literal set of size \a numLiterals suffer * performance degradation. */ size_t hwlmFloodProneSuffixLen(size_t numLiterals, const CompileContext &cc); /** \brief Return the size in bytes of an HWLM structure. */ size_t hwlmSize(const HWLM *h); } // namespace #endif // HWLM_BUILD_H hyperscan-4.4.1/src/hwlm/hwlm_internal.h0000644000175000017500000000507313055426554021056 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: data structures. */ #ifndef HWLM_INTERNAL_H #define HWLM_INTERNAL_H #include "hwlm.h" #include "ue2common.h" #include "nfa/accel.h" /** \brief Underlying engine is FDR. */ #define HWLM_ENGINE_FDR 12 /** \brief Underlying engine is Noodle. */ #define HWLM_ENGINE_NOOD 16 /** \brief Main Hamster Wheel Literal Matcher header. Followed by * engine-specific structure. */ struct HWLM { u8 type; /**< HWLM_ENGINE_NOOD or HWLM_ENGINE_FDR */ hwlm_group_t accel1_groups; /**< accelerable groups. */ union AccelAux accel1; /**< used if group mask is subset of accel1_groups */ union AccelAux accel0; /**< fallback accel scheme */ }; /** \brief Fetch a const pointer to the underlying engine. */ #define HWLM_C_DATA(p) ((const void *)((const char *)(p) \ + ROUNDUP_CL(sizeof(struct HWLM)))) /** \brief Fetch a pointer to the underlying engine. */ #define HWLM_DATA(p) ((void *)((char *)(p) + ROUNDUP_CL(sizeof(struct HWLM)))) #endif hyperscan-4.4.1/src/hwlm/noodle_build.cpp0000644000175000017500000000705113055426554021203 0ustar sleuthkidsleuthkid/* * 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. */ /** * \file * \brief Noodle literal matcher: build code. */ #include "noodle_build.h" #include "hwlm_literal.h" #include "noodle_internal.h" #include "util/alloc.h" #include "util/compare.h" #include "util/verify_types.h" #include "ue2common.h" #include // for memcpy namespace ue2 { static size_t findNoodFragOffset(const hwlmLiteral &lit) { const auto &s = lit.s; const size_t len = lit.s.length(); size_t offset = 0; for (size_t i = 0; i + 1 < len; i++) { int diff = 0; const char c = s[i]; const char d = s[i + 1]; if (lit.nocase && ourisalpha(c)) { diff = (mytoupper(c) != mytoupper(d)); } else { diff = (c != d); } offset = i; if (diff) { break; } } return offset; } aligned_unique_ptr noodBuildTable(const hwlmLiteral &lit) { if (!lit.msk.empty()) { DEBUG_PRINTF("noodle can't handle supplementary masks\n"); return nullptr; } const auto &s = lit.s; size_t noodle_len = sizeof(noodTable) + s.length(); auto n = aligned_zmalloc_unique(noodle_len); assert(n); size_t key_offset = findNoodFragOffset(lit); n->id = lit.id; n->len = verify_u32(s.length()); n->key_offset = verify_u32(key_offset); n->nocase = lit.nocase ? 1 : 0; memcpy(n->str, s.c_str(), s.length()); return n; } size_t noodSize(const noodTable *n) { assert(n); // shouldn't call with null return sizeof(*n) + n->len; } } // namespace ue2 #ifdef DUMP_SUPPORT #include namespace ue2 { void noodPrintStats(const noodTable *n, FILE *f) { fprintf(f, "Noodle table\n"); fprintf(f, "Len: %u Key Offset: %u\n", n->len, n->key_offset); fprintf(f, "String: "); for (u32 i = 0; i < n->len; i++) { if (isgraph(n->str[i]) && n->str[i] != '\\') { fprintf(f, "%c", n->str[i]); } else { fprintf(f, "\\x%02hhx", n->str[i]); } } fprintf(f, "\n"); } } // namespace ue2 #endif hyperscan-4.4.1/src/hwlm/hwlm_literal.h0000644000175000017500000001141113055426554020667 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: literal representation at build time. */ #ifndef HWLM_LITERAL_H #define HWLM_LITERAL_H #include "hwlm.h" #include "ue2common.h" #include #include namespace ue2 { /** \brief Max length of the literal passed to HWLM. */ #define HWLM_LITERAL_MAX_LEN 255 /** \brief Max length of the hwlmLiteral::msk and hwlmLiteral::cmp vectors. */ #define HWLM_MASKLEN 8 /** \brief Class representing a literal, fed to \ref hwlmBuild. */ struct hwlmLiteral { std::string s; //!< \brief The literal itself. /** \brief The ID to pass to the callback if this literal matches. * * Note that the special value 0xFFFFFFFF is reserved for internal use and * should not be used. */ u32 id; bool nocase; //!< \brief True if literal is case-insensitive. /** \brief Matches for runs of this literal can be quashed. * * Advisory flag meaning that there is no value in returning runs of * additional matches for a literal after the first one, so such matches * can be quashed by the literal matcher. */ bool noruns; /** \brief Set of groups that literal belongs to. * * Use \ref HWLM_ALL_GROUPS for a literal that could match regardless of * the groups that are switched on. */ hwlm_group_t groups; /** \brief Supplementary comparison mask. * * These two values add a supplementary comparison that is done over the * final 8 bytes of the string -- if v is those bytes, then the string must * match as well as (v & msk) == cmp. * * An empty msk is the safe way of not adding any comparison to the string * unnecessarily filling in msk may turn off optimizations. * * The msk/cmp mechanism must NOT place a value into the literal that * conflicts with the contents of the string, but can be allowed to add * additional power within the string -- for example, to allow some case * sensitivity within a case-insensitive string. * Values are stored in memory order -- i.e. the last byte of the mask * corresponds to the last byte of the string. Both vectors must be the * same size, and must not exceed \ref HWLM_MASKLEN in length. */ std::vector msk; /** \brief Supplementary comparison value. * * See documentation for \ref msk. */ std::vector cmp; /** \brief Complete constructor, takes group information and msk/cmp. * * This constructor takes a msk/cmp pair. Both must be vectors of length <= * \ref HWLM_MASKLEN. */ hwlmLiteral(const std::string &s_in, bool nocase_in, bool noruns_in, u32 id_in, hwlm_group_t groups_in, const std::vector &msk_in, const std::vector &cmp_in); /** \brief Simple constructor: no group information, no msk/cmp. */ hwlmLiteral(const std::string &s_in, bool nocase_in, u32 id_in) : hwlmLiteral(s_in, nocase_in, false, id_in, HWLM_ALL_GROUPS, {}, {}) {} }; /** * Consistency test; returns false if the given msk/cmp test can never match * the literal string s. */ bool maskIsConsistent(const std::string &s, bool nocase, const std::vector &msk, const std::vector &cmp); } // namespace ue2 #endif // HWLM_LITERAL_H hyperscan-4.4.1/src/hwlm/noodle_engine.c0000644000175000017500000003270013055426554021010 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Noodle literal matcher: runtime. */ #include "hwlm.h" #include "noodle_engine.h" #include "noodle_internal.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/compare.h" #include "util/masked_move.h" #include "util/simd_utils.h" #include #include #include /** \brief Noodle runtime context. */ struct cb_info { HWLMCallback cb; //!< callback function called on match u32 id; //!< ID to pass to callback on match void *ctx; //!< caller-supplied context to pass to callback size_t offsetAdj; //!< used in streaming mode }; #define RETURN_IF_TERMINATED(x) \ { \ if ((x) == HWLM_TERMINATED) { \ return HWLM_TERMINATED; \ } \ } #define SINGLE_ZSCAN() \ do { \ while (unlikely(z)) { \ u32 pos = findAndClearLSB_32(&z); \ size_t matchPos = d - buf + pos; \ hwlmcb_rv_t rv = final(buf, len, key, 1, 0, 0, noCase, cbi, \ matchPos); \ RETURN_IF_TERMINATED(rv); \ } \ } while (0) #define DOUBLE_ZSCAN() \ do { \ while (unlikely(z)) { \ u32 pos = findAndClearLSB_32(&z); \ size_t matchPos = d - buf + pos - 1; \ hwlmcb_rv_t rv = final(buf, len, key, keyLen, keyOffset, 1, \ noCase, cbi, matchPos); \ RETURN_IF_TERMINATED(rv); \ } \ } while (0) static really_inline u8 caseClear8(u8 x, bool noCase) { return (u8)(noCase ? (x & (u8)0xdf) : x); } // Make sure the rest of the string is there. The single character scanner // is used only for single chars with case insensitivity used correctly, // so it can go straight to the callback if we get this far. static really_inline hwlm_error_t final(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, bool is_double, bool noCase, const struct cb_info *cbi, size_t pos) { pos -= keyOffset; if (is_double) { if (pos + keyLen > len) { return HWLM_SUCCESS; } if (cmpForward(buf + pos, key, keyLen, noCase)) { // ret 1 on mismatch return HWLM_SUCCESS; } } pos += cbi->offsetAdj; DEBUG_PRINTF("match @ %zu->%zu\n", pos, (pos + keyLen - 1)); hwlmcb_rv_t rv = cbi->cb(pos, (pos + keyLen - 1), cbi->id, cbi->ctx); if (rv == HWLM_TERMINATE_MATCHING) { return HWLM_TERMINATED; } return HWLM_SUCCESS; } #if defined(__AVX2__) #define CHUNKSIZE 32 #define MASK_TYPE m256 #include "noodle_engine_avx2.c" #else #define CHUNKSIZE 16 #define MASK_TYPE m128 #include "noodle_engine_sse.c" #endif static really_inline hwlm_error_t scanSingleMain(const u8 *buf, size_t len, const u8 *key, bool noCase, const struct cb_info *cbi) { hwlm_error_t rv; size_t end = len; const MASK_TYPE mask1 = getMask(key[0], noCase); const MASK_TYPE caseMask = getCaseMask(); if (len < CHUNKSIZE) { rv = scanSingleShort(buf, len, key, noCase, caseMask, mask1, cbi, 0, len); return rv; } if (len == CHUNKSIZE) { rv = scanSingleUnaligned(buf, len, 0, key, noCase, caseMask, mask1, cbi, 0, len); return rv; } uintptr_t data = (uintptr_t)buf; uintptr_t s2Start = ROUNDUP_N(data, CHUNKSIZE) - data; uintptr_t last = data + end; uintptr_t s2End = ROUNDDOWN_N(last, CHUNKSIZE) - data; uintptr_t s3Start = len - CHUNKSIZE; if (s2Start) { // first scan out to the fast scan starting point DEBUG_PRINTF("stage 1: -> %zu\n", s2Start); rv = scanSingleUnaligned(buf, len, 0, key, noCase, caseMask, mask1, cbi, 0, s2Start); RETURN_IF_TERMINATED(rv); } if (likely(s2Start != s2End)) { // scan as far as we can, bounded by the last point this key can // possibly match DEBUG_PRINTF("fast: ~ %zu -> %zu\n", s2Start, s2End); rv = scanSingleFast(buf, len, key, noCase, caseMask, mask1, cbi, s2Start, s2End); RETURN_IF_TERMINATED(rv); } // if we are done bail out if (s2End == end) { return HWLM_SUCCESS; } DEBUG_PRINTF("stage 3: %zu -> %zu\n", s2End, end); rv = scanSingleUnaligned(buf, len, s3Start, key, noCase, caseMask, mask1, cbi, s2End, end); return rv; } static really_inline hwlm_error_t scanDoubleMain(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, const struct cb_info *cbi) { hwlm_error_t rv; // we stop scanning for the key-fragment when the rest of the key can't // possibly fit in the remaining buffer size_t end = len - keyLen + keyOffset + 2; const MASK_TYPE caseMask = getCaseMask(); const MASK_TYPE mask1 = getMask(key[keyOffset + 0], noCase); const MASK_TYPE mask2 = getMask(key[keyOffset + 1], noCase); if (end - keyOffset < CHUNKSIZE) { rv = scanDoubleShort(buf, len, key, keyLen, keyOffset, noCase, caseMask, mask1, mask2, cbi, keyOffset, end); return rv; } if (end - keyOffset == CHUNKSIZE) { rv = scanDoubleUnaligned(buf, len, keyOffset, key, keyLen, keyOffset, noCase, caseMask, mask1, mask2, cbi, keyOffset, end); return rv; } uintptr_t data = (uintptr_t)buf; uintptr_t s2Start = ROUNDUP_N(data + keyOffset, CHUNKSIZE) - data; uintptr_t s1End = s2Start + 1; uintptr_t last = data + end; uintptr_t s2End = ROUNDDOWN_N(last, CHUNKSIZE) - data; uintptr_t s3Start = end - CHUNKSIZE; uintptr_t off = keyOffset; if (s2Start != keyOffset) { // first scan out to the fast scan starting point plus one char past to // catch the key on the overlap DEBUG_PRINTF("stage 1: -> %zu\n", s2Start); rv = scanDoubleUnaligned(buf, len, keyOffset, key, keyLen, keyOffset, noCase, caseMask, mask1, mask2, cbi, off, s1End); RETURN_IF_TERMINATED(rv); } off = s1End; if (s2Start >= end) { DEBUG_PRINTF("s2 == mL %zu\n", end); return HWLM_SUCCESS; } if (likely(s2Start != s2End)) { // scan as far as we can, bounded by the last point this key can // possibly match DEBUG_PRINTF("fast: ~ %zu -> %zu\n", s2Start, s3Start); rv = scanDoubleFast(buf, len, key, keyLen, keyOffset, noCase, caseMask, mask1, mask2, cbi, s2Start, s2End); RETURN_IF_TERMINATED(rv); off = s2End; } // if there isn't enough data left to match the key, bail out if (s2End == end) { return HWLM_SUCCESS; } DEBUG_PRINTF("stage 3: %zu -> %zu\n", s3Start, end); rv = scanDoubleUnaligned(buf, len, s3Start, key, keyLen, keyOffset, noCase, caseMask, mask1, mask2, cbi, off, end); return rv; } static really_inline hwlm_error_t scanSingleNoCase(const u8 *buf, size_t len, const u8 *key, const struct cb_info *cbi) { return scanSingleMain(buf, len, key, 1, cbi); } static really_inline hwlm_error_t scanSingleCase(const u8 *buf, size_t len, const u8 *key, const struct cb_info *cbi) { return scanSingleMain(buf, len, key, 0, cbi); } // Single-character specialisation, used when keyLen = 1 static really_inline hwlm_error_t scanSingle(const u8 *buf, size_t len, const u8 *key, bool noCase, const struct cb_info *cbi) { if (!ourisalpha(key[0])) { noCase = 0; // force noCase off if we don't have an alphabetic char } // kinda ugly, but this forces constant propagation if (noCase) { return scanSingleNoCase(buf, len, key, cbi); } else { return scanSingleCase(buf, len, key, cbi); } } static really_inline hwlm_error_t scanDoubleNoCase(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, const struct cb_info *cbi) { return scanDoubleMain(buf, len, key, keyLen, keyOffset, 1, cbi); } static really_inline hwlm_error_t scanDoubleCase(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, const struct cb_info *cbi) { return scanDoubleMain(buf, len, key, keyLen, keyOffset, 0, cbi); } static really_inline hwlm_error_t scanDouble(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, const struct cb_info *cbi) { // kinda ugly, but this forces constant propagation if (noCase) { return scanDoubleNoCase(buf, len, key, keyLen, keyOffset, cbi); } else { return scanDoubleCase(buf, len, key, keyLen, keyOffset, cbi); } } // main entry point for the scan code static really_inline hwlm_error_t scan(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, const struct cb_info *cbi) { if (len < keyLen) { // can't find string of length keyLen in a shorter buffer return HWLM_SUCCESS; } if (keyLen == 1) { assert(keyOffset == 0); return scanSingle(buf, len, key, noCase, cbi); } else { return scanDouble(buf, len, key, keyLen, keyOffset, noCase, cbi); } } /** \brief Block-mode scanner. */ hwlm_error_t noodExec(const struct noodTable *n, const u8 *buf, size_t len, size_t offset_adj, HWLMCallback cb, void *ctxt) { assert(n && buf); struct cb_info cbi = { cb, n->id, ctxt, offset_adj }; DEBUG_PRINTF("nood scan of %zu bytes for %*s\n", len, n->len, n->str); return scan(buf, len, n->str, n->len, n->key_offset, n->nocase, &cbi); } /** \brief Streaming-mode scanner. */ hwlm_error_t noodExecStreaming(const struct noodTable *n, const u8 *hbuf, size_t hlen, const u8 *buf, size_t len, HWLMCallback cb, void *ctxt, u8 *temp_buf, UNUSED size_t temp_buffer_size) { assert(n); struct cb_info cbi = {cb, n->id, ctxt, 0}; hwlm_error_t rv; if (hlen) { assert(hbuf); size_t tl1 = MIN(n->len - 1, hlen); size_t tl2 = MIN(n->len - 1, len); size_t temp_len = tl1 + tl2; assert(temp_len < temp_buffer_size); memcpy(temp_buf, hbuf + hlen - tl1, tl1); memcpy(temp_buf + tl1, buf, tl2); cbi.offsetAdj = -tl1; rv = scan(temp_buf, temp_len, n->str, n->len, n->key_offset, n->nocase, &cbi); if (rv == HWLM_TERMINATED) { return HWLM_TERMINATED; } } assert(buf); cbi.offsetAdj = 0; return scan(buf, len, n->str, n->len, n->key_offset, n->nocase, &cbi); } hyperscan-4.4.1/src/hwlm/hwlm_build.cpp0000644000175000017500000005166213055426554020701 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: build code. */ #include "grey.h" #include "hwlm.h" #include "hwlm_build.h" #include "hwlm_internal.h" #include "noodle_engine.h" #include "noodle_build.h" #include "scratch.h" #include "ue2common.h" #include "fdr/fdr_compile.h" #include "nfa/shufticompile.h" #include "nfa/trufflecompile.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/compile_error.h" #include "util/dump_charclass.h" #include "util/target_info.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include #include using namespace std; namespace ue2 { static const unsigned int MAX_ACCEL_OFFSET = 16; static const unsigned int MAX_SHUFTI_WIDTH = 240; static size_t mask_overhang(const hwlmLiteral &lit) { size_t msk_true_size = lit.msk.size(); assert(msk_true_size <= HWLM_MASKLEN); assert(HWLM_MASKLEN <= MAX_ACCEL_OFFSET); for (u8 c : lit.msk) { if (!c) { msk_true_size--; } else { break; } } if (lit.s.length() >= msk_true_size) { return 0; } /* only short literals should be able to have a mask which overhangs */ assert(lit.s.length() < MAX_ACCEL_OFFSET); return msk_true_size - lit.s.length(); } static bool findDVerm(const vector &lits, AccelAux *aux) { const hwlmLiteral &first = *lits.front(); struct candidate { candidate(void) : c1(0), c2(0), max_offset(0), b5insens(false), valid(false) {} candidate(const hwlmLiteral &base, u32 offset) : c1(base.s[offset]), c2(base.s[offset + 1]), max_offset(0), b5insens(false), valid(true) {} char c1; char c2; u32 max_offset; bool b5insens; bool valid; bool operator>(const candidate &other) const { if (!valid) { return false; } if (!other.valid) { return true; } if (other.cdiffers() && !cdiffers()) { return false; } if (!other.cdiffers() && cdiffers()) { return true; } if (!other.b5insens && b5insens) { return false; } if (other.b5insens && !b5insens) { return true; } if (max_offset > other.max_offset) { return false; } return true; } bool cdiffers(void) const { if (!b5insens) { return c1 != c2; } return (c1 & CASE_CLEAR) != (c2 & CASE_CLEAR); } }; candidate best; for (u32 i = 0; i < MIN(MAX_ACCEL_OFFSET, first.s.length()) - 1; i++) { candidate curr(first, i); /* check to see if this pair appears in each string */ for (const auto &lit_ptr : lits) { const hwlmLiteral &lit = *lit_ptr; if (lit.nocase && (ourisalpha(curr.c1) || ourisalpha(curr.c2))) { curr.b5insens = true; /* no choice but to be case insensitive */ } bool found = false; bool found_nc = false; for (u32 j = 0; !found && j < MIN(MAX_ACCEL_OFFSET, lit.s.length()) - 1; j++) { found |= curr.c1 == lit.s[j] && curr.c2 == lit.s[j + 1]; found_nc |= (curr.c1 & CASE_CLEAR) == (lit.s[j] & CASE_CLEAR) && (curr.c2 & CASE_CLEAR) == (lit.s[j + 1] & CASE_CLEAR); if (curr.b5insens) { found = found_nc; } } if (!curr.b5insens && !found && found_nc) { curr.b5insens = true; found = true; } if (!found) { goto next_candidate; } } /* check to find the max offset where this appears */ for (const auto &lit_ptr : lits) { const hwlmLiteral &lit = *lit_ptr; for (u32 j = 0; j < MIN(MAX_ACCEL_OFFSET, lit.s.length()) - 1; j++) { bool found = false; if (curr.b5insens) { found = (curr.c1 & CASE_CLEAR) == (lit.s[j] & CASE_CLEAR) && (curr.c2 & CASE_CLEAR) == (lit.s[j + 1] & CASE_CLEAR); } else { found = curr.c1 == lit.s[j] && curr.c2 == lit.s[j + 1]; } if (found) { assert(j + mask_overhang(lit) <= MAX_ACCEL_OFFSET); ENSURE_AT_LEAST(&curr.max_offset, j + mask_overhang(lit)); break; } } } if (curr > best) { best = curr; } next_candidate:; } if (!best.valid) { return false; } aux->dverm.offset = verify_u8(best.max_offset); if (!best.b5insens) { aux->dverm.accel_type = ACCEL_DVERM; aux->dverm.c1 = best.c1; aux->dverm.c2 = best.c2; DEBUG_PRINTF("built dverm for %02hhx%02hhx\n", aux->dverm.c1, aux->dverm.c2); } else { aux->dverm.accel_type = ACCEL_DVERM_NOCASE; aux->dverm.c1 = best.c1 & CASE_CLEAR; aux->dverm.c2 = best.c2 & CASE_CLEAR; DEBUG_PRINTF("built dverm nc for %02hhx%02hhx\n", aux->dverm.c1, aux->dverm.c2); } return true; } static bool findSVerm(const vector &lits, AccelAux *aux) { const hwlmLiteral &first = *lits.front(); struct candidate { candidate(void) : c(0), max_offset(0), b5insens(false), valid(false) {} candidate(const hwlmLiteral &base, u32 offset) : c(base.s[offset]), max_offset(0), b5insens(false), valid(true) {} char c; u32 max_offset; bool b5insens; bool valid; bool operator>(const candidate &other) const { if (!valid) { return false; } if (!other.valid) { return true; } if (!other.b5insens && b5insens) { return false; } if (other.b5insens && !b5insens) { return true; } if (max_offset > other.max_offset) { return false; } return true; } }; candidate best; for (u32 i = 0; i < MIN(MAX_ACCEL_OFFSET, first.s.length()); i++) { candidate curr(first, i); /* check to see if this pair appears in each string */ for (const auto &lit_ptr : lits) { const hwlmLiteral &lit = *lit_ptr; if (lit.nocase && ourisalpha(curr.c)) { curr.b5insens = true; /* no choice but to be case insensitive */ } bool found = false; bool found_nc = false; for (u32 j = 0; !found && j < MIN(MAX_ACCEL_OFFSET, lit.s.length()); j++) { found |= curr.c == lit.s[j]; found_nc |= (curr.c & CASE_CLEAR) == (lit.s[j] & CASE_CLEAR); if (curr.b5insens) { found = found_nc; } } if (!curr.b5insens && !found && found_nc) { curr.b5insens = true; found = true; } if (!found) { goto next_candidate; } } /* check to find the max offset where this appears */ for (const auto &lit_ptr : lits) { const hwlmLiteral &lit = *lit_ptr; for (u32 j = 0; j < MIN(MAX_ACCEL_OFFSET, lit.s.length()); j++) { bool found = false; if (curr.b5insens) { found = (curr.c & CASE_CLEAR) == (lit.s[j] & CASE_CLEAR); } else { found = curr.c == lit.s[j]; } if (found) { assert(j + mask_overhang(lit) <= MAX_ACCEL_OFFSET); ENSURE_AT_LEAST(&curr.max_offset, j + mask_overhang(lit)); } } } if (curr > best) { best = curr; } next_candidate:; } if (!best.valid) { return false; } if (!best.b5insens) { aux->verm.accel_type = ACCEL_VERM; aux->verm.c = best.c; DEBUG_PRINTF("built verm for %02hhx\n", aux->verm.c); } else { aux->verm.accel_type = ACCEL_VERM_NOCASE; aux->verm.c = best.c & CASE_CLEAR; DEBUG_PRINTF("built verm nc for %02hhx\n", aux->verm.c); } aux->verm.offset = verify_u8(best.max_offset); return true; } static void filterLits(const vector &lits, hwlm_group_t expected_groups, vector *filtered_lits, u32 *min_len) { *min_len = MAX_ACCEL_OFFSET; for (const auto &lit : lits) { if (!(lit.groups & expected_groups)) { continue; } const size_t lit_len = lit.s.length(); if (lit_len < *min_len) { *min_len = verify_u32(lit_len); } filtered_lits->push_back(&lit); #ifdef DEBUG DEBUG_PRINTF("lit:"); for (u32 i = 0; i < lit.s.length(); i++) { printf("%02hhx", lit.s[i]); } printf("\n"); #endif } } static bool litGuardedByCharReach(const CharReach &cr, const hwlmLiteral &lit, u32 max_offset) { for (u32 i = 0; i <= max_offset && i < lit.s.length(); i++) { unsigned char c = lit.s[i]; if (lit.nocase) { if (cr.test(mytoupper(c)) && cr.test(mytolower(c))) { return true; } } else { if (cr.test(c)) { return true; } } } return false; } static void findForwardAccelScheme(const vector &lits, hwlm_group_t expected_groups, AccelAux *aux) { DEBUG_PRINTF("building accel expected=%016llx\n", expected_groups); u32 min_len = MAX_ACCEL_OFFSET; vector filtered_lits; filterLits(lits, expected_groups, &filtered_lits, &min_len); if (filtered_lits.empty()) { return; } if (findDVerm(filtered_lits, aux) || findSVerm(filtered_lits, aux)) { return; } /* look for shufti/truffle */ vector reach(MAX_ACCEL_OFFSET, CharReach()); for (const auto &lit : lits) { if (!(lit.groups & expected_groups)) { continue; } u32 overhang = mask_overhang(lit); for (u32 i = 0; i < overhang; i++) { /* this offset overhangs the start of the real literal; look at the * msk/cmp */ for (u32 j = 0; j < N_CHARS; j++) { if ((j & lit.msk[i]) == lit.cmp[i]) { reach[i].set(j); } } } for (u32 i = overhang; i < MAX_ACCEL_OFFSET; i++) { CharReach &reach_i = reach[i]; u32 i_effective = i - overhang; if (litGuardedByCharReach(reach_i, lit, i_effective)) { continue; } unsigned char c = i_effective < lit.s.length() ? lit.s[i_effective] : lit.s.back(); if (lit.nocase) { reach_i.set(mytoupper(c)); reach_i.set(mytolower(c)); } else { reach_i.set(c); } } } u32 min_count = ~0U; u32 min_offset = ~0U; for (u32 i = 0; i < MAX_ACCEL_OFFSET; i++) { size_t count = reach[i].count(); DEBUG_PRINTF("offset %u is %s (reach %zu)\n", i, describeClass(reach[i]).c_str(), count); if (count < min_count) { min_count = (u32)count; min_offset = i; } } if (min_count > MAX_SHUFTI_WIDTH) { DEBUG_PRINTF("FAIL: min shufti with %u chars is too wide\n", min_count); return; } const CharReach &cr = reach[min_offset]; if (-1 != shuftiBuildMasks(cr, (u8 *)&aux->shufti.lo, (u8 *)&aux->shufti.hi)) { DEBUG_PRINTF("built shufti for %s (%zu chars, offset %u)\n", describeClass(cr).c_str(), cr.count(), min_offset); aux->shufti.accel_type = ACCEL_SHUFTI; aux->shufti.offset = verify_u8(min_offset); return; } truffleBuildMasks(cr, (u8 *)&aux->truffle.mask1, (u8 *)&aux->truffle.mask2); DEBUG_PRINTF("built truffle for %s (%zu chars, offset %u)\n", describeClass(cr).c_str(), cr.count(), min_offset); aux->truffle.accel_type = ACCEL_TRUFFLE; aux->truffle.offset = verify_u8(min_offset); } static void buildForwardAccel(HWLM *h, const vector &lits, hwlm_group_t expected_groups) { findForwardAccelScheme(lits, expected_groups, &h->accel1); findForwardAccelScheme(lits, HWLM_ALL_GROUPS, &h->accel0); h->accel1_groups = expected_groups; } static void dumpLits(UNUSED const vector &lits) { #ifdef DEBUG DEBUG_PRINTF("building lit table for:\n"); for (const auto &lit : lits) { printf("\t%u:%016llx %s%s\n", lit.id, lit.groups, escapeString(lit.s).c_str(), lit.nocase ? " (nc)" : ""); } #endif } #ifndef NDEBUG // Called by an assertion. static bool everyoneHasGroups(const vector &lits) { for (const auto &lit : lits) { if (!lit.groups) { return false; } } return true; } #endif static bool isNoodleable(const vector &lits, const hwlmStreamingControl *stream_control, const CompileContext &cc) { if (!cc.grey.allowNoodle) { return false; } if (lits.size() != 1) { DEBUG_PRINTF("too many literals for noodle\n"); return false; } if (stream_control) { // nullptr if in block mode if (lits.front().s.length() > stream_control->history_max + 1) { DEBUG_PRINTF("length of %zu too long for history max %zu\n", lits.front().s.length(), stream_control->history_max); return false; } if (2 * lits.front().s.length() - 2 > FDR_TEMP_BUF_SIZE) { assert(0); return false; } } if (!lits.front().msk.empty()) { DEBUG_PRINTF("noodle can't handle supplementary masks\n"); return false; } return true; } aligned_unique_ptr hwlmBuild(const vector &lits, hwlmStreamingControl *stream_control, bool make_small, const CompileContext &cc, hwlm_group_t expected_groups) { assert(!lits.empty()); dumpLits(lits); if (stream_control) { assert(stream_control->history_min <= stream_control->history_max); // We should not have been passed any literals that are too long to // match with a maximally-sized history buffer. assert(all_of(begin(lits), end(lits), [&](const hwlmLiteral &lit) { return lit.s.length() <= stream_control->history_max + 1; })); } // Check that we haven't exceeded the maximum number of literals. if (lits.size() > cc.grey.limitLiteralCount) { throw ResourceLimitError(); } // Safety and resource limit checks. u64a total_chars = 0; for (const auto &lit : lits) { assert(!lit.s.empty()); if (lit.s.length() > cc.grey.limitLiteralLength) { throw ResourceLimitError(); } total_chars += lit.s.length(); if (total_chars > cc.grey.limitLiteralMatcherChars) { throw ResourceLimitError(); } // We do not allow the all-ones ID, as we reserve that for internal use // within literal matchers. if (lit.id == 0xffffffffu) { assert(!"reserved id 0xffffffff used"); throw CompileError("Internal error."); } } u8 engType = 0; size_t engSize = 0; shared_ptr eng; DEBUG_PRINTF("building table with %zu strings\n", lits.size()); assert(everyoneHasGroups(lits)); if (isNoodleable(lits, stream_control, cc)) { DEBUG_PRINTF("build noodle table\n"); engType = HWLM_ENGINE_NOOD; const hwlmLiteral &lit = lits.front(); auto noodle = noodBuildTable(lit); if (noodle) { engSize = noodSize(noodle.get()); } if (stream_control) { // For now, a single literal still goes to noodle and asks // for a great big history stream_control->literal_history_required = lit.s.length() - 1; assert(stream_control->literal_history_required <= stream_control->history_max); } eng = move(noodle); } else { DEBUG_PRINTF("building a new deal\n"); engType = HWLM_ENGINE_FDR; auto fdr = fdrBuildTable(lits, make_small, cc.target_info, cc.grey, stream_control); if (fdr) { engSize = fdrSize(fdr.get()); } eng = move(fdr); } if (!eng) { return nullptr; } assert(engSize); if (engSize > cc.grey.limitLiteralMatcherSize) { throw ResourceLimitError(); } auto h = aligned_zmalloc_unique(ROUNDUP_CL(sizeof(HWLM)) + engSize); h->type = engType; memcpy(HWLM_DATA(h.get()), eng.get(), engSize); if (engType == HWLM_ENGINE_FDR && cc.grey.hamsterAccelForward) { buildForwardAccel(h.get(), lits, expected_groups); } if (stream_control) { DEBUG_PRINTF("requires %zu (of max %zu) bytes of history\n", stream_control->literal_history_required, stream_control->history_max); assert(stream_control->literal_history_required <= stream_control->history_max); } return h; } size_t hwlmSize(const HWLM *h) { size_t engSize = 0; switch (h->type) { case HWLM_ENGINE_NOOD: engSize = noodSize((const noodTable *)HWLM_C_DATA(h)); break; case HWLM_ENGINE_FDR: engSize = fdrSize((const FDR *)HWLM_C_DATA(h)); break; } if (!engSize) { return 0; } return engSize + ROUNDUP_CL(sizeof(*h)); } size_t hwlmFloodProneSuffixLen(size_t numLiterals, const CompileContext &cc) { const size_t NO_LIMIT = ~(size_t)0; // NOTE: this function contains a number of magic numbers which are // conservative estimates of flood-proneness based on internal details of // the various literal engines that fall under the HWLM aegis. If you // change those engines, you might need to change this function too. DEBUG_PRINTF("%zu literals\n", numLiterals); if (cc.grey.allowNoodle && numLiterals <= 1) { DEBUG_PRINTF("noodle\n"); return NO_LIMIT; } if (cc.grey.fdrAllowTeddy) { if (numLiterals <= 48) { DEBUG_PRINTF("teddy\n"); return 3; } if (cc.target_info.has_avx2() && numLiterals <= 96) { DEBUG_PRINTF("avx2 teddy\n"); return 3; } } // TODO: we had thought we could push this value up to 9, but it seems that // hurts performance on floods in some FDR models. Super-conservative for // now. DEBUG_PRINTF("fdr\n"); return 3; } } // namespace ue2 hyperscan-4.4.1/src/hwlm/hwlm_dump.h0000644000175000017500000000353113055426554020204 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: dump API. */ #ifndef HWLM_DUMP_H #define HWLM_DUMP_H #ifdef DUMP_SUPPORT #include struct HWLM; namespace ue2 { /** \brief Dump some information about the give HWLM structure. */ void hwlmPrintStats(const HWLM *h, FILE *f); } // namespace ue2 #endif #endif hyperscan-4.4.1/src/hwlm/noodle_engine.h0000644000175000017500000000437513055426554021024 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Noodle literal matcher: runtime API. */ #ifndef NOODLE_ENGINE_H #define NOODLE_ENGINE_H #include "hwlm.h" #ifdef __cplusplus extern "C" { #endif struct noodTable; /** \brief Block-mode scanner. */ hwlm_error_t noodExec(const struct noodTable *n, const u8 *buf, size_t len, size_t offset_adj, HWLMCallback cb, void *ctxt); /** \brief Streaming-mode scanner. */ hwlm_error_t noodExecStreaming(const struct noodTable *n, const u8 *hbuf, size_t hlen, const u8 *buf, size_t len, HWLMCallback cb, void *ctxt, u8 *temp_buf, size_t temp_buffer_size); #ifdef __cplusplus } /* extern "C" */ #endif #endif hyperscan-4.4.1/src/hwlm/noodle_engine_avx2.c0000644000175000017500000001640113055426554021750 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /* noodle scan parts for AVX */ static really_inline m256 getMask(u8 c, bool noCase) { u8 k = caseClear8(c, noCase); return set32x8(k); } static really_inline m256 getCaseMask(void) { return set32x8(0xdf); } static really_inline hwlm_error_t scanSingleUnaligned(const u8 *buf, size_t len, size_t offset, const u8 *key, bool noCase, m256 caseMask, m256 mask1, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + offset; DEBUG_PRINTF("start %zu end %zu offset %zu\n", start, end, offset); const size_t l = end - start; m256 v = loadu256(d); if (noCase) { v = and256(v, caseMask); } u32 z = movemask256(eq256(mask1, v)); u32 buf_off = start - offset; u32 mask = (u32)((u64a)(1ULL << l) - 1) << buf_off; DEBUG_PRINTF("mask 0x%08x z 0x%08x\n", mask, z); z &= mask; SINGLE_ZSCAN(); return HWLM_SUCCESS; } static really_inline hwlm_error_t scanDoubleUnaligned(const u8 *buf, size_t len, size_t offset, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, m256 caseMask, m256 mask1, m256 mask2, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + offset; DEBUG_PRINTF("start %zu end %zu offset %zu\n", start, end, offset); size_t l = end - start; m256 v = loadu256(d); if (noCase) { v = and256(v, caseMask); } u32 z0 = movemask256(eq256(mask1, v)); u32 z1 = movemask256(eq256(mask2, v)); u32 z = (z0 << 1) & z1; // mask out where we can't match u32 buf_off = start - offset; u32 mask = (u32)((u64a)(1ULL << l) - 1) << buf_off; DEBUG_PRINTF("mask 0x%08x z 0x%08x\n", mask, z); z &= mask; DOUBLE_ZSCAN(); return HWLM_SUCCESS; } // The short scan routine. It is used both to scan data up to an // alignment boundary if needed and to finish off data that the aligned scan // function can't handle (due to small/unaligned chunk at end) static really_inline hwlm_error_t scanSingleShort(const u8 *buf, size_t len, const u8 *key, bool noCase, m256 caseMask, m256 mask1, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + start; size_t l = end - start; DEBUG_PRINTF("l %zu\n", l); assert(l <= 32); if (!l) { return HWLM_SUCCESS; } m256 v; if (l < 4) { u8 *vp = (u8*)&v; switch (l) { case 3: vp[2] = d[2]; case 2: vp[1] = d[1]; case 1: vp[0] = d[0]; } } else { v = masked_move256_len(d, l); } if (noCase) { v = and256(v, caseMask); } // mask out where we can't match u32 mask = (0xFFFFFFFF >> (32 - l)); u32 z = mask & movemask256(eq256(mask1, v)); SINGLE_ZSCAN(); return HWLM_SUCCESS; } static really_inline hwlm_error_t scanDoubleShort(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, m256 caseMask, m256 mask1, m256 mask2, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + start; size_t l = end - start; if (!l) { return HWLM_SUCCESS; } assert(l <= 32); m256 v; DEBUG_PRINTF("d %zu\n", d - buf); if (l < 4) { u8 *vp = (u8*)&v; switch (l) { case 3: vp[2] = d[2]; case 2: vp[1] = d[1]; case 1: vp[0] = d[0]; } } else { v = masked_move256_len(d, l); } if (noCase) { v = and256(v, caseMask); } u32 z0 = movemask256(eq256(mask1, v)); u32 z1 = movemask256(eq256(mask2, v)); u32 z = (z0 << 1) & z1; // mask out where we can't match u32 mask = (0xFFFFFFFF >> (32 - l)); z &= mask; DOUBLE_ZSCAN(); return HWLM_SUCCESS; } static really_inline hwlm_error_t scanSingleFast(const u8 *buf, size_t len, const u8 *key, bool noCase, m256 caseMask, m256 mask1, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + start, *e = buf + end; assert(d < e); for (; d < e; d += 32) { m256 v = noCase ? and256(load256(d), caseMask) : load256(d); u32 z = movemask256(eq256(mask1, v)); // On large packet buffers, this prefetch appears to get us about 2%. __builtin_prefetch(d + 128); SINGLE_ZSCAN(); } return HWLM_SUCCESS; } static really_inline hwlm_error_t scanDoubleFast(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, m256 caseMask, m256 mask1, m256 mask2, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + start, *e = buf + end; DEBUG_PRINTF("start %zu end %zu \n", start, end); assert(d < e); u8 lastz0 = 0; for (; d < e; d += 32) { m256 v = noCase ? and256(load256(d), caseMask) : load256(d); // we have to pull the masks out of the AVX registers because we can't // byte shift between the lanes u32 z0 = movemask256(eq256(mask1, v)); u32 z1 = movemask256(eq256(mask2, v)); u32 z = (lastz0 | (z0 << 1)) & z1; lastz0 = z0 >> 31; // On large packet buffers, this prefetch appears to get us about 2%. __builtin_prefetch(d + 128); DOUBLE_ZSCAN(); } return HWLM_SUCCESS; } hyperscan-4.4.1/src/hwlm/hwlm_dump.cpp0000644000175000017500000000457713055426554020552 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: dump code. */ #include "config.h" #include "hwlm_dump.h" #include "hwlm_internal.h" #include "noodle_build.h" #include "ue2common.h" #include "fdr/fdr_dump.h" #include "nfa/accel_dump.h" #include #ifndef DUMP_SUPPORT #error No dump support! #endif namespace ue2 { void hwlmPrintStats(const HWLM *h, FILE *f) { switch (h->type) { case HWLM_ENGINE_NOOD: noodPrintStats((const noodTable *)HWLM_C_DATA(h), f); break; case HWLM_ENGINE_FDR: fdrPrintStats((const FDR *)HWLM_C_DATA(h), f); break; default: fprintf(f, "\n"); } fprintf(f, "accel1_groups: %016llx\n", h->accel1_groups); fprintf(f, "accel1:"); dumpAccelInfo(f, h->accel1); fprintf(f, "accel0:"); dumpAccelInfo(f, h->accel0); } } // namespace ue2 hyperscan-4.4.1/src/hwlm/hwlm.h0000644000175000017500000001267713055426554017172 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Hamster Wheel Literal Matcher: runtime API. */ #ifndef HWLM_H #define HWLM_H #include "ue2common.h" #ifdef __cplusplus extern "C" { #endif /** \brief Error return type for exec functions. */ typedef int hwlm_error_t; /** \brief Type representing a set of groups as a bitmap. */ typedef u64a hwlm_group_t; /** \brief HWLM callback return type. */ typedef hwlm_group_t hwlmcb_rv_t; /** \brief Value representing all possible literal groups. */ #define HWLM_ALL_GROUPS ((hwlm_group_t)~0ULL) /** \brief Callback return value indicating that we should continue matching. */ #define HWLM_CONTINUE_MATCHING HWLM_ALL_GROUPS /** \brief Callback return value indicating that we should halt matching. */ #define HWLM_TERMINATE_MATCHING 0 /** \brief Matching finished without being terminated by the user. */ #define HWLM_SUCCESS 0 /** \brief The user terminated matching by returning HWLM_TERMINATE_MATCHING * from the match callback. */ #define HWLM_TERMINATED 1 /** \brief An error occurred during matching. * * This should only be used if an unsupported engine was called (like one * designed for a different architecture). */ #define HWLM_ERROR_UNKNOWN 2 struct hs_scratch; struct HWLM; /** \brief The type for an HWLM callback. * * This callback receives a start-of-match offset, an end-of-match offset, the * ID of the match and the context pointer that was passed into \ref * hwlmExec or \ref hwlmExecStreaming. * * A callback return of \ref HWLM_TERMINATE_MATCHING will stop matching. * * A callback return of \ref HWLM_CONTINUE_MATCHING continues matching. * * An arbitrary group mask may be given as the return value. This will be taken * as a hint by the underlying engine that only literals with groups * overlapping the provided mask need to be reported. * * The underlying engine may choose not to report a match if there is no group * belonging to the literal which was active at the when the end match location * was first reached. */ typedef hwlmcb_rv_t (*HWLMCallback)(size_t start, size_t end, u32 id, void *context); /** \brief Match strings in table. * * If a match occurs, the callback function given will be called with the index * of the last character in the string and the \p context (passed through * without interpretation). * * Returns \ref HWLM_TERMINATED if scanning is cancelled due to the callback * returning \ref HWLM_TERMINATE_MATCHING. * * \p start is the first offset at which a match may start. * * The underlying engine may choose not to report any match which starts before * the first possible match of a literal which is in the initial group mask. */ hwlm_error_t hwlmExec(const struct HWLM *tab, const u8 *buf, size_t len, size_t start, HWLMCallback callback, void *context, hwlm_group_t groups); /** \brief As for \ref hwlmExec, but a streaming case across two buffers. * * \p scratch is used to access fdr_temp_buf and to access the history buffer, * history length and the main buffer. * * \p len is the length of the main buffer to be scanned. * * \p start is an advisory hint representing the first offset at which a match * may start. Some underlying literal matches may not respect it. * * Two buffers/lengths are provided. Matches that occur entirely within * the history buffer will not be reported by this function. The offsets * reported for the main buffer are relative to the start of that buffer (a * match at byte 10 of the main buffer is reported as 10). Matches that start * in the history buffer will have starts reported with 'negative' values. */ hwlm_error_t hwlmExecStreaming(const struct HWLM *tab, struct hs_scratch *scratch, size_t len, size_t start, HWLMCallback callback, void *context, hwlm_group_t groups); #ifdef __cplusplus } /* extern "C" */ #endif #endif hyperscan-4.4.1/src/hwlm/noodle_internal.h0000644000175000017500000000353513055426554021370 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Data structures for Noodle literal matcher engine. */ #ifndef NOODLE_INTERNAL_H_25D751C42E34A6 #define NOODLE_INTERNAL_H_25D751C42E34A6 #include "ue2common.h" struct noodTable { u32 id; u32 len; u32 key_offset; u8 nocase; u8 str[]; }; #endif /* NOODLE_INTERNAL_H_25D751C42E34A6 */ hyperscan-4.4.1/src/hwlm/noodle_engine_sse.c0000644000175000017500000001510713055426554021664 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /* noodle scan parts for SSE */ static really_inline m128 getMask(u8 c, bool noCase) { u8 k = caseClear8(c, noCase); return set16x8(k); } static really_inline m128 getCaseMask(void) { return set16x8(0xdf); } static really_inline hwlm_error_t scanSingleShort(const u8 *buf, size_t len, const u8 *key, bool noCase, m128 caseMask, m128 mask1, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + start; size_t l = end - start; DEBUG_PRINTF("l %zu\n", l); assert(l <= 16); if (!l) { return HWLM_SUCCESS; } m128 v = zeroes128(); // we don't have a clever way of doing this move yet memcpy(&v, d, l); if (noCase) { v = and128(v, caseMask); } // mask out where we can't match u32 mask = (0xFFFF >> (16 - l)); u32 z = mask & movemask128(eq128(mask1, v)); SINGLE_ZSCAN(); return HWLM_SUCCESS; } static really_inline hwlm_error_t scanSingleUnaligned(const u8 *buf, size_t len, size_t offset, const u8 *key, bool noCase, m128 caseMask, m128 mask1, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + offset; DEBUG_PRINTF("start %zu end %zu offset %zu\n", start, end, offset); const size_t l = end - start; m128 v = loadu128(d); if (noCase) { v = and128(v, caseMask); } u32 buf_off = start - offset; u32 mask = ((1 << l) - 1) << buf_off; u32 z = mask & movemask128(eq128(mask1, v)); DEBUG_PRINTF("mask 0x%08x z 0x%08x\n", mask, z); z &= mask; SINGLE_ZSCAN(); return HWLM_SUCCESS; } static really_inline hwlm_error_t scanDoubleShort(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, m128 caseMask, m128 mask1, m128 mask2, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + start; size_t l = end - start; if (!l) { return HWLM_SUCCESS; } assert(l <= 32); DEBUG_PRINTF("d %zu\n", d - buf); m128 v = zeroes128(); memcpy(&v, d, l); if (noCase) { v = and128(v, caseMask); } u32 z = movemask128(and128(lshiftbyte_m128(eq128(mask1, v), 1), eq128(mask2, v))); // mask out where we can't match u32 mask = (0xFFFF >> (16 - l)); z &= mask; DOUBLE_ZSCAN(); return HWLM_SUCCESS; } static really_inline hwlm_error_t scanDoubleUnaligned(const u8 *buf, size_t len, size_t offset, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, m128 caseMask, m128 mask1, m128 mask2, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + offset; DEBUG_PRINTF("start %zu end %zu offset %zu\n", start, end, offset); size_t l = end - start; m128 v = loadu128(d); if (noCase) { v = and128(v, caseMask); } u32 z = movemask128(and128(lshiftbyte_m128(eq128(mask1, v), 1), eq128(mask2, v))); // mask out where we can't match u32 buf_off = start - offset; u32 mask = ((1 << l) - 1) << buf_off; DEBUG_PRINTF("mask 0x%08x z 0x%08x\n", mask, z); z &= mask; DOUBLE_ZSCAN(); return HWLM_SUCCESS; } static really_inline hwlm_error_t scanSingleFast(const u8 *buf, size_t len, const u8 *key, bool noCase, m128 caseMask, m128 mask1, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + start, *e = buf + end; assert(d < e); for (; d < e; d += 16) { m128 v = noCase ? and128(load128(d), caseMask) : load128(d); u32 z = movemask128(eq128(mask1, v)); // On large packet buffers, this prefetch appears to get us about 2%. __builtin_prefetch(d + 128); SINGLE_ZSCAN(); } return HWLM_SUCCESS; } static really_inline hwlm_error_t scanDoubleFast(const u8 *buf, size_t len, const u8 *key, size_t keyLen, size_t keyOffset, bool noCase, m128 caseMask, m128 mask1, m128 mask2, const struct cb_info *cbi, size_t start, size_t end) { const u8 *d = buf + start, *e = buf + end; assert(d < e); m128 lastz1 = zeroes128(); for (; d < e; d += 16) { m128 v = noCase ? and128(load128(d), caseMask) : load128(d); m128 z1 = eq128(mask1, v); m128 z2 = eq128(mask2, v); u32 z = movemask128(and128(palignr(z1, lastz1, 15), z2)); lastz1 = z1; // On large packet buffers, this prefetch appears to get us about 2%. __builtin_prefetch(d + 128); DEBUG_PRINTF("z 0x%08x\n", z); DOUBLE_ZSCAN(); } return HWLM_SUCCESS; } hyperscan-4.4.1/src/allocator.h0000644000175000017500000000461113055426554017221 0ustar sleuthkidsleuthkid/* * 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 ALLOCATOR_H #define ALLOCATOR_H #include "hs_common.h" #include "ue2common.h" #ifdef __cplusplus extern "C" { #endif extern hs_alloc_t hs_database_alloc; extern hs_alloc_t hs_misc_alloc; extern hs_alloc_t hs_scratch_alloc; extern hs_alloc_t hs_stream_alloc; extern hs_free_t hs_database_free; extern hs_free_t hs_misc_free; extern hs_free_t hs_scratch_free; extern hs_free_t hs_stream_free; #ifdef __cplusplus } /* extern C */ #endif /** \brief Check the results of an alloc done with hs_alloc for alignment. * * If we have incorrect alignment, return an error. Caller should free the * offending block. */ static really_inline hs_error_t hs_check_alloc(const void *mem) { hs_error_t ret = HS_SUCCESS; if (!mem) { ret = HS_NOMEM; } else if (!ISALIGNED_N(mem, alignof(unsigned long long))) { ret = HS_BAD_ALLOC; } return ret; } #endif hyperscan-4.4.1/src/scratch.c0000644000175000017500000003407713055426554016674 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Functions for allocating and manipulating scratch space. */ #include #include #include "allocator.h" #include "hs_internal.h" #include "hs_runtime.h" #include "scratch.h" #include "state.h" #include "ue2common.h" #include "database.h" #include "nfa/nfa_api_queue.h" #include "rose/rose_internal.h" #include "util/fatbit.h" /** * Determine the space required for a correctly aligned array of fatbit * structure, laid out as: * * - an array of num_entries pointers, each to a fatbit. * - an array of fatbit structures, each of size fatbit_len. * * fatbit_len should have been determined at compile time, via the * fatbit_size() call. */ static size_t fatbit_array_size(u32 num_entries, u32 fatbit_len) { size_t len = 0; // Array of pointers to each fatbit entry. len += sizeof(struct fatbit *) * num_entries; // Fatbit entries themselves. len = ROUNDUP_N(len, alignof(struct fatbit)); len += (size_t)fatbit_len * num_entries; return ROUNDUP_N(len, 8); // Round up for potential padding. } /** Used by hs_alloc_scratch and hs_clone_scratch to allocate a complete * scratch region from a prototype structure. */ static hs_error_t alloc_scratch(const hs_scratch_t *proto, hs_scratch_t **scratch) { u32 queueCount = proto->queueCount; u32 activeQueueArraySize = proto->activeQueueArraySize; u32 deduperCount = proto->deduper.dkey_count; u32 deduperLogSize = proto->deduper.log_size; u32 bStateSize = proto->bStateSize; u32 tStateSize = proto->tStateSize; u32 fullStateSize = proto->fullStateSize; u32 anchored_literal_region_len = proto->anchored_literal_region_len; u32 anchored_literal_fatbit_size = proto->anchored_literal_fatbit_size; u32 som_store_size = proto->som_store_count * sizeof(u64a); u32 som_attempted_store_size = proto->som_store_count * sizeof(u64a); u32 som_now_size = proto->som_fatbit_size; u32 som_attempted_size = proto->som_fatbit_size; struct hs_scratch *s; struct hs_scratch *s_tmp; size_t queue_size = queueCount * sizeof(struct mq); size_t qmpq_size = queueCount * sizeof(struct queue_match); assert(anchored_literal_region_len < 8 * sizeof(s->al_log_sum)); size_t anchored_literal_region_size = fatbit_array_size( anchored_literal_region_len, proto->anchored_literal_fatbit_size); size_t delay_region_size = fatbit_array_size(DELAY_SLOT_COUNT, proto->delay_fatbit_size); // the size is all the allocated stuff, not including the struct itself size_t size = queue_size + 63 + bStateSize + tStateSize + fullStateSize + 63 /* cacheline padding */ + proto->handledKeyFatbitSize /* handled roles */ + activeQueueArraySize /* active queue array */ + 2 * deduperLogSize /* need odd and even logs */ + 2 * deduperLogSize /* ditto som logs */ + 2 * sizeof(u64a) * deduperCount /* start offsets for som */ + anchored_literal_region_size + qmpq_size + delay_region_size + som_store_size + som_now_size + som_attempted_size + som_attempted_store_size + 15; /* the struct plus the allocated stuff plus padding for cacheline * alignment */ const size_t alloc_size = sizeof(struct hs_scratch) + size + 256; s_tmp = hs_scratch_alloc(alloc_size); hs_error_t err = hs_check_alloc(s_tmp); if (err != HS_SUCCESS) { hs_scratch_free(s_tmp); *scratch = NULL; return err; } memset(s_tmp, 0, alloc_size); s = ROUNDUP_PTR(s_tmp, 64); DEBUG_PRINTF("allocated %zu bytes at %p but realigning to %p\n", alloc_size, s_tmp, s); DEBUG_PRINTF("sizeof %zu\n", sizeof(struct hs_scratch)); *s = *proto; s->magic = SCRATCH_MAGIC; s->in_use = 0; s->scratchSize = alloc_size; s->scratch_alloc = (char *)s_tmp; // each of these is at an offset from the previous char *current = (char *)s + sizeof(*s); // align current so that the following arrays are naturally aligned: this // is accounted for in the padding allocated current = ROUNDUP_PTR(current, 8); s->queues = (struct mq *)current; current += queue_size; assert(ISALIGNED_N(current, 8)); s->som_store = (u64a *)current; current += som_store_size; s->som_attempted_store = (u64a *)current; current += som_attempted_store_size; current = ROUNDUP_PTR(current, alignof(struct fatbit *)); s->delay_slots = (struct fatbit **)current; current += sizeof(struct fatbit *) * DELAY_SLOT_COUNT; current = ROUNDUP_PTR(current, alignof(struct fatbit)); for (u32 i = 0; i < DELAY_SLOT_COUNT; i++) { s->delay_slots[i] = (struct fatbit *)current; assert(ISALIGNED(s->delay_slots[i])); current += proto->delay_fatbit_size; } current = ROUNDUP_PTR(current, alignof(struct fatbit *)); s->al_log = (struct fatbit **)current; current += sizeof(struct fatbit *) * anchored_literal_region_len; current = ROUNDUP_PTR(current, alignof(struct fatbit)); for (u32 i = 0; i < anchored_literal_region_len; i++) { s->al_log[i] = (struct fatbit *)current; assert(ISALIGNED(s->al_log[i])); current += anchored_literal_fatbit_size; } current = ROUNDUP_PTR(current, 8); s->catchup_pq.qm = (struct queue_match *)current; current += qmpq_size; s->bstate = (char *)current; s->bStateSize = bStateSize; current += bStateSize; s->tstate = (char *)current; s->tStateSize = tStateSize; current += tStateSize; current = ROUNDUP_PTR(current, 64); assert(ISALIGNED_N(current, 8)); s->deduper.som_start_log[0] = (u64a *)current; current += sizeof(u64a) * deduperCount; s->deduper.som_start_log[1] = (u64a *)current; current += sizeof(u64a) * deduperCount; assert(ISALIGNED_N(current, 8)); s->aqa = (struct fatbit *)current; current += activeQueueArraySize; s->handled_roles = (struct fatbit *)current; current += proto->handledKeyFatbitSize; s->deduper.log[0] = (struct fatbit *)current; current += deduperLogSize; s->deduper.log[1] = (struct fatbit *)current; current += deduperLogSize; s->deduper.som_log[0] = (struct fatbit *)current; current += deduperLogSize; s->deduper.som_log[1] = (struct fatbit *)current; current += deduperLogSize; s->som_set_now = (struct fatbit *)current; current += som_now_size; s->som_attempted_set = (struct fatbit *)current; current += som_attempted_size; current = ROUNDUP_PTR(current, 64); assert(ISALIGNED_CL(current)); s->fullState = (char *)current; s->fullStateSize = fullStateSize; current += fullStateSize; *scratch = s; // Don't get too big for your boots assert((size_t)(current - (char *)s) <= alloc_size); // Init q->scratch ptr for every queue. for (struct mq *qi = s->queues; qi != s->queues + queueCount; ++qi) { qi->scratch = s; } return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_alloc_scratch(const hs_database_t *db, hs_scratch_t **scratch) { if (!db || !scratch) { return HS_INVALID; } /* We need to do some real sanity checks on the database as some users mmap * in old deserialised databases, so this is the first real opportunity we * have to make sure it is sane. */ hs_error_t rv = dbIsValid(db); if (rv != HS_SUCCESS) { return rv; } /* We can also sanity-check the scratch parameter: if it points to an * existing scratch area, that scratch should have valid magic bits. */ if (*scratch != NULL) { /* has to be aligned before we can do anything with it */ if (!ISALIGNED_CL(*scratch)) { return HS_INVALID; } if ((*scratch)->magic != SCRATCH_MAGIC) { return HS_INVALID; } if (markScratchInUse(*scratch)) { return HS_SCRATCH_IN_USE; } } const struct RoseEngine *rose = hs_get_bytecode(db); int resize = 0; hs_scratch_t *proto; hs_scratch_t *proto_tmp = hs_scratch_alloc(sizeof(struct hs_scratch) + 256); hs_error_t proto_ret = hs_check_alloc(proto_tmp); if (proto_ret != HS_SUCCESS) { hs_scratch_free(proto_tmp); hs_scratch_free(*scratch); *scratch = NULL; return proto_ret; } proto = ROUNDUP_PTR(proto_tmp, 64); if (*scratch) { *proto = **scratch; } else { memset(proto, 0, sizeof(*proto)); resize = 1; } proto->scratch_alloc = (char *)proto_tmp; if (rose->anchoredDistance > proto->anchored_literal_region_len) { resize = 1; proto->anchored_literal_region_len = rose->anchoredDistance; } if (rose->anchored_fatbit_size > proto->anchored_literal_fatbit_size) { resize = 1; proto->anchored_literal_fatbit_size = rose->anchored_fatbit_size; } if (rose->delay_fatbit_size > proto->delay_fatbit_size) { resize = 1; proto->delay_fatbit_size = rose->delay_fatbit_size; } if (rose->handledKeyFatbitSize > proto->handledKeyFatbitSize) { resize = 1; proto->handledKeyFatbitSize = rose->handledKeyFatbitSize; } if (rose->tStateSize > proto->tStateSize) { resize = 1; proto->tStateSize = rose->tStateSize; } u32 som_store_count = rose->somLocationCount; if (som_store_count > proto->som_store_count) { resize = 1; proto->som_store_count = som_store_count; } if (rose->somLocationFatbitSize > proto->som_fatbit_size) { resize = 1; proto->som_fatbit_size = rose->somLocationFatbitSize; } u32 queueCount = rose->queueCount; if (queueCount > proto->queueCount) { resize = 1; proto->queueCount = queueCount; } if (rose->activeQueueArraySize > proto->activeQueueArraySize) { resize = 1; proto->activeQueueArraySize = rose->activeQueueArraySize; } u32 bStateSize = 0; if (rose->mode == HS_MODE_BLOCK) { bStateSize = rose->stateOffsets.end; } else if (rose->mode == HS_MODE_VECTORED) { /* vectoring database require a full stream state (inc header) */ bStateSize = sizeof(struct hs_stream) + rose->stateOffsets.end; } if (bStateSize > proto->bStateSize) { resize = 1; proto->bStateSize = bStateSize; } u32 fullStateSize = rose->scratchStateSize; if (fullStateSize > proto->fullStateSize) { resize = 1; proto->fullStateSize = fullStateSize; } if (rose->dkeyCount > proto->deduper.dkey_count) { resize = 1; proto->deduper.dkey_count = rose->dkeyCount; proto->deduper.log_size = rose->dkeyLogSize; } if (resize) { if (*scratch) { hs_scratch_free((*scratch)->scratch_alloc); } hs_error_t alloc_ret = alloc_scratch(proto, scratch); hs_scratch_free(proto_tmp); /* kill off temp used for sizing */ if (alloc_ret != HS_SUCCESS) { *scratch = NULL; return alloc_ret; } } else { hs_scratch_free(proto_tmp); /* kill off temp used for sizing */ unmarkScratchInUse(*scratch); } assert(!(*scratch)->in_use); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_clone_scratch(const hs_scratch_t *src, hs_scratch_t **dest) { if (!dest || !src || !ISALIGNED_CL(src) || src->magic != SCRATCH_MAGIC) { return HS_INVALID; } *dest = NULL; hs_error_t ret = alloc_scratch(src, dest); if (ret != HS_SUCCESS) { *dest = NULL; return ret; } assert(!(*dest)->in_use); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_free_scratch(hs_scratch_t *scratch) { if (scratch) { /* has to be aligned before we can do anything with it */ if (!ISALIGNED_CL(scratch)) { return HS_INVALID; } if (scratch->magic != SCRATCH_MAGIC) { return HS_INVALID; } if (markScratchInUse(scratch)) { return HS_SCRATCH_IN_USE; } scratch->magic = 0; assert(scratch->scratch_alloc); DEBUG_PRINTF("scratch %p is really at %p : freeing\n", scratch, scratch->scratch_alloc); hs_scratch_free(scratch->scratch_alloc); } return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_scratch_size(const hs_scratch_t *scratch, size_t *size) { if (!size || !scratch || !ISALIGNED_CL(scratch) || scratch->magic != SCRATCH_MAGIC) { return HS_INVALID; } *size = scratch->scratchSize; return HS_SUCCESS; } hyperscan-4.4.1/src/smallwrite/0000755000175000017500000000000013055426554017251 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/smallwrite/smallwrite_build.h0000644000175000017500000000557513055426554023000 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 SMWR_BUILD_H #define SMWR_BUILD_H /** * SmallWrite Build interface. Everything you ever needed to feed literals in * and get a SmallWriteEngine out. This header should be everything needed by * the rest of UE2. */ #include "ue2common.h" #include "util/alloc.h" #include #include struct SmallWriteEngine; namespace ue2 { struct CompileContext; struct ue2_literal; class NGWrapper; class ReportManager; // Abstract interface intended for callers from elsewhere in the tree, real // underlying implementation is SmallWriteBuildImpl in smwr_build_impl.h. class SmallWriteBuild : boost::noncopyable { public: // Destructor virtual ~SmallWriteBuild(); // Construct a runtime implementation. virtual ue2::aligned_unique_ptr build(u32 roseQuality) = 0; virtual void add(const NGWrapper &w) = 0; virtual void add(const ue2_literal &literal, ReportID r) = 0; virtual std::set all_reports() const = 0; }; // Construct a usable SmallWrite builder. std::unique_ptr makeSmallWriteBuilder(size_t num_patterns, const ReportManager &rm, const CompileContext &cc); size_t smwrSize(const SmallWriteEngine *t); } // namespace ue2 #endif // SMWR_BUILD_H hyperscan-4.4.1/src/smallwrite/smallwrite_dump.cpp0000644000175000017500000000541713055426554023174 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "smallwrite_dump.h" #include "smallwrite_internal.h" #include "ue2common.h" #include "nfa/nfa_build_util.h" #include "nfa/nfa_dump_api.h" #include "nfa/nfa_internal.h" #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { void smwrDumpText(const SmallWriteEngine *smwr, FILE *f) { if (!smwr) { fprintf(f, "<< no smallwrite >>\n"); return; } const struct NFA *n = getSmwrNfa(smwr); fprintf(f, "SmallWrite:\n\n"); fprintf(f, "%s\n", describe(*n).c_str()); fprintf(f, "States: %u\n", n->nPositions); fprintf(f, "Length: %u\n", n->length); fprintf(f, "Largest Short Buffer: %u\n", smwr->largestBuffer); fprintf(f, "Start Offset: %u\n", smwr->start_offset); } void smwrDumpNFA(const SmallWriteEngine *smwr, bool dump_raw, const string &base) { if (!smwr) { DEBUG_PRINTF("no smallwrite\n"); return; } const struct NFA *n = getSmwrNfa(smwr); nfaGenerateDumpFiles(n, base + "smallwrite_nfa"); if (dump_raw) { FILE *f = fopen((base + "smallwrite_nfa.raw").c_str(), "w"); fwrite(n, 1, n->length, f); fclose(f); } } } // namespace ue2 hyperscan-4.4.1/src/smallwrite/smallwrite_build.cpp0000644000175000017500000003653313055426554023331 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "smallwrite/smallwrite_build.h" #include "grey.h" #include "ue2common.h" #include "nfa/dfa_min.h" #include "nfa/mcclellancompile.h" #include "nfa/mcclellancompile_util.h" #include "nfa/nfa_internal.h" #include "nfa/rdfa_merge.h" #include "nfa/shengcompile.h" #include "nfagraph/ng.h" #include "nfagraph/ng_depth.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_mcclellan.h" #include "nfagraph/ng_prune.h" #include "nfagraph/ng_util.h" #include "smallwrite/smallwrite_internal.h" #include "util/alloc.h" #include "util/charreach.h" #include "util/compile_context.h" #include "util/container.h" #include "util/make_unique.h" #include "util/ue2string.h" #include "util/verify_types.h" #include #include #include #include using namespace std; namespace ue2 { #define LITERAL_MERGE_CHUNK_SIZE 25 #define DFA_MERGE_MAX_STATES 8000 namespace { // unnamed // Concrete impl class class SmallWriteBuildImpl : public SmallWriteBuild { public: SmallWriteBuildImpl(size_t num_patterns, const ReportManager &rm, const CompileContext &cc); // Construct a runtime implementation. aligned_unique_ptr build(u32 roseQuality) override; void add(const NGWrapper &w) override; void add(const ue2_literal &literal, ReportID r) override; set all_reports() const override; bool determiniseLiterals(); const ReportManager &rm; const CompileContext &cc; unique_ptr rdfa; vector > cand_literals; bool poisoned; }; } // namespace SmallWriteBuild::~SmallWriteBuild() { } SmallWriteBuildImpl::SmallWriteBuildImpl(size_t num_patterns, const ReportManager &rm_in, const CompileContext &cc_in) : rm(rm_in), cc(cc_in), /* small write is block mode only */ poisoned(!cc.grey.allowSmallWrite || cc.streaming || num_patterns > cc.grey.smallWriteMaxPatterns) { } /** * \brief Remove any reports from the given vertex that cannot match within * max_depth due to their constraints. */ static bool pruneOverlongReports(NFAVertex v, NGHolder &g, const depth &max_depth, const ReportManager &rm) { assert(!g[v].reports.empty()); vector bad_reports; for (ReportID id : g[v].reports) { const auto &report = rm.getReport(id); if (report.minOffset > max_depth) { bad_reports.push_back(id); } } for (ReportID id : bad_reports) { g[v].reports.erase(id); } if (g[v].reports.empty()) { DEBUG_PRINTF("none of vertex %zu's reports can match, cut accepts\n", g[v].index); remove_edge(v, g.accept, g); remove_edge(v, g.acceptEod, g); } return !bad_reports.empty(); } /** * \brief Prune vertices and reports from the graph that cannot match within * max_depth. */ static bool pruneOverlong(NGHolder &g, const depth &max_depth, const ReportManager &rm) { bool modified = false; std::vector depths; calcDepths(g, depths); for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } const auto &d = depths.at(g[v].index); depth min_depth = min(d.fromStart.min, d.fromStartDotStar.min); if (min_depth > max_depth) { clear_vertex(v, g); modified = true; continue; } if (is_match_vertex(v, g)) { modified |= pruneOverlongReports(v, g, max_depth, rm); } } if (modified) { pruneUseless(g); DEBUG_PRINTF("pruned graph down to %zu vertices\n", num_vertices(g)); } return modified; } void SmallWriteBuildImpl::add(const NGWrapper &w) { // If the graph is poisoned (i.e. we can't build a SmallWrite version), // we don't even try. if (poisoned) { return; } if (w.som || w.min_length || isVacuous(w)) { /* cannot support in smwr */ poisoned = true; return; } DEBUG_PRINTF("w=%p\n", &w); // make a copy of the graph so that we can modify it for our purposes unique_ptr h = cloneHolder(w); pruneOverlong(*h, depth(cc.grey.smallWriteLargestBuffer), rm); reduceGraph(*h, SOM_NONE, w.utf8, cc); if (can_never_match(*h)) { DEBUG_PRINTF("graph can never match in small block\n"); return; } // Now we can actually build the McClellan DFA assert(h->kind == NFA_OUTFIX); auto r = buildMcClellan(*h, &rm, cc.grey); // If we couldn't build a McClellan DFA for this portion, we won't be able // build a smwr which represents the pattern set if (!r) { DEBUG_PRINTF("failed to determinise\n"); poisoned = true; return; } if (prune_overlong(*r, cc.grey.smallWriteLargestBuffer)) { minimize_hopcroft(*r, cc.grey); } if (rdfa) { // do a merge of the new dfa with the existing dfa auto merged = mergeTwoDfas(rdfa.get(), r.get(), DFA_MERGE_MAX_STATES, &rm, cc.grey); if (!merged) { DEBUG_PRINTF("merge failed\n"); poisoned = true; return; } DEBUG_PRINTF("merge succeeded, built %p\n", merged.get()); rdfa = move(merged); } else { rdfa = move(r); } } void SmallWriteBuildImpl::add(const ue2_literal &literal, ReportID r) { // If the graph is poisoned (i.e. we can't build a SmallWrite version), // we don't even try. if (poisoned) { return; } if (literal.length() > cc.grey.smallWriteLargestBuffer) { return; /* too long */ } cand_literals.push_back(make_pair(literal, r)); if (cand_literals.size() > cc.grey.smallWriteMaxLiterals) { poisoned = true; } } static void lit_to_graph(NGHolder *h, const ue2_literal &literal, ReportID r) { NFAVertex u = h->startDs; for (const auto &c : literal) { NFAVertex v = add_vertex(*h); add_edge(u, v, *h); (*h)[v].char_reach = c; u = v; } (*h)[u].reports.insert(r); add_edge(u, h->accept, *h); } bool SmallWriteBuildImpl::determiniseLiterals() { DEBUG_PRINTF("handling literals\n"); assert(!poisoned); assert(cand_literals.size() <= cc.grey.smallWriteMaxLiterals); if (cand_literals.empty()) { return true; /* nothing to do */ } vector > temp_dfas; for (const auto &cand : cand_literals) { NGHolder h; DEBUG_PRINTF("determinising %s\n", dumpString(cand.first).c_str()); lit_to_graph(&h, cand.first, cand.second); temp_dfas.push_back(buildMcClellan(h, &rm, cc.grey)); // If we couldn't build a McClellan DFA for this portion, then we // can't SmallWrite optimize the entire graph, so we can't // optimize any of it if (!temp_dfas.back()) { DEBUG_PRINTF("failed to determinise\n"); poisoned = true; return false; } } if (!rdfa && temp_dfas.size() == 1) { /* no need to merge there is only one dfa */ rdfa = move(temp_dfas[0]); return true; } /* do a merge of the new dfas */ vector to_merge; if (rdfa) {/* also include the existing dfa */ to_merge.push_back(rdfa.get()); } for (const auto &d : temp_dfas) { to_merge.push_back(d.get()); } assert(to_merge.size() > 1); while (to_merge.size() > LITERAL_MERGE_CHUNK_SIZE) { vector small_merge; small_merge.insert(small_merge.end(), to_merge.begin(), to_merge.begin() + LITERAL_MERGE_CHUNK_SIZE); temp_dfas.push_back( mergeAllDfas(small_merge, DFA_MERGE_MAX_STATES, &rm, cc.grey)); if (!temp_dfas.back()) { DEBUG_PRINTF("merge failed\n"); poisoned = true; return false; } to_merge.erase(to_merge.begin(), to_merge.begin() + LITERAL_MERGE_CHUNK_SIZE); to_merge.push_back(temp_dfas.back().get()); } auto merged = mergeAllDfas(to_merge, DFA_MERGE_MAX_STATES, &rm, cc.grey); if (!merged) { DEBUG_PRINTF("merge failed\n"); poisoned = true; return false; } DEBUG_PRINTF("merge succeeded, built %p\n", merged.get()); // Replace our only DFA with the merged one rdfa = move(merged); return true; } #define MAX_GOOD_ACCEL_DEPTH 4 static bool is_slow(const raw_dfa &rdfa, const set &accel, u32 roseQuality) { /* we consider a dfa as slow if there is no way to quickly get into an accel * state/dead state. In these cases, it is more likely that we will be * running at our unaccelerated dfa speeds so the small write engine is only * competitive over a small region where start up costs are dominant. */ if (roseQuality) { return true; } set visited; set next; set curr; curr.insert(rdfa.start_anchored); u32 ialpha_size = rdfa.getImplAlphaSize(); for (u32 i = 0; i < MAX_GOOD_ACCEL_DEPTH; i++) { next.clear(); for (dstate_id_t s : curr) { if (contains(visited, s)) { continue; } visited.insert(s); if (s == DEAD_STATE || contains(accel, s)) { return false; } for (size_t j = 0; j < ialpha_size; j++) { next.insert(rdfa.states[s].next[j]); } } curr.swap(next); } return true; } static aligned_unique_ptr getDfa(raw_dfa &rdfa, const CompileContext &cc, const ReportManager &rm, set &accel_states) { aligned_unique_ptr dfa = nullptr; if (cc.grey.allowSmallWriteSheng) { dfa = shengCompile(rdfa, cc, rm, &accel_states); } if (!dfa) { dfa = mcclellanCompile(rdfa, cc, rm, &accel_states); } return dfa; } static aligned_unique_ptr prepEngine(raw_dfa &rdfa, u32 roseQuality, const CompileContext &cc, const ReportManager &rm, u32 *start_offset, u32 *small_region) { *start_offset = remove_leading_dots(rdfa); // Unleash the McClellan! set accel_states; auto nfa = getDfa(rdfa, cc, rm, accel_states); if (!nfa) { DEBUG_PRINTF("DFA compile failed for smallwrite NFA\n"); return nullptr; } if (is_slow(rdfa, accel_states, roseQuality)) { DEBUG_PRINTF("is slow\n"); *small_region = cc.grey.smallWriteLargestBufferBad; if (*small_region <= *start_offset) { return nullptr; } if (prune_overlong(rdfa, *small_region - *start_offset)) { minimize_hopcroft(rdfa, cc.grey); if (rdfa.start_anchored == DEAD_STATE) { DEBUG_PRINTF("all patterns pruned out\n"); return nullptr; } nfa = getDfa(rdfa, cc, rm, accel_states); if (!nfa) { DEBUG_PRINTF("DFA compile failed for smallwrite NFA\n"); assert(0); /* able to build orig dfa but not the trimmed? */ return nullptr; } } } else { *small_region = cc.grey.smallWriteLargestBuffer; } assert(isDfaType(nfa->type)); if (nfa->length > cc.grey.limitSmallWriteOutfixSize || nfa->length > cc.grey.limitDFASize) { DEBUG_PRINTF("smallwrite outfix size too large\n"); return nullptr; /* this is just a soft failure - don't build smwr */ } nfa->queueIndex = 0; /* dummy, small write API does not use queue */ return nfa; } // SmallWriteBuild factory unique_ptr makeSmallWriteBuilder(size_t num_patterns, const ReportManager &rm, const CompileContext &cc) { return ue2::make_unique(num_patterns, rm, cc); } aligned_unique_ptr SmallWriteBuildImpl::build(u32 roseQuality) { if (!rdfa && cand_literals.empty()) { DEBUG_PRINTF("no smallwrite engine\n"); poisoned = true; return nullptr; } if (poisoned) { DEBUG_PRINTF("some pattern could not be made into a smallwrite dfa\n"); return nullptr; } if (!determiniseLiterals()) { DEBUG_PRINTF("some literal could not be made into a smallwrite dfa\n"); return nullptr; } DEBUG_PRINTF("building rdfa %p\n", rdfa.get()); u32 start_offset; u32 small_region; auto nfa = prepEngine(*rdfa, roseQuality, cc, rm, &start_offset, &small_region); if (!nfa) { DEBUG_PRINTF("some smallwrite outfix could not be prepped\n"); /* just skip the smallwrite optimization */ poisoned = true; return nullptr; } u32 size = sizeof(SmallWriteEngine) + nfa->length; auto smwr = aligned_zmalloc_unique(size); smwr->size = size; smwr->start_offset = start_offset; smwr->largestBuffer = small_region; /* copy in nfa after the smwr */ assert(ISALIGNED_CL(smwr.get() + 1)); memcpy(smwr.get() + 1, nfa.get(), nfa->length); DEBUG_PRINTF("smallwrite done %p\n", smwr.get()); return smwr; } set SmallWriteBuildImpl::all_reports() const { set reports; if (poisoned) { return reports; } if (rdfa) { insert(&reports, ::ue2::all_reports(*rdfa)); } for (const auto &cand : cand_literals) { reports.insert(cand.second); } return reports; } size_t smwrSize(const SmallWriteEngine *smwr) { assert(smwr); return smwr->size; } } // namespace ue2 hyperscan-4.4.1/src/smallwrite/smallwrite_internal.h0000644000175000017500000000432113055426554023501 0ustar sleuthkidsleuthkid/* * 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 SMALLWRITE_INTERNAL_H #define SMALLWRITE_INTERNAL_H #include "ue2common.h" // Runtime structure header for SmallWrite. struct ALIGN_CL_DIRECTIVE SmallWriteEngine { u32 largestBuffer; /**< largest buffer that can be considered small write */ u32 start_offset; /**< where to start scanning in the buffer. */ u32 size; /**< size of the small write engine in bytes (including the nfa) */ }; struct NFA; static really_inline const struct NFA *getSmwrNfa(const struct SmallWriteEngine *smwr) { assert(smwr); const struct NFA *n = (const struct NFA *)((const char *)smwr + sizeof(*smwr)); assert(ISALIGNED_CL(n)); return n; } #endif // SMALLWRITE_INTERNAL_H hyperscan-4.4.1/src/smallwrite/smallwrite_dump.h0000644000175000017500000000354713055426554022643 0ustar sleuthkidsleuthkid/* * 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 SMWR_DUMP_H #define SMWR_DUMP_H #ifdef DUMP_SUPPORT #include #include struct SmallWriteEngine; namespace ue2 { void smwrDumpText(const SmallWriteEngine *smwr, FILE *f); void smwrDumpNFA(const SmallWriteEngine *smwr, bool dump_raw, const std::string &base); } // namespace ue2 #endif #endif hyperscan-4.4.1/src/nfa/0000755000175000017500000000000013055426554015632 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/nfa/limex_internal.h0000644000175000017500000002233013055426554021015 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ /** \file This file provides the internal structures and definitions required for the real NFAs (aka limex NFAs ); Limex NFAs now have variable length in memory. They look like this: LimExNFA structure Fixed length, e.g. LimExNFA256. Reachability table Variable length array of state bitvectors, mapped into by NFACommonXXX.reachMap. Tops Variable length array of state bitvectors, used for TOP_N events. Acceleration structures Variable length array of AccelAux structs. Accepts Variable length array of NFAAccept structs. EOD Accepts Variable length array of NFAAccept structs. Exceptions Variable length array of NFAExceptionXXX structs. Repeat Structure Offsets Array of u32 offsets that point at each "Repeat Structure" (below) Repeat Structures Variable length repeat structures, addressed via NFAException32::repeatOffset etc. The state associated with the NFA is split into: -# The "traditional" NFA state as a bitvector. This is stored in the first N bytes of the state space (length given in NFACommonXXX.stateSize), and may be stored shrunk to CEIL(stateSize/8) or compressed. If it is stored compressed, than the LIMEX_FLAG_COMPRESS_STATE flag is set in NFACommonXXX.flags. -# Extended NFA state, only used in some LimEx NFAs. This consists of a variable length array of LimExNFAExtendedState structures, each with pointers to a packed list of mmbit structures that follows them. Only present when used. The value of NFA.stateSize gives the total state size in bytes (the sum of all the above). Number of shifts should be always greater or equal to 1 Number of shifts 0 means that no appropriate NFA engine was found. */ #ifndef LIMEX_INTERNAL_H #define LIMEX_INTERNAL_H #include "nfa_internal.h" #include "repeat_internal.h" // Constants #define MAX_SHIFT_COUNT 8 /**< largest number of shifts used by a LimEx NFA */ #define MAX_SHIFT_AMOUNT 16 /**< largest shift amount used by a LimEx NFA */ #define LIMEX_FLAG_COMPRESS_STATE 1 /**< pack state into stream state */ #define LIMEX_FLAG_COMPRESS_MASKED 2 /**< use reach mask-based compression */ enum LimExTrigger { LIMEX_TRIGGER_NONE = 0, LIMEX_TRIGGER_POS = 1, LIMEX_TRIGGER_TUG = 2 }; enum LimExSquash { LIMEX_SQUASH_NONE = 0, //!< no squash for you! LIMEX_SQUASH_CYCLIC = 1, //!< squash due to cyclic state LIMEX_SQUASH_TUG = 2, //!< squash due to tug trigger with stale estate LIMEX_SQUASH_REPORT = 3 //!< squash when report is raised }; /* uniform looking types for the macros */ typedef u8 u_8; typedef u16 u_16; typedef u32 u_32; typedef u64a u_64; typedef m128 u_128; typedef m256 u_256; typedef m384 u_384; typedef m512 u_512; #define CREATE_NFA_LIMEX(size) \ struct NFAException##size { \ u_##size squash; /**< mask of states to leave on */ \ u_##size successors; /**< mask of states to switch on */ \ u32 reports; /**< offset to start of reports list, or MO_INVALID_IDX */ \ u32 repeatOffset; /**< offset to NFARepeatInfo, or MO_INVALID_IDX */ \ u8 hasSquash; /**< from enum LimExSquash */ \ u8 trigger; /**< from enum LimExTrigger */ \ }; \ \ struct LimExNFA##size { \ u8 reachMap[N_CHARS]; /**< map of char -> entry in reach[] */ \ u32 reachSize; /**< number of reach masks */ \ u32 accelCount; /**< number of entries in accel table */ \ u32 accelTableOffset; /* rel. to start of LimExNFA */ \ u32 accelAuxCount; /**< number of entries in aux table */ \ u32 accelAuxOffset; /* rel. to start of LimExNFA */ \ u32 acceptCount; \ u32 acceptOffset; /* rel. to start of LimExNFA */ \ u32 acceptEodCount; \ u32 acceptEodOffset; /* rel. to start of LimExNFA */ \ u32 exceptionCount; \ u32 exceptionOffset; /* rel. to start of LimExNFA */ \ u32 repeatCount; \ u32 repeatOffset; \ u32 squashOffset; /* rel. to start of LimExNFA; for accept squashing */ \ u32 squashCount; \ u32 topCount; \ u32 topOffset; /* rel. to start of LimExNFA */ \ u32 stateSize; /**< not including extended history */ \ u32 flags; \ u_##size init; \ u_##size initDS; \ u_##size accept; /**< mask of accept states */ \ u_##size acceptAtEOD; /**< mask of states that accept at EOD */ \ u_##size accel; /**< mask of accelerable states */ \ u_##size accelPermute; /**< pshufb permute mask (not GPR) */ \ u_##size accelCompare; /**< pshufb compare mask (not GPR) */ \ u_##size accel_and_friends; /**< mask of accelerable states + likely * followers */ \ u_##size compressMask; /**< switch off before compress */ \ u_##size exceptionMask; \ u_##size repeatCyclicMask; /**< also includes tug states */ \ u_##size zombieMask; /**< zombie if in any of the set states */ \ u_##size shift[MAX_SHIFT_COUNT]; \ u32 shiftCount; /**< number of shift masks used */ \ u8 shiftAmount[MAX_SHIFT_COUNT]; /**< shift amount for each mask */ \ }; CREATE_NFA_LIMEX(32) CREATE_NFA_LIMEX(64) CREATE_NFA_LIMEX(128) CREATE_NFA_LIMEX(256) CREATE_NFA_LIMEX(384) CREATE_NFA_LIMEX(512) /** \brief Structure describing a bounded repeat within the LimEx NFA. * * This struct is followed in memory by: * * -# a RepeatInfo structure * -# a variable-sized lookup table for REPEAT_SPARSE_OPTIMAL_P repeats * -# a TUG mask */ struct NFARepeatInfo { u32 cyclicState; //!< index of this repeat's cyclic state u32 ctrlIndex; //!< index of this repeat's control block u32 packedCtrlOffset; //!< offset to packed control block in stream state u32 stateOffset; //!< offset to repeat state in stream state u32 stateSize; //!< total size of packed stream state for this repeat u32 tugMaskOffset; //!< offset to tug mask (rel. to NFARepeatInfo) }; struct NFAAccept { u8 single_report; //!< If true, 'reports' is report id. /** * \brief If single report is true, this is the report id to fire. * Otherwise, it is the offset (relative to the start of the LimExNFA * structure) of a list of reports, terminated with MO_INVALID_IDX. */ u32 reports; u32 squash; //!< Offset (from LimEx) into squash masks, or MO_INVALID_IDX. }; #endif hyperscan-4.4.1/src/nfa/rdfa_merge.h0000644000175000017500000000506513055426554020104 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Merge code for McClellan DFA. */ #ifndef RDFA_MERGE_H #define RDFA_MERGE_H #include #include namespace ue2 { class ReportManager; struct raw_dfa; struct Grey; /** \brief Attempts to merge two raw_dfas into one. */ std::unique_ptr mergeTwoDfas(const raw_dfa *d1, const raw_dfa *d2, size_t max_states, const ReportManager *rm, const Grey &grey); /** \brief Attempts to merge all the given raw_dfas into one. */ std::unique_ptr mergeAllDfas(const std::vector &dfas, size_t max_states, const ReportManager *rm, const Grey &grey); /** \brief Merges the given list of raw_dfas as much as possible in-place. */ void mergeDfas(std::vector> &dfas, size_t max_states, const ReportManager *rm, const Grey &grey); } // namespace ue2 #endif // RDFA_MERGE_H hyperscan-4.4.1/src/nfa/multivermicelli_sse.h0000644000175000017500000003272513055426554022074 0ustar sleuthkidsleuthkid/* * 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. */ #include "util/bitutils.h" #include "util/simd_utils.h" #include "util/unaligned.h" #define VERM_BOUNDARY 16 #define VERM_TYPE m128 #define VERM_SET_FN set16x8 #include "multiaccel_common.h" static really_inline const u8 *JOIN(MATCH_ALGO, vermUnalignNocase)(m128 chars, const u8 *buf, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { m128 casemask = set16x8(CASE_CLEAR); const u8 *ptr; m128 data = loadu128(buf); u32 z = movemask128(eq128(chars, and128(casemask, data))); ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (buf, z #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } static really_inline const u8 *JOIN(MATCH_ALGO, vermUnalign)(m128 chars, const u8 *buf, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8 *ptr; m128 data = loadu128(buf); u32 z = movemask128(eq128(chars, data)); ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (buf, z #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } /* * 16-byte pipeline, for smaller scans */ static const u8 *JOIN(MATCH_ALGO, vermPipeline16)(m128 chars, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8* ptr, *last_buf; u32 last_res; // pipeline prologue: scan first 16 bytes m128 data = load128(buf); u32 z = movemask128(eq128(chars, data)); last_buf = buf; last_res = z; buf += 16; // now, start the pipeline! assert((size_t)buf % 16 == 0); for (; buf + 15 < buf_end; buf += 16) { // scan more data data = load128(buf); z = movemask128(eq128(chars, data)); // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_buf = buf; last_res = z; } assert(buf <= buf_end && buf >= buf_end - 16); // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } /* * 16-byte pipeline, for smaller scans */ static const u8 *JOIN(MATCH_ALGO, vermPipeline16Nocase)(m128 chars, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { m128 casemask = set16x8(CASE_CLEAR); const u8* ptr, *last_buf; u32 last_res; // pipeline prologue: scan first 16 bytes m128 data = load128(buf); u32 z = movemask128(eq128(chars, and128(casemask, data))); last_buf = buf; last_res = z; buf += 16; // now, start the pipeline! assert((size_t)buf % 16 == 0); for (; buf + 15 < buf_end; buf += 16) { // scan more data data = load128(buf); z = movemask128(eq128(chars, and128(casemask, data))); // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_buf = buf; last_res = z; } assert(buf <= buf_end && buf >= buf_end - 16); // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } /* * 32-byte pipeline, for bigger scans */ static const u8 *JOIN(MATCH_ALGO, vermPipeline32)(m128 chars, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8* ptr, *last_buf; u32 res; // pipeline prologue: scan first 32 bytes m128 data1 = load128(buf); u32 z1 = movemask128(eq128(chars, data1)); m128 data2 = load128(buf + 16); u32 z2 = movemask128(eq128(chars, data2)); // store the results u32 last_res = z1 | (z2 << VERM_BOUNDARY); last_buf = buf; buf += 32; // now, start the pipeline! assert((size_t)buf % 16 == 0); for (; buf + 31 < buf_end; buf += 32) { // scan more data data1 = load128(buf); z1 = movemask128(eq128(chars, data1)); data2 = load128(buf + 16); z2 = movemask128(eq128(chars, data2)); res = z1 | (z2 << 16); // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_res = res; last_buf = buf; } // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } // if we still have some data left, scan it too if (buf + 15 < buf_end) { return JOIN(MATCH_ALGO, vermPipeline16)(chars, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); } assert(buf <= buf_end && buf >= buf_end - 16); return NULL; } /* * 32-byte caseless pipeline, for bigger scans */ static const u8 *JOIN(MATCH_ALGO, vermPipeline32Nocase)(m128 chars, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { m128 casemask = set16x8(CASE_CLEAR); const u8* ptr, *last_buf; u32 last_res; // pipeline prologue: scan first 32 bytes m128 data1 = load128(buf); u32 z1 = movemask128(eq128(chars, and128(casemask, data1))); m128 data2 = load128(buf + 16); u32 z2 = movemask128(eq128(chars, and128(casemask, data2))); u32 z = z1 | (z2 << VERM_BOUNDARY); last_res = z; last_buf = buf; buf += 32; // now, start the pipeline! assert((size_t)buf % 16 == 0); for (; buf + 31 < buf_end; buf += 32) { // scan more data data1 = load128(buf); z1 = movemask128(eq128(chars, and128(casemask, data1))); data2 = load128(buf + 16); z2 = movemask128(eq128(chars, and128(casemask, data2))); z = z1 | (z2 << 16); // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_res = z; last_buf = buf; } // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } // if we still have some data left, scan it too if (buf + 15 < buf_end) { return JOIN(MATCH_ALGO, vermPipeline16Nocase)(chars, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); } assert(buf <= buf_end && buf >= buf_end - 16); return NULL; } const u8 *JOIN(MATCH_ALGO, vermicelliExec)(char c, char nocase, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { DEBUG_PRINTF("verm scan %s\\x%02hhx over %zu bytes\n", nocase ? "nocase " : "", c, (size_t)(buf_end - buf)); assert(buf < buf_end); const u8 *ptr; // Handle small scans. if (buf_end - buf < VERM_BOUNDARY) { for (; buf < buf_end; buf++) { char cur = (char)*buf; if (nocase) { cur &= CASE_CLEAR; } if (cur == c) { break; } } return buf; } VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY; if (min) { ptr = nocase ? JOIN(MATCH_ALGO, vermUnalignNocase)(chars, buf, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ) : JOIN(MATCH_ALGO, vermUnalign)(chars, buf, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } buf += VERM_BOUNDARY - min; } // if we have enough data, run bigger pipeline; otherwise run smaller one if (buf_end - buf >= 128) { ptr = nocase ? JOIN(MATCH_ALGO, vermPipeline32Nocase)(chars, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ) : JOIN(MATCH_ALGO, vermPipeline32)(chars, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } } else if (buf_end - buf >= 16){ ptr = nocase ? JOIN(MATCH_ALGO, vermPipeline16Nocase)(chars, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ) : JOIN(MATCH_ALGO, vermPipeline16)(chars, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } } // final unaligned scan ptr = nocase ? JOIN(MATCH_ALGO, vermUnalignNocase)(chars, buf_end - VERM_BOUNDARY, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ) : JOIN(MATCH_ALGO, vermUnalign)(chars, buf_end - VERM_BOUNDARY, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); // run our pipeline return ptr ? ptr : buf_end; } hyperscan-4.4.1/src/nfa/lbr_dump.cpp0000644000175000017500000001152313055426554020144 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Large Bounded Repeat (LBR): dump code. */ #include "config.h" #include "lbr_dump.h" #include "lbr_internal.h" #include "nfa_dump_internal.h" #include "nfa_internal.h" #include "repeat_internal.h" #include "shufticompile.h" #include "trufflecompile.h" #include "util/charreach.h" #include "util/dump_charclass.h" #include "util/dump_util.h" #ifndef DUMP_SUPPORT #error No dump support! #endif /* Note: No dot files for LBR */ using namespace std; namespace ue2 { static void lbrDumpCommon(const lbr_common *lc, FILE *f) { const RepeatInfo *info = (const RepeatInfo *)((const char *)lc + lc->repeatInfoOffset); fprintf(f, "Limited Bounded Repeat\n"); fprintf(f, "\n"); fprintf(f, "repeat model: %s\n", repeatTypeName(info->type)); fprintf(f, "repeat bounds: {%u, %u}\n", info->repeatMin, info->repeatMax); fprintf(f, "report id: %u\n", lc->report); fprintf(f, "\n"); fprintf(f, "min period: %u\n", info->minPeriod); } void nfaExecLbrDot_dump(const NFA *nfa, const string &base) { assert(nfa); assert(nfa->type == LBR_NFA_DOT); const lbr_dot *ld = (const lbr_dot *)getImplNfa(nfa); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); lbrDumpCommon(&ld->common, f); fprintf(f, "DOT model\n"); fprintf(f, "\n"); dumpTextReverse(nfa, f); fclose(f); } void nfaExecLbrVerm_dump(const NFA *nfa, const string &base) { assert(nfa); assert(nfa->type == LBR_NFA_VERM); const lbr_verm *lv = (const lbr_verm *)getImplNfa(nfa); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); lbrDumpCommon(&lv->common, f); fprintf(f, "VERM model, scanning for 0x%02x\n", lv->c); fprintf(f, "\n"); dumpTextReverse(nfa, f); fclose(f); } void nfaExecLbrNVerm_dump(const NFA *nfa, const string &base) { assert(nfa); assert(nfa->type == LBR_NFA_NVERM); const lbr_verm *lv = (const lbr_verm *)getImplNfa(nfa); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); lbrDumpCommon(&lv->common, f); fprintf(f, "NEGATED VERM model, scanning for 0x%02x\n", lv->c); fprintf(f, "\n"); dumpTextReverse(nfa, f); fclose(f); } void nfaExecLbrShuf_dump(const NFA *nfa, const string &base) { assert(nfa); assert(nfa->type == LBR_NFA_SHUF); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); const lbr_shuf *ls = (const lbr_shuf *)getImplNfa(nfa); lbrDumpCommon(&ls->common, f); CharReach cr = shufti2cr((const u8 *)&ls->mask_lo, (const u8 *)&ls->mask_hi); fprintf(f, "SHUF model, scanning for: %s (%zu chars)\n", describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count()); fprintf(f, "\n"); dumpTextReverse(nfa, f); fclose(f); } void nfaExecLbrTruf_dump(const NFA *nfa, const string &base) { assert(nfa); assert(nfa->type == LBR_NFA_TRUF); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); const lbr_truf *lt = (const lbr_truf *)getImplNfa(nfa); lbrDumpCommon(<->common, f); CharReach cr = truffle2cr((const u8 *)<->mask1, (const u8 *)<->mask2); fprintf(f, "TRUFFLE model, scanning for: %s (%zu chars)\n", describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count()); fprintf(f, "\n"); dumpTextReverse(nfa, f); fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfa/mcclellandump.cpp0000644000175000017500000003253413055426554021165 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "mcclellandump.h" #include "accel.h" #include "accel_dump.h" #include "nfa_dump_internal.h" #include "nfa_internal.h" #include "mcclellan_internal.h" #include "rdfa.h" #include "ue2common.h" #include "util/charreach.h" #include "util/dump_charclass.h" #include "util/dump_util.h" #include "util/unaligned.h" #include #include #include #include #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { const mstate_aux *getAux(const NFA *n, dstate_id_t i) { assert(n && isDfaType(n->type)); const mcclellan *m = (const mcclellan *)getImplNfa(n); const mstate_aux *aux_base = (const mstate_aux *)((const char *)n + m->aux_offset); const mstate_aux *aux = aux_base + i; assert((const char *)aux < (const char *)n + m->length); return aux; } static void mcclellanGetTransitions(const NFA *n, u16 s, u16 *t) { assert(isMcClellanType(n->type)); const mcclellan *m = (const mcclellan *)getImplNfa(n); const mstate_aux *aux = getAux(n, s); const u32 as = m->alphaShift; if (n->type == MCCLELLAN_NFA_8) { const u8 *succ_table = (const u8 *)((const char *)m + sizeof(mcclellan)); for (u16 c = 0; c < N_CHARS; c++) { t[c] = succ_table[((u32)s << as) + m->remap[c]]; } } else { u16 base_s = s; const char *winfo_base = (const char *)n + m->sherman_offset; const char *state_base = winfo_base + SHERMAN_FIXED_SIZE * (s - m->sherman_limit); if (s >= m->sherman_limit) { base_s = unaligned_load_u16(state_base + SHERMAN_DADDY_OFFSET); } const u16 *succ_table = (const u16 *)((const char *)m + sizeof(mcclellan)); for (u16 c = 0; c < N_CHARS; c++) { const u8 *addr = (const u8*)(succ_table + (((u32)base_s << as) + m->remap[c])); t[c] = unaligned_load_u16(addr); t[c] &= STATE_MASK; } if (s >= m->sherman_limit) { UNUSED char type = *(state_base + SHERMAN_TYPE_OFFSET); assert(type == SHERMAN_STATE); u8 len = *(const u8 *)(SHERMAN_LEN_OFFSET + state_base); const char *chars = state_base + SHERMAN_CHARS_OFFSET; const u16 *states = (const u16 *)(state_base + SHERMAN_STATES_OFFSET(len)); for (u8 i = 0; i < len; i++) { for (u16 c = 0; c < N_CHARS; c++) { if (m->remap[c] == chars[i]) { t[c] = unaligned_load_u16((const u8*)&states[i]) & STATE_MASK; } } } } } t[TOP] = aux->top & STATE_MASK; } void describeEdge(FILE *f, const u16 *t, u16 i) { for (u16 s = 0; s < N_CHARS; s++) { if (!t[s]) { continue; } u16 ss; for (ss = 0; ss < s; ss++) { if (t[s] == t[ss]) { break; } } if (ss != s) { continue; } CharReach reach; for (ss = s; ss < 256; ss++) { if (t[s] == t[ss]) { reach.set(ss); } } fprintf(f, "%u -> %u [ label = \"", i, t[s]); describeClass(f, reach, 5, CC_OUT_DOT); fprintf(f, "\" ];\n"); } } void dumpAccelText(FILE *f, const union AccelAux *accel) { switch(accel->accel_type) { case ACCEL_NONE: break; case ACCEL_VERM: fprintf(f, ":V"); break; case ACCEL_DVERM: fprintf(f, ":VV"); break; case ACCEL_VERM_NOCASE: fprintf(f, ":VN"); break; case ACCEL_DVERM_NOCASE: fprintf(f, ":VVN"); break; case ACCEL_SHUFTI: fprintf(f, ":S"); break; case ACCEL_DSHUFTI: fprintf(f, ":SS"); break; case ACCEL_TRUFFLE: fprintf(f, ":M"); break; default: fprintf(f, ":??"); break; } } void dumpAccelDot(FILE *f, u16 i, const union AccelAux *accel) { switch(accel->accel_type) { case ACCEL_NONE: break; case ACCEL_VERM: case ACCEL_VERM_NOCASE: case ACCEL_DVERM: case ACCEL_DVERM_NOCASE: fprintf(f, "%u [ color = forestgreen style=diagonals];\n", i); break; case ACCEL_SHUFTI: case ACCEL_DSHUFTI: case ACCEL_TRUFFLE: fprintf(f, "%u [ color = darkgreen style=diagonals ];\n", i); break; default: fprintf(f, "%u [ color = yellow style=diagonals ];\n", i); break; } } static void describeNode(const NFA *n, const mcclellan *m, u16 i, FILE *f) { const mstate_aux *aux = getAux(n, i); bool isSherman = m->sherman_limit && i >= m->sherman_limit; fprintf(f, "%u [ width = 1, fixedsize = true, fontsize = 12, " "label = \"%u%s\" ]; \n", i, i, isSherman ? "w":""); if (aux->accel_offset) { dumpAccelDot(f, i, (const union AccelAux *) ((const char *)m + aux->accel_offset)); } if (aux->accept_eod) { fprintf(f, "%u [ color = darkorchid ];\n", i); } if (aux->accept) { fprintf(f, "%u [ shape = doublecircle ];\n", i); } if (aux->top && aux->top != i) { fprintf(f, "%u -> %u [color = darkgoldenrod weight=0.1 ]\n", i, aux->top); } if (i == m->start_anchored) { fprintf(f, "STARTA -> %u [color = blue ]\n", i); } if (i == m->start_floating) { fprintf(f, "STARTF -> %u [color = red ]\n", i); } if (isSherman) { const char *winfo_base = (const char *)n + m->sherman_offset; const char *state_base = winfo_base + SHERMAN_FIXED_SIZE * (i - m->sherman_limit); assert(state_base < (const char *)m + m->length - sizeof(NFA)); UNUSED u8 type = *(const u8 *)(state_base + SHERMAN_TYPE_OFFSET); assert(type == SHERMAN_STATE); fprintf(f, "%u [ fillcolor = lightblue style=filled ];\n", i); u16 daddy = *(const u16 *)(state_base + SHERMAN_DADDY_OFFSET); if (daddy) { fprintf(f, "%u -> %u [ color=royalblue style=dashed weight=0.1]\n", i, daddy); } } } void dumpDotPreambleDfa(FILE *f) { dumpDotPreamble(f); // DFA specific additions. fprintf(f, "STARTF [style=invis];\n"); fprintf(f, "STARTA [style=invis];\n"); fprintf(f, "0 [style=invis];\n"); } static void nfaExecMcClellan16_dumpDot(const NFA *nfa, FILE *f) { assert(nfa->type == MCCLELLAN_NFA_16); const mcclellan *m = (const mcclellan *)getImplNfa(nfa); dumpDotPreambleDfa(f); for (u16 i = 1; i < m->state_count; i++) { describeNode(nfa, m, i, f); u16 t[ALPHABET_SIZE]; mcclellanGetTransitions(nfa, i, t); describeEdge(f, t, i); } fprintf(f, "}\n"); } static void nfaExecMcClellan8_dumpDot(const NFA *nfa, FILE *f) { assert(nfa->type == MCCLELLAN_NFA_8); const mcclellan *m = (const mcclellan *)getImplNfa(nfa); dumpDotPreambleDfa(f); for (u16 i = 1; i < m->state_count; i++) { describeNode(nfa, m, i, f); u16 t[ALPHABET_SIZE]; mcclellanGetTransitions(nfa, i, t); describeEdge(f, t, i); } fprintf(f, "}\n"); } static void dumpAccelMasks(FILE *f, const mcclellan *m, const mstate_aux *aux) { fprintf(f, "\n"); fprintf(f, "Acceleration\n"); fprintf(f, "------------\n"); for (u16 i = 0; i < m->state_count; i++) { if (!aux[i].accel_offset) { continue; } const AccelAux *accel = (const AccelAux *)((const char *)m + aux[i].accel_offset); fprintf(f, "%05hu ", i); dumpAccelInfo(f, *accel); } } void describeAlphabet(FILE *f, const mcclellan *m) { map rev; for (u16 i = 0; i < N_CHARS; i++) { rev[m->remap[i]].clear(); } for (u16 i = 0; i < N_CHARS; i++) { rev[m->remap[i]].set(i); } map::const_iterator it; fprintf(f, "\nAlphabet\n"); for (it = rev.begin(); it != rev.end(); ++it) { fprintf(f, "%3hhu: ", it->first); describeClass(f, it->second, 10240, CC_OUT_TEXT); fprintf(f, "\n"); } fprintf(f, "\n"); } static void dumpCommonHeader(FILE *f, const mcclellan *m) { fprintf(f, "report: %u, states: %u, length: %u\n", m->arb_report, m->state_count, m->length); fprintf(f, "astart: %hu, fstart: %hu\n", m->start_anchored, m->start_floating); fprintf(f, "single accept: %d, has_accel: %d\n", !!(int)m->flags & MCCLELLAN_FLAG_SINGLE, m->has_accel); } static void dumpTransitions(FILE *f, const NFA *nfa, const mcclellan *m, const mstate_aux *aux) { for (u16 i = 0; i < m->state_count; i++) { fprintf(f, "%05hu", i); if (aux[i].accel_offset) { dumpAccelText(f, (const union AccelAux *)((const char *)m + aux[i].accel_offset)); } u16 trans[ALPHABET_SIZE]; mcclellanGetTransitions(nfa, i, trans); int rstart = 0; u16 prev = 0xffff; for (int j = 0; j < N_CHARS; j++) { u16 curr = trans[j]; if (curr == prev) { continue; } if (prev != 0xffff) { if (j == rstart + 1) { fprintf(f, " %02x->%hu", rstart, prev); } else { fprintf(f, " [%02x - %02x]->%hu", rstart, j - 1, prev); } } prev = curr; rstart = j; } if (N_CHARS == rstart + 1) { fprintf(f, " %02x->%hu", rstart, prev); } else { fprintf(f, " [%02x - %02x]->%hu", rstart, N_CHARS - 1, prev); } fprintf(f, "\n"); } } static void nfaExecMcClellan16_dumpText(const NFA *nfa, FILE *f) { assert(nfa->type == MCCLELLAN_NFA_16); const mcclellan *m = (const mcclellan *)getImplNfa(nfa); const mstate_aux *aux = (const mstate_aux *)((const char *)nfa + m->aux_offset); fprintf(f, "mcclellan 16\n"); dumpCommonHeader(f, m); fprintf(f, "sherman_limit: %d, sherman_end: %d\n", (int)m->sherman_limit, (int)m->sherman_end); fprintf(f, "\n"); describeAlphabet(f, m); dumpTransitions(f, nfa, m, aux); dumpAccelMasks(f, m, aux); fprintf(f, "\n"); dumpTextReverse(nfa, f); } static void nfaExecMcClellan8_dumpText(const NFA *nfa, FILE *f) { assert(nfa->type == MCCLELLAN_NFA_8); const mcclellan *m = (const mcclellan *)getImplNfa(nfa); const mstate_aux *aux = (const mstate_aux *)((const char *)nfa + m->aux_offset); fprintf(f, "mcclellan 8\n"); dumpCommonHeader(f, m); fprintf(f, "accel_limit: %hu, accept_limit %hu\n", m->accel_limit_8, m->accept_limit_8); fprintf(f, "\n"); describeAlphabet(f, m); dumpTransitions(f, nfa, m, aux); dumpAccelMasks(f, m, aux); fprintf(f, "\n"); dumpTextReverse(nfa, f); } void nfaExecMcClellan16_dump(const NFA *nfa, const string &base) { assert(nfa->type == MCCLELLAN_NFA_16); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); nfaExecMcClellan16_dumpText(nfa, f); fclose(f); f = fopen_or_throw((base + ".dot").c_str(), "w"); nfaExecMcClellan16_dumpDot(nfa, f); fclose(f); } void nfaExecMcClellan8_dump(const NFA *nfa, const string &base) { assert(nfa->type == MCCLELLAN_NFA_8); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); nfaExecMcClellan8_dumpText(nfa, f); fclose(f); f = fopen_or_throw((base + ".dot").c_str(), "w"); nfaExecMcClellan8_dumpDot(nfa, f); fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfa/goughcompile_dump.h0000644000175000017500000000452313055426554021516 0ustar sleuthkidsleuthkid/* * 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 GOUGHCOMPILE_DUMP_H #define GOUGHCOMPILE_DUMP_H #include "goughcompile_internal.h" #include #include namespace ue2 { struct Grey; #ifdef DUMP_SUPPORT std::string dump_name(const GoughVertexProps &vp); std::string dump_name(const gough_edge_id &e); void dump(const GoughGraph &g, const std::string &base, const Grey &grey); void dump_blocks(const std::map > &blocks, const std::string &base, const Grey &grey); #else static UNUSED void dump(UNUSED const GoughGraph &g, UNUSED const std::string &base, UNUSED const Grey &grey) { } static UNUSED void dump_blocks( UNUSED const std::map > &blocks, UNUSED const std::string &base, UNUSED const Grey &grey) { } #endif } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/nfa_rev_api.h0000644000175000017500000001277713055426554020272 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Reverse-acceleration optimizations for the NFA API block mode scans. */ #ifndef NFA_REV_API_H #define NFA_REV_API_H #include "accel.h" #include "nfa_internal.h" #include "vermicelli.h" #include "util/unaligned.h" static really_inline size_t nfaRevAccel_i(const struct NFA *nfa, const u8 *buffer, size_t length) { DEBUG_PRINTF("checking rev accel mw %u\n", nfa->minWidth); assert(nfa->rAccelOffset >= 1); assert(nfa->rAccelOffset <= nfa->minWidth); const u8 *rv; // result for accel engine switch (nfa->rAccelType) { case ACCEL_RVERM: DEBUG_PRINTF("ACCEL_RVERM\n"); if (length + 1 - nfa->rAccelOffset < 16) { break; } rv = rvermicelliExec(nfa->rAccelData.c, 0, buffer, buffer + length + 1 - nfa->rAccelOffset); length = (size_t)(rv - buffer + nfa->rAccelOffset); break; case ACCEL_RVERM_NOCASE: DEBUG_PRINTF("ACCEL_RVERM_NOCASE\n"); if (length + 1 - nfa->rAccelOffset < 16) { break; } rv = rvermicelliExec(nfa->rAccelData.c, 1, buffer, buffer + length + 1 - nfa->rAccelOffset); length = (size_t)(rv - buffer + nfa->rAccelOffset); break; case ACCEL_RDVERM: DEBUG_PRINTF("ACCEL_RDVERM\n"); if (length + 1 - nfa->rAccelOffset < 17) { break; } rv = rvermicelliDoubleExec(nfa->rAccelData.array[0], nfa->rAccelData.array[1], 0, buffer, buffer + length + 1 - nfa->rAccelOffset); length = (size_t)(rv - buffer + nfa->rAccelOffset); break; case ACCEL_RDVERM_NOCASE: DEBUG_PRINTF("ACCEL_RVERM_NOCASE\n"); if (length + 1 - nfa->rAccelOffset < 17) { break; } rv = rvermicelliDoubleExec(nfa->rAccelData.array[0], nfa->rAccelData.array[1], 1, buffer, buffer + length + 1 - nfa->rAccelOffset); length = (size_t)(rv - buffer + nfa->rAccelOffset); break; case ACCEL_REOD: DEBUG_PRINTF("ACCEL_REOD\n"); if (buffer[length - nfa->rAccelOffset] != nfa->rAccelData.c) { return 0; } break; case ACCEL_REOD_NOCASE: DEBUG_PRINTF("ACCEL_REOD_NOCASE\n"); if ((buffer[length - nfa->rAccelOffset] & CASE_CLEAR) != nfa->rAccelData.c) { return 0; } break; case ACCEL_RDEOD: DEBUG_PRINTF("ACCEL_RDEOD\n"); if (unaligned_load_u16(buffer + length - nfa->rAccelOffset) != nfa->rAccelData.dc) { return 0; } break; case ACCEL_RDEOD_NOCASE: DEBUG_PRINTF("ACCEL_RDEOD_NOCASE\n"); if ((unaligned_load_u16(buffer + length - nfa->rAccelOffset) & DOUBLE_CASE_CLEAR) != nfa->rAccelData.dc) { return 0; } break; default: assert(!"not here"); } if (nfa->minWidth > length) { DEBUG_PRINTF("post-accel, scan skipped: %zu < min %u bytes\n", length, nfa->minWidth); return 0; } return length; } /** \brief Reverse acceleration check. Returns a new length for the block, * guaranteeing that a match cannot occur beyond that point. */ static really_inline size_t nfaRevAccelCheck(const struct NFA *nfa, const u8 *buffer, size_t length) { assert(nfa); // If this block is not long enough to satisfy the minimum width // constraint on this NFA, we can avoid the scan altogether. if (nfa->minWidth > length) { DEBUG_PRINTF("scan skipped: %zu < min %u bytes\n", length, nfa->minWidth); return 0; } if (nfa->rAccelType == ACCEL_NONE) { DEBUG_PRINTF("no rev accel available\n"); return length; } size_t rv_length = nfaRevAccel_i(nfa, buffer, length); assert(rv_length <= length); return rv_length; } #endif hyperscan-4.4.1/src/nfa/multitruffle_sse.h0000644000175000017500000002136613055426554021407 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "ue2common.h" #include "multiaccel_common.h" /* * include "block" function */ #include "truffle_common.h" /* * single-byte truffle fwd match function, should only be defined when not * compiling multiaccel */ static really_inline const u8 *JOIN(MATCH_ALGO, fwdBlock)(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, m128 v, const u8 *buf, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v) ^ 0xFFFF; return (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])(buf, z #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); } /* * 16-byte pipeline, for smaller scans */ static const u8 *JOIN(MATCH_ALGO, trufflePipeline16)(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8* ptr, *last_buf; u32 last_res; // pipeline prologue: scan first 16 bytes m128 data = load128(buf); u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data) ^ 0xFFFF; last_buf = buf; last_res = z; buf += 16; // now, start the pipeline! assert((size_t)buf % 16 == 0); for (; buf + 15 < buf_end; buf += 16) { // scan more data data = load128(buf); z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data) ^ 0xFFFF; // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_buf = buf; last_res = z; } assert(buf <= buf_end && buf >= buf_end - 16); // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } /* * 32-byte pipeline, for bigger scans */ static const u8 *JOIN(MATCH_ALGO, trufflePipeline32)(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8* ptr, *last_buf; u32 res; // pipeline prologue: scan first 32 bytes m128 data1 = load128(buf); u32 z1 = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data1) ^ 0xFFFF; m128 data2 = load128(buf + 16); u32 z2 = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data2) ^ 0xFFFF; // store the results u32 last_res = z1 | (z2 << 16); last_buf = buf; buf += 32; // now, start the pipeline! assert((size_t)buf % 16 == 0); for (; buf + 31 < buf_end; buf += 32) { // scan more data data1 = load128(buf); z1 = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data1) ^ 0xFFFF; data2 = load128(buf + 16); z2 = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, data2) ^ 0xFFFF; res = z1 | (z2 << 16); // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_res = res; last_buf = buf; } // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } // if we still have some data left, scan it too for (; buf + 15 < buf_end; buf += 16) { m128 chars = load128(buf); ptr = JOIN(MATCH_ALGO, fwdBlock)(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars, buf, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } } assert(buf <= buf_end && buf >= buf_end - 16); return NULL; } const u8 *JOIN(MATCH_ALGO, truffleExec)(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { DEBUG_PRINTF("run_len %zu\n", buf_end - buf); assert(buf && buf_end); assert(buf < buf_end); const u8 *rv; if (buf_end - buf < 16) { return truffleMini(shuf_mask_lo_highclear, shuf_mask_lo_highset, buf, buf_end); } size_t min = (size_t)buf % 16; assert(buf_end - buf >= 16); // Preconditioning: most of the time our buffer won't be aligned. m128 chars = loadu128(buf); rv = JOIN(MATCH_ALGO, fwdBlock)(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars, buf, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } buf += (16 - min); // if we have enough data, run bigger pipeline; otherwise run smaller one if (buf_end - buf >= 128) { rv = JOIN(MATCH_ALGO, trufflePipeline32)(shuf_mask_lo_highclear, shuf_mask_lo_highset, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(rv)) { return rv; } } else if (buf_end - buf >= 16){ rv = JOIN(MATCH_ALGO, trufflePipeline16)(shuf_mask_lo_highclear, shuf_mask_lo_highset, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(rv)) { return rv; } } // Use an unaligned load to mop up the last 16 bytes and get an accurate // picture to buf_end. chars = loadu128(buf_end - 16); rv = JOIN(MATCH_ALGO, fwdBlock)(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars, buf_end - 16, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } return buf_end; } hyperscan-4.4.1/src/nfa/dfa_build_strat.cpp0000644000175000017500000000341413055426554021466 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "dfa_build_strat.h" namespace ue2 { // prevent weak vtables for raw_report_info, dfa_build_strat and raw_dfa raw_report_info::~raw_report_info() {} dfa_build_strat::~dfa_build_strat() {} raw_dfa::~raw_dfa() {} } // namespace ue2 hyperscan-4.4.1/src/nfa/rdfa.h0000644000175000017500000000577213055426554016732 0ustar sleuthkidsleuthkid/* * 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 RDFA_H #define RDFA_H #include "nfa_kind.h" #include "ue2common.h" #include "util/ue2_containers.h" #include #include namespace ue2 { typedef u16 dstate_id_t; typedef u16 symbol_t; static constexpr symbol_t TOP = 256; static constexpr symbol_t ALPHABET_SIZE = 257; static constexpr symbol_t N_SPECIAL_SYMBOL = 1; static constexpr dstate_id_t DEAD_STATE = 0; /** Structure representing a dfa state during construction. */ struct dstate { /** Next state; indexed by remapped sym */ std::vector next; /** Set by ng_mcclellan, refined by mcclellancompile */ dstate_id_t daddy = 0; /** Set by mcclellancompile, implementation state id, excludes edge * decorations */ dstate_id_t impl_id = 0; /** Reports to fire (at any location). */ flat_set reports; /** Reports to fire (at EOD). */ flat_set reports_eod; explicit dstate(size_t alphabet_size) : next(alphabet_size, 0) {} }; struct raw_dfa { nfa_kind kind; std::vector states; dstate_id_t start_anchored = DEAD_STATE; dstate_id_t start_floating = DEAD_STATE; u16 alpha_size = 0; /* including special symbols */ /* mapping from input symbol --> equiv class id */ std::array alpha_remap; explicit raw_dfa(nfa_kind k) : kind(k) {} virtual ~raw_dfa(); u16 getImplAlphaSize() const; virtual void stripExtraEodReports(void); bool hasEodReports(void) const; }; } #endif hyperscan-4.4.1/src/nfa/rdfa_merge.cpp0000644000175000017500000003012013055426554020425 0ustar sleuthkidsleuthkid/* * 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. */ #include "rdfa_merge.h" #include "grey.h" #include "dfa_min.h" #include "mcclellancompile_util.h" #include "rdfa.h" #include "ue2common.h" #include "nfagraph/ng_mcclellan_internal.h" #include "util/container.h" #include "util/determinise.h" #include "util/make_unique.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include using namespace std; namespace ue2 { #define MAX_DFA_STATES 16383 namespace { class Automaton_Merge { public: typedef vector StateSet; typedef ue2::unordered_map StateMap; Automaton_Merge(const raw_dfa *rdfa1, const raw_dfa *rdfa2, const ReportManager *rm_in, const Grey &grey_in) : rm(rm_in), grey(grey_in), nfas{rdfa1, rdfa2}, dead(2) { calculateAlphabet(); populateAsFs(); prunable = isPrunable(); } Automaton_Merge(const vector &dfas, const ReportManager *rm_in, const Grey &grey_in) : rm(rm_in), grey(grey_in), nfas(dfas), dead(nfas.size()) { calculateAlphabet(); populateAsFs(); prunable = isPrunable(); } void populateAsFs(void) { bool fs_same = true; bool fs_dead = true; as.resize(nfas.size()); fs.resize(nfas.size()); for (size_t i = 0, end = nfas.size(); i < end; i++) { as[i] = nfas[i]->start_anchored; fs[i] = nfas[i]->start_floating; if (fs[i]) { fs_dead = false; } if (as[i] != fs[i]) { fs_same = false; } } start_anchored = DEAD_STATE + 1; if (fs_same) { start_floating = start_anchored; } else if (fs_dead) { start_floating = DEAD_STATE; } else { start_floating = start_anchored + 1; } } void calculateAlphabet(void) { DEBUG_PRINTF("calculating alphabet\n"); vector esets = {CharReach::dot()}; for (const auto &rdfa : nfas) { DEBUG_PRINTF("...next dfa alphabet\n"); assert(rdfa); const auto &alpha_remap = rdfa->alpha_remap; for (size_t i = 0; i < esets.size(); i++) { assert(esets[i].count()); if (esets[i].count() == 1) { DEBUG_PRINTF("skipping singleton eq set\n"); continue; } CharReach t; u8 leader_s = alpha_remap[esets[i].find_first()]; DEBUG_PRINTF("checking eq set, leader %02hhx \n", leader_s); for (size_t s = esets[i].find_first(); s != CharReach::npos; s = esets[i].find_next(s)) { if (alpha_remap[s] != leader_s) { t.set(s); } } if (t.any() && t != esets[i]) { esets[i] &= ~t; esets.push_back(t); } } } alphasize = buildAlphabetFromEquivSets(esets, alpha, unalpha); } bool isPrunable() const { if (!grey.highlanderPruneDFA || !rm) { DEBUG_PRINTF("disabled, or not managed reports\n"); return false; } assert(!nfas.empty()); if (!generates_callbacks(nfas.front()->kind)) { DEBUG_PRINTF("doesn't generate callbacks\n"); return false; } // Collect all reports from all merge candidates. flat_set merge_reports; for (const auto &rdfa : nfas) { insert(&merge_reports, all_reports(*rdfa)); } DEBUG_PRINTF("all reports: %s\n", as_string_list(merge_reports).c_str()); // Return true if they're all exhaustible with the same exhaustion key. u32 ekey = INVALID_EKEY; for (const auto &report_id : merge_reports) { const Report &r = rm->getReport(report_id); if (!isSimpleExhaustible(r)) { DEBUG_PRINTF("report %u not simple exhaustible\n", report_id); return false; } assert(r.ekey != INVALID_EKEY); if (ekey == INVALID_EKEY) { ekey = r.ekey; } else if (ekey != r.ekey) { DEBUG_PRINTF("two different ekeys, %u and %u\n", ekey, r.ekey); return false; } } DEBUG_PRINTF("is prunable\n"); return true; } void transition(const StateSet &in, StateSet *next) { u16 t[ALPHABET_SIZE]; for (u32 i = 0; i < alphasize; i++) { next[i].resize(nfas.size()); } for (size_t j = 0, j_end = nfas.size(); j < j_end; j++) { getFullTransitionFromState(*nfas[j], in[j], t); for (u32 i = 0; i < alphasize; i++) { next[i][j] = t[unalpha[i]]; } } } const vector initial() { vector rv = {as}; if (start_floating != DEAD_STATE && start_floating != start_anchored) { rv.push_back(fs); } return rv; } private: void reports_i(const StateSet &in, flat_set dstate::*r_set, flat_set &r) const { for (size_t i = 0, end = nfas.size(); i < end; i++) { const auto &rs = nfas[i]->states[in[i]].*r_set; insert(&r, rs); } } public: void reports(const StateSet &in, flat_set &rv) const { reports_i(in, &dstate::reports, rv); } void reportsEod(const StateSet &in, flat_set &rv) const { reports_i(in, &dstate::reports_eod, rv); } bool canPrune(const flat_set &test_reports) const { if (!grey.highlanderPruneDFA || !prunable) { return false; } // Must all be external reports. assert(rm); for (const auto &report_id : test_reports) { if (!isExternalReport(rm->getReport(report_id))) { return false; } } return true; } /** True if the minimization algorithm should be run after merging. */ bool shouldMinimize() const { // We only need to run minimization if our merged DFAs shared a report. flat_set seen_reports; for (const auto &rdfa : nfas) { for (const auto &report_id : all_reports(*rdfa)) { if (!seen_reports.insert(report_id).second) { DEBUG_PRINTF("report %u in several dfas\n", report_id); return true; } } } return false; } private: const ReportManager *rm; const Grey &grey; vector nfas; vector as; vector fs; bool prunable = false; public: std::array alpha; std::array unalpha; u16 alphasize; StateSet dead; u16 start_anchored; u16 start_floating; }; } // namespace unique_ptr mergeTwoDfas(const raw_dfa *d1, const raw_dfa *d2, size_t max_states, const ReportManager *rm, const Grey &grey) { assert(d1 && d2); assert(d1->kind == d2->kind); assert(max_states <= MAX_DFA_STATES); auto rdfa = ue2::make_unique(d1->kind); Automaton_Merge autom(d1, d2, rm, grey); if (!determinise(autom, rdfa->states, max_states)) { rdfa->start_anchored = autom.start_anchored; rdfa->start_floating = autom.start_floating; rdfa->alpha_size = autom.alphasize; rdfa->alpha_remap = autom.alpha; DEBUG_PRINTF("merge succeeded, %zu states\n", rdfa->states.size()); if (autom.shouldMinimize()) { minimize_hopcroft(*rdfa, grey); DEBUG_PRINTF("minimized, %zu states\n", rdfa->states.size()); } return rdfa; } return nullptr; } void mergeDfas(vector> &dfas, size_t max_states, const ReportManager *rm, const Grey &grey) { assert(max_states <= MAX_DFA_STATES); if (dfas.size() <= 1) { return; } DEBUG_PRINTF("before merging, we have %zu dfas\n", dfas.size()); queue> q; for (auto &dfa : dfas) { q.push(move(dfa)); } // All DFAs are now on the queue, so we'll clear the vector and use it for // output from here. dfas.clear(); while (q.size() > 1) { // Attempt to merge the two front elements of the queue. unique_ptr d1 = move(q.front()); q.pop(); unique_ptr d2 = move(q.front()); q.pop(); auto rdfa = mergeTwoDfas(d1.get(), d2.get(), max_states, rm, grey); if (rdfa) { q.push(move(rdfa)); } else { DEBUG_PRINTF("failed to merge\n"); // Put the larger of the two DFAs on the output list, retain the // smaller one on the queue for further merge attempts. if (d2->states.size() > d1->states.size()) { dfas.push_back(move(d2)); q.push(move(d1)); } else { dfas.push_back(move(d1)); q.push(move(d2)); } } } while (!q.empty()) { dfas.push_back(move(q.front())); q.pop(); } DEBUG_PRINTF("after merging, we have %zu dfas\n", dfas.size()); } unique_ptr mergeAllDfas(const vector &dfas, size_t max_states, const ReportManager *rm, const Grey &grey) { assert(max_states <= MAX_DFA_STATES); assert(!dfas.empty()); // All the DFAs should be of the same kind. const auto kind = dfas.front()->kind; assert(all_of(begin(dfas), end(dfas), [&kind](const raw_dfa *rdfa) { return rdfa->kind == kind; })); auto rdfa = ue2::make_unique(kind); Automaton_Merge n(dfas, rm, grey); DEBUG_PRINTF("merging dfa\n"); if (determinise(n, rdfa->states, max_states)) { DEBUG_PRINTF("state limit (%zu) exceeded\n", max_states); return nullptr; /* over state limit */ } rdfa->start_anchored = n.start_anchored; rdfa->start_floating = n.start_floating; rdfa->alpha_size = n.alphasize; rdfa->alpha_remap = n.alpha; DEBUG_PRINTF("merged, building impl dfa (a,f) = (%hu,%hu)\n", rdfa->start_anchored, rdfa->start_floating); if (n.shouldMinimize()) { minimize_hopcroft(*rdfa, grey); DEBUG_PRINTF("minimized, %zu states\n", rdfa->states.size()); } return rdfa; } } // namespace ue2 hyperscan-4.4.1/src/nfa/shufti.c0000644000175000017500000005110213055426554017277 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Shufti: character class acceleration. * * Utilises the SSSE3 pshufb shuffle instruction */ #include "shufti.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" #include "util/unaligned.h" #include "shufti_common.h" /** \brief Naive byte-by-byte implementation. */ static really_inline const u8 *shuftiRevSlow(const u8 *lo, const u8 *hi, const u8 *buf, const u8 *buf_end) { assert(buf < buf_end); for (buf_end--; buf_end >= buf; buf_end--) { u8 c = *buf_end; if (lo[c & 0xf] & hi[c >> 4]) { break; } } return buf_end; } #if !defined(__AVX2__) /* Normal SSSE3 shufti */ static really_inline const u8 *firstMatch(const u8 *buf, u32 z) { if (unlikely(z != 0xffff)) { u32 pos = ctz32(~z & 0xffff); assert(pos < 16); return buf + pos; } else { return NULL; // no match } } static really_inline const u8 *fwdBlock(m128 mask_lo, m128 mask_hi, m128 chars, const u8 *buf, const m128 low4bits, const m128 zeroes) { u32 z = block(mask_lo, mask_hi, chars, low4bits, zeroes); return firstMatch(buf, z); } const u8 *shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end) { assert(buf && buf_end); assert(buf < buf_end); // Slow path for small cases. if (buf_end - buf < 16) { return shuftiFwdSlow((const u8 *)&mask_lo, (const u8 *)&mask_hi, buf, buf_end); } const m128 zeroes = zeroes128(); const m128 low4bits = _mm_set1_epi8(0xf); const u8 *rv; size_t min = (size_t)buf % 16; assert(buf_end - buf >= 16); // Preconditioning: most of the time our buffer won't be aligned. m128 chars = loadu128(buf); rv = fwdBlock(mask_lo, mask_hi, chars, buf, low4bits, zeroes); if (rv) { return rv; } buf += (16 - min); // Unrolling was here, but it wasn't doing anything but taking up space. // Reroll FTW. const u8 *last_block = buf_end - 16; while (buf < last_block) { m128 lchars = load128(buf); rv = fwdBlock(mask_lo, mask_hi, lchars, buf, low4bits, zeroes); if (rv) { return rv; } buf += 16; } // Use an unaligned load to mop up the last 16 bytes and get an accurate // picture to buf_end. assert(buf <= buf_end && buf >= buf_end - 16); chars = loadu128(buf_end - 16); rv = fwdBlock(mask_lo, mask_hi, chars, buf_end - 16, low4bits, zeroes); if (rv) { return rv; } return buf_end; } static really_inline const u8 *lastMatch(const u8 *buf, m128 t, m128 compare) { #ifdef DEBUG DEBUG_PRINTF("confirming match in:"); dumpMsk128(t); printf("\n"); #endif u32 z = movemask128(eq128(t, compare)); if (unlikely(z != 0xffff)) { u32 pos = clz32(~z & 0xffff); DEBUG_PRINTF("buf=%p, pos=%u\n", buf, pos); assert(pos >= 16 && pos < 32); return buf + (31 - pos); } else { return NULL; // no match } } static really_inline const u8 *revBlock(m128 mask_lo, m128 mask_hi, m128 chars, const u8 *buf, const m128 low4bits, const m128 zeroes) { m128 c_lo = pshufb(mask_lo, GET_LO_4(chars)); m128 c_hi = pshufb(mask_hi, GET_HI_4(chars)); m128 t = and128(c_lo, c_hi); #ifdef DEBUG DEBUG_PRINTF(" chars: "); dumpMsk128AsChars(chars); printf("\n"); DEBUG_PRINTF(" char: "); dumpMsk128(chars); printf("\n"); DEBUG_PRINTF(" c_lo: "); dumpMsk128(c_lo); printf("\n"); DEBUG_PRINTF(" c_hi: "); dumpMsk128(c_hi); printf("\n"); DEBUG_PRINTF(" t: "); dumpMsk128(t); printf("\n"); #endif return lastMatch(buf, t, zeroes); } const u8 *rshuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end) { assert(buf && buf_end); assert(buf < buf_end); // Slow path for small cases. if (buf_end - buf < 16) { return shuftiRevSlow((const u8 *)&mask_lo, (const u8 *)&mask_hi, buf, buf_end); } const m128 zeroes = zeroes128(); const m128 low4bits = _mm_set1_epi8(0xf); const u8 *rv; assert(buf_end - buf >= 16); // Preconditioning: most of the time our buffer won't be aligned. m128 chars = loadu128(buf_end - 16); rv = revBlock(mask_lo, mask_hi, chars, buf_end - 16, low4bits, zeroes); if (rv) { return rv; } buf_end = (const u8 *)((size_t)buf_end & ~((size_t)0xf)); // Unrolling was here, but it wasn't doing anything but taking up space. // Reroll FTW. const u8 *last_block = buf + 16; while (buf_end > last_block) { buf_end -= 16; m128 lchars = load128(buf_end); rv = revBlock(mask_lo, mask_hi, lchars, buf_end, low4bits, zeroes); if (rv) { return rv; } } // Use an unaligned load to mop up the last 16 bytes and get an accurate // picture to buf. chars = loadu128(buf); rv = revBlock(mask_lo, mask_hi, chars, buf, low4bits, zeroes); if (rv) { return rv; } return buf - 1; } static really_inline const u8 *fwdBlock2(m128 mask1_lo, m128 mask1_hi, m128 mask2_lo, m128 mask2_hi, m128 chars, const u8 *buf, const m128 low4bits, const m128 ones) { m128 chars_lo = GET_LO_4(chars); m128 chars_hi = GET_HI_4(chars); m128 c_lo = pshufb(mask1_lo, chars_lo); m128 c_hi = pshufb(mask1_hi, chars_hi); m128 t = or128(c_lo, c_hi); #ifdef DEBUG DEBUG_PRINTF(" chars: "); dumpMsk128AsChars(chars); printf("\n"); DEBUG_PRINTF(" char: "); dumpMsk128(chars); printf("\n"); DEBUG_PRINTF(" c_lo: "); dumpMsk128(c_lo); printf("\n"); DEBUG_PRINTF(" c_hi: "); dumpMsk128(c_hi); printf("\n"); DEBUG_PRINTF(" t: "); dumpMsk128(t); printf("\n"); #endif m128 c2_lo = pshufb(mask2_lo, chars_lo); m128 c2_hi = pshufb(mask2_hi, chars_hi); m128 t2 = or128(t, rshiftbyte_m128(or128(c2_lo, c2_hi), 1)); #ifdef DEBUG DEBUG_PRINTF(" c2_lo: "); dumpMsk128(c2_lo); printf("\n"); DEBUG_PRINTF(" c2_hi: "); dumpMsk128(c2_hi); printf("\n"); DEBUG_PRINTF(" t2: "); dumpMsk128(t2); printf("\n"); #endif u32 z = movemask128(eq128(t2, ones)); DEBUG_PRINTF(" z: 0x%08x\n", z); return firstMatch(buf, z); } const u8 *shuftiDoubleExec(m128 mask1_lo, m128 mask1_hi, m128 mask2_lo, m128 mask2_hi, const u8 *buf, const u8 *buf_end) { const m128 ones = ones128(); const m128 low4bits = _mm_set1_epi8(0xf); const u8 *rv; size_t min = (size_t)buf % 16; // Preconditioning: most of the time our buffer won't be aligned. m128 chars = loadu128(buf); rv = fwdBlock2(mask1_lo, mask1_hi, mask2_lo, mask2_hi, chars, buf, low4bits, ones); if (rv) { return rv; } buf += (16 - min); // Unrolling was here, but it wasn't doing anything but taking up space. // Reroll FTW. const u8 *last_block = buf_end - 16; while (buf < last_block) { m128 lchars = load128(buf); rv = fwdBlock2(mask1_lo, mask1_hi, mask2_lo, mask2_hi, lchars, buf, low4bits, ones); if (rv) { return rv; } buf += 16; } // Use an unaligned load to mop up the last 16 bytes and get an accurate // picture to buf_end. chars = loadu128(buf_end - 16); rv = fwdBlock2(mask1_lo, mask1_hi, mask2_lo, mask2_hi, chars, buf_end - 16, low4bits, ones); if (rv) { return rv; } return buf_end; } #else // AVX2 - 256 wide shuftis static really_inline const u8 *firstMatch(const u8 *buf, u32 z) { if (unlikely(z != 0xffffffff)) { u32 pos = ctz32(~z); assert(pos < 32); return buf + pos; } else { return NULL; // no match } } static really_inline const u8 *fwdBlockShort(m256 mask, m128 chars, const u8 *buf, const m256 low4bits) { // do the hi and lo shuffles in the one avx register m256 c = combine2x128(rshift64_m128(chars, 4), chars); c = and256(c, low4bits); m256 c_shuf = vpshufb(mask, c); m128 t = and128(movdq_hi(c_shuf), cast256to128(c_shuf)); // the upper 32-bits can't match u32 z = 0xffff0000U | movemask128(eq128(t, zeroes128())); return firstMatch(buf, z); } static really_inline const u8 *shuftiFwdShort(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const m256 low4bits) { // run shufti over two overlapping 16-byte unaligned reads const m256 mask = combine2x128(mask_hi, mask_lo); m128 chars = loadu128(buf); const u8 *rv = fwdBlockShort(mask, chars, buf, low4bits); if (rv) { return rv; } chars = loadu128(buf_end - 16); rv = fwdBlockShort(mask, chars, buf_end - 16, low4bits); if (rv) { return rv; } return buf_end; } static really_inline const u8 *fwdBlock(m256 mask_lo, m256 mask_hi, m256 chars, const u8 *buf, const m256 low4bits, const m256 zeroes) { u32 z = block(mask_lo, mask_hi, chars, low4bits, zeroes); return firstMatch(buf, z); } /* takes 128 bit masks, but operates on 256 bits of data */ const u8 *shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end) { assert(buf && buf_end); assert(buf < buf_end); DEBUG_PRINTF("shufti %p len %zu\n", buf, buf_end - buf); // Slow path for small cases. if (buf_end - buf < 16) { return shuftiFwdSlow((const u8 *)&mask_lo, (const u8 *)&mask_hi, buf, buf_end); } const m256 low4bits = set32x8(0xf); if (buf_end - buf <= 32) { return shuftiFwdShort(mask_lo, mask_hi, buf, buf_end, low4bits); } const m256 zeroes = zeroes256(); const m256 wide_mask_lo = set2x128(mask_lo); const m256 wide_mask_hi = set2x128(mask_hi); const u8 *rv; size_t min = (size_t)buf % 32; assert(buf_end - buf >= 32); // Preconditioning: most of the time our buffer won't be aligned. m256 chars = loadu256(buf); rv = fwdBlock(wide_mask_lo, wide_mask_hi, chars, buf, low4bits, zeroes); if (rv) { return rv; } buf += (32 - min); // Unrolling was here, but it wasn't doing anything but taking up space. // Reroll FTW. const u8 *last_block = buf_end - 32; while (buf < last_block) { m256 lchars = load256(buf); rv = fwdBlock(wide_mask_lo, wide_mask_hi, lchars, buf, low4bits, zeroes); if (rv) { return rv; } buf += 32; } // Use an unaligned load to mop up the last 32 bytes and get an accurate // picture to buf_end. assert(buf <= buf_end && buf >= buf_end - 32); chars = loadu256(buf_end - 32); rv = fwdBlock(wide_mask_lo, wide_mask_hi, chars, buf_end - 32, low4bits, zeroes); if (rv) { return rv; } return buf_end; } static really_inline const u8 *lastMatch(const u8 *buf, u32 z) { if (unlikely(z != 0xffffffff)) { u32 pos = clz32(~z); DEBUG_PRINTF("buf=%p, pos=%u\n", buf, pos); return buf + (31 - pos); } else { return NULL; // no match } } static really_inline const u8 *revBlock(m256 mask_lo, m256 mask_hi, m256 chars, const u8 *buf, const m256 low4bits, const m256 zeroes) { m256 c_lo = vpshufb(mask_lo, GET_LO_4(chars)); m256 c_hi = vpshufb(mask_hi, GET_HI_4(chars)); m256 t = and256(c_lo, c_hi); #ifdef DEBUG DEBUG_PRINTF(" chars: "); dumpMsk256AsChars(chars); printf("\n"); DEBUG_PRINTF(" char: "); dumpMsk256(chars); printf("\n"); DEBUG_PRINTF(" c_lo: "); dumpMsk256(c_lo); printf("\n"); DEBUG_PRINTF(" c_hi: "); dumpMsk256(c_hi); printf("\n"); DEBUG_PRINTF(" t: "); dumpMsk256(t); printf("\n"); #endif u32 z = movemask256(eq256(t, zeroes)); return lastMatch(buf, z); } static really_inline const u8 *revBlockShort(m256 mask, m128 chars, const u8 *buf, const m256 low4bits) { // do the hi and lo shuffles in the one avx register m256 c = combine2x128(rshift64_m128(chars, 4), chars); c = and256(c, low4bits); m256 c_shuf = vpshufb(mask, c); m128 t = and128(movdq_hi(c_shuf), cast256to128(c_shuf)); // the upper 32-bits can't match u32 z = 0xffff0000U | movemask128(eq128(t, zeroes128())); return lastMatch(buf, z); } static really_inline const u8 *shuftiRevShort(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const m256 low4bits) { // run shufti over two overlapping 16-byte unaligned reads const m256 mask = combine2x128(mask_hi, mask_lo); m128 chars = loadu128(buf_end - 16); const u8 *rv = revBlockShort(mask, chars, buf_end - 16, low4bits); if (rv) { return rv; } chars = loadu128(buf); rv = revBlockShort(mask, chars, buf, low4bits); if (rv) { return rv; } return buf - 1; } /* takes 128 bit masks, but operates on 256 bits of data */ const u8 *rshuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end) { assert(buf && buf_end); assert(buf < buf_end); // Slow path for small cases. if (buf_end - buf < 16) { return shuftiRevSlow((const u8 *)&mask_lo, (const u8 *)&mask_hi, buf, buf_end); } const m256 low4bits = set32x8(0xf); if (buf_end - buf <= 32) { return shuftiRevShort(mask_lo, mask_hi, buf, buf_end, low4bits); } const m256 zeroes = zeroes256(); const m256 wide_mask_lo = set2x128(mask_lo); const m256 wide_mask_hi = set2x128(mask_hi); const u8 *rv; assert(buf_end - buf >= 32); // Preconditioning: most of the time our buffer won't be aligned. m256 chars = loadu256(buf_end - 32); rv = revBlock(wide_mask_lo, wide_mask_hi, chars, buf_end - 32, low4bits, zeroes); if (rv) { return rv; } buf_end = (const u8 *)((size_t)buf_end & ~((size_t)0x1f)); // Unrolling was here, but it wasn't doing anything but taking up space. // Reroll FTW. const u8 *last_block = buf + 32; while (buf_end > last_block) { buf_end -= 32; m256 lchars = load256(buf_end); rv = revBlock(wide_mask_lo, wide_mask_hi, lchars, buf_end, low4bits, zeroes); if (rv) { return rv; } } // Use an unaligned load to mop up the last 32 bytes and get an accurate // picture to buf. chars = loadu256(buf); rv = revBlock(wide_mask_lo, wide_mask_hi, chars, buf, low4bits, zeroes); if (rv) { return rv; } return buf - 1; } static really_inline const u8 *fwdBlock2(m256 mask1_lo, m256 mask1_hi, m256 mask2_lo, m256 mask2_hi, m256 chars, const u8 *buf, const m256 low4bits, const m256 ones) { DEBUG_PRINTF("buf %p\n", buf); m256 chars_lo = GET_LO_4(chars); m256 chars_hi = GET_HI_4(chars); m256 c_lo = vpshufb(mask1_lo, chars_lo); m256 c_hi = vpshufb(mask1_hi, chars_hi); m256 t = or256(c_lo, c_hi); #ifdef DEBUG DEBUG_PRINTF(" chars: "); dumpMsk256AsChars(chars); printf("\n"); DEBUG_PRINTF(" char: "); dumpMsk256(chars); printf("\n"); DEBUG_PRINTF(" c_lo: "); dumpMsk256(c_lo); printf("\n"); DEBUG_PRINTF(" c_hi: "); dumpMsk256(c_hi); printf("\n"); DEBUG_PRINTF(" t: "); dumpMsk256(t); printf("\n"); #endif m256 c2_lo = vpshufb(mask2_lo, chars_lo); m256 c2_hi = vpshufb(mask2_hi, chars_hi); m256 t2 = or256(t, rshift128_m256(or256(c2_lo, c2_hi), 1)); #ifdef DEBUG DEBUG_PRINTF(" c2_lo: "); dumpMsk256(c2_lo); printf("\n"); DEBUG_PRINTF(" c2_hi: "); dumpMsk256(c2_hi); printf("\n"); DEBUG_PRINTF(" t2: "); dumpMsk256(t2); printf("\n"); #endif u32 z = movemask256(eq256(t2, ones)); return firstMatch(buf, z); } static really_inline const u8 *fwdBlockShort2(m256 mask1, m256 mask2, m128 chars, const u8 *buf, const m256 low4bits) { // do the hi and lo shuffles in the one avx register m256 c = combine2x128(rshift64_m128(chars, 4), chars); c = and256(c, low4bits); m256 c_shuf1 = vpshufb(mask1, c); m256 c_shuf2 = rshift128_m256(vpshufb(mask2, c), 1); m256 t0 = or256(c_shuf1, c_shuf2); m128 t = or128(movdq_hi(t0), cast256to128(t0)); // the upper 32-bits can't match u32 z = 0xffff0000U | movemask128(eq128(t, ones128())); return firstMatch(buf, z); } static really_inline const u8 *shuftiDoubleShort(m128 mask1_lo, m128 mask1_hi, m128 mask2_lo, m128 mask2_hi, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("buf %p len %zu\n", buf, buf_end - buf); const m256 low4bits = set32x8(0xf); // run shufti over two overlapping 16-byte unaligned reads const m256 mask1 = combine2x128(mask1_hi, mask1_lo); const m256 mask2 = combine2x128(mask2_hi, mask2_lo); m128 chars = loadu128(buf); const u8 *rv = fwdBlockShort2(mask1, mask2, chars, buf, low4bits); if (rv) { return rv; } chars = loadu128(buf_end - 16); rv = fwdBlockShort2(mask1, mask2, chars, buf_end - 16, low4bits); if (rv) { return rv; } return buf_end; } /* takes 128 bit masks, but operates on 256 bits of data */ const u8 *shuftiDoubleExec(m128 mask1_lo, m128 mask1_hi, m128 mask2_lo, m128 mask2_hi, const u8 *buf, const u8 *buf_end) { /* we should always have at least 16 bytes */ assert(buf_end - buf >= 16); if (buf_end - buf < 32) { return shuftiDoubleShort(mask1_lo, mask1_hi, mask2_lo, mask2_hi, buf, buf_end); } const m256 ones = ones256(); const m256 low4bits = set32x8(0xf); const m256 wide_mask1_lo = set2x128(mask1_lo); const m256 wide_mask1_hi = set2x128(mask1_hi); const m256 wide_mask2_lo = set2x128(mask2_lo); const m256 wide_mask2_hi = set2x128(mask2_hi); const u8 *rv; size_t min = (size_t)buf % 32; // Preconditioning: most of the time our buffer won't be aligned. m256 chars = loadu256(buf); rv = fwdBlock2(wide_mask1_lo, wide_mask1_hi, wide_mask2_lo, wide_mask2_hi, chars, buf, low4bits, ones); if (rv) { return rv; } buf += (32 - min); // Unrolling was here, but it wasn't doing anything but taking up space. // Reroll FTW. const u8 *last_block = buf_end - 32; while (buf < last_block) { m256 lchars = load256(buf); rv = fwdBlock2(wide_mask1_lo, wide_mask1_hi, wide_mask2_lo, wide_mask2_hi, lchars, buf, low4bits, ones); if (rv) { return rv; } buf += 32; } // Use an unaligned load to mop up the last 32 bytes and get an accurate // picture to buf_end. chars = loadu256(buf_end - 32); rv = fwdBlock2(wide_mask1_lo, wide_mask1_hi, wide_mask2_lo, wide_mask2_hi, chars, buf_end - 32, low4bits, ones); if (rv) { return rv; } return buf_end; } #endif //AVX2 hyperscan-4.4.1/src/nfa/gough.c0000644000175000017500000011177413055426554017122 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "gough.h" #include "accel.h" #include "gough_internal.h" #include "mcclellan.h" #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "util/bitutils.h" #include "util/compare.h" #include "util/simd_utils.h" #include "util/unaligned.h" #include "ue2common.h" #include #include "mcclellan_common_impl.h" #define GOUGH_SOM_EARLY (~0ULL) static really_inline void compressSomValue(u32 comp_slot_width, u64a curr_offset, void *dest_som_base, u32 i, u64a val) { void *dest_som = (u8 *)dest_som_base + i * comp_slot_width; /* gough does not initialise all slots, so may contain garbage */ u64a delta = curr_offset - val; switch (comp_slot_width) { case 2: if (delta >= (u16)~0U) { delta = GOUGH_SOM_EARLY; } unaligned_store_u16(dest_som, delta); break; case 4: if (delta >= (u32)~0U) { delta = GOUGH_SOM_EARLY; } unaligned_store_u32(dest_som, delta); break; case 8: if (delta >= ~0ULL) { delta = GOUGH_SOM_EARLY; } unaligned_store_u64a(dest_som, delta); break; default: assert(0); } } static really_inline u64a expandSomValue(u32 comp_slot_width, u64a curr_offset, const void *src_som_base, u32 i) { /* Note: gough does not initialise all slots, so we may end up decompressing * garbage */ const void *src_som = (const u8 *)src_som_base + i * comp_slot_width; u64a val = 0; switch (comp_slot_width) { case 2: val = unaligned_load_u16(src_som); if (val == (u16)~0U) { return GOUGH_SOM_EARLY; } break; case 4: val = unaligned_load_u32(src_som); if (val == (u32)~0U) { return GOUGH_SOM_EARLY; } break; case 8: val = unaligned_load_u64a(src_som); if (val == ~0ULL) { return GOUGH_SOM_EARLY; } break; default: assert(0); } return curr_offset - val; } static really_inline char doReports(NfaCallback cb, void *ctxt, const struct mcclellan *m, const struct gough_som_info *som, u16 s, u64a loc, char eod, u16 * const cached_accept_state, u32 * const cached_accept_id, u32 * const cached_accept_som) { DEBUG_PRINTF("reporting state = %hu, loc=%llu, eod %hhu\n", (u16)(s & STATE_MASK), loc, eod); if (!eod && s == *cached_accept_state) { u64a from = *cached_accept_som == INVALID_SLOT ? loc : som->slots[*cached_accept_som]; if (cb(from, loc, *cached_accept_id, ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } const struct mstate_aux *aux = get_aux(m, s); size_t offset = eod ? aux->accept_eod : aux->accept; assert(offset); const struct gough_report_list *rl = (const void *)((const char *)m + offset - sizeof(struct NFA)); assert(ISALIGNED(rl)); DEBUG_PRINTF("report list size %u\n", rl->count); u32 count = rl->count; if (!eod && count == 1) { *cached_accept_state = s; *cached_accept_id = rl->report[0].r; *cached_accept_som = rl->report[0].som; u64a from = *cached_accept_som == INVALID_SLOT ? loc : som->slots[*cached_accept_som]; DEBUG_PRINTF("reporting %u, using som[%u]=%llu\n", rl->report[0].r, *cached_accept_som, from); if (cb(from, loc, *cached_accept_id, ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } for (u32 i = 0; i < count; i++) { u32 slot = rl->report[i].som; u64a from = slot == INVALID_SLOT ? loc : som->slots[slot]; DEBUG_PRINTF("reporting %u, using som[%u] = %llu\n", rl->report[i].r, slot, from); if (cb(from, loc, rl->report[i].r, ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } } return MO_CONTINUE_MATCHING; /* continue execution */ } #ifdef DUMP_SUPPORT static UNUSED const char *dump_op(u8 op) { switch (op) { case GOUGH_INS_END: return "END"; case GOUGH_INS_MOV: return "MOV"; case GOUGH_INS_NEW: return "NEW"; case GOUGH_INS_MIN: return "MIN"; default: return "???"; } } #endif static really_inline void run_prog_i(UNUSED const struct NFA *nfa, const struct gough_ins *pc, u64a som_offset, struct gough_som_info *som) { DEBUG_PRINTF("run prog at som_offset of %llu\n", som_offset); while (1) { assert((const u8 *)pc >= (const u8 *)nfa); assert((const u8 *)pc < (const u8 *)nfa + nfa->length); u32 dest = pc->dest; u32 src = pc->src; assert(pc->op == GOUGH_INS_END || dest < (nfa->scratchStateSize - 16) / 8); DEBUG_PRINTF("%s %u %u\n", dump_op(pc->op), dest, src); switch (pc->op) { case GOUGH_INS_END: return; case GOUGH_INS_MOV: som->slots[dest] = som->slots[src]; break; case GOUGH_INS_NEW: /* note: c has already been advanced */ DEBUG_PRINTF("current offset %llu; adjust %u\n", som_offset, pc->src); assert(som_offset >= pc->src); som->slots[dest] = som_offset - pc->src; break; case GOUGH_INS_MIN: /* TODO: shift all values along by one so that a normal min works */ if (som->slots[src] == GOUGH_SOM_EARLY) { som->slots[dest] = som->slots[src]; } else if (som->slots[dest] != GOUGH_SOM_EARLY) { LIMIT_TO_AT_MOST(&som->slots[dest], som->slots[src]); } break; default: assert(0); return; } DEBUG_PRINTF("dest slot[%u] = %llu\n", dest, som->slots[dest]); ++pc; } } static really_inline void run_prog(const struct NFA *nfa, const u32 *edge_prog_table, const u8 *buf, u64a offAdj, const u8 *c, u32 edge_num, struct gough_som_info *som) { DEBUG_PRINTF("taking edge %u\n", edge_num); u32 prog_offset = edge_prog_table[edge_num]; if (!prog_offset) { DEBUG_PRINTF("no prog on edge\n"); return; } const struct gough_ins *pc = (const void *)((const u8 *)nfa + prog_offset); u64a curr_offset = (u64a)(c - buf) + offAdj - 1; run_prog_i(nfa, pc, curr_offset, som); } static never_inline void run_accel_prog(const struct NFA *nfa, const struct gough_accel *gacc, const u8 *buf, u64a offAdj, const u8 *c, const u8 *c2, struct gough_som_info *som) { assert(gacc->prog_offset); assert(c2 > c); const struct gough_ins *pc = (const void *)((const u8 *)nfa + gacc->prog_offset); s64a margin_dist = gacc->margin_dist; DEBUG_PRINTF("run accel after skip %lld margin; advanced %zd\n", margin_dist, c2 - c); if (c2 - c <= 2 * margin_dist) { while (c < c2) { u64a curr_offset = (u64a)(c - buf) + offAdj; run_prog_i(nfa, pc, curr_offset, som); c++; } } else { u64a curr_offset = (u64a)(c - buf) + offAdj; for (s64a i = 0; i < margin_dist; i++) { run_prog_i(nfa, pc, curr_offset + i, som); } curr_offset = (u64a)(c2 - buf) + offAdj - margin_dist; for (s64a i = 0; i < margin_dist; i++) { run_prog_i(nfa, pc, curr_offset + i, som); } } } static never_inline u16 goughEnableStarts(const struct mcclellan *m, u16 s, u64a som_offset, struct gough_som_info *som) { DEBUG_PRINTF("top triggered while at %hu\n", s); const struct mstate_aux *aux = get_aux(m, s); DEBUG_PRINTF("now going to state %hu\n", aux->top); const u32 *top_offsets = get_gough_top_offsets(m); if (!top_offsets) { return aux->top; } u32 prog_offset = top_offsets[s]; if (!prog_offset) { return aux->top; } DEBUG_PRINTF("doing som for top\n"); const struct NFA *nfa = (const struct NFA *)((const char *)m - sizeof(struct NFA)); const struct gough_ins *pc = (const void *)((const u8 *)nfa + prog_offset); run_prog_i(nfa, pc, som_offset, som); return aux->top; } static really_inline char goughExec16_i(const struct mcclellan *m, struct gough_som_info *som, u16 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, const u8 **c_final, enum MatchMode mode) { assert(ISALIGNED_N(state, 2)); u16 s = *state; const struct NFA *nfa = (const struct NFA *)((const char *)m - sizeof(struct NFA)); const u8 *c = buf, *c_end = buf + len; const u16 *succ_table = (const u16 *)((const char *)m + sizeof(struct mcclellan)); assert(ISALIGNED_N(succ_table, 2)); const u16 sherman_base = m->sherman_limit; const char *sherman_base_offset = (const char *)nfa + m->sherman_offset; const u32 as = m->alphaShift; s &= STATE_MASK; u32 cached_accept_id = 0; u16 cached_accept_state = 0; u32 cached_accept_som = 0; const u32 *edge_prog_table = (const u32 *)(get_gough(m) + 1); DEBUG_PRINTF("s: %hu, len %zu\n", s, len); const u8 *min_accel_offset = c; if (!m->has_accel || len < ACCEL_MIN_LEN) { min_accel_offset = c_end; goto without_accel; } goto with_accel; without_accel: while (c < min_accel_offset && s) { u8 cprime = m->remap[*(c++)]; DEBUG_PRINTF("c: %02hhx cp:%02hhx (s=%hu)\n", *(c-1), cprime, s); u32 edge_num = ((u32)s << as) + cprime; run_prog(nfa, edge_prog_table, buf, offAdj, c, edge_num, som); if (s < sherman_base) { DEBUG_PRINTF("doing normal\n"); assert(s < m->state_count); s = succ_table[edge_num]; } else { const char *sherman_state = findShermanState(m, sherman_base_offset, sherman_base, s); DEBUG_PRINTF("doing sherman\n"); s = doSherman16(sherman_state, cprime, succ_table, as); } DEBUG_PRINTF("s: %hu (%hu)\n", s, (u16)(s & STATE_MASK)); if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) { if (mode == STOP_AT_MATCH) { *state = s & STATE_MASK; *c_final = c - 1; return MO_CONTINUE_MATCHING; } u64a loc = (c - 1) - buf + offAdj + 1; if (doReports(cb, ctxt, m, som, s & STATE_MASK, loc, 0, &cached_accept_state, &cached_accept_id, &cached_accept_som) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } s &= STATE_MASK; } with_accel: while (c < c_end && s) { u8 cprime = m->remap[*(c++)]; DEBUG_PRINTF("c: %02hhx cp:%02hhx (s=%hu)\n", *(c-1), cprime, s); u32 edge_num = ((u32)s << as) + cprime; run_prog(nfa, edge_prog_table, buf, offAdj, c, edge_num, som); if (s < sherman_base) { DEBUG_PRINTF("doing normal\n"); assert(s < m->state_count); s = succ_table[edge_num]; } else { const char *sherman_state = findShermanState(m, sherman_base_offset, sherman_base, s); DEBUG_PRINTF("doing sherman\n"); s = doSherman16(sherman_state, cprime, succ_table, as); } DEBUG_PRINTF("s: %hu (%hu)\n", s, (u16)(s & STATE_MASK)); if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) { if (mode == STOP_AT_MATCH) { *state = s & STATE_MASK; *c_final = c - 1; return MO_CONTINUE_MATCHING; } u64a loc = (c - 1) - buf + offAdj + 1; if (doReports(cb, ctxt, m, som, s & STATE_MASK, loc, 0, &cached_accept_state, &cached_accept_id, &cached_accept_som) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } else if (s & ACCEL_FLAG) { DEBUG_PRINTF("skipping\n"); const struct mstate_aux *this_aux = get_aux(m, s & STATE_MASK); u32 accel_offset = this_aux->accel_offset; assert(accel_offset >= m->aux_offset); assert(accel_offset < m->sherman_offset); const struct gough_accel *gacc = (const void *)((const char *)m + accel_offset); assert(!gacc->prog_offset == !gacc->margin_dist); const u8 *c2 = run_accel(&gacc->accel, c, c_end); if (c2 != c && gacc->prog_offset) { run_accel_prog(nfa, gacc, buf, offAdj, c, c2, som); } if (c2 < min_accel_offset + BAD_ACCEL_DIST) { min_accel_offset = c2 + BIG_ACCEL_PENALTY; } else { min_accel_offset = c2 + SMALL_ACCEL_PENALTY; } if (min_accel_offset >= c_end - ACCEL_MIN_LEN) { min_accel_offset = c_end; } DEBUG_PRINTF("advanced %zd, next accel chance in %zd/%zd\n", c2 - c, min_accel_offset - c2, c_end - c2); c = c2; s &= STATE_MASK; goto without_accel; } s &= STATE_MASK; } if (mode == STOP_AT_MATCH) { *c_final = c_end; } *state = s; return MO_CONTINUE_MATCHING; } static really_inline char goughExec8_i(const struct mcclellan *m, struct gough_som_info *som, u8 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, const u8 **c_final, enum MatchMode mode) { u8 s = *state; const u8 *c = buf, *c_end = buf + len; const u8 *succ_table = (const u8 *)((const char *)m + sizeof(struct mcclellan)); const u32 as = m->alphaShift; const struct mstate_aux *aux; const struct NFA *nfa = (const struct NFA *)((const char *)m - sizeof(struct NFA)); aux = (const struct mstate_aux *)((const char *)nfa + m->aux_offset); const u32 *edge_prog_table = (const u32 *)(get_gough(m) + 1); u16 accel_limit = m->accel_limit_8; u16 accept_limit = m->accept_limit_8; u32 cached_accept_id = 0; u16 cached_accept_state = 0; u32 cached_accept_som = 0; DEBUG_PRINTF("accel %hu, accept %hu\n", accel_limit, accept_limit); DEBUG_PRINTF("s: %hhu, len %zu\n", s, len); const u8 *min_accel_offset = c; if (!m->has_accel || len < ACCEL_MIN_LEN) { min_accel_offset = c_end; goto without_accel; } goto with_accel; without_accel: while (c < min_accel_offset && s) { u8 cprime = m->remap[*(c++)]; DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx\n", *(c-1), ourisprint(*(c-1)) ? *(c-1) : '?', cprime); u32 edge_num = ((u32)s << as) + cprime; run_prog(nfa, edge_prog_table, buf, offAdj, c, edge_num, som); s = succ_table[edge_num]; DEBUG_PRINTF("s: %hhu\n", s); if (mode != NO_MATCHES && s >= accept_limit) { if (mode == STOP_AT_MATCH) { DEBUG_PRINTF("match - pausing\n"); *state = s; *c_final = c - 1; return MO_CONTINUE_MATCHING; } u64a loc = (c - 1) - buf + offAdj + 1; if (doReports(cb, ctxt, m, som, s, loc, 0, &cached_accept_state, &cached_accept_id, &cached_accept_som) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } } with_accel: while (c < c_end && s) { u8 cprime = m->remap[*(c++)]; DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx\n", *(c-1), ourisprint(*(c-1)) ? *(c-1) : '?', cprime); u32 edge_num = ((u32)s << as) + cprime; run_prog(nfa, edge_prog_table, buf, offAdj, c, edge_num, som); s = succ_table[edge_num]; DEBUG_PRINTF("s: %hhu\n", s); if (s >= accel_limit) { /* accept_limit >= accel_limit */ if (mode != NO_MATCHES && s >= accept_limit) { if (mode == STOP_AT_MATCH) { DEBUG_PRINTF("match - pausing\n"); *state = s; *c_final = c - 1; return MO_CONTINUE_MATCHING; } u64a loc = (c - 1) - buf + offAdj + 1; if (doReports(cb, ctxt, m, som, s, loc, 0, &cached_accept_state, &cached_accept_id, &cached_accept_som) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } else if (aux[s].accel_offset) { DEBUG_PRINTF("skipping\n"); const struct gough_accel *gacc = (const void *)((const char *)m + aux[s].accel_offset); const u8 *c2 = run_accel(&gacc->accel, c, c_end); if (c2 != c && gacc->prog_offset) { run_accel_prog(nfa, gacc, buf, offAdj, c, c2, som); } if (c2 < min_accel_offset + BAD_ACCEL_DIST) { min_accel_offset = c2 + BIG_ACCEL_PENALTY; } else { min_accel_offset = c2 + SMALL_ACCEL_PENALTY; } if (min_accel_offset >= c_end - ACCEL_MIN_LEN) { min_accel_offset = c_end; } DEBUG_PRINTF("advanced %zd, next accel chance in %zd/%zd\n", c2 - c, min_accel_offset - c2, c_end - c2); c = c2; goto without_accel; } } } *state = s; if (mode == STOP_AT_MATCH) { *c_final = c_end; } return MO_CONTINUE_MATCHING; } static never_inline char goughExec8_i_ni(const struct mcclellan *m, struct gough_som_info *som, u8 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, const u8 **final_point, enum MatchMode mode) { return goughExec8_i(m, som, state, buf, len, offAdj, cb, ctxt, final_point, mode); } static never_inline char goughExec16_i_ni(const struct mcclellan *m, struct gough_som_info *som, u16 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, const u8 **final_point, enum MatchMode mode) { return goughExec16_i(m, som, state, buf, len, offAdj, cb, ctxt, final_point, mode); } static really_inline struct gough_som_info *getSomInfo(char *state_base) { return (struct gough_som_info *)(state_base + 16); } static really_inline const struct gough_som_info *getSomInfoConst(const char *state_base) { return (const struct gough_som_info *)(state_base + 16); } static really_inline char nfaExecGough8_Q2i(const struct NFA *n, u64a offset, const u8 *buffer, const u8 *hend, NfaCallback cb, void *context, struct mq *q, s64a end, enum MatchMode mode) { DEBUG_PRINTF("enter\n"); struct gough_som_info *som = getSomInfo(q->state); assert(n->type == GOUGH_NFA_8); const struct mcclellan *m = (const struct mcclellan *)getImplNfa(n); s64a sp; u8 s = *(u8 *)q->state; if (q->report_current) { assert(s); assert(s >= m->accept_limit_8); u32 cached_accept_id = 0; u16 cached_accept_state = 0; u32 cached_accept_som = 0; int rv = doReports(cb, context, m, som, s, q_cur_offset(q), 0, &cached_accept_state, &cached_accept_id, &cached_accept_som); q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } sp = q_cur_loc(q); q->cur++; const u8 *cur_buf = sp < 0 ? hend : buffer; if (mode != NO_MATCHES && q->items[q->cur - 1].location > end) { /* this is as far as we go */ q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u8 *)q->state = s; return MO_ALIVE; } while (1) { DEBUG_PRINTF("%s @ %llu [som %llu]\n", q->items[q->cur].type == MQE_TOP ? "TOP" : q->items[q->cur].type == MQE_END ? "END" : "???", q->items[q->cur].location + offset, q->items[q->cur].som); assert(q->cur < q->end); s64a ep = q->items[q->cur].location; if (mode != NO_MATCHES) { ep = MIN(ep, end); } assert(ep >= sp); DEBUG_PRINTF("run to %lld from %lld\n", ep, sp); s64a local_ep = ep; if (sp < 0) { local_ep = MIN(0, ep); } const u8 *final_look; if (goughExec8_i_ni(m, som, &s, cur_buf + sp, local_ep - sp, offset + sp, cb, context, &final_look, mode) == MO_HALT_MATCHING) { *(u8 *)q->state = 0; return 0; } if (mode == STOP_AT_MATCH && final_look != cur_buf + local_ep) { /* found a match */ DEBUG_PRINTF("found a match\n"); assert(q->cur); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = final_look - cur_buf + 1; /* due to * early -1 */ *(u8 *)q->state = s; return MO_MATCHES_PENDING; } assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur].location > end) { /* this is as far as we go */ assert(q->cur); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u8 *)q->state = s; return MO_ALIVE; } sp = local_ep; if (sp == 0) { cur_buf = buffer; } if (sp != ep) { continue; } switch (q->items[q->cur].type) { case MQE_TOP: assert(!s || sp + offset > 0); if (sp + offset == 0) { s = (u8)m->start_anchored; break; } s = goughEnableStarts(m, s, q->items[q->cur].som, som); break; case MQE_END: *(u8 *)q->state = s; q->cur++; return s ? MO_ALIVE : 0; default: assert(!"invalid queue event"); } q->cur++; } } static really_inline char nfaExecGough16_Q2i(const struct NFA *n, u64a offset, const u8 *buffer, const u8 *hend, NfaCallback cb, void *context, struct mq *q, s64a end, enum MatchMode mode) { struct gough_som_info *som = getSomInfo(q->state); assert(n->type == GOUGH_NFA_16); const struct mcclellan *m = (const struct mcclellan *)getImplNfa(n); s64a sp; assert(ISALIGNED_N(q->state, 2)); u16 s = *(u16 *)q->state; if (q->report_current) { assert(s); assert(get_aux(m, s)->accept); u32 cached_accept_id = 0; u16 cached_accept_state = 0; u32 cached_accept_som = 0; int rv = doReports(cb, context, m, som, s, q_cur_offset(q), 0, &cached_accept_state, &cached_accept_id, &cached_accept_som); q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } sp = q_cur_loc(q); q->cur++; const u8 *cur_buf = sp < 0 ? hend : buffer; assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur - 1].location > end) { /* this is as far as we go */ q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u16 *)q->state = s; return MO_ALIVE; } while (1) { assert(q->cur < q->end); s64a ep = q->items[q->cur].location; if (mode != NO_MATCHES) { ep = MIN(ep, end); } assert(ep >= sp); s64a local_ep = ep; if (sp < 0) { local_ep = MIN(0, ep); } /* do main buffer region */ const u8 *final_look; if (goughExec16_i_ni(m, som, &s, cur_buf + sp, local_ep - sp, offset + sp, cb, context, &final_look, mode) == MO_HALT_MATCHING) { *(u16 *)q->state = 0; return 0; } if (mode == STOP_AT_MATCH && final_look != cur_buf + local_ep) { /* this is as far as we go */ assert(q->cur); DEBUG_PRINTF("state %hu final_look %zd\n", s, final_look - cur_buf); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = final_look - cur_buf + 1; /* due to * early -1 */ *(u16 *)q->state = s; return MO_MATCHES_PENDING; } assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur].location > end) { /* this is as far as we go */ q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u16 *)q->state = s; return MO_ALIVE; } sp = local_ep; if (sp == 0) { cur_buf = buffer; } if (sp != ep) { continue; } switch (q->items[q->cur].type) { case MQE_TOP: assert(!s || sp + offset > 0); if (sp + offset == 0) { s = m->start_anchored; break; } s = goughEnableStarts(m, s, q->items[q->cur].som, som); break; case MQE_END: *(u16 *)q->state = s; q->cur++; return s ? MO_ALIVE : 0; default: assert(!"invalid queue event"); } q->cur++; } } char nfaExecGough8_Q(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == GOUGH_NFA_8); const u8 *hend = q->history + q->hlength; return nfaExecGough8_Q2i(n, offset, buffer, hend, cb, context, q, end, CALLBACK_OUTPUT); } char nfaExecGough16_Q(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == GOUGH_NFA_16); const u8 *hend = q->history + q->hlength; return nfaExecGough16_Q2i(n, offset, buffer, hend, cb, context, q, end, CALLBACK_OUTPUT); } char nfaExecGough8_Q2(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == GOUGH_NFA_8); const u8 *hend = q->history + q->hlength; return nfaExecGough8_Q2i(n, offset, buffer, hend, cb, context, q, end, STOP_AT_MATCH); } char nfaExecGough16_Q2(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == GOUGH_NFA_16); const u8 *hend = q->history + q->hlength; return nfaExecGough16_Q2i(n, offset, buffer, hend, cb, context, q, end, STOP_AT_MATCH); } char nfaExecGough8_QR(const struct NFA *n, struct mq *q, ReportID report) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == GOUGH_NFA_8); const u8 *hend = q->history + q->hlength; char rv = nfaExecGough8_Q2i(n, offset, buffer, hend, cb, context, q, 0 /* end */, NO_MATCHES); if (rv && nfaExecMcClellan8_inAccept(n, report, q)) { return MO_MATCHES_PENDING; } else { return rv; } } char nfaExecGough16_QR(const struct NFA *n, struct mq *q, ReportID report) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == GOUGH_NFA_16); const u8 *hend = q->history + q->hlength; char rv = nfaExecGough16_Q2i(n, offset, buffer, hend, cb, context, q, 0 /* end */, NO_MATCHES); if (rv && nfaExecMcClellan16_inAccept(n, report, q)) { return MO_MATCHES_PENDING; } else { return rv; } } char nfaExecGough8_initCompressedState(const struct NFA *nfa, u64a offset, void *state, UNUSED u8 key) { const struct mcclellan *m = (const struct mcclellan *)getImplNfa(nfa); memset(state, 0, nfa->streamStateSize); u8 s = offset ? m->start_floating : m->start_anchored; if (s) { *(u8 *)state = s; return 1; } return 0; } char nfaExecGough16_initCompressedState(const struct NFA *nfa, u64a offset, void *state, UNUSED u8 key) { const struct mcclellan *m = (const struct mcclellan *)getImplNfa(nfa); memset(state, 0, nfa->streamStateSize); u16 s = offset ? m->start_floating : m->start_anchored; if (s) { unaligned_store_u16(state, s); return 1; } return 0; } char nfaExecGough8_reportCurrent(const struct NFA *n, struct mq *q) { const struct mcclellan *m = (const struct mcclellan *)getImplNfa(n); NfaCallback cb = q->cb; void *ctxt = q->context; u8 s = *(u8 *)q->state; u64a offset = q_cur_offset(q); struct gough_som_info *som = getSomInfo(q->state); assert(q_cur_type(q) == MQE_START); assert(s); if (s >= m->accept_limit_8) { u32 cached_accept_id = 0; u16 cached_accept_state = 0; u32 cached_accept_som = 0; doReports(cb, ctxt, m, som, s, offset, 0, &cached_accept_state, &cached_accept_id, &cached_accept_som); } return 0; } char nfaExecGough16_reportCurrent(const struct NFA *n, struct mq *q) { const struct mcclellan *m = (const struct mcclellan *)getImplNfa(n); NfaCallback cb = q->cb; void *ctxt = q->context; u16 s = *(u16 *)q->state; const struct mstate_aux *aux = get_aux(m, s); u64a offset = q_cur_offset(q); struct gough_som_info *som = getSomInfo(q->state); assert(q_cur_type(q) == MQE_START); DEBUG_PRINTF("state %hu\n", s); assert(s); if (aux->accept) { u32 cached_accept_id = 0; u16 cached_accept_state = 0; u32 cached_accept_som = 0; doReports(cb, ctxt, m, som, s, offset, 0, &cached_accept_state, &cached_accept_id, &cached_accept_som); } return 0; } char nfaExecGough8_inAccept(const struct NFA *n, ReportID report, struct mq *q) { return nfaExecMcClellan8_inAccept(n, report, q); } char nfaExecGough16_inAccept(const struct NFA *n, ReportID report, struct mq *q) { return nfaExecMcClellan16_inAccept(n, report, q); } char nfaExecGough8_inAnyAccept(const struct NFA *n, struct mq *q) { return nfaExecMcClellan8_inAnyAccept(n, q); } char nfaExecGough16_inAnyAccept(const struct NFA *n, struct mq *q) { return nfaExecMcClellan16_inAnyAccept(n, q); } static char goughCheckEOD(const struct NFA *nfa, u16 s, const struct gough_som_info *som, u64a offset, NfaCallback cb, void *ctxt) { const struct mcclellan *m = (const struct mcclellan *)getImplNfa(nfa); const struct mstate_aux *aux = get_aux(m, s); if (!aux->accept_eod) { return MO_CONTINUE_MATCHING; } return doReports(cb, ctxt, m, som, s, offset, 1, NULL, NULL, NULL); } char nfaExecGough8_testEOD(const struct NFA *nfa, const char *state, UNUSED const char *streamState, u64a offset, NfaCallback callback, void *context) { const struct gough_som_info *som = getSomInfoConst(state); return goughCheckEOD(nfa, *(const u8 *)state, som, offset, callback, context); } char nfaExecGough16_testEOD(const struct NFA *nfa, const char *state, UNUSED const char *streamState, u64a offset, NfaCallback callback, void *context) { assert(ISALIGNED_N(state, 8)); const struct gough_som_info *som = getSomInfoConst(state); return goughCheckEOD(nfa, *(const u16 *)state, som, offset, callback, context); } char nfaExecGough8_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) { memset(q->state, 0, nfa->scratchStateSize); return 0; } char nfaExecGough16_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) { memset(q->state, 0, nfa->scratchStateSize); assert(ISALIGNED_N(q->state, 2)); return 0; } static really_inline void compSomSpace(const struct NFA *nfa, u8 *dest_som_base, const struct gough_som_info *src, u64a curr_offset) { const struct mcclellan *m = (const struct mcclellan *)getImplNfa(nfa); const struct gough_info *gi = get_gough(m); u32 count = gi->stream_som_loc_count; u32 width = gi->stream_som_loc_width; for (u32 i = 0; i < count; i++) { compressSomValue(width, curr_offset, dest_som_base, i, src->slots[i]); } } static really_inline void expandSomSpace(const struct NFA *nfa, struct gough_som_info *som, const u8 *src_som_base, u64a curr_offset) { const struct mcclellan *m = (const struct mcclellan *)getImplNfa(nfa); const struct gough_info *gi = get_gough(m); u32 count = gi->stream_som_loc_count; u32 width = gi->stream_som_loc_width; for (u32 i = 0; i < count; i++) { som->slots[i] = expandSomValue(width, curr_offset, src_som_base, i); } } char nfaExecGough8_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc) { void *dest = q->streamState; const void *src = q->state; *(u8 *)dest = *(const u8 *)src; compSomSpace(nfa, (u8 *)dest + 1, getSomInfoConst(src), q->offset + loc); return 0; } char nfaExecGough8_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, UNUSED u8 key) { *(u8 *)dest = *(const u8 *)src; expandSomSpace(nfa, getSomInfo(dest), (const u8 *)src + 1, offset); return 0; } char nfaExecGough16_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc) { void *dest = q->streamState; const void *src = q->state; assert(ISALIGNED_N(src, 2)); unaligned_store_u16(dest, *(const u16 *)(src)); compSomSpace(nfa, (u8 *)dest + 2, getSomInfoConst(src), q->offset + loc); return 0; } char nfaExecGough16_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, UNUSED u8 key) { assert(ISALIGNED_N(dest, 2)); *(u16 *)dest = unaligned_load_u16(src); expandSomSpace(nfa, getSomInfo(dest), (const u8 *)src + 2, offset); return 0; } hyperscan-4.4.1/src/nfa/multiaccel_shiftgrab.h0000644000175000017500000001120213055426554022152 0ustar sleuthkidsleuthkid/* * 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_ */ hyperscan-4.4.1/src/nfa/sheng_defs.h0000644000175000017500000002312313055426554020111 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 SHENG_DEFS_H #define SHENG_DEFS_H /* * Utility functions used by various versions of Sheng engine */ static really_inline u8 isDeadState(const u8 a) { return a & SHENG_STATE_DEAD; } static really_inline u8 isAcceptState(const u8 a) { return a & SHENG_STATE_ACCEPT; } static really_inline u8 isAccelState(const u8 a) { return a & SHENG_STATE_ACCEL; } static really_inline u8 hasInterestingStates(const u8 a, const u8 b, const u8 c, const u8 d) { return (a | b | c | d) & (SHENG_STATE_FLAG_MASK); } /* these functions should be optimized out, used by NO_MATCHES mode */ static really_inline u8 dummyFunc4(UNUSED const u8 a, UNUSED const u8 b, UNUSED const u8 c, UNUSED const u8 d) { return 0; } static really_inline u8 dummyFunc(UNUSED const u8 a) { return 0; } /* * Sheng function definitions for single byte loops */ /* callback output, can die */ #define SHENG_IMPL sheng_cod #define DEAD_FUNC isDeadState #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 0 #include "sheng_impl.h" #undef SHENG_IMPL #undef DEAD_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* callback output, can't die */ #define SHENG_IMPL sheng_co #define DEAD_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 0 #include "sheng_impl.h" #undef SHENG_IMPL #undef DEAD_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* stop at match, can die */ #define SHENG_IMPL sheng_samd #define DEAD_FUNC isDeadState #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 1 #include "sheng_impl.h" #undef SHENG_IMPL #undef DEAD_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* stop at match, can't die */ #define SHENG_IMPL sheng_sam #define DEAD_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 1 #include "sheng_impl.h" #undef SHENG_IMPL #undef DEAD_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* no match, can die */ #define SHENG_IMPL sheng_nmd #define DEAD_FUNC isDeadState #define ACCEPT_FUNC dummyFunc #define STOP_AT_MATCH 0 #include "sheng_impl.h" #undef SHENG_IMPL #undef DEAD_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* no match, can't die */ #define SHENG_IMPL sheng_nm #define DEAD_FUNC dummyFunc #define ACCEPT_FUNC dummyFunc #define STOP_AT_MATCH 0 #include "sheng_impl.h" #undef SHENG_IMPL #undef DEAD_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* * Sheng function definitions for 4-byte loops */ /* callback output, can die, accelerated */ #define SHENG_IMPL sheng4_coda #define INTERESTING_FUNC hasInterestingStates #define INNER_DEAD_FUNC isDeadState #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC isAccelState #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 0 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* callback output, can die, not accelerated */ #define SHENG_IMPL sheng4_cod #define INTERESTING_FUNC hasInterestingStates #define INNER_DEAD_FUNC isDeadState #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC dummyFunc #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 0 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* callback output, can't die, accelerated */ #define SHENG_IMPL sheng4_coa #define INTERESTING_FUNC hasInterestingStates #define INNER_DEAD_FUNC dummyFunc #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC isAccelState #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 0 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* callback output, can't die, not accelerated */ #define SHENG_IMPL sheng4_co #define INTERESTING_FUNC hasInterestingStates #define INNER_DEAD_FUNC dummyFunc #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC dummyFunc #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 0 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* stop at match, can die, accelerated */ #define SHENG_IMPL sheng4_samda #define INTERESTING_FUNC hasInterestingStates #define INNER_DEAD_FUNC isDeadState #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC isAccelState #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 1 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* stop at match, can die, not accelerated */ #define SHENG_IMPL sheng4_samd #define INTERESTING_FUNC hasInterestingStates #define INNER_DEAD_FUNC isDeadState #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC dummyFunc #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 1 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* stop at match, can't die, accelerated */ #define SHENG_IMPL sheng4_sama #define INTERESTING_FUNC hasInterestingStates #define INNER_DEAD_FUNC dummyFunc #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC isAccelState #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 1 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* stop at match, can't die, not accelerated */ #define SHENG_IMPL sheng4_sam #define INTERESTING_FUNC hasInterestingStates #define INNER_DEAD_FUNC dummyFunc #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC dummyFunc #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC isAcceptState #define STOP_AT_MATCH 1 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* no-match have interesting func as dummy, and die/accel checks are outer */ /* no match, can die, accelerated */ #define SHENG_IMPL sheng4_nmda #define INTERESTING_FUNC dummyFunc4 #define INNER_DEAD_FUNC dummyFunc #define OUTER_DEAD_FUNC isDeadState #define INNER_ACCEL_FUNC dummyFunc #define OUTER_ACCEL_FUNC isAccelState #define ACCEPT_FUNC dummyFunc #define STOP_AT_MATCH 0 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* no match, can die, not accelerated */ #define SHENG_IMPL sheng4_nmd #define INTERESTING_FUNC dummyFunc4 #define INNER_DEAD_FUNC dummyFunc #define OUTER_DEAD_FUNC isDeadState #define INNER_ACCEL_FUNC dummyFunc #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC dummyFunc #define STOP_AT_MATCH 0 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH /* there is no performance benefit in accelerating a no-match case that can't * die */ /* no match, can't die */ #define SHENG_IMPL sheng4_nm #define INTERESTING_FUNC dummyFunc4 #define INNER_DEAD_FUNC dummyFunc #define OUTER_DEAD_FUNC dummyFunc #define INNER_ACCEL_FUNC dummyFunc #define OUTER_ACCEL_FUNC dummyFunc #define ACCEPT_FUNC dummyFunc #define STOP_AT_MATCH 0 #include "sheng_impl4.h" #undef SHENG_IMPL #undef INTERESTING_FUNC #undef INNER_DEAD_FUNC #undef OUTER_DEAD_FUNC #undef INNER_ACCEL_FUNC #undef OUTER_ACCEL_FUNC #undef ACCEPT_FUNC #undef STOP_AT_MATCH #endif // SHENG_DEFS_H hyperscan-4.4.1/src/nfa/repeat_internal.h0000644000175000017500000002005013055426554021154 0ustar sleuthkidsleuthkid/* * 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 REPEAT_INTERNAL_H #define REPEAT_INTERNAL_H #include "ue2common.h" /** \file * \brief Bounded Repeat models. * * Used by the NFA, to represent bounded repeats managed via special POS and * TUG exceptions, and by the LBR (limited bounded repeat) and Castle * specialist engines. * * We currently have a number of different kinds of bounded repeat model, for * different kinds of {N,M} repeats, described by ::RepeatType. */ /** Different types of bounded repeats. */ enum RepeatType { /** General mechanism for tracking {N,M} repeats. Stores the first top as * an absolute offset, then subsequent tops in the {N,M} range as a ring of * relative top indices stored in a multibit. */ REPEAT_RING, /** Used to track {N,} repeats. Uses the \ref RepeatOffsetControl structure, * since only the first top encountered needs to be stored. */ REPEAT_FIRST, /** Used to track {0,N} repeats. Much like ::REPEAT_FIRST, except that we * store the most recent top encountered. */ REPEAT_LAST, /** Like ::REPEAT_RING, this is also used for {N,M} repeats, but for cases * where there is a large difference between N and M, and developed to * reduce the state requirements of this case (relative to the RING model). * Uses a small ordered array of top indices relative to \ref * RepeatRangeControl::offset. */ REPEAT_RANGE, /** Used for {N,M} repeats where 0 < M <= 64. Uses the \ref * RepeatBitmapControl structure at runtime. */ REPEAT_BITMAP, /** Optimal mechanism for tracking {N,M} repeats when there is a bound on * how frequently they can be retriggered. * Assume f(repeat, min) representing the number of possible bit patterns * we can have for repeat size = repeat, minimum period = min * We will have the following recurrence relation: * f(repeat, min) = f(repeat - 1, min) + f(repeat - min, min); * We use this recurrence to encode bit patterns with 64-bit values by * referencing a table that stores values from f(0, min) to f(repeat, min) * eg: repeat = 5, min = 2. 10001 => f(4,2) + f(0,2) = 9. * We search the optimal patch size between min and repeat in advance and * use the scheme above to do encoding and decoding to reduce stream state * size. */ REPEAT_SPARSE_OPTIMAL_P, /** Used for {N,M} repeats where 0 < N < 64. Uses the * \ref RepeatTrailerControl structure at runtime. */ REPEAT_TRAILER, /** Degenerate repeat that always returns true. Used by castle for pseudo * [^X]* repeats. */ REPEAT_ALWAYS, }; /** * \brief Value used to represent an unbounded max repeat. * * Note that we do not support \ref RepeatInfo::repeatMax values larger than * this. */ #define REPEAT_INF 65535 /** Max slots used by ::REPEAT_RANGE repeat model. */ #define REPEAT_RANGE_MAX_SLOTS 16 /** Structure describing a bounded repeat in the bytecode */ struct RepeatInfo { u8 type; //!< from enum RepeatType. u32 repeatMin; //!< minimum number of repeats. u32 repeatMax; //!< maximum number of repeats, or REPEAT_INF if unbounded. /** Maximum value that is required to be stored in the control block * counters. Any value greater than this will be capped at the horizon. */ u32 horizon; /** Size of the compressed control block in bytes. This is what is written * out to stream state at stream boundaries. */ u32 packedCtrlSize; /** Size of the repeat state block in bytes. This is where the REPEAT_RANGE * vector and REPEAT_RING multibit are stored, in stream state, and they * are manipulated directly (i.e. not copied at stream boundaries). */ u32 stateSize; /** How soon after one trigger we can see the next trigger. * Used by REPEAT_SPARSE_OPTIMAL_P. */ u32 minPeriod; /** Packed control block field sizes (in bits), used by REPEAT_TRAILER. */ u32 packedFieldSizes[2]; /* Number of patches, used by REPEAT_SPARSE_OPTIMAL_P. */ u32 patchCount; /* Optimal patch length, used by REPEAT_SPARSE_OPTIMAL_P. */ u32 patchSize; /* Encoding patch length in bytes, used by REPEAT_SPARSE_OPTIMAL_P. */ u32 encodingSize; /* RepeatInfo struct length including table size. */ u32 length; /** Offset of patches relative to the start of repeat stream state, * used by REPEAT_SPARSE_OPTIMAL_P. */ u32 patchesOffset; }; /** Runtime control block structure for ::REPEAT_RING and * ::REPEAT_SPARSE_OPTIMAL_P bounded repeats. Note that this struct is packed * (may not be aligned). */ struct RepeatRingControl { u64a offset; //!< index of first top. u16 first; //!< start index in ring. u16 last; //!< end index in ring. }; /** Runtime control block structure for ::REPEAT_RANGE bounded repeats. Note * that this struct is packed (may not be aligned). */ struct RepeatRangeControl { u64a offset; //!< index of first top. u8 num; //!< number of elements in array. }; /** Runtime control block structure for cases where only a single offset is * needed to track the repeat, both ::REPEAT_FIRST and ::REPEAT_LAST. Note that * this struct is packed (may not be aligned). */ struct RepeatOffsetControl { u64a offset; //!< index of a top. }; /** Runtime control block structure for ::REPEAT_BITMAP bounded repeats. */ struct RepeatBitmapControl { u64a offset; //!< index of first top. u64a bitmap; //!< forward bitmap of tops relative to base offset. }; /** Runtime control block structure for ::REPEAT_TRAILER bounded repeats. */ struct RepeatTrailerControl { u64a offset; //!< min extent of most recent match window. u64a bitmap; //!< trailing bitmap of earlier matches, relative to offset. }; /** \brief Union of control block types, used at runtime. */ union RepeatControl { struct RepeatRingControl ring; struct RepeatRangeControl range; struct RepeatOffsetControl offset; struct RepeatBitmapControl bitmap; struct RepeatTrailerControl trailer; }; /** For debugging, returns the name of a repeat model. */ static really_inline UNUSED const char *repeatTypeName(u8 type) { switch ((enum RepeatType)type) { case REPEAT_RING: return "RING"; case REPEAT_FIRST: return "FIRST"; case REPEAT_LAST: return "LAST"; case REPEAT_RANGE: return "RANGE"; case REPEAT_BITMAP: return "BITMAP"; case REPEAT_SPARSE_OPTIMAL_P: return "SPARSE_OPTIMAL_P"; case REPEAT_TRAILER: return "TRAILER"; case REPEAT_ALWAYS: return "ALWAYS"; } assert(0); return "UNKNOWN"; } #endif // REPEAT_INTERNAL_H hyperscan-4.4.1/src/nfa/mcclellan.c0000644000175000017500000011576413055426554017746 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ #include "mcclellan.h" #include "accel.h" #include "mcclellan_internal.h" #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "util/bitutils.h" #include "util/compare.h" #include "util/simd_utils.h" #include "ue2common.h" #include "mcclellan_common_impl.h" static really_inline char doComplexReport(NfaCallback cb, void *ctxt, const struct mcclellan *m, u32 s, u64a loc, char eod, u32 *cached_accept_state, u32 *cached_accept_id) { DEBUG_PRINTF("reporting state = %u, loc=%llu, eod %hhu\n", s & STATE_MASK, loc, eod); if (!eod && s == *cached_accept_state) { if (cb(0, loc, *cached_accept_id, ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } const struct mstate_aux *aux = get_aux(m, s); size_t offset = eod ? aux->accept_eod : aux->accept; assert(offset); const struct report_list *rl = (const void *)((const char *)m + offset - sizeof(struct NFA)); assert(ISALIGNED(rl)); DEBUG_PRINTF("report list size %u\n", rl->count); u32 count = rl->count; if (!eod && count == 1) { *cached_accept_state = s; *cached_accept_id = rl->report[0]; DEBUG_PRINTF("reporting %u\n", rl->report[0]); if (cb(0, loc, rl->report[0], ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } for (u32 i = 0; i < count; i++) { DEBUG_PRINTF("reporting %u\n", rl->report[i]); if (cb(0, loc, rl->report[i], ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } } return MO_CONTINUE_MATCHING; /* continue execution */ } static really_inline const u8 *run_mcclellan_accel(const struct mcclellan *m, const struct mstate_aux *aux, u32 s, const u8 **min_accel_offset, const u8 *c, const u8 *c_end) { DEBUG_PRINTF("skipping\n"); u32 accel_offset = aux[s].accel_offset; assert(aux[s].accel_offset); assert(accel_offset >= m->aux_offset); assert(!m->sherman_offset || accel_offset < m->sherman_offset); const union AccelAux *aaux = (const void *)((const char *)m + accel_offset); const u8 *c2 = run_accel(aaux, c, c_end); if (c2 < *min_accel_offset + BAD_ACCEL_DIST) { *min_accel_offset = c2 + BIG_ACCEL_PENALTY; } else { *min_accel_offset = c2 + SMALL_ACCEL_PENALTY; } if (*min_accel_offset >= c_end - ACCEL_MIN_LEN) { *min_accel_offset = c_end; } DEBUG_PRINTF("advanced %zd, next accel chance in %zd/%zd\n", c2 - c, *min_accel_offset - c2, c_end - c2); return c2; } static really_inline u32 doNormal16(const struct mcclellan *m, const u8 **c_inout, const u8 *end, u32 s, char do_accel, enum MatchMode mode) { const u8 *c = *c_inout; const u16 *succ_table = (const u16 *)((const char *)m + sizeof(struct mcclellan)); assert(ISALIGNED_N(succ_table, 2)); u32 sherman_base = m->sherman_limit; const char *sherman_base_offset = (const char *)m - sizeof(struct NFA) + m->sherman_offset; u32 as = m->alphaShift; s &= STATE_MASK; while (c < end && s) { u8 cprime = m->remap[*c]; DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx (s=%u)\n", *c, ourisprint(*c) ? *c : '?', cprime, s); if (s < sherman_base) { DEBUG_PRINTF("doing normal\n"); assert(s < m->state_count); s = succ_table[(s << as) + cprime]; } else { const char *sherman_state = findShermanState(m, sherman_base_offset, sherman_base, s); DEBUG_PRINTF("doing sherman (%u)\n", s); s = doSherman16(sherman_state, cprime, succ_table, as); } DEBUG_PRINTF("s: %u (%u)\n", s, s & STATE_MASK); c++; if (do_accel && (s & ACCEL_FLAG)) { break; } if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) { break; } s &= STATE_MASK; } *c_inout = c; return s; } static really_inline char mcclellanExec16_i(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **c_final, enum MatchMode mode) { assert(ISALIGNED_N(state, 2)); if (!len) { if (mode == STOP_AT_MATCH) { *c_final = buf; } return MO_ALIVE; } u32 s = *state; const u8 *c = buf; const u8 *c_end = buf + len; const struct mstate_aux *aux = (const struct mstate_aux *)((const char *)m + m->aux_offset - sizeof(struct NFA)); s &= STATE_MASK; u32 cached_accept_id = 0; u32 cached_accept_state = 0; DEBUG_PRINTF("s: %u, len %zu\n", s, len); const u8 *min_accel_offset = c; if (!m->has_accel || len < ACCEL_MIN_LEN) { min_accel_offset = c_end; goto without_accel; } goto with_accel; without_accel: do { assert(c < min_accel_offset); if (!s) { goto exit; } s = doNormal16(m, &c, min_accel_offset, s, 0, mode); if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) { if (mode == STOP_AT_MATCH) { *state = s & STATE_MASK; *c_final = c - 1; return MO_MATCHES_PENDING; } u64a loc = (c - 1) - buf + offAdj + 1; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); if (cb(0, loc, m->arb_report, ctxt) == MO_HALT_MATCHING) { return MO_DEAD; /* termination requested */ } } else if (doComplexReport(cb, ctxt, m, s & STATE_MASK, loc, 0, &cached_accept_state, &cached_accept_id) == MO_HALT_MATCHING) { return MO_DEAD; } } assert(c <= min_accel_offset); } while (c < min_accel_offset); s &= STATE_MASK; if (c == c_end) { goto exit; } else { goto with_accel; } with_accel: do { assert(c < c_end); if (!s) { goto exit; } if (s & ACCEL_FLAG) { DEBUG_PRINTF("skipping\n"); s &= STATE_MASK; c = run_mcclellan_accel(m, aux, s, &min_accel_offset, c, c_end); if (c == c_end) { goto exit; } else { goto without_accel; } } s = doNormal16(m, &c, c_end, s, 1, mode); if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) { if (mode == STOP_AT_MATCH) { *state = s & STATE_MASK; *c_final = c - 1; return MO_MATCHES_PENDING; } u64a loc = (c - 1) - buf + offAdj + 1; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); if (cb(0, loc, m->arb_report, ctxt) == MO_HALT_MATCHING) { return MO_DEAD; /* termination requested */ } } else if (doComplexReport(cb, ctxt, m, s & STATE_MASK, loc, 0, &cached_accept_state, &cached_accept_id) == MO_HALT_MATCHING) { return MO_DEAD; } } assert(c <= c_end); } while (c < c_end); exit: s &= STATE_MASK; if (mode == STOP_AT_MATCH) { *c_final = c_end; } *state = s; return MO_ALIVE; } static never_inline char mcclellanExec16_i_cb(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, CALLBACK_OUTPUT); } static never_inline char mcclellanExec16_i_sam(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, STOP_AT_MATCH); } static never_inline char mcclellanExec16_i_nm(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcclellanExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, NO_MATCHES); } static really_inline char mcclellanExec16_i_ni(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point, enum MatchMode mode) { if (mode == CALLBACK_OUTPUT) { return mcclellanExec16_i_cb(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } else if (mode == STOP_AT_MATCH) { return mcclellanExec16_i_sam(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } else { assert(mode == NO_MATCHES); return mcclellanExec16_i_nm(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } } static really_inline u32 doNormal8(const struct mcclellan *m, const u8 **c_inout, const u8 *end, u32 s, char do_accel, enum MatchMode mode) { const u8 *c = *c_inout; u32 accel_limit = m->accel_limit_8; u32 accept_limit = m->accept_limit_8; const u32 as = m->alphaShift; const u8 *succ_table = (const u8 *)((const char *)m + sizeof(struct mcclellan)); while (c < end && s) { u8 cprime = m->remap[*c]; DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx\n", *c, ourisprint(*c) ? *c : '?', cprime); s = succ_table[(s << as) + cprime]; DEBUG_PRINTF("s: %u\n", s); c++; if (do_accel) { if (s >= accel_limit) { break; } } else { if (mode != NO_MATCHES && s >= accept_limit) { break; } } } *c_inout = c; return s; } static really_inline char mcclellanExec8_i(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **c_final, enum MatchMode mode) { if (!len) { if (mode == STOP_AT_MATCH) { *c_final = buf; } return MO_ALIVE; } u32 s = *state; const u8 *c = buf; const u8 *c_end = buf + len; const struct mstate_aux *aux = (const struct mstate_aux *)((const char *)m + m->aux_offset - sizeof(struct NFA)); u32 accept_limit = m->accept_limit_8; u32 cached_accept_id = 0; u32 cached_accept_state = 0; DEBUG_PRINTF("accel %hu, accept %u\n", m->accel_limit_8, accept_limit); DEBUG_PRINTF("s: %u, len %zu\n", s, len); const u8 *min_accel_offset = c; if (!m->has_accel || len < ACCEL_MIN_LEN) { min_accel_offset = c_end; goto without_accel; } goto with_accel; without_accel: do { assert(c < min_accel_offset); if (!s) { goto exit; } s = doNormal8(m, &c, min_accel_offset, s, 0, mode); if (mode != NO_MATCHES && s >= accept_limit) { if (mode == STOP_AT_MATCH) { DEBUG_PRINTF("match - pausing\n"); *state = s; *c_final = c - 1; return MO_MATCHES_PENDING; } u64a loc = (c - 1) - buf + offAdj + 1; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); if (cb(0, loc, m->arb_report, ctxt) == MO_HALT_MATCHING) { return MO_DEAD; } } else if (doComplexReport(cb, ctxt, m, s, loc, 0, &cached_accept_state, &cached_accept_id) == MO_HALT_MATCHING) { return MO_DEAD; } } assert(c <= min_accel_offset); } while (c < min_accel_offset); if (c == c_end) { goto exit; } with_accel: do { u32 accel_limit = m->accel_limit_8; assert(c < c_end); if (!s) { goto exit; } if (s >= accel_limit && aux[s].accel_offset) { c = run_mcclellan_accel(m, aux, s, &min_accel_offset, c, c_end); if (c == c_end) { goto exit; } else { goto without_accel; } } s = doNormal8(m, &c, c_end, s, 1, mode); if (mode != NO_MATCHES && s >= accept_limit) { if (mode == STOP_AT_MATCH) { DEBUG_PRINTF("match - pausing\n"); *state = s; *c_final = c - 1; return MO_MATCHES_PENDING; } u64a loc = (c - 1) - buf + offAdj + 1; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); if (cb(0, loc, m->arb_report, ctxt) == MO_HALT_MATCHING) { return MO_DEAD; } } else if (doComplexReport(cb, ctxt, m, s, loc, 0, &cached_accept_state, &cached_accept_id) == MO_HALT_MATCHING) { return MO_DEAD; } } assert(c <= c_end); } while (c < c_end); exit: *state = s; if (mode == STOP_AT_MATCH) { *c_final = c_end; } return MO_ALIVE; } static never_inline char mcclellanExec8_i_cb(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, CALLBACK_OUTPUT); } static never_inline char mcclellanExec8_i_sam(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, STOP_AT_MATCH); } static never_inline char mcclellanExec8_i_nm(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcclellanExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, NO_MATCHES); } static really_inline char mcclellanExec8_i_ni(const struct mcclellan *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point, enum MatchMode mode) { if (mode == CALLBACK_OUTPUT) { return mcclellanExec8_i_cb(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } else if (mode == STOP_AT_MATCH) { return mcclellanExec8_i_sam(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } else { assert(mode == NO_MATCHES); return mcclellanExec8_i_nm(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } } static really_inline char mcclellanCheckEOD(const struct NFA *nfa, u32 s, u64a offset, NfaCallback cb, void *ctxt) { const struct mcclellan *m = getImplNfa(nfa); const struct mstate_aux *aux = get_aux(m, s); if (!aux->accept_eod) { return MO_CONTINUE_MATCHING; } return doComplexReport(cb, ctxt, m, s, offset, 1, NULL, NULL); } static really_inline char nfaExecMcClellan16_Q2i(const struct NFA *n, u64a offset, const u8 *buffer, const u8 *hend, NfaCallback cb, void *context, struct mq *q, char single, s64a end, enum MatchMode mode) { assert(n->type == MCCLELLAN_NFA_16); const struct mcclellan *m = getImplNfa(n); s64a sp; assert(ISALIGNED_N(q->state, 2)); u32 s = *(u16 *)q->state; if (q->report_current) { assert(s); assert(get_aux(m, s)->accept); int rv; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); rv = cb(0, q_cur_offset(q), m->arb_report, context); } else { u32 cached_accept_id = 0; u32 cached_accept_state = 0; rv = doComplexReport(cb, context, m, s, q_cur_offset(q), 0, &cached_accept_state, &cached_accept_id); } q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_DEAD; } } sp = q_cur_loc(q); q->cur++; const u8 *cur_buf = sp < 0 ? hend : buffer; assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur - 1].location > end) { DEBUG_PRINTF("this is as far as we go\n"); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u16 *)q->state = s; return MO_ALIVE; } while (1) { assert(q->cur < q->end); s64a ep = q->items[q->cur].location; if (mode != NO_MATCHES) { ep = MIN(ep, end); } assert(ep >= sp); s64a local_ep = ep; if (sp < 0) { local_ep = MIN(0, ep); } /* do main buffer region */ const u8 *final_look; char rv = mcclellanExec16_i_ni(m, &s, cur_buf + sp, local_ep - sp, offset + sp, cb, context, single, &final_look, mode); if (rv == MO_DEAD) { *(u16 *)q->state = 0; return MO_DEAD; } if (mode == STOP_AT_MATCH && rv == MO_MATCHES_PENDING) { DEBUG_PRINTF("this is as far as we go\n"); DEBUG_PRINTF("state %u final_look %zd\n", s, final_look - cur_buf); assert(q->cur); assert(final_look != cur_buf + local_ep); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = final_look - cur_buf + 1; /* due to * early -1 */ *(u16 *)q->state = s; return MO_MATCHES_PENDING; } assert(rv == MO_ALIVE); assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur].location > end) { DEBUG_PRINTF("this is as far as we go\n"); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u16 *)q->state = s; return MO_ALIVE; } sp = local_ep; if (sp == 0) { cur_buf = buffer; } if (sp != ep) { continue; } switch (q->items[q->cur].type) { case MQE_TOP: assert(sp + offset || !s); if (sp + offset == 0) { s = m->start_anchored; break; } s = mcclellanEnableStarts(m, s); break; case MQE_END: *(u16 *)q->state = s; q->cur++; return s ? MO_ALIVE : MO_DEAD; default: assert(!"invalid queue event"); } q->cur++; } } static really_inline char nfaExecMcClellan16_Bi(const struct NFA *n, u64a offset, const u8 *buffer, size_t length, NfaCallback cb, void *context, char single) { assert(n->type == MCCLELLAN_NFA_16); const struct mcclellan *m = getImplNfa(n); u32 s = m->start_anchored; if (mcclellanExec16_i(m, &s, buffer, length, offset, cb, context, single, NULL, CALLBACK_OUTPUT) == MO_DEAD) { return s ? MO_ALIVE : MO_DEAD; } const struct mstate_aux *aux = get_aux(m, s); if (aux->accept_eod) { doComplexReport(cb, context, m, s, offset + length, 1, NULL, NULL); } return MO_ALIVE; } static really_inline char nfaExecMcClellan8_Q2i(const struct NFA *n, u64a offset, const u8 *buffer, const u8 *hend, NfaCallback cb, void *context, struct mq *q, char single, s64a end, enum MatchMode mode) { assert(n->type == MCCLELLAN_NFA_8); const struct mcclellan *m = getImplNfa(n); s64a sp; u32 s = *(u8 *)q->state; if (q->report_current) { assert(s); assert(s >= m->accept_limit_8); int rv; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); rv = cb(0, q_cur_offset(q), m->arb_report, context); } else { u32 cached_accept_id = 0; u32 cached_accept_state = 0; rv = doComplexReport(cb, context, m, s, q_cur_offset(q), 0, &cached_accept_state, &cached_accept_id); } q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_DEAD; } } sp = q_cur_loc(q); q->cur++; const u8 *cur_buf = sp < 0 ? hend : buffer; if (mode != NO_MATCHES && q->items[q->cur - 1].location > end) { DEBUG_PRINTF("this is as far as we go\n"); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u8 *)q->state = s; return MO_ALIVE; } while (1) { DEBUG_PRINTF("%s @ %llu\n", q->items[q->cur].type == MQE_TOP ? "TOP" : q->items[q->cur].type == MQE_END ? "END" : "???", q->items[q->cur].location + offset); assert(q->cur < q->end); s64a ep = q->items[q->cur].location; if (mode != NO_MATCHES) { ep = MIN(ep, end); } assert(ep >= sp); s64a local_ep = ep; if (sp < 0) { local_ep = MIN(0, ep); } const u8 *final_look; char rv = mcclellanExec8_i_ni(m, &s, cur_buf + sp, local_ep - sp, offset + sp, cb, context, single, &final_look, mode); if (rv == MO_HALT_MATCHING) { *(u8 *)q->state = 0; return MO_DEAD; } if (mode == STOP_AT_MATCH && rv == MO_MATCHES_PENDING) { DEBUG_PRINTF("this is as far as we go\n"); DEBUG_PRINTF("state %u final_look %zd\n", s, final_look - cur_buf); assert(q->cur); assert(final_look != cur_buf + local_ep); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = final_look - cur_buf + 1; /* due to * early -1 */ *(u8 *)q->state = s; return MO_MATCHES_PENDING; } assert(rv == MO_ALIVE); assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur].location > end) { DEBUG_PRINTF("this is as far as we go\n"); assert(q->cur); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u8 *)q->state = s; return MO_ALIVE; } sp = local_ep; if (sp == 0) { cur_buf = buffer; } if (sp != ep) { continue; } switch (q->items[q->cur].type) { case MQE_TOP: assert(sp + offset || !s); if (sp + offset == 0) { s = (u8)m->start_anchored; break; } s = mcclellanEnableStarts(m, s); break; case MQE_END: *(u8 *)q->state = s; q->cur++; return s ? MO_ALIVE : MO_DEAD; default: assert(!"invalid queue event"); } q->cur++; } } static really_inline char nfaExecMcClellan8_Bi(const struct NFA *n, u64a offset, const u8 *buffer, size_t length, NfaCallback cb, void *context, char single) { assert(n->type == MCCLELLAN_NFA_8); const struct mcclellan *m = getImplNfa(n); u32 s = m->start_anchored; if (mcclellanExec8_i(m, &s, buffer, length, offset, cb, context, single, NULL, CALLBACK_OUTPUT) == MO_DEAD) { return MO_DEAD; } const struct mstate_aux *aux = get_aux(m, s); if (aux->accept_eod) { doComplexReport(cb, context, m, s, offset + length, 1, NULL, NULL); } return s ? MO_ALIVE : MO_DEAD; } char nfaExecMcClellan8_B(const struct NFA *n, u64a offset, const u8 *buffer, size_t length, NfaCallback cb, void *context) { assert(n->type == MCCLELLAN_NFA_8); const struct mcclellan *m = getImplNfa(n); if (m->flags & MCCLELLAN_FLAG_SINGLE) { return nfaExecMcClellan8_Bi(n, offset, buffer, length, cb, context, 1); } else { return nfaExecMcClellan8_Bi(n, offset, buffer, length, cb, context, 0); } } char nfaExecMcClellan8_Q(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCCLELLAN_NFA_8); const struct mcclellan *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; return nfaExecMcClellan8_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCCLELLAN_FLAG_SINGLE, end, CALLBACK_OUTPUT); } char nfaExecMcClellan16_B(const struct NFA *n, u64a offset, const u8 *buffer, size_t length, NfaCallback cb, void *context) { assert(n->type == MCCLELLAN_NFA_16); const struct mcclellan *m = getImplNfa(n); if (m->flags & MCCLELLAN_FLAG_SINGLE) { return nfaExecMcClellan16_Bi(n, offset, buffer, length, cb, context, 1); } else { return nfaExecMcClellan16_Bi(n, offset, buffer, length, cb, context, 0); } } char nfaExecMcClellan16_Q(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCCLELLAN_NFA_16); const struct mcclellan *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; return nfaExecMcClellan16_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCCLELLAN_FLAG_SINGLE, end, CALLBACK_OUTPUT); } char nfaExecMcClellan8_reportCurrent(const struct NFA *n, struct mq *q) { const struct mcclellan *m = getImplNfa(n); NfaCallback cb = q->cb; void *ctxt = q->context; u32 s = *(u8 *)q->state; u8 single = m->flags & MCCLELLAN_FLAG_SINGLE; u64a offset = q_cur_offset(q); assert(q_cur_type(q) == MQE_START); assert(s); if (s >= m->accept_limit_8) { if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); cb(0, offset, m->arb_report, ctxt); } else { u32 cached_accept_id = 0; u32 cached_accept_state = 0; doComplexReport(cb, ctxt, m, s, offset, 0, &cached_accept_state, &cached_accept_id); } } return 0; } char nfaExecMcClellan16_reportCurrent(const struct NFA *n, struct mq *q) { const struct mcclellan *m = getImplNfa(n); NfaCallback cb = q->cb; void *ctxt = q->context; u32 s = *(u16 *)q->state; const struct mstate_aux *aux = get_aux(m, s); u8 single = m->flags & MCCLELLAN_FLAG_SINGLE; u64a offset = q_cur_offset(q); assert(q_cur_type(q) == MQE_START); DEBUG_PRINTF("state %u\n", s); assert(s); if (aux->accept) { if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); cb(0, offset, m->arb_report, ctxt); } else { u32 cached_accept_id = 0; u32 cached_accept_state = 0; doComplexReport(cb, ctxt, m, s, offset, 0, &cached_accept_state, &cached_accept_id); } } return 0; } static char mcclellanHasAccept(const struct mcclellan *m, const struct mstate_aux *aux, ReportID report) { assert(m && aux); if (!aux->accept) { return 0; } const struct report_list *rl = (const struct report_list *) ((const char *)m + aux->accept - sizeof(struct NFA)); assert(ISALIGNED_N(rl, 4)); DEBUG_PRINTF("report list has %u entries\n", rl->count); for (u32 i = 0; i < rl->count; i++) { if (rl->report[i] == report) { return 1; } } return 0; } char nfaExecMcClellan8_inAccept(const struct NFA *n, ReportID report, struct mq *q) { assert(n && q); const struct mcclellan *m = getImplNfa(n); u8 s = *(u8 *)q->state; DEBUG_PRINTF("checking accepts for %hhu\n", s); if (s < m->accept_limit_8) { return 0; } return mcclellanHasAccept(m, get_aux(m, s), report); } char nfaExecMcClellan8_inAnyAccept(const struct NFA *n, struct mq *q) { assert(n && q); const struct mcclellan *m = getImplNfa(n); u8 s = *(u8 *)q->state; DEBUG_PRINTF("checking accepts for %hhu\n", s); assert(s < m->accept_limit_8 || get_aux(m, s)->accept); return s >= m->accept_limit_8; } char nfaExecMcClellan16_inAccept(const struct NFA *n, ReportID report, struct mq *q) { assert(n && q); const struct mcclellan *m = getImplNfa(n); u16 s = *(u16 *)q->state; DEBUG_PRINTF("checking accepts for %hu\n", s); return mcclellanHasAccept(m, get_aux(m, s), report); } char nfaExecMcClellan16_inAnyAccept(const struct NFA *n, struct mq *q) { assert(n && q); const struct mcclellan *m = getImplNfa(n); u16 s = *(u16 *)q->state; DEBUG_PRINTF("checking accepts for %hu\n", s); return !!get_aux(m, s)->accept; } char nfaExecMcClellan8_Q2(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCCLELLAN_NFA_8); const struct mcclellan *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; return nfaExecMcClellan8_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCCLELLAN_FLAG_SINGLE, end, STOP_AT_MATCH); } char nfaExecMcClellan16_Q2(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCCLELLAN_NFA_16); const struct mcclellan *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; return nfaExecMcClellan16_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCCLELLAN_FLAG_SINGLE, end, STOP_AT_MATCH); } char nfaExecMcClellan8_QR(const struct NFA *n, struct mq *q, ReportID report) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCCLELLAN_NFA_8); const struct mcclellan *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; char rv = nfaExecMcClellan8_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCCLELLAN_FLAG_SINGLE, 0 /* end */, NO_MATCHES); if (rv && nfaExecMcClellan8_inAccept(n, report, q)) { return MO_MATCHES_PENDING; } else { return rv; } } char nfaExecMcClellan16_QR(const struct NFA *n, struct mq *q, ReportID report) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCCLELLAN_NFA_16); const struct mcclellan *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; char rv = nfaExecMcClellan16_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCCLELLAN_FLAG_SINGLE, 0 /* end */, NO_MATCHES); if (rv && nfaExecMcClellan16_inAccept(n, report, q)) { return MO_MATCHES_PENDING; } else { return rv; } } char nfaExecMcClellan8_initCompressedState(const struct NFA *nfa, u64a offset, void *state, UNUSED u8 key) { const struct mcclellan *m = getImplNfa(nfa); u8 s = offset ? m->start_floating : m->start_anchored; if (s) { *(u8 *)state = s; return 1; } return 0; } char nfaExecMcClellan16_initCompressedState(const struct NFA *nfa, u64a offset, void *state, UNUSED u8 key) { const struct mcclellan *m = getImplNfa(nfa); u16 s = offset ? m->start_floating : m->start_anchored; if (s) { unaligned_store_u16(state, s); return 1; } return 0; } void nfaExecMcClellan8_SimpStream(const struct NFA *nfa, char *state, const u8 *buf, char top, size_t start_off, size_t len, NfaCallback cb, void *ctxt) { const struct mcclellan *m = getImplNfa(nfa); u32 s = top ? m->start_anchored : *(u8 *)state; if (m->flags & MCCLELLAN_FLAG_SINGLE) { mcclellanExec8_i(m, &s, buf + start_off, len - start_off, start_off, cb, ctxt, 1, NULL, CALLBACK_OUTPUT); } else { mcclellanExec8_i(m, &s, buf + start_off, len - start_off, start_off, cb, ctxt, 0, NULL, CALLBACK_OUTPUT); } *(u8 *)state = s; } void nfaExecMcClellan16_SimpStream(const struct NFA *nfa, char *state, const u8 *buf, char top, size_t start_off, size_t len, NfaCallback cb, void *ctxt) { const struct mcclellan *m = getImplNfa(nfa); u32 s = top ? m->start_anchored : unaligned_load_u16(state); if (m->flags & MCCLELLAN_FLAG_SINGLE) { mcclellanExec16_i(m, &s, buf + start_off, len - start_off, start_off, cb, ctxt, 1, NULL, CALLBACK_OUTPUT); } else { mcclellanExec16_i(m, &s, buf + start_off, len - start_off, start_off, cb, ctxt, 0, NULL, CALLBACK_OUTPUT); } unaligned_store_u16(state, s); } char nfaExecMcClellan8_testEOD(const struct NFA *nfa, const char *state, UNUSED const char *streamState, u64a offset, NfaCallback callback, void *context) { return mcclellanCheckEOD(nfa, *(const u8 *)state, offset, callback, context); } char nfaExecMcClellan16_testEOD(const struct NFA *nfa, const char *state, UNUSED const char *streamState, u64a offset, NfaCallback callback, void *context) { assert(ISALIGNED_N(state, 2)); return mcclellanCheckEOD(nfa, *(const u16 *)state, offset, callback, context); } char nfaExecMcClellan8_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) { assert(nfa->scratchStateSize == 1); *(u8 *)q->state = 0; return 0; } char nfaExecMcClellan16_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) { assert(nfa->scratchStateSize == 2); assert(ISALIGNED_N(q->state, 2)); *(u16 *)q->state = 0; return 0; } char nfaExecMcClellan8_queueCompressState(UNUSED const struct NFA *nfa, const struct mq *q, UNUSED s64a loc) { void *dest = q->streamState; const void *src = q->state; assert(nfa->scratchStateSize == 1); assert(nfa->streamStateSize == 1); *(u8 *)dest = *(const u8 *)src; return 0; } char nfaExecMcClellan8_expandState(UNUSED const struct NFA *nfa, void *dest, const void *src, UNUSED u64a offset, UNUSED u8 key) { assert(nfa->scratchStateSize == 1); assert(nfa->streamStateSize == 1); *(u8 *)dest = *(const u8 *)src; return 0; } char nfaExecMcClellan16_queueCompressState(UNUSED const struct NFA *nfa, const struct mq *q, UNUSED s64a loc) { void *dest = q->streamState; const void *src = q->state; assert(nfa->scratchStateSize == 2); assert(nfa->streamStateSize == 2); assert(ISALIGNED_N(src, 2)); unaligned_store_u16(dest, *(const u16 *)(src)); return 0; } char nfaExecMcClellan16_expandState(UNUSED const struct NFA *nfa, void *dest, const void *src, UNUSED u64a offset, UNUSED u8 key) { assert(nfa->scratchStateSize == 2); assert(nfa->streamStateSize == 2); assert(ISALIGNED_N(dest, 2)); *(u16 *)dest = unaligned_load_u16(src); return 0; } hyperscan-4.4.1/src/nfa/castle_dump.h0000644000175000017500000000341013055426554020301 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 CASTLE_DUMP_H #define CASTLE_DUMP_H #if defined(DUMP_SUPPORT) #include struct NFA; namespace ue2 { void nfaExecCastle_dump(const NFA *nfa, const std::string &base); } // namespace ue2 #endif // DUMP_SUPPORT #endif hyperscan-4.4.1/src/nfa/accel_dfa_build_strat.h0000644000175000017500000000466413055426554022272 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ACCEL_DFA_BUILD_STRAT_H #define ACCEL_DFA_BUILD_STRAT_H #include "rdfa.h" #include "dfa_build_strat.h" #include "ue2common.h" #include "util/accel_scheme.h" #include namespace ue2 { class ReportManager; struct Grey; class accel_dfa_build_strat : public dfa_build_strat { public: explicit accel_dfa_build_strat(const ReportManager &rm_in) : dfa_build_strat(rm_in) {} virtual AccelScheme find_escape_strings(dstate_id_t this_idx) const; virtual size_t accelSize(void) const = 0; virtual u32 max_allowed_offset_accel() const = 0; virtual u32 max_stop_char() const = 0; virtual u32 max_floating_stop_char() const = 0; virtual void buildAccel(dstate_id_t this_idx, const AccelScheme &info, void *accel_out); virtual std::map getAccelInfo(const Grey &grey); }; } // namespace ue2 #endif // ACCEL_DFA_BUILD_STRAT_H hyperscan-4.4.1/src/nfa/trufflecompile.h0000644000175000017500000000345713055426554021034 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 TRUFFLECOMPILE_H #define TRUFFLECOMPILE_H #include "ue2common.h" #include "util/charreach.h" namespace ue2 { void truffleBuildMasks(const CharReach &cr, u8 *mask1, u8 *mask2); CharReach truffle2cr(const u8 *lo_in, const u8 *hi_in); } #endif /* TRUFFLECOMPILE_H */ hyperscan-4.4.1/src/nfa/mcclellan_internal.h0000644000175000017500000001035513055426554021635 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MCCLELLAN_INTERNAL_H #define MCCLELLAN_INTERNAL_H #include "nfa_internal.h" #ifdef __cplusplus extern "C" { #endif #define ACCEPT_FLAG 0x8000 #define ACCEL_FLAG 0x4000 #define STATE_MASK 0x3fff #define SHERMAN_STATE 1 #define SHERMAN_TYPE_OFFSET 0 #define SHERMAN_FIXED_SIZE 32 #define SHERMAN_LEN_OFFSET 1 #define SHERMAN_DADDY_OFFSET 2 #define SHERMAN_CHARS_OFFSET 4 #define SHERMAN_STATES_OFFSET(sso_len) (4 + (sso_len)) struct report_list { u32 count; ReportID report[]; }; struct mstate_aux { u32 accept; u32 accept_eod; u16 top; u32 accel_offset; /* relative to start of struct mcclellan; 0 if no accel */ }; #define MCCLELLAN_FLAG_SINGLE 1 /**< we raise only single accept id */ struct mcclellan { u16 state_count; /**< total number of states */ u32 length; /**< length of dfa in bytes */ u16 start_anchored; /**< anchored start state */ u16 start_floating; /**< floating start state */ u32 aux_offset; /**< offset of the aux structures relative to the start of * the nfa structure */ u32 sherman_offset; /**< offset of array of sherman state offsets the * state_info structures relative to the start of the * nfa structure */ u32 sherman_end; /**< offset of the end of the state_info structures * relative to the start of the nfa structure */ u16 accel_limit_8; /**< 8 bit, lowest accelerable state */ u16 accept_limit_8; /**< 8 bit, lowest accept state */ u16 sherman_limit; /**< lowest sherman state */ u8 alphaShift; u8 flags; u8 has_accel; /**< 1 iff there are any accel plans */ u8 remap[256]; /**< remaps characters to a smaller alphabet */ ReportID arb_report; /**< one of the accepts that this dfa may raise */ u32 accel_offset; /**< offset of the accel structures from start of NFA */ u32 haig_offset; /**< reserved for use by Haig, relative to start of NFA */ }; static really_inline const char *findShermanState(UNUSED const struct mcclellan *m, const char *sherman_base_offset, u32 sherman_base, u32 s) { const char *rv = sherman_base_offset + SHERMAN_FIXED_SIZE * (s - sherman_base); assert(rv < (const char *)m + m->length - sizeof(struct NFA)); UNUSED u8 type = *(const u8 *)(rv + SHERMAN_TYPE_OFFSET); assert(type == SHERMAN_STATE); return rv; } static really_inline char *findMutableShermanState(char *sherman_base_offset, u16 sherman_base, u32 s) { return sherman_base_offset + SHERMAN_FIXED_SIZE * (s - sherman_base); } #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/shengdump.h0000644000175000017500000000342413055426554020000 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 SHENGDUMP_H_ #define SHENGDUMP_H_ #ifdef DUMP_SUPPORT #include struct NFA; namespace ue2 { void nfaExecSheng_dump(const struct NFA *nfa, const std::string &base); } // namespace ue2 #endif // DUMP_SUPPORT #endif /* SHENGDUMP_H_ */ hyperscan-4.4.1/src/nfa/mcsheng_internal.h0000644000175000017500000000747613055426554021341 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 MCSHENG_INTERNAL_H #define MCSHENG_INTERNAL_H #include "nfa_internal.h" #include "ue2common.h" #include "util/simd_types.h" #define ACCEPT_FLAG 0x8000 #define ACCEL_FLAG 0x4000 #define STATE_MASK 0x3fff #define SHERMAN_STATE 1 #define SHERMAN_TYPE_OFFSET 0 #define SHERMAN_FIXED_SIZE 32 #define SHERMAN_LEN_OFFSET 1 #define SHERMAN_DADDY_OFFSET 2 #define SHERMAN_CHARS_OFFSET 4 #define SHERMAN_STATES_OFFSET(sso_len) (4 + (sso_len)) struct report_list { u32 count; ReportID report[]; }; struct mstate_aux { u32 accept; u32 accept_eod; u16 top; u32 accel_offset; /* relative to start of struct mcsheng; 0 if no accel */ }; #define MCSHENG_FLAG_SINGLE 1 /**< we raise only single accept id */ struct mcsheng { u16 state_count; /**< total number of states */ u32 length; /**< length of dfa in bytes */ u16 start_anchored; /**< anchored start state */ u16 start_floating; /**< floating start state */ u32 aux_offset; /**< offset of the aux structures relative to the start of * the nfa structure */ u32 sherman_offset; /**< offset of array of sherman state offsets the * state_info structures relative to the start of the * nfa structure */ u32 sherman_end; /**< offset of the end of the state_info structures * relative to the start of the nfa structure */ u16 sheng_end; /**< first non-sheng state */ u16 sheng_accel_limit; /**< first sheng accel state. state given in terms of * internal sheng ids */ u16 accel_limit_8; /**< 8 bit, lowest accelerable state */ u16 accept_limit_8; /**< 8 bit, lowest accept state */ u16 sherman_limit; /**< lowest sherman state */ u8 alphaShift; u8 flags; u8 has_accel; /**< 1 iff there are any accel plans */ u8 remap[256]; /**< remaps characters to a smaller alphabet */ ReportID arb_report; /**< one of the accepts that this dfa may raise */ u32 accel_offset; /**< offset of the accel structures from start of NFA */ m128 sheng_masks[N_CHARS]; }; /* pext masks for the runtime to access appropriately copies of bytes 1..7 * representing the data from a u64a. */ extern const u64a mcsheng_pext_mask[8]; #endif hyperscan-4.4.1/src/nfa/mpv.c0000644000175000017500000011004213055426554016576 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "mpv.h" #include "mpv_internal.h" #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "shufti.h" #include "truffle.h" #include "ue2common.h" #include "vermicelli.h" #include "vermicelli_run.h" #include "util/multibit.h" #include "util/partial_store.h" #include "util/simd_utils.h" #include "util/unaligned.h" #include #define MIN_SKIP_REPEAT 32 typedef struct mpv_pq_item PQ_T; #define PQ_COMP(pqc_items, a, b) \ ((pqc_items)[a].trigger_loc < (pqc_items)[b].trigger_loc) #define PQ_COMP_B(pqc_items, a, b_fixed) \ ((pqc_items)[a].trigger_loc < (b_fixed).trigger_loc) #include "util/pqueue.h" static really_inline u64a *get_counter_n(struct mpv_decomp_state *s, const struct mpv *m, u32 n) { return (u64a *)((char *)s + get_counter_info(m)[n].counter_offset); } static really_inline u64a *get_counter_for_kilo(struct mpv_decomp_state *s, const struct mpv_kilopuff *kp) { return (u64a *)((char *)s + kp->counter_offset); } static really_inline u64a get_counter_value_for_kilo(struct mpv_decomp_state *s, const struct mpv_kilopuff *kp) { return *get_counter_for_kilo(s, kp) + s->counter_adj; } static really_inline const u64a *get_counter_for_kilo_c(const struct mpv_decomp_state *s, const struct mpv_kilopuff *kp) { return (const u64a *)((const char *)s + kp->counter_offset); } static never_inline void normalize_counters(struct mpv_decomp_state *dstate, const struct mpv *m) { u64a adj = dstate->counter_adj; u64a *counters = get_counter_n(dstate, m, 0); if (!adj) { return; } for (u32 i = 0; i < m->counter_count; i++) { /* update all counters - alive or dead */ counters[i] += adj; DEBUG_PRINTF("counter %u: %llu\n", i, counters[i]); } dstate->counter_adj = 0; } static really_inline char processReports(const struct mpv *m, u8 *reporters, const struct mpv_decomp_state *dstate, u64a counter_adj, u64a report_offset, NfaCallback cb, void *ctxt, ReportID *rl, u32 *rl_count_out) { DEBUG_PRINTF("reporting at offset %llu\n", report_offset); const struct mpv_kilopuff *kp = (const void *)(m + 1); u32 rl_count = 0; for (u32 i = mmbit_iterate(reporters, m->kilo_count, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(reporters, m->kilo_count, i)) { const struct mpv_puffette *curr = dstate->active[i].curr; u64a curr_counter_val = *get_counter_for_kilo_c(dstate, &kp[i]) + counter_adj; DEBUG_PRINTF("kilo %u, underlying counter: %llu current: %llu\n", i, *get_counter_for_kilo_c(dstate, &kp[i]), curr_counter_val); assert(curr_counter_val != MPV_DEAD_VALUE); /* counter_adj should take * care if underlying value * is -1 */ char did_stuff = 0; while (curr->report != INVALID_REPORT) { assert(curr_counter_val >= curr->repeats); if (curr->unbounded || curr_counter_val == curr->repeats) { DEBUG_PRINTF("report %u at %llu\n", curr->report, report_offset); if (curr->unbounded && !curr->simple_exhaust) { assert(rl_count < m->puffette_count); *rl = curr->report; ++rl; rl_count++; } if (cb(0, report_offset, curr->report, ctxt) == MO_HALT_MATCHING) { DEBUG_PRINTF("bailing\n"); return MO_HALT_MATCHING; } did_stuff = 1; } curr--; } if (!did_stuff) { mmbit_unset(reporters, m->kilo_count, i); } } *rl_count_out = rl_count; return MO_CONTINUE_MATCHING; } static ReportID *get_report_list(const struct mpv *m, struct mpv_decomp_state *s) { return (ReportID *)((char *)s + m->report_list_offset); } static really_inline char processReportsForRange(const struct mpv *m, u8 *reporters, struct mpv_decomp_state *dstate, u64a first_offset, size_t length, NfaCallback cb, void *ctxt) { if (!length) { return MO_CONTINUE_MATCHING; } u64a counter_adj = dstate->counter_adj; u32 rl_count = 0; ReportID *rl = get_report_list(m, dstate); char rv = processReports(m, reporters, dstate, 1 + counter_adj, first_offset + 1, cb, ctxt, rl, &rl_count); if (rv != MO_CONTINUE_MATCHING) { DEBUG_PRINTF("bailing\n"); return rv; } if (!rl_count) { return MO_CONTINUE_MATCHING; } DEBUG_PRINTF("length=%zu, rl_count=%u\n", length, rl_count); for (size_t i = 2; i <= length; i++) { for (u32 j = 0; j < rl_count; j++) { if (cb(0, first_offset + i, rl[j], ctxt) == MO_HALT_MATCHING) { DEBUG_PRINTF("bailing\n"); return MO_HALT_MATCHING; } } } return MO_CONTINUE_MATCHING; } /* returns last puffette that we have satisfied */ static const struct mpv_puffette *get_curr_puff(const struct mpv *m, const struct mpv_kilopuff *kp, struct mpv_decomp_state *dstate) { u64a counter = *get_counter_for_kilo(dstate, kp); assert(counter != MPV_DEAD_VALUE); const struct mpv_puffette *p = get_puff_array(m, kp); DEBUG_PRINTF("looking for current puffette (counter = %llu)\n", counter); DEBUG_PRINTF("next: (%u, %u)\n", p->repeats, p->report); while (counter + 1 >= p->repeats && p->report != INVALID_REPORT) { DEBUG_PRINTF("advancing\n"); ++p; DEBUG_PRINTF("next: (%u, %u)\n", p->repeats, p->report); } return p - 1; } static const struct mpv_puffette *get_init_puff(const struct mpv *m, const struct mpv_kilopuff *kp) { const struct mpv_puffette *p = get_puff_array(m, kp); while (p->repeats == 1) { ++p; } return p - 1; } /* returns the last puffette whose repeats have been satisfied */ static really_inline const struct mpv_puffette *update_curr_puff(const struct mpv *m, u8 *reporters, u64a counter, const struct mpv_puffette *in, u32 kilo_index) { assert(counter != MPV_DEAD_VALUE); const struct mpv_puffette *p = in; DEBUG_PRINTF("looking for current puffette (counter = %llu)\n", counter); DEBUG_PRINTF("curr: (%u, %u)\n", p->repeats, p->report); while (counter + 1 >= p[1].repeats && p[1].report != INVALID_REPORT) { DEBUG_PRINTF("advancing\n"); ++p; DEBUG_PRINTF("curr: (%u, %u)\n", p->repeats, p->report); } if (p != in) { mmbit_set(reporters, m->kilo_count, kilo_index); } return p; } static really_inline size_t limitByReach(const struct mpv_kilopuff *kp, const u8 *buf, size_t length) { if (kp->type == MPV_VERM) { return vermicelliExec(kp->u.verm.c, 0, buf, buf + length) - buf; } else if (kp->type == MPV_SHUFTI) { m128 mask_lo = kp->u.shuf.mask_lo; m128 mask_hi = kp->u.shuf.mask_hi; return shuftiExec(mask_lo, mask_hi, buf, buf + length) - buf; } else if (kp->type == MPV_TRUFFLE) { return truffleExec(kp->u.truffle.mask1, kp->u.truffle.mask2, buf, buf + length) - buf; } else if (kp->type == MPV_NVERM) { return nvermicelliExec(kp->u.verm.c, 0, buf, buf + length) - buf; } assert(kp->type == MPV_DOT); return length; } static never_inline void fillLimits(const struct mpv *m, u8 *active, u8 *reporters, struct mpv_decomp_state *dstate, struct mpv_pq_item *pq, const u8 *buf, size_t length) { DEBUG_PRINTF("filling limits %zu\n", length); assert(!dstate->pq_size); if (!length) { DEBUG_PRINTF("0 length\n"); return; } const struct mpv_kilopuff *kp = (const void *)(m + 1); for (u32 i = mmbit_iterate(active, m->kilo_count, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, m->kilo_count, i)) { dstate->active[i].curr = get_curr_puff(m, &kp[i], dstate); if (dstate->active[i].curr->report != INVALID_REPORT) { /* this kilo puff may fire reports */ mmbit_set(reporters, m->kilo_count, i); } u64a lim = limitByReach(&kp[i], buf, length); DEBUG_PRINTF("lim %llu/%zu\n", lim, length); if (kp[i].dead_point != MPV_DEAD_VALUE) { assert(!kp[i].auto_restart); u64a counter = get_counter_value_for_kilo(dstate, &kp[i]); u64a dp_trigger = kp[i].dead_point - counter; if (dp_trigger < lim) { DEBUG_PRINTF("dead point trigger %llu\n", dp_trigger); lim = dp_trigger; } } if (kp[i].auto_restart && !lim) { *get_counter_for_kilo(dstate, &kp[i]) = MPV_DEAD_VALUE; mmbit_unset(reporters, m->kilo_count, i); /* the counter value will cause the nex_trigger calculation below to * adjust correctly */ if (length == 1) { dstate->active[i].limit = 0; continue; } lim = limitByReach(&kp[i], buf + 1, length - 1) + 1; /* restart active counters */ dstate->active[i].curr = get_init_puff(m, &kp[i]); assert(dstate->active[i].curr[0].report == INVALID_REPORT); DEBUG_PRINTF("lim now %llu/%zu\n", lim, length); } dstate->active[i].limit = lim; if (!lim) { mmbit_unset(active, m->kilo_count, i); mmbit_unset(reporters, m->kilo_count, i); continue; } if (dstate->active[i].curr[1].report != INVALID_REPORT) { u32 next_trigger = dstate->active[i].curr[1].repeats - 1ULL - *get_counter_for_kilo(dstate, &kp[i]); DEBUG_PRINTF("next trigger %u\n", next_trigger); lim = MIN(lim, next_trigger); } if (lim != length) { struct mpv_pq_item temp = { .trigger_loc = lim, .kilo = i }; DEBUG_PRINTF("push for %u at %llu\n", i, lim); pq_insert(pq, dstate->pq_size, temp); ++dstate->pq_size; } assert(lim || kp[i].auto_restart); } DEBUG_PRINTF("filled\n"); dstate->filled = 1; } static never_inline void handleTopN(const struct mpv *m, s64a loc, u8 *active, u8 *reporters, struct mpv_decomp_state *dstate, struct mpv_pq_item *pq, const u8 *buf, size_t length, u32 i) { assert(i < m->kilo_count); DEBUG_PRINTF("MQE_TOP + %u @%lld\n", i, loc); if (mmbit_set(active, m->kilo_count, i)) { DEBUG_PRINTF("kilo is already alive and kicking\n"); return; } const struct mpv_kilopuff *kp = (const struct mpv_kilopuff *)(m + 1); assert(!kp[i].auto_restart); /* handle later/never */ /* we need to ensure that the counters are upto date */ normalize_counters(dstate, m); /* reset counter */ *get_counter_for_kilo(dstate, &kp[i]) = 0; if ((size_t)loc == length) { /* end of buffer, just make sure it is active */ dstate->active[i].limit = loc; dstate->active[i].curr = get_init_puff(m, &kp[i]); return; } /* find the limit */ u64a lim = limitByReach(&kp[i], buf + loc, length - loc) + loc; /* no need to worry about dead_point triggers here as kilopuff must first * update chain (to fire a report) before it goes dead. */ if (lim == (u64a)loc) { DEBUG_PRINTF("dead on arrival\n"); mmbit_unset(active, m->kilo_count, i); return; } dstate->active[i].limit = lim; /* setup puffette, find next trigger */ dstate->active[i].curr = get_init_puff(m, &kp[i]); if (dstate->active[i].curr[1].report != INVALID_REPORT) { u32 next_trigger = dstate->active[i].curr[1].repeats - 1ULL + loc; lim = MIN(lim, next_trigger); } assert(dstate->active[i].curr[0].repeats == 1 || dstate->active[i].curr[0].report == INVALID_REPORT); if (dstate->active[i].curr[0].repeats == 1) { DEBUG_PRINTF("yippee\n"); mmbit_set(reporters, m->kilo_count, i); } assert(lim > (u64a)loc); /* add to pq */ if (lim != length) { struct mpv_pq_item temp = { .trigger_loc = lim, .kilo = i }; DEBUG_PRINTF("push for %u at %llu\n", i, lim); pq_insert(pq, dstate->pq_size, temp); ++dstate->pq_size; } } static really_inline void killKilo(const struct mpv *m, u8 *active, u8 *reporters, struct mpv_decomp_state *dstate, struct mpv_pq_item *pq, u32 i) { DEBUG_PRINTF("squashing kilo %u (progress %llu, limit %llu)\n", i, pq_top(pq)->trigger_loc, dstate->active[i].limit); mmbit_unset(active, m->kilo_count, i); mmbit_unset(reporters, m->kilo_count, i); pq_pop(pq, dstate->pq_size); dstate->pq_size--; } static really_inline void updateKiloChains(const struct mpv *m, u8 *reporters, struct mpv_decomp_state *dstate, struct mpv_pq_item *pq, u64a curr_loc, size_t buf_length, u32 i) { const struct mpv_kilopuff *kp = (const void *)(m + 1); u64a counter = get_counter_value_for_kilo(dstate, &kp[i]); DEBUG_PRINTF("updating active puff for kilo %u\n", i); dstate->active[i].curr = update_curr_puff(m, reporters, counter, dstate->active[i].curr, i); u64a next_trigger = dstate->active[i].limit; if (dstate->active[i].curr[1].report != INVALID_REPORT) { u64a next_rep_trigger = dstate->active[i].curr[1].repeats - 1 - counter + curr_loc; next_trigger = MIN(next_trigger, next_rep_trigger); } else if (kp[i].dead_point != MPV_DEAD_VALUE) { u64a dp_trigger = kp[i].dead_point - counter + curr_loc; DEBUG_PRINTF("dead point trigger %llu\n", dp_trigger); if (dp_trigger < dstate->active[i].limit) { dstate->active[i].limit = dp_trigger; next_trigger = dp_trigger; } } DEBUG_PRINTF("next trigger location is %llu\n", next_trigger); if (next_trigger < buf_length) { assert(dstate->pq_size <= m->kilo_count); assert(next_trigger > pq_top(pq)->trigger_loc); struct mpv_pq_item temp = { .trigger_loc = next_trigger, .kilo = i }; DEBUG_PRINTF("(replace) push for %u at %llu\n", i, next_trigger); pq_replace_top(pq, dstate->pq_size, temp); } else { pq_pop(pq, dstate->pq_size); dstate->pq_size--; DEBUG_PRINTF("PQ_POP\n"); } DEBUG_PRINTF("pq size now %u next top %llu\n", dstate->pq_size, pq_top(pq)->trigger_loc); } static really_inline u8 do_single_shufti(const m128 l, const m128 h, u8 c) { const u8 *lo = (const u8 *)&l; const u8 *hi = (const u8 *)&h; return lo[c & 0xf] & hi[c >> 4]; } static really_inline size_t find_last_bad(const struct mpv_kilopuff *kp, const u8 *buf, size_t length, size_t curr, u32 min_rep) { assert(kp->type != MPV_DOT); DEBUG_PRINTF("repeats = %u\n", min_rep); /* TODO: this should be replace by some sort of simd stuff */ if (kp->type == MPV_VERM) { if (min_rep < MIN_SKIP_REPEAT) { return find_nverm_run(kp->u.verm.c, 0, min_rep, buf, buf + curr, buf + length) - buf - 1; } verm_restart:; assert(buf[curr] == kp->u.verm.c); size_t test = curr; if (curr + min_rep < length) { test = curr + min_rep; } else { test = length - 1; } while (test > curr) { if (buf[test] == kp->u.verm.c) { curr = test; if (curr == length - 1) { return curr; } goto verm_restart; } --test; } } else if (kp->type == MPV_SHUFTI) { m128 lo = kp->u.shuf.mask_lo; m128 hi = kp->u.shuf.mask_hi; shuf_restart: assert(do_single_shufti(lo, hi, buf[curr])); size_t test = curr; if (curr + min_rep < length) { test = curr + min_rep; } else { test = length - 1; } while (test > curr) { if (do_single_shufti(lo, hi, buf[test])) { DEBUG_PRINTF("updating curr from %zu to %zu\n", curr, test); curr = test; if (curr == length - 1) { return curr; } goto shuf_restart; } --test; } } else if (kp->type == MPV_TRUFFLE) { const m128 mask1 = kp->u.truffle.mask1; const m128 mask2 = kp->u.truffle.mask2; truffle_restart:; size_t test = curr; if (curr + min_rep < length) { test = curr + min_rep; } else { test = length - 1; } while (test > curr) { const u8 *rv = truffleExec(mask1, mask2, buf + test, buf + test + 1); if (rv == buf + test) { curr = test; if (curr == length - 1) { return curr; } goto truffle_restart; } --test; } } else if (kp->type == MPV_NVERM) { if (min_rep < MIN_SKIP_REPEAT) { return find_verm_run(kp->u.verm.c, 0, min_rep, buf, buf + curr, buf + length) - buf - 1; } nverm_restart:; assert(buf[curr] != kp->u.verm.c); size_t test = curr; if (curr + min_rep < length) { test = curr + min_rep; } else { test = length - 1; } while (test > curr) { if (buf[test] != kp->u.verm.c) { curr = test; if (curr == length - 1) { return curr; } goto nverm_restart; } --test; } } else { assert(0); } return curr; } static really_inline void restartKilo(const struct mpv *m, UNUSED u8 *active, u8 *reporters, struct mpv_decomp_state *dstate, struct mpv_pq_item *pq, const u8 *buf, u64a prev_limit, size_t buf_length, u32 i) { const struct mpv_kilopuff *kp = (const void *)(m + 1); assert(kp[i].auto_restart); assert(mmbit_isset(active, m->kilo_count, i)); DEBUG_PRINTF("we got to %llu,%llu\n", prev_limit, dstate->active[i].limit); assert(prev_limit == dstate->active[i].limit); DEBUG_PRINTF("resetting counter\n"); /* we need to ensure that the counters are upto date */ normalize_counters(dstate, m); /* current byte is dead, will wrap to 0 after processing this byte */ assert(MPV_DEAD_VALUE + 1 == 0); *get_counter_for_kilo(dstate, &kp[i]) = MPV_DEAD_VALUE; DEBUG_PRINTF("resetting puffettes\n"); dstate->active[i].curr = get_init_puff(m, &kp[i]); assert(dstate->active[i].curr[0].report == INVALID_REPORT); /* TODO: handle restart .{1,}s */ mmbit_unset(reporters, m->kilo_count, i); if (prev_limit != buf_length - 1) { size_t last_bad = find_last_bad(&kp[i], buf, buf_length, prev_limit, dstate->active[i].curr[1].repeats); assert(last_bad >= prev_limit && last_bad < buf_length); if (last_bad != prev_limit) { /* there is no point in getting restarted at this location */ dstate->active[i].limit = last_bad; assert(dstate->pq_size <= m->kilo_count); struct mpv_pq_item temp = { .trigger_loc = last_bad, .kilo = i }; pq_replace_top(pq, dstate->pq_size, temp); return; } } /* TODO: skipping would really come in handy about now */ u64a lim; if (buf_length > prev_limit + 1) { lim = limitByReach(&kp[i], buf + prev_limit + 1, buf_length - (prev_limit + 1)) + prev_limit + 1; } else { assert(buf_length == prev_limit + 1); lim = buf_length; } DEBUG_PRINTF("next limit is %llu\n", lim); assert(lim > prev_limit); dstate->active[i].limit = lim; if (dstate->active[i].curr[1].report != INVALID_REPORT) { u32 next_trigger = dstate->active[i].curr[1].repeats + prev_limit; lim = MIN(lim, next_trigger); } DEBUG_PRINTF("next trigger for kilo at %llu\n", lim); if (lim < buf_length) { assert(dstate->pq_size <= m->kilo_count); assert(lim >= prev_limit); struct mpv_pq_item temp = { .trigger_loc = lim, .kilo = i }; pq_replace_top(pq, dstate->pq_size, temp); } else { pq_pop(pq, dstate->pq_size); dstate->pq_size--; } } static really_inline void handle_events(const struct mpv *m, u8 *active, u8 *reporters, struct mpv_decomp_state *dstate, struct mpv_pq_item *pq, u64a loc, const u8 *buf, size_t buf_length) { const struct mpv_kilopuff *kp = (const void *)(m + 1); while (dstate->pq_size && pq_top(pq)->trigger_loc <= loc) { assert(pq_top(pq)->trigger_loc == loc); u32 kilo = pq_top(pq)->kilo; DEBUG_PRINTF("pop for kilo %u at %llu\n", kilo, pq_top(pq)->trigger_loc); if (dstate->active[kilo].limit <= loc) { if (!kp[kilo].auto_restart) { killKilo(m, active, reporters, dstate, pq, kilo); } else { restartKilo(m, active, reporters, dstate, pq, buf, loc, buf_length, kilo); } } else { updateKiloChains(m, reporters, dstate, pq, loc, buf_length, kilo); } } } static really_inline u64a find_next_limit(const struct mpv *m, u8 *active, u8 *reporters, struct mpv_decomp_state *dstate, struct mpv_pq_item *pq, const u8 *buf, u64a prev_limit, u64a ep, size_t buf_length) { u64a limit = ep; DEBUG_PRINTF("length %llu (prev %llu), pq %u\n", limit, prev_limit, dstate->pq_size); handle_events(m, active, reporters, dstate, pq, prev_limit, buf, buf_length); if (dstate->pq_size) { limit = MIN(pq_top(pq)->trigger_loc, limit); assert(limit > prev_limit); } DEBUG_PRINTF("limit now %llu\n", limit); return limit; } static really_inline char mpvExec(const struct mpv *m, u8 *active, u8 *reporters, struct mpv_decomp_state *dstate, struct mpv_pq_item *pq, const u8 *buf, s64a start, size_t length, size_t buf_length, u64a offsetAdj, NfaCallback cb, void *ctxt) { DEBUG_PRINTF("running mpv (s %lliu, l %zu, o %llu)\n", *get_counter_n(dstate, m, 0) + dstate->counter_adj, length, offsetAdj); u64a progress = start; /* progress is relative to buffer offsets */ while (progress < length) { DEBUG_PRINTF("progress %llu\n", progress); /* find next limit and update chains */ u64a limit = find_next_limit(m, active, reporters, dstate, pq, buf, progress, length, buf_length); assert(limit != progress); u64a incr = limit - progress; DEBUG_PRINTF("incr = %llu\n", incr); /* report matches upto next limit */ char rv = processReportsForRange(m, reporters, dstate, offsetAdj + progress, limit - progress, cb, ctxt); if (rv != MO_CONTINUE_MATCHING) { DEBUG_PRINTF("mpvExec done %llu/%zu\n", progress, length); return rv; } dstate->counter_adj += incr; progress = limit; } assert(progress == length); DEBUG_PRINTF("mpvExec done\n"); return MO_CONTINUE_MATCHING; } static really_inline void mpvLoadState(struct mpv_decomp_state *out, const struct NFA *n, const char *state) { assert(16 >= sizeof(struct mpv_decomp_kilo)); assert(sizeof(*out) <= n->scratchStateSize); assert(ISALIGNED(out)); const struct mpv *m = getImplNfa(n); const struct mpv_counter_info *counter_info = get_counter_info(m); u64a *counters = get_counter_n(out, m, 0); const char *comp_counter = state; for (u32 i = 0; i < m->counter_count; i++) { u32 counter_size = counter_info[i].counter_size; counters[i] = partial_load_u64a(comp_counter, counter_size); DEBUG_PRINTF("loaded %llu counter %u\n", counters[i], i); comp_counter += counter_size; } out->filled = 0; /* _Q_i will fill limits, curr puffetes, and populate pq * on first call */ out->counter_adj = 0; out->pq_size = 0; u8 *reporters = (u8 *)out + m->reporter_offset; mmbit_clear(reporters, m->kilo_count); } static really_inline void mpvStoreState(const struct NFA *n, char *state, const struct mpv_decomp_state *in) { assert(ISALIGNED(in)); const struct mpv *m = getImplNfa(n); const struct mpv_counter_info *counter_info = get_counter_info(m); const u64a *counters = (const u64a *)((const char *)in + get_counter_info(m)[0].counter_offset); u64a adj = in->counter_adj; char *comp_counter = state; for (u32 i = 0; i < m->counter_count; i++) { /* clamp counter to allow storage in smaller ints */ u64a curr_counter = MIN(counters[i] + adj, counter_info[i].max_counter); u32 counter_size = counter_info[i].counter_size; partial_store_u64a(comp_counter, curr_counter, counter_size); DEBUG_PRINTF("stored %llu counter %u (orig %llu)\n", curr_counter, i, counters[i]); /* assert(counters[i] != MPV_DEAD_VALUE); /\* should have process 1 byte */ /* * since a clear *\/ */ comp_counter += counter_size; } } char nfaExecMpv_queueCompressState(const struct NFA *nfa, const struct mq *q, UNUSED s64a loc) { void *dest = q->streamState; const void *src = q->state; mpvStoreState(nfa, dest, src); return 0; } char nfaExecMpv_expandState(const struct NFA *nfa, void *dest, const void *src, UNUSED u64a offset, UNUSED u8 key) { mpvLoadState(dest, nfa, src); return 0; } char nfaExecMpv_reportCurrent(const struct NFA *n, struct mq *q) { const struct mpv *m = getImplNfa(n); u64a offset = q_cur_offset(q); struct mpv_decomp_state *s = (struct mpv_decomp_state *)q->state; DEBUG_PRINTF("report current: offset %llu\n", offset); u8 *active = (u8 *)q->streamState + m->active_offset; u32 rl_count = 0; ReportID *rl = get_report_list(m, s); processReports(m, active, s, s->counter_adj, offset, q->cb, q->context, rl, &rl_count); return 0; } char nfaExecMpv_queueInitState(const struct NFA *n, struct mq *q) { struct mpv_decomp_state *out = (void *)q->state; const struct mpv *m = getImplNfa(n); assert(sizeof(*out) <= n->scratchStateSize); DEBUG_PRINTF("queue init state\n"); u64a *counters = get_counter_n(out, m, 0); for (u32 i = 0; i < m->counter_count; i++) { counters[i] = MPV_DEAD_VALUE; } out->filled = 0; out->counter_adj = 0; out->pq_size = 0; out->active[0].curr = NULL; assert(q->streamState); u8 *active_kpuff = (u8 *)q->streamState + m->active_offset; u8 *reporters = (u8 *)q->state + m->reporter_offset; mmbit_clear(active_kpuff, m->kilo_count); mmbit_clear(reporters, m->kilo_count); return 0; } char nfaExecMpv_initCompressedState(const struct NFA *n, u64a offset, void *state, UNUSED u8 key) { const struct mpv *m = getImplNfa(n); memset(state, 0, m->active_offset); /* active_offset marks end of comp * counters */ u8 *active_kpuff = (u8 *)state + m->active_offset; if (!offset) { mmbit_init_range(active_kpuff, m->kilo_count, m->top_kilo_begin, m->top_kilo_end); return 1; } else { return 0; } } static really_inline char nfaExecMpv_Q_i(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; size_t length = q->length; NfaCallback cb = q->cb; void *context = q->context; s64a sp; const struct mpv *m = getImplNfa(n); struct mpv_decomp_state *s = (struct mpv_decomp_state *)q->state; u8 *active = (u8 *)q->streamState + m->active_offset; u8 *reporters = (u8 *)q->state + m->reporter_offset; struct mpv_pq_item *pq = (struct mpv_pq_item *)(q->state + m->pq_offset); if (!s->filled) { fillLimits(m, active, reporters, s, pq, q->buffer, q->length); } assert(!q->report_current); if (q->cur == q->end) { return 1; } assert(q->cur + 1 < q->end); /* require at least two items */ assert(q_cur_type(q) == MQE_START); assert(q_cur_loc(q) >= 0); sp = q->items[q->cur].location; q->cur++; if (q->items[q->cur - 1].location > end) { /* this is as far as we go */ q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; return MO_ALIVE; } while (q->cur < q->end) { s64a ep = q->items[q->cur].location; ep = MIN(ep, end); assert(ep >= sp); assert(sp >= 0); /* mpv should be an outfix; outfixes are not lazy */ if (sp >= ep) { goto scan_done; } /* do main buffer region */ assert((u64a)ep <= length); char rv = mpvExec(m, active, reporters, s, pq, buffer, sp, ep, length, offset, cb, context); if (rv == MO_HALT_MATCHING) { q->cur = q->end; return 0; } scan_done: if (q->items[q->cur].location > end) { /* this is as far as we go */ q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; return MO_ALIVE; } sp = ep; switch (q->items[q->cur].type) { case MQE_TOP: DEBUG_PRINTF("top %u %u\n", m->top_kilo_begin, m->top_kilo_end); /* MQE_TOP initialise all counters to 0; activates all kilos */ { u64a *counters = get_counter_n(s, m, 0); assert(counters[0] == MPV_DEAD_VALUE); assert(!s->counter_adj); for (u32 i = 0; i < m->counter_count; i++) { counters[i] = 0; } mmbit_init_range(active, m->kilo_count, m->top_kilo_begin, m->top_kilo_end); fillLimits(m, active, reporters, s, pq, buffer, length); } break; case MQE_START: case MQE_END: break; default: /* MQE_TOP_N --> switch on kilo puff N */ assert(q->items[q->cur].type >= MQE_TOP_FIRST); assert(q->items[q->cur].type < MQE_INVALID); u32 i = q->items[q->cur].type - MQE_TOP_FIRST; handleTopN(m, sp, active, reporters, s, pq, buffer, length, i); break; } q->cur++; } char alive = 0; assert(q->items[q->cur - 1].type == MQE_END); if (q->items[q->cur - 1].location == (s64a)q->length) { normalize_counters(s, m); const struct mpv_kilopuff *kp = (const struct mpv_kilopuff *)(m + 1); for (u32 i = mmbit_iterate(active, m->kilo_count, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, m->kilo_count, i)) { if (*get_counter_for_kilo(s, &kp[i]) >= kp[i].dead_point) { mmbit_unset(active, m->kilo_count, i); } else { alive = 1; } } } else { alive = mmbit_iterate(active, m->kilo_count, MMB_INVALID) != MMB_INVALID; } DEBUG_PRINTF("finished %d\n", (int)alive); return alive; } char nfaExecMpv_Q(const struct NFA *n, struct mq *q, s64a end) { DEBUG_PRINTF("_Q %lld\n", end); return nfaExecMpv_Q_i(n, q, end); } s64a nfaExecMpv_QueueExecRaw(const struct NFA *nfa, struct mq *q, s64a end) { DEBUG_PRINTF("nfa=%p end=%lld\n", nfa, end); #ifdef DEBUG debugQueue(q); #endif assert(nfa->type == MPV_NFA); assert(q && q->context && q->state); assert(end >= 0); assert(q->cur < q->end); assert(q->end <= MAX_MQE_LEN); assert(ISALIGNED_16(nfa) && ISALIGNED_16(getImplNfa(nfa))); assert(end < q->items[q->end - 1].location || q->items[q->end - 1].type == MQE_END); if (q->items[q->cur].location > end) { return 1; } char q_trimmed = 0; assert(end <= (s64a)q->length || !q->hlength); /* due to reverse accel in block mode some queues may work on a truncated * buffer */ if (end > (s64a)q->length) { end = q->length; q_trimmed = 1; } /* TODO: restore max offset stuff, if/when _interesting_ max offset stuff * is filled in */ char rv = nfaExecMpv_Q_i(nfa, q, end); assert(!q->report_current); DEBUG_PRINTF("returned rv=%d, q_trimmed=%d\n", rv, q_trimmed); if (q_trimmed || !rv) { return 0; } else { const struct mpv *m = getImplNfa(nfa); u8 *reporters = (u8 *)q->state + m->reporter_offset; if (mmbit_any_precise(reporters, m->kilo_count)) { DEBUG_PRINTF("next byte\n"); return 1; /* need to match at next byte */ } else { s64a next_event = q->length; s64a next_pq = q->length; if (q->cur < q->end) { next_event = q->items[q->cur].location; } struct mpv_decomp_state *s = (struct mpv_decomp_state *)q->state; struct mpv_pq_item *pq = (struct mpv_pq_item *)(q->state + m->pq_offset); if (s->pq_size) { next_pq = pq_top(pq)->trigger_loc; } assert(next_event); assert(next_pq); DEBUG_PRINTF("next pq %lld event %lld\n", next_pq, next_event); return MIN(next_pq, next_event); } } } hyperscan-4.4.1/src/nfa/limex_simd128.c0000644000175000017500000000425713055426554020373 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief LimEx NFA: 128-bit SIMD runtime implementations. */ //#define DEBUG_INPUT //#define DEBUG_EXCEPTIONS #include "limex.h" #include "accel.h" #include "limex_internal.h" #include "nfa_internal.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" // Common code #define STATE_ON_STACK #define ESTATE_ON_STACK #include "limex_runtime.h" #define SIZE 128 #define STATE_T m128 #define ENG_STATE_T m128 #define LOAD_FROM_ENG load_m128 #include "limex_exceptional.h" #include "limex_state_impl.h" #define INLINE_ATTR really_inline #include "limex_common_impl.h" #include "limex_runtime_impl.h" hyperscan-4.4.1/src/nfa/limex_compile.cpp0000644000175000017500000025105113055426554021170 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ /** \file * \brief Main NFA build code. */ #include "limex_compile.h" #include "accel.h" #include "accelcompile.h" #include "grey.h" #include "limex_internal.h" #include "limex_limits.h" #include "nfa_build_util.h" #include "nfagraph/ng_dominators.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_limex_accel.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_squash.h" #include "nfagraph/ng_util.h" #include "ue2common.h" #include "repeatcompile.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/order_check.h" #include "util/verify_types.h" #include "util/ue2_containers.h" #include #include #include #include #include #include #include #include #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { /** * \brief Special state index value meaning that the vertex will not * participate in an (NFA/DFA/etc) implementation. */ static constexpr u32 NO_STATE = ~0; namespace { struct precalcAccel { precalcAccel() : single_offset(0), double_offset(0) {} CharReach single_cr; u32 single_offset; CharReach double_cr; flat_set> double_lits; /* double-byte accel stop literals */ u32 double_offset; MultibyteAccelInfo ma_info; }; struct limex_accel_info { ue2::unordered_set accelerable; map precalc; ue2::unordered_map> friends; ue2::unordered_map accel_map; }; static map reindexByStateId(const map &in, const NGHolder &g, const ue2::unordered_map &state_ids, const u32 num_states) { map out; vector indexToState(num_vertices(g), NO_STATE); for (const auto &m : state_ids) { u32 vert_id = g[m.first].index; assert(vert_id < indexToState.size()); indexToState[vert_id] = m.second; } for (const auto &m : in) { NFAVertex v = m.first; assert(m.second.size() <= indexToState.size()); NFAStateSet mask(num_states); for (size_t i = m.second.find_first(); i != m.second.npos; i = m.second.find_next(i)) { u32 state_id = indexToState[i]; if (state_id == NO_STATE) { continue; } mask.set(state_id); } out.emplace(v, mask); } return out; } struct build_info { build_info(NGHolder &hi, const ue2::unordered_map &states_in, const vector &ri, const map &rsmi, const map &smi, const map> &ti, const set &zi, bool dai, bool sci, const CompileContext &cci, u32 nsi) : h(hi), state_ids(states_in), repeats(ri), tops(ti), zombies(zi), do_accel(dai), stateCompression(sci), cc(cci), num_states(nsi) { for (const auto &br : repeats) { insert(&tugs, br.tug_triggers); br_cyclic[br.cyclic] = BoundedRepeatSummary(br.repeatMin, br.repeatMax); } // Convert squash maps to be indexed by state index rather than // vertex_index. squashMap = reindexByStateId(smi, h, state_ids, num_states); reportSquashMap = reindexByStateId(rsmi, h, state_ids, num_states); } NGHolder &h; const ue2::unordered_map &state_ids; const vector &repeats; // Squash maps; state sets are indexed by state_id. map reportSquashMap; map squashMap; const map> &tops; ue2::unordered_set tugs; map br_cyclic; const set &zombies; bool do_accel; bool stateCompression; const CompileContext &cc; u32 num_states; limex_accel_info accel; }; #define LAST_LIMEX_NFA LIMEX_NFA_512 // Constants for scoring mechanism const int SHIFT_COST = 10; // limex: cost per shift mask const int EXCEPTION_COST = 4; // limex: per exception template struct NFATraits { }; template class sfunc, typename rv_t, typename arg_t, NFAEngineType lb> struct DISPATCH_BY_LIMEX_TYPE_INT { static rv_t doOp(NFAEngineType i, const arg_t &arg) { if (i == lb) { return sfunc::call(arg); } else { return DISPATCH_BY_LIMEX_TYPE_INT ::doOp(i, arg); } } }; template class sfunc, typename rv_t, typename arg_t> struct DISPATCH_BY_LIMEX_TYPE_INT { // dummy static rv_t doOp(NFAEngineType, const arg_t &) { assert(0); throw std::logic_error("Unreachable"); } }; #define DISPATCH_BY_LIMEX_TYPE(i, op, arg) \ DISPATCH_BY_LIMEX_TYPE_INT::call(arg)), \ decltype(arg), (NFAEngineType)0>::doOp(i, arg) // Given a number of states, find the size of the smallest container NFA it // will fit in. We support NFAs of the following sizes: 32, 64, 128, 256, 384, // 512. size_t findContainerSize(size_t states) { if (states > 256 && states <= 384) { return 384; } return 1ULL << (lg2(states - 1) + 1); } bool isLimitedTransition(int from, int to, int maxshift) { int diff = to - from; // within our shift? if (diff < 0 || diff > maxshift) { return false; } // can't jump over a bollard return (from & ~63) == (to & ~63); } // Fill a bit mask template void maskFill(Mask &m, char c) { memset(&m, c, sizeof(m)); } // Clear a bit mask. template void maskClear(Mask &m) { memset(&m, 0, sizeof(m)); } template u8 *maskGetByte(Mask &m, u32 bit) { assert(bit < sizeof(m)*8); u8 *m8 = (u8 *)&m; return m8 + bit/8; } // Set a bit in a mask, starting from the little end. template void maskSetBit(Mask &m, const unsigned int bit) { u8 *byte = maskGetByte(m, bit); *byte |= 1U << (bit % 8); } template void maskSetBits(Mask &m, const NFAStateSet &bits) { for (size_t i = bits.find_first(); i != bits.npos; i = bits.find_next(i)) { maskSetBit(m, i); } } template bool isMaskZero(Mask &m) { u8 *m8 = (u8 *)&m; for (u32 i = 0; i < sizeof(m); i++) { if (m8[i]) { return false; } } return true; } // Sets an entire byte in a mask to the given value template void maskSetByte(Mask &m, const unsigned int idx, const char val) { assert(idx < sizeof(m)); char *m8 = (char *)&m; char &byte = m8[idx]; byte = val; } // Clear a bit in the mask, starting from the little end. template void maskClearBit(Mask &m, const u32 bit) { u8 *byte = maskGetByte(m, bit); *byte &= ~(1U << (bit % 8)); } /* * Common code: the following code operates on parts of the NFA that are common * to both the (defunct) General and the LimEx models. */ static void buildReachMapping(const build_info &args, vector &reach, vector &reachMap) { const NGHolder &h = args.h; const auto &state_ids = args.state_ids; // Build a list of vertices with a state index assigned. vector verts; verts.reserve(args.num_states); for (auto v : vertices_range(h)) { if (state_ids.at(v) != NO_STATE) { verts.push_back(v); } } // Build a mapping from set-of-states -> reachability. map mapping; NFAStateSet states(args.num_states); for (size_t i = 0; i < N_CHARS; i++) { states.reset(); for (auto v : verts) { const CharReach &cr = h[v].char_reach; if (cr.test(i)) { u32 state_id = state_ids.at(v); states.set(state_id); } } mapping[states].set(i); } DEBUG_PRINTF("%zu distinct reachability entries\n", mapping.size()); assert(!mapping.empty()); // Build a vector of distinct reachability entries and a mapping from every // character to one of those entries. reach.reserve(mapping.size()); reachMap.assign(N_CHARS, 0); u8 num = 0; for (auto mi = mapping.begin(), me = mapping.end(); mi != me; ++mi, ++num) { // Reach entry. reach.push_back(mi->first); // Character mapping. const CharReach &cr = mi->second; for (size_t i = cr.find_first(); i != CharReach::npos; i = cr.find_next(i)) { reachMap[i] = num; } } } struct AccelBuild { AccelBuild() : v(NGHolder::null_vertex()), state(0), offset(0), ma_len1(0), ma_len2(0), ma_type(MultibyteAccelInfo::MAT_NONE) {} NFAVertex v; u32 state; u32 offset; // offset correction to apply CharReach stop1; // single-byte accel stop literals flat_set> stop2; // double-byte accel stop literals u32 ma_len1; // multiaccel len1 u32 ma_len2; // multiaccel len2 MultibyteAccelInfo::multiaccel_type ma_type; // multiaccel type }; static void findStopLiterals(const build_info &bi, NFAVertex v, AccelBuild &build) { u32 state = bi.state_ids.at(v); build.v = v; build.state = state; NFAStateSet ss(bi.num_states); ss.set(state); if (!contains(bi.accel.precalc, ss)) { build.stop1 = CharReach::dot(); } else { const precalcAccel &precalc = bi.accel.precalc.at(ss); unsigned ma_len = precalc.ma_info.len1 + precalc.ma_info.len2; if (ma_len >= MULTIACCEL_MIN_LEN) { build.ma_len1 = precalc.ma_info.len1; build.stop1 = precalc.ma_info.cr; build.offset = precalc.ma_info.offset; } else if (precalc.double_lits.empty()) { build.stop1 = precalc.single_cr; build.offset = precalc.single_offset; } else { build.stop1 = precalc.double_cr; build.stop2 = precalc.double_lits; build.offset = precalc.double_offset; } } #ifdef DEBUG printf("state %u stop1:", state); for (size_t j = build.stop1.find_first(); j != build.stop1.npos; j = build.stop1.find_next(j)) { printf(" 0x%02x", (u32)j); } printf("\n"); printf("state %u stop2:", state); for (auto it = build.stop2.begin(); it != build.stop2.end(); ++it) { printf(" 0x%02hhx%02hhx", it->first, it->second); } printf("\n"); #endif } // Generate all the data we need for at most NFA_MAX_ACCEL_STATES accelerable // states. static void gatherAccelStates(const build_info &bi, vector &accelStates) { for (auto v : bi.accel.accelerable) { DEBUG_PRINTF("state %u is accelerable\n", bi.state_ids.at(v)); AccelBuild a; findStopLiterals(bi, v, a); accelStates.push_back(a); } // AccelStates should be sorted by state number, so that we build our accel // masks correctly. sort(accelStates.begin(), accelStates.end(), [](const AccelBuild &a, const AccelBuild &b) { return a.state < b.state; }); // Our caller shouldn't have fed us too many accel states. assert(accelStates.size() <= NFA_MAX_ACCEL_STATES); if (accelStates.size() > NFA_MAX_ACCEL_STATES) { accelStates.resize(NFA_MAX_ACCEL_STATES); } } static void combineAccel(const AccelBuild &in, AccelBuild &out) { // stop1 and stop2 union out.stop1 |= in.stop1; out.stop2.insert(in.stop2.begin(), in.stop2.end()); // offset is maximum of the two out.offset = max(out.offset, in.offset); } static void minimiseAccel(AccelBuild &build) { flat_set> new_stop2; // Any two-byte accels beginning with a one-byte accel should be removed for (const auto &si : build.stop2) { if (!build.stop1.test(si.first)) { new_stop2.insert(si); } } build.stop2 = new_stop2; } struct AccelAuxCmp { explicit AccelAuxCmp(const AccelAux &aux_in) : aux(aux_in) {} bool operator()(const AccelAux &a) const { return !memcmp(&a, &aux, sizeof(AccelAux)); } private: const AccelAux &aux; }; static bool allow_wide_accel(NFAVertex v, const NGHolder &g, NFAVertex sds_or_proxy) { return v == sds_or_proxy || edge(g.start, v, g).second; } static bool allow_wide_accel(const vector &vv, const NGHolder &g, NFAVertex sds_or_proxy) { for (auto v : vv) { if (allow_wide_accel(v, g, sds_or_proxy)) { return true; } } return false; } // identify and mark states that we feel are accelerable (for a limex NFA) /* Note: leftfix nfas allow accepts to be accelerated */ static void nfaFindAccelSchemes(const NGHolder &g, const map &br_cyclic, ue2::unordered_map *out) { vector refined_cr = reduced_cr(g, br_cyclic); NFAVertex sds_or_proxy = get_sds_or_proxy(g); for (auto v : vertices_range(g)) { // We want to skip any vertices that don't lead to at least one other // (self-loops don't count) vertex. if (!has_proper_successor(v, g)) { DEBUG_PRINTF("skipping vertex %zu\n", g[v].index); continue; } bool allow_wide = allow_wide_accel(v, g, sds_or_proxy); AccelScheme as; if (nfaCheckAccel(g, v, refined_cr, br_cyclic, &as, allow_wide)) { DEBUG_PRINTF("graph vertex %zu is accelerable with offset %u.\n", g[v].index, as.offset); (*out)[v] = as; } } } struct fas_visitor : public boost::default_bfs_visitor { fas_visitor(const ue2::unordered_map &am_in, ue2::unordered_map *out_in) : accel_map(am_in), out(out_in) {} void discover_vertex(NFAVertex v, const NGHolder &) { if (accel_map.find(v) != accel_map.end()) { (*out)[v] = accel_map.find(v)->second; } if (out->size() >= NFA_MAX_ACCEL_STATES) { throw this; /* done */ } } const ue2::unordered_map &accel_map; ue2::unordered_map *out; }; static void filterAccelStates(NGHolder &g, const map> &tops, ue2::unordered_map *accel_map) { /* We want the NFA_MAX_ACCEL_STATES best acceleration states, everything * else should be ditched. We use a simple BFS to choose accel states near * the start. */ vector tempEdges; for (const auto &vv : tops | map_values) { for (NFAVertex v : vv) { if (!edge(g.start, v, g).second) { tempEdges.push_back(add_edge(g.start, v, g).first); } } } // Similarly, connect (start, startDs) if necessary. if (!edge(g.start, g.startDs, g).second) { NFAEdge e = add_edge(g.start, g.startDs, g); tempEdges.push_back(e); // Remove edge later. } ue2::unordered_map out; try { vector colour(num_vertices(g)); boost::breadth_first_search(g, g.start, visitor(fas_visitor(*accel_map, &out)) .color_map(make_iterator_property_map(colour.begin(), get(vertex_index, g)))); } catch (fas_visitor *) { ; /* found max accel_states */ } remove_edges(tempEdges, g); assert(out.size() <= NFA_MAX_ACCEL_STATES); accel_map->swap(out); } static bool containsBadSubset(const limex_accel_info &accel, const NFAStateSet &state_set, const u32 effective_sds) { NFAStateSet subset(state_set.size()); for (size_t j = state_set.find_first(); j != state_set.npos; j = state_set.find_next(j)) { subset = state_set; subset.reset(j); if (effective_sds != NO_STATE && subset.count() == 1 && subset.test(effective_sds)) { continue; } if (subset.any() && !contains(accel.precalc, subset)) { return true; } } return false; } static bool is_too_wide(const AccelScheme &as) { return as.cr.count() > MAX_MERGED_ACCEL_STOPS; } static void fillAccelInfo(build_info &bi) { if (!bi.do_accel) { return; } NGHolder &g = bi.h; limex_accel_info &accel = bi.accel; unordered_map &accel_map = accel.accel_map; const map &br_cyclic = bi.br_cyclic; const CompileContext &cc = bi.cc; const unordered_map &state_ids = bi.state_ids; const u32 num_states = bi.num_states; nfaFindAccelSchemes(g, br_cyclic, &accel_map); filterAccelStates(g, bi.tops, &accel_map); assert(accel_map.size() <= NFA_MAX_ACCEL_STATES); vector refined_cr = reduced_cr(g, br_cyclic); vector astates; for (const auto &m : accel_map) { astates.push_back(m.first); } NFAStateSet useful(num_states); NFAStateSet state_set(num_states); vector states; NFAVertex sds_or_proxy = get_sds_or_proxy(g); const u32 effective_sds = state_ids.at(sds_or_proxy); /* for each subset of the accel keys need to find an accel scheme */ assert(astates.size() < 32); sort(astates.begin(), astates.end()); for (u32 i = 1, i_end = 1U << astates.size(); i < i_end; i++) { DEBUG_PRINTF("saving info for accel %u\n", i); states.clear(); state_set.reset(); for (u32 j = 0, j_end = astates.size(); j < j_end; j++) { if (i & (1U << j)) { NFAVertex v = astates[j]; states.push_back(v); state_set.set(state_ids.at(v)); } } if (containsBadSubset(accel, state_set, effective_sds)) { DEBUG_PRINTF("accel %u has bad subset\n", i); continue; /* if a subset failed to build we would too */ } const bool allow_wide = allow_wide_accel(states, g, sds_or_proxy); AccelScheme as = nfaFindAccel(g, states, refined_cr, br_cyclic, allow_wide, true); if (is_too_wide(as)) { DEBUG_PRINTF("accel %u too wide (%zu, %d)\n", i, as.cr.count(), MAX_MERGED_ACCEL_STOPS); continue; } DEBUG_PRINTF("accel %u ok with offset s%u, d%u\n", i, as.offset, as.double_offset); // try multibyte acceleration first MultibyteAccelInfo mai = nfaCheckMultiAccel(g, states, cc); precalcAccel &pa = accel.precalc[state_set]; useful |= state_set; // if we successfully built a multibyte accel scheme, use that if (mai.type != MultibyteAccelInfo::MAT_NONE) { pa.ma_info = mai; DEBUG_PRINTF("multibyte acceleration!\n"); continue; } pa.single_offset = as.offset; pa.single_cr = as.cr; if (as.double_byte.size() != 0) { pa.double_offset = as.double_offset; pa.double_lits = as.double_byte; pa.double_cr = as.double_cr; }; } for (const auto &m : accel_map) { NFAVertex v = m.first; const u32 state_id = state_ids.at(v); /* if we we unable to make a scheme out of the state in any context, * there is not point marking it as accelerable */ if (!useful.test(state_id)) { continue; } u32 offset = 0; state_set.reset(); state_set.set(state_id); bool is_multi = false; auto p_it = accel.precalc.find(state_set); if (p_it != accel.precalc.end()) { const precalcAccel &pa = p_it->second; offset = max(pa.double_offset, pa.single_offset); is_multi = pa.ma_info.type != MultibyteAccelInfo::MAT_NONE; assert(offset <= MAX_ACCEL_DEPTH); } accel.accelerable.insert(v); if (!is_multi) { findAccelFriends(g, v, br_cyclic, offset, &accel.friends[v]); } } } /** The AccelAux structure has large alignment specified, and this makes some * compilers do odd things unless we specify a custom allocator. */ typedef vector> AccelAuxVector; #define IMPOSSIBLE_ACCEL_MASK (~0U) static u32 getEffectiveAccelStates(const build_info &args, u32 active_accel_mask, const vector &accelStates) { /* accelStates is indexed by the acceleration bit index and contains a * reference to the original vertex & state_id */ /* Cases to consider: * * 1: Accel states a and b are on and b can squash a * --> we can ignore a. This will result in a no longer being accurately * modelled - we may miss escapes turning it off and we may also miss * its successors being activated. * * 2: Accel state b is on but accel state a is off and a is .* and must be * seen before b is reached (and would not be covered by (1)) * --> if a is squashable (or may die unexpectedly) we should continue * as is * --> if a is not squashable we can treat this as a+b or as a no accel, * impossible case * --> this case could be extended to handle non dot reaches by * effectively creating something similar to squash masks for the * reverse graph * * * Other cases: * * 3: Accel states a and b are on but have incompatible reaches * --> we should treat this as an impossible case. Actually, this case * is unlikely to arise as we pick states with wide reaches to * accelerate so an empty intersection is unlikely. * * Note: we need to be careful when dealing with accel states corresponding * to bounded repeat cyclics - they may 'turn off' based on a max bound and * so we may still require on earlier states to be accurately modelled. */ const NGHolder &h = args.h; auto dom_map = findDominators(h); /* map from accel_id to mask of accel_ids that it is dominated by */ vector dominated_by(accelStates.size()); map accel_id_map; for (u32 accel_id = 0; accel_id < accelStates.size(); accel_id++) { NFAVertex v = accelStates[accel_id].v; accel_id_map[v] = accel_id; } /* Note: we want a slightly less strict defn of dominate as skip edges * prevent .* 'truly' dominating */ for (u32 local_accel_mask = active_accel_mask; local_accel_mask; ) { u32 accel_id = findAndClearLSB_32(&local_accel_mask); assert(accel_id < accelStates.size()); NFAVertex v = accelStates[accel_id].v; while (dom_map[v]) { v = dom_map[v]; if (contains(accel_id_map, v)) { dominated_by[accel_id] |= 1U << accel_id_map[v]; } /* TODO: could also look at inv_adj vertices to handle fan-in */ for (NFAVertex a : adjacent_vertices_range(v, h)) { if (a == v || !contains(accel_id_map, a) || a == accelStates[accel_id].v /* not likely */) { continue; } if (!is_subset_of(h[v].reports, h[a].reports)) { continue; } auto v_succ = succs(v, h); auto a_succ = succs(a, h); if (is_subset_of(v_succ, a_succ)) { dominated_by[accel_id] |= 1U << accel_id_map[a]; } } } } u32 may_turn_off = 0; /* BR with max bound, non-dots, squashed, etc */ for (u32 local_accel_mask = active_accel_mask; local_accel_mask; ) { u32 accel_id = findAndClearLSB_32(&local_accel_mask); NFAVertex v = accelStates[accel_id].v; u32 state_id = accelStates[accel_id].state; assert(contains(args.accel.accelerable, v)); if (!h[v].char_reach.all()) { may_turn_off |= 1U << accel_id; continue; } if (contains(args.br_cyclic, v) && args.br_cyclic.at(v).repeatMax != depth::infinity()) { may_turn_off |= 1U << accel_id; continue; } for (const auto &s_mask : args.squashMap | map_values) { if (!s_mask.test(state_id)) { may_turn_off |= 1U << accel_id; break; } } for (const auto &s_mask : args.reportSquashMap | map_values) { if (!s_mask.test(state_id)) { may_turn_off |= 1U << accel_id; break; } } } /* Case 1: */ u32 ignored = 0; for (u32 local_accel_mask = active_accel_mask; local_accel_mask; ) { u32 accel_id_b = findAndClearLSB_32(&local_accel_mask); NFAVertex v = accelStates[accel_id_b].v; if (!contains(args.squashMap, v)) { continue; } assert(!contains(args.br_cyclic, v) || args.br_cyclic.at(v).repeatMax == depth::infinity()); NFAStateSet squashed = args.squashMap.at(v); squashed.flip(); /* default sense for mask of survivors */ for (u32 local_accel_mask2 = active_accel_mask; local_accel_mask2; ) { u32 accel_id_a = findAndClearLSB_32(&local_accel_mask2); if (squashed.test(accelStates[accel_id_a].state)) { ignored |= 1U << accel_id_a; } } } /* Case 2: */ for (u32 local_accel_mask = active_accel_mask; local_accel_mask; ) { u32 accel_id = findAndClearLSB_32(&local_accel_mask); u32 stuck_dominators = dominated_by[accel_id] & ~may_turn_off; if ((stuck_dominators & active_accel_mask) != stuck_dominators) { DEBUG_PRINTF("only %08x on, but we require %08x\n", active_accel_mask, stuck_dominators); return IMPOSSIBLE_ACCEL_MASK; } } if (ignored) { DEBUG_PRINTF("in %08x, ignoring %08x\n", active_accel_mask, ignored); } return active_accel_mask & ~ignored; } static void buildAccel(const build_info &args, NFAStateSet &accelMask, NFAStateSet &accelFriendsMask, AccelAuxVector &auxvec, vector &accelTable) { const limex_accel_info &accel = args.accel; // Init, all zeroes. accelMask.resize(args.num_states); accelFriendsMask.resize(args.num_states); if (!args.do_accel) { return; } vector accelStates; gatherAccelStates(args, accelStates); if (accelStates.empty()) { DEBUG_PRINTF("no accelerable states\n"); return; } // We have 2^n different accel entries, one for each possible // combination of accelerable states. assert(accelStates.size() < 32); const u32 accelCount = 1U << accelStates.size(); assert(accelCount <= 256); // Set up a unioned AccelBuild for every possible combination of the set // bits in accelStates. vector accelOuts(accelCount); vector effective_accel_set; effective_accel_set.push_back(0); /* empty is effectively empty */ for (u32 i = 1; i < accelCount; i++) { u32 effective_i = getEffectiveAccelStates(args, i, accelStates); effective_accel_set.push_back(effective_i); if (effective_i == IMPOSSIBLE_ACCEL_MASK) { DEBUG_PRINTF("this combination of accel states is not possible\n"); accelOuts[i].stop1 = CharReach::dot(); continue; } while (effective_i) { u32 base_accel_state = findAndClearLSB_32(&effective_i); combineAccel(accelStates[base_accel_state], accelOuts[i]); } minimiseAccel(accelOuts[i]); } accelTable.resize(accelCount); // We dedupe our AccelAux structures here, so that we only write one copy // of each unique accel scheme into the bytecode, using the accelTable as // an index. // Start with the NONE case. auxvec.push_back(AccelAux()); memset(&auxvec[0], 0, sizeof(AccelAux)); auxvec[0].accel_type = ACCEL_NONE; // no states on. AccelAux aux; for (u32 i = 1; i < accelCount; i++) { memset(&aux, 0, sizeof(aux)); NFAStateSet effective_states(args.num_states); u32 effective_i = effective_accel_set[i]; AccelInfo ainfo; ainfo.double_offset = accelOuts[i].offset; ainfo.double_stop1 = accelOuts[i].stop1; ainfo.double_stop2 = accelOuts[i].stop2; if (effective_i != IMPOSSIBLE_ACCEL_MASK) { while (effective_i) { u32 base_accel_id = findAndClearLSB_32(&effective_i); effective_states.set(accelStates[base_accel_id].state); } if (contains(accel.precalc, effective_states)) { const auto &precalc = accel.precalc.at(effective_states); if (precalc.ma_info.type != MultibyteAccelInfo::MAT_NONE) { ainfo.ma_len1 = precalc.ma_info.len1; ainfo.ma_len2 = precalc.ma_info.len2; ainfo.multiaccel_offset = precalc.ma_info.offset; ainfo.multiaccel_stops = precalc.ma_info.cr; ainfo.ma_type = precalc.ma_info.type; } else { ainfo.single_offset = precalc.single_offset; ainfo.single_stops = precalc.single_cr; } } } buildAccelAux(ainfo, &aux); // FIXME: We may want a faster way to find AccelAux structures that // we've already built before. auto it = find_if(auxvec.begin(), auxvec.end(), AccelAuxCmp(aux)); if (it == auxvec.end()) { accelTable[i] = verify_u8(auxvec.size()); auxvec.push_back(aux); } else { accelTable[i] = verify_u8(it - auxvec.begin()); } } DEBUG_PRINTF("%zu unique accel schemes (of max %u)\n", auxvec.size(), accelCount); // XXX: ACCEL_NONE? for (const auto &as : accelStates) { NFAVertex v = as.v; assert(v && args.state_ids.at(v) == as.state); accelMask.set(as.state); accelFriendsMask.set(as.state); if (!contains(accel.friends, v)) { continue; } // Add the friends of this state to the friends mask. const flat_set &friends = accel.friends.at(v); DEBUG_PRINTF("%u has %zu friends\n", as.state, friends.size()); for (auto friend_v : friends) { u32 state_id = args.state_ids.at(friend_v); DEBUG_PRINTF("--> %u\n", state_id); accelFriendsMask.set(state_id); } } } static u32 addSquashMask(const build_info &args, const NFAVertex &v, vector &squash) { auto sit = args.reportSquashMap.find(v); if (sit == args.reportSquashMap.end()) { return MO_INVALID_IDX; } // This state has a squash mask. Paw through the existing vector to // see if we've already seen it, otherwise add a new one. auto it = find(squash.begin(), squash.end(), sit->second); if (it != squash.end()) { return verify_u32(distance(squash.begin(), it)); } u32 idx = verify_u32(squash.size()); squash.push_back(sit->second); return idx; } static u32 addReports(const flat_set &r, vector &reports, unordered_map, u32> &reportListCache) { assert(!r.empty()); vector my_reports(begin(r), end(r)); my_reports.push_back(MO_INVALID_IDX); // sentinel auto cache_it = reportListCache.find(my_reports); if (cache_it != end(reportListCache)) { u32 offset = cache_it->second; DEBUG_PRINTF("reusing cached report list at %u\n", offset); return offset; } auto it = search(begin(reports), end(reports), begin(my_reports), end(my_reports)); if (it != end(reports)) { u32 offset = verify_u32(distance(begin(reports), it)); DEBUG_PRINTF("reusing found report list at %u\n", offset); return offset; } u32 offset = verify_u32(reports.size()); insert(&reports, reports.end(), my_reports); reportListCache.emplace(move(my_reports), offset); return offset; } static void buildAcceptsList(const build_info &args, unordered_map, u32> &reports_cache, vector &verts, vector &accepts, vector &reports, vector &squash) { if (verts.empty()) { return; } DEBUG_PRINTF("building accept lists for %zu states\n", verts.size()); auto cmp_state_id = [&args](NFAVertex a, NFAVertex b) { u32 a_state = args.state_ids.at(a); u32 b_state = args.state_ids.at(b); assert(a_state != b_state || a == b); return a_state < b_state; }; sort(begin(verts), end(verts), cmp_state_id); const NGHolder &h = args.h; for (const auto &v : verts) { DEBUG_PRINTF("state=%u, reports: [%s]\n", args.state_ids.at(v), as_string_list(h[v].reports).c_str()); NFAAccept a; memset(&a, 0, sizeof(a)); assert(!h[v].reports.empty()); if (h[v].reports.size() == 1) { a.single_report = 1; a.reports = *h[v].reports.begin(); } else { a.single_report = 0; a.reports = addReports(h[v].reports, reports, reports_cache); } a.squash = addSquashMask(args, v, squash); accepts.push_back(move(a)); } } static void buildAccepts(const build_info &args, unordered_map, u32> &reports_cache, NFAStateSet &acceptMask, NFAStateSet &acceptEodMask, vector &accepts, vector &acceptsEod, vector &reports, vector &squash) { const NGHolder &h = args.h; acceptMask.resize(args.num_states); acceptEodMask.resize(args.num_states); vector verts_accept, verts_accept_eod; for (auto v : vertices_range(h)) { u32 state_id = args.state_ids.at(v); if (state_id == NO_STATE || !is_match_vertex(v, h)) { continue; } if (edge(v, h.accept, h).second) { acceptMask.set(state_id); verts_accept.push_back(v); } else { assert(edge(v, h.acceptEod, h).second); acceptEodMask.set(state_id); verts_accept_eod.push_back(v); } } buildAcceptsList(args, reports_cache, verts_accept, accepts, reports, squash); buildAcceptsList(args, reports_cache, verts_accept_eod, acceptsEod, reports, squash); } static void buildTopMasks(const build_info &args, vector &topMasks) { if (args.tops.empty()) { return; // No tops, probably an outfix NFA. } u32 numMasks = args.tops.rbegin()->first + 1; // max mask index DEBUG_PRINTF("we have %u top masks\n", numMasks); topMasks.assign(numMasks, NFAStateSet(args.num_states)); // all zeroes for (const auto &m : args.tops) { u32 mask_idx = m.first; for (NFAVertex v : m.second) { u32 state_id = args.state_ids.at(v); DEBUG_PRINTF("state %u is in top mask %u\n", state_id, mask_idx); assert(mask_idx < numMasks); assert(state_id != NO_STATE); topMasks[mask_idx].set(state_id); } } } static u32 uncompressedStateSize(u32 num_states) { // Number of bytes required to store all our states. return ROUNDUP_N(num_states, 8)/8; } static u32 compressedStateSize(const NGHolder &h, const NFAStateSet &maskedStates, const ue2::unordered_map &state_ids) { // Shrink state requirement to enough to fit the compressed largest reach. vector allreach(N_CHARS, 0); for (auto v : vertices_range(h)) { u32 i = state_ids.at(v); if (i == NO_STATE || maskedStates.test(i)) { continue; } const CharReach &cr = h[v].char_reach; for (size_t j = cr.find_first(); j != cr.npos; j = cr.find_next(j)) { allreach[j]++; // state 'i' can reach character 'j'. } } u32 maxreach = *max_element(allreach.begin(), allreach.end()); DEBUG_PRINTF("max reach is %u\n", maxreach); return (maxreach + 7) / 8; } static bool hasSquashableInitDs(const build_info &args) { const NGHolder &h = args.h; if (args.squashMap.empty()) { DEBUG_PRINTF("squash map is empty\n"); return false; } NFAStateSet initDs(args.num_states); u32 sds_state = args.state_ids.at(h.startDs); if (sds_state == NO_STATE) { DEBUG_PRINTF("no states in initds\n"); return false; } initDs.set(sds_state); /* TODO: simplify */ // Check normal squash map. for (const auto &m : args.squashMap) { DEBUG_PRINTF("checking squash mask for state %u\n", args.state_ids.at(m.first)); NFAStateSet squashed = ~(m.second); // flip mask assert(squashed.size() == initDs.size()); if (squashed.intersects(initDs)) { DEBUG_PRINTF("state %u squashes initds states\n", args.state_ids.at(m.first)); return true; } } // Check report squash map. for (const auto &m : args.reportSquashMap) { DEBUG_PRINTF("checking report squash mask for state %u\n", args.state_ids.at(m.first)); NFAStateSet squashed = ~(m.second); // flip mask assert(squashed.size() == initDs.size()); if (squashed.intersects(initDs)) { DEBUG_PRINTF("state %u squashes initds states\n", args.state_ids.at(m.first)); return true; } } return false; } static bool hasInitDsStates(const NGHolder &h, const ue2::unordered_map &state_ids) { if (state_ids.at(h.startDs) != NO_STATE) { return true; } if (is_triggered(h) && state_ids.at(h.start) != NO_STATE) { return true; } return false; } static void findMaskedCompressionStates(const build_info &args, NFAStateSet &maskedStates) { const NGHolder &h = args.h; if (!generates_callbacks(h)) { // Rose leftfixes can mask out initds, which is worth doing if it will // stay on forever (i.e. it's not squashable). u32 sds_i = args.state_ids.at(h.startDs); if (sds_i != NO_STATE && !hasSquashableInitDs(args)) { maskedStates.set(sds_i); DEBUG_PRINTF("masking out initds state\n"); } } // Suffixes and outfixes can mask out leaf states, which should all be // accepts. Right now we can only do this when there is nothing in initDs, // as we switch that on unconditionally in the expand call. if (!inspects_states_for_accepts(h) && !hasInitDsStates(h, args.state_ids)) { NFAStateSet nonleaf(args.num_states); for (const auto &e : edges_range(h)) { u32 from = args.state_ids.at(source(e, h)); u32 to = args.state_ids.at(target(e, h)); if (from == NO_STATE) { continue; } // We cannot mask out EOD accepts, as they have to perform an // action after they're switched on that may be delayed until the // next stream write. if (to == NO_STATE && target(e, h) != h.acceptEod) { continue; } nonleaf.set(from); } for (u32 i = 0; i < args.num_states; i++) { if (!nonleaf.test(i)) { maskedStates.set(i); } } DEBUG_PRINTF("masking out %zu leaf states\n", maskedStates.count()); } } /** \brief Sets a given flag in the LimEx structure. */ template static void setLimexFlag(implNFA_t *limex, u32 flag) { assert(flag); assert((flag & (flag - 1)) == 0); limex->flags |= flag; } /** \brief Sets a given flag in the NFA structure */ static void setNfaFlag(NFA *nfa, u32 flag) { assert(flag); assert((flag & (flag - 1)) == 0); nfa->flags |= flag; } // Some of our NFA types support compressing the state down if we're not using // all of it. template static void findStateSize(const build_info &args, implNFA_t *limex) { // Nothing is masked off by default. maskFill(limex->compressMask, 0xff); u32 sizeUncompressed = uncompressedStateSize(args.num_states); assert(sizeUncompressed <= sizeof(limex->compressMask)); if (!args.stateCompression) { DEBUG_PRINTF("compression disabled, uncompressed state size %u\n", sizeUncompressed); limex->stateSize = sizeUncompressed; return; } NFAStateSet maskedStates(args.num_states); findMaskedCompressionStates(args, maskedStates); u32 sizeCompressed = compressedStateSize(args.h, maskedStates, args.state_ids); assert(sizeCompressed <= sizeof(limex->compressMask)); DEBUG_PRINTF("compressed=%u, uncompressed=%u\n", sizeCompressed, sizeUncompressed); // Must be at least a 10% saving. if ((sizeCompressed * 100) <= (sizeUncompressed * 90)) { DEBUG_PRINTF("using compression, state size %u\n", sizeCompressed); setLimexFlag(limex, LIMEX_FLAG_COMPRESS_STATE); limex->stateSize = sizeCompressed; if (maskedStates.any()) { DEBUG_PRINTF("masking %zu states\n", maskedStates.count()); setLimexFlag(limex, LIMEX_FLAG_COMPRESS_MASKED); for (size_t i = maskedStates.find_first(); i != NFAStateSet::npos; i = maskedStates.find_next(i)) { maskClearBit(limex->compressMask, i); } } } else { DEBUG_PRINTF("not using compression, state size %u\n", sizeUncompressed); limex->stateSize = sizeUncompressed; } } /* * LimEx NFA: code for building NFAs in the Limited+Exceptional model. Most * transitions are limited, with transitions outside the constraints of our * shifts taken care of as 'exceptions'. Exceptions are also used to handle * accepts and squash behaviour. */ /** * \brief Prototype exception class. * * Used to build up the map of exceptions before being converted to real * NFAException32 (etc) structures. */ struct ExceptionProto { u32 reports_index = MO_INVALID_IDX; NFAStateSet succ_states; NFAStateSet squash_states; u32 repeat_index = MO_INVALID_IDX; enum LimExTrigger trigger = LIMEX_TRIGGER_NONE; enum LimExSquash squash = LIMEX_SQUASH_NONE; explicit ExceptionProto(u32 num_states) : succ_states(num_states), squash_states(num_states) { // Squash states are represented as the set of states to leave on, // so we start with all-ones. squash_states.set(); } bool operator<(const ExceptionProto &b) const { const ExceptionProto &a = *this; ORDER_CHECK(reports_index); ORDER_CHECK(repeat_index); ORDER_CHECK(trigger); ORDER_CHECK(squash); ORDER_CHECK(succ_states); ORDER_CHECK(squash_states); return false; } }; static u32 buildExceptionMap(const build_info &args, unordered_map, u32> &reports_cache, const ue2::unordered_set &exceptional, map> &exceptionMap, vector &reportList) { const NGHolder &h = args.h; const u32 num_states = args.num_states; u32 exceptionCount = 0; ue2::unordered_map pos_trigger; ue2::unordered_map tug_trigger; for (u32 i = 0; i < args.repeats.size(); i++) { const BoundedRepeatData &br = args.repeats[i]; assert(!contains(pos_trigger, br.pos_trigger)); pos_trigger[br.pos_trigger] = i; for (auto v : br.tug_triggers) { assert(!contains(tug_trigger, v)); tug_trigger[v] = i; } } for (auto v : vertices_range(h)) { const u32 i = args.state_ids.at(v); if (i == NO_STATE) { continue; } bool addMe = false; ExceptionProto e(num_states); if (edge(v, h.accept, h).second && generates_callbacks(h)) { /* if nfa is never used to produce callbacks, no need to mark * states as exceptional */ const auto &reports = h[v].reports; DEBUG_PRINTF("state %u is exceptional due to accept " "(%zu reports)\n", i, reports.size()); if (reports.empty()) { e.reports_index = MO_INVALID_IDX; } else { e.reports_index = addReports(reports, reportList, reports_cache); } // We may be applying a report squash too. auto mi = args.reportSquashMap.find(v); if (mi != args.reportSquashMap.end()) { DEBUG_PRINTF("report squashes states\n"); assert(e.squash_states.size() == mi->second.size()); e.squash_states = mi->second; e.squash = LIMEX_SQUASH_REPORT; } addMe = true; } if (contains(pos_trigger, v)) { u32 repeat_index = pos_trigger[v]; assert(e.trigger == LIMEX_TRIGGER_NONE); e.trigger = LIMEX_TRIGGER_POS; e.repeat_index = repeat_index; DEBUG_PRINTF("state %u has pos trigger for repeat %u\n", i, repeat_index); addMe = true; } if (contains(tug_trigger, v)) { u32 repeat_index = tug_trigger[v]; assert(e.trigger == LIMEX_TRIGGER_NONE); e.trigger = LIMEX_TRIGGER_TUG; e.repeat_index = repeat_index; // TUG triggers can squash the preceding cyclic state. u32 cyclic = args.state_ids.at(args.repeats[repeat_index].cyclic); e.squash_states.reset(cyclic); e.squash = LIMEX_SQUASH_TUG; DEBUG_PRINTF("state %u has tug trigger for repeat %u, can squash " "state %u\n", i, repeat_index, cyclic); addMe = true; } // are we a non-limited transition? for (const auto &oe : out_edges_range(v, h)) { if (contains(exceptional, oe)) { NFAVertex w = target(oe, h); u32 w_idx = args.state_ids.at(w); assert(w_idx != NO_STATE); e.succ_states.set(w_idx); DEBUG_PRINTF("exceptional transition %u->%u\n", i, w_idx); addMe = true; } } // do we lead SOLELY to a squasher state? (we use the successors as // a proxy for the out-edge here, so there must be only one for us // to do this safely) /* The above comment is IMHO bogus and would result in all squashing * being disabled around stars */ if (e.trigger != LIMEX_TRIGGER_TUG) { for (auto w : adjacent_vertices_range(v, h)) { if (w == v) { continue; } u32 j = args.state_ids.at(w); if (j == NO_STATE) { continue; } DEBUG_PRINTF("we are checking if succ %u is a squasher\n", j); auto mi = args.squashMap.find(w); if (mi != args.squashMap.end()) { DEBUG_PRINTF("squasher edge (%u, %u)\n", i, j); DEBUG_PRINTF("e.squash_states.size() == %zu, " "mi->second.size() = %zu\n", e.squash_states.size(), mi->second.size()); assert(e.squash_states.size() == mi->second.size()); e.squash_states = mi->second; // NOTE: this might be being combined with the report // squashing above. e.squash = LIMEX_SQUASH_CYCLIC; DEBUG_PRINTF("squashing succ %u (turns off %zu states)\n", j, mi->second.size() - mi->second.count()); addMe = true; } } } if (addMe) { // Add 'e' if it isn't in the map, and push state i on to its list // of states. assert(e.succ_states.size() == num_states); assert(e.squash_states.size() == num_states); exceptionMap[e].push_back(i); exceptionCount++; } } DEBUG_PRINTF("%u exceptions found (%zu unique)\n", exceptionCount, exceptionMap.size()); return exceptionCount; } static u32 depth_to_u32(const depth &d) { assert(d.is_reachable()); if (d.is_infinite()) { return REPEAT_INF; } u32 d_val = d; assert(d_val < REPEAT_INF); return d_val; } static bool isExceptionalTransition(const NGHolder &h, const NFAEdge &e, const build_info &args, u32 maxShift) { NFAVertex from = source(e, h); NFAVertex to = target(e, h); u32 f = args.state_ids.at(from); u32 t = args.state_ids.at(to); if (!isLimitedTransition(f, t, maxShift)) { return true; } // All transitions out of a tug trigger are exceptional. if (contains(args.tugs, from)) { return true; } return false; } static u32 findMaxVarShift(const build_info &args, u32 nShifts) { const NGHolder &h = args.h; u32 shiftMask = 0; for (const auto &e : edges_range(h)) { u32 from = args.state_ids.at(source(e, h)); u32 to = args.state_ids.at(target(e, h)); if (from == NO_STATE || to == NO_STATE) { continue; } if (!isExceptionalTransition(h, e, args, MAX_SHIFT_AMOUNT)) { shiftMask |= (1UL << (to - from)); } } u32 maxVarShift = 0; for (u32 shiftCnt = 0; shiftMask != 0 && shiftCnt < nShifts; shiftCnt++) { maxVarShift = findAndClearLSB_32(&shiftMask); } return maxVarShift; } static int getLimexScore(const build_info &args, u32 nShifts) { const NGHolder &h = args.h; u32 maxVarShift = nShifts; int score = 0; score += SHIFT_COST * nShifts; maxVarShift = findMaxVarShift(args, nShifts); NFAStateSet exceptionalStates(args.num_states); for (const auto &e : edges_range(h)) { u32 from = args.state_ids.at(source(e, h)); u32 to = args.state_ids.at(target(e, h)); if (from == NO_STATE || to == NO_STATE) { continue; } if (isExceptionalTransition(h, e, args, maxVarShift)) { exceptionalStates.set(from); } } score += EXCEPTION_COST * exceptionalStates.count(); return score; } // This function finds the best shift scheme with highest score // Returns number of shifts and score calculated for appropriate scheme // Returns zero if no appropriate scheme was found static u32 findBestNumOfVarShifts(const build_info &args, int *bestScoreRet = nullptr) { u32 bestNumOfVarShifts = 0; int bestScore = INT_MAX; for (u32 shiftCount = 1; shiftCount <= MAX_SHIFT_COUNT; shiftCount++) { int score = getLimexScore(args, shiftCount); if (score < bestScore) { bestScore = score; bestNumOfVarShifts = shiftCount; } } if (bestScoreRet != nullptr) { *bestScoreRet = bestScore; } return bestNumOfVarShifts; } template struct Factory { // typedefs for readability, for types derived from traits typedef typename NFATraits::exception_t exception_t; typedef typename NFATraits::implNFA_t implNFA_t; typedef typename NFATraits::tableRow_t tableRow_t; static void allocState(NFA *nfa, u32 repeatscratchStateSize, u32 repeatStreamState) { implNFA_t *limex = (implNFA_t *)getMutableImplNfa(nfa); // LimEx NFAs now store the following in state: // 1. state bitvector (always present) // 2. space associated with repeats // This function just needs to size these correctly. u32 stateSize = limex->stateSize; DEBUG_PRINTF("bitvector=%zu/%u, repeat full=%u, stream=%u\n", sizeof(limex->init), stateSize, repeatscratchStateSize, repeatStreamState); size_t scratchStateSize = NFATraits::scratch_state_size; if (repeatscratchStateSize) { scratchStateSize = ROUNDUP_N(scratchStateSize, alignof(RepeatControl)); scratchStateSize += repeatscratchStateSize; } size_t streamStateSize = stateSize + repeatStreamState; nfa->scratchStateSize = verify_u32(scratchStateSize); nfa->streamStateSize = verify_u32(streamStateSize); } static size_t repeatAllocSize(const BoundedRepeatData &br, u32 *tableOffset, u32 *tugMaskOffset) { size_t len = sizeof(NFARepeatInfo) + sizeof(RepeatInfo); // sparse lookup table. if (br.type == REPEAT_SPARSE_OPTIMAL_P) { len = ROUNDUP_N(len, alignof(u64a)); *tableOffset = verify_u32(len); len += sizeof(u64a) * (br.repeatMax + 1); } else { *tableOffset = 0; } // tug mask. len = ROUNDUP_N(len, alignof(tableRow_t)); *tugMaskOffset = verify_u32(len); len += sizeof(tableRow_t); // to simplify layout. len = ROUNDUP_CL(len); return len; } static void buildRepeats(const build_info &args, vector, size_t>> &out, u32 *scratchStateSize, u32 *streamState) { out.reserve(args.repeats.size()); u32 repeat_idx = 0; for (auto it = args.repeats.begin(), ite = args.repeats.end(); it != ite; ++it, ++repeat_idx) { const BoundedRepeatData &br = *it; assert(args.state_ids.at(br.cyclic) != NO_STATE); u32 tableOffset, tugMaskOffset; size_t len = repeatAllocSize(br, &tableOffset, &tugMaskOffset); auto info = aligned_zmalloc_unique(len); char *info_ptr = (char *)info.get(); // Collect state space info. RepeatStateInfo rsi(br.type, br.repeatMin, br.repeatMax, br.minPeriod); u32 streamStateLen = rsi.packedCtrlSize + rsi.stateSize; // Fill the NFARepeatInfo structure. info->cyclicState = args.state_ids.at(br.cyclic); info->ctrlIndex = repeat_idx; info->packedCtrlOffset = *streamState; info->stateOffset = *streamState + rsi.packedCtrlSize; info->stateSize = streamStateLen; info->tugMaskOffset = tugMaskOffset; // Fill the RepeatInfo structure. RepeatInfo *repeat = (RepeatInfo *)(info_ptr + sizeof(NFARepeatInfo)); repeat->type = br.type; repeat->repeatMin = depth_to_u32(br.repeatMin); repeat->repeatMax = depth_to_u32(br.repeatMax); repeat->horizon = rsi.horizon; repeat->packedCtrlSize = rsi.packedCtrlSize; repeat->stateSize = rsi.stateSize; copy_bytes(repeat->packedFieldSizes, rsi.packedFieldSizes); repeat->patchCount = rsi.patchCount; repeat->patchSize = rsi.patchSize; repeat->encodingSize = rsi.encodingSize; repeat->patchesOffset = rsi.patchesOffset; u32 repeat_len = sizeof(RepeatInfo); if (br.type == REPEAT_SPARSE_OPTIMAL_P) { repeat_len += sizeof(u64a) * (rsi.patchSize + 1); } repeat->length = repeat_len; // Copy in the sparse lookup table. if (br.type == REPEAT_SPARSE_OPTIMAL_P) { assert(!rsi.table.empty()); copy_bytes(info_ptr + tableOffset, rsi.table); } // Fill the tug mask. tableRow_t *tugMask = (tableRow_t *)(info_ptr + tugMaskOffset); for (auto v : br.tug_triggers) { u32 state_id = args.state_ids.at(v); assert(state_id != NO_STATE); maskSetBit(*tugMask, state_id); } assert(streamStateLen); *streamState += streamStateLen; *scratchStateSize += sizeof(RepeatControl); out.emplace_back(move(info), len); } } static void writeLimexMasks(const build_info &args, implNFA_t *limex) { const NGHolder &h = args.h; // Init masks. u32 s_i = args.state_ids.at(h.start); u32 sds_i = args.state_ids.at(h.startDs); if (s_i != NO_STATE) { maskSetBit(limex->init, s_i); if (is_triggered(h)) { maskSetBit(limex->initDS, s_i); } } if (sds_i != NO_STATE) { maskSetBit(limex->init, sds_i); maskSetBit(limex->initDS, sds_i); } // Zombie mask. for (auto v : args.zombies) { u32 state_id = args.state_ids.at(v); assert(state_id != NO_STATE); maskSetBit(limex->zombieMask, state_id); } // Repeat cyclic mask. for (const auto &br : args.repeats) { u32 cyclic = args.state_ids.at(br.cyclic); assert(cyclic != NO_STATE); maskSetBit(limex->repeatCyclicMask, cyclic); } /* also include tugs in repeat cyclic mask */ for (NFAVertex v : args.tugs) { u32 v_state = args.state_ids.at(v); assert(v_state != NO_STATE); maskSetBit(limex->repeatCyclicMask, v_state); } } static void writeShiftMasks(const build_info &args, implNFA_t *limex) { const NGHolder &h = args.h; u32 maxShift = findMaxVarShift(args, limex->shiftCount); u32 shiftMask = 0; int shiftMaskIdx = 0; for (const auto &e : edges_range(h)) { u32 from = args.state_ids.at(source(e, h)); u32 to = args.state_ids.at(target(e, h)); if (from == NO_STATE || to == NO_STATE) { continue; } // We check for exceptional transitions here, as we don't want tug // trigger transitions emitted as limited transitions (even if they // could be in this model). if (!isExceptionalTransition(h, e, args, maxShift)) { u32 shift = to - from; if ((shiftMask & (1UL << shift)) == 0UL) { shiftMask |= (1UL << shift); limex->shiftAmount[shiftMaskIdx++] = (u8)shift; } assert(limex->shiftCount <= MAX_SHIFT_COUNT); for (u32 i = 0; i < limex->shiftCount; i++) { if (limex->shiftAmount[i] == (u8)shift) { maskSetBit(limex->shift[i], from); break; } } } } if (maxShift && limex->shiftCount > 1) { for (u32 i = 0; i < limex->shiftCount; i++) { assert(!isMaskZero(limex->shift[i])); } } } static void findExceptionalTransitions(const build_info &args, ue2::unordered_set &exceptional, u32 maxShift) { const NGHolder &h = args.h; for (const auto &e : edges_range(h)) { u32 from = args.state_ids.at(source(e, h)); u32 to = args.state_ids.at(target(e, h)); if (from == NO_STATE || to == NO_STATE) { continue; } if (isExceptionalTransition(h, e, args, maxShift)) { exceptional.insert(e); } } } static void writeExceptions(const map> &exceptionMap, const vector &repeatOffsets, implNFA_t *limex, const u32 exceptionsOffset, const u32 reportListOffset) { DEBUG_PRINTF("exceptionsOffset=%u\n", exceptionsOffset); exception_t *etable = (exception_t *)((char *)limex + exceptionsOffset); assert(ISALIGNED(etable)); map exception_by_state; for (const auto &m : exceptionMap) { const ExceptionProto &proto = m.first; const vector &states = m.second; for (u32 i : states) { assert(!contains(exception_by_state, i)); exception_by_state.emplace(i, proto); } } u32 ecount = 0; for (const auto &m : exception_by_state) { const ExceptionProto &proto = m.second; u32 state_id = m.first; DEBUG_PRINTF("exception %u, triggered by state %u\n", ecount, state_id); // Write the exception entry. exception_t &e = etable[ecount]; maskSetBits(e.squash, proto.squash_states); maskSetBits(e.successors, proto.succ_states); if (proto.reports_index == MO_INVALID_IDX) { e.reports = MO_INVALID_IDX; } else { e.reports = reportListOffset + proto.reports_index * sizeof(ReportID); } e.hasSquash = verify_u8(proto.squash); e.trigger = verify_u8(proto.trigger); u32 repeat_offset = proto.repeat_index == MO_INVALID_IDX ? MO_INVALID_IDX : repeatOffsets[proto.repeat_index]; e.repeatOffset = repeat_offset; // for the state that can switch it on // set this bit in the exception mask maskSetBit(limex->exceptionMask, state_id); ecount++; } limex->exceptionOffset = exceptionsOffset; limex->exceptionCount = ecount; } static void writeReachMapping(const vector &reach, const vector &reachMap, implNFA_t *limex, const u32 reachOffset) { DEBUG_PRINTF("reachOffset=%u\n", reachOffset); // Reach mapping is inside the LimEx structure. copy(reachMap.begin(), reachMap.end(), &limex->reachMap[0]); // Reach table is right after the LimEx structure. tableRow_t *reachMask = (tableRow_t *)((char *)limex + reachOffset); assert(ISALIGNED(reachMask)); for (size_t i = 0, end = reach.size(); i < end; i++) { maskSetBits(reachMask[i], reach[i]); } limex->reachSize = verify_u32(reach.size()); } static void writeTopMasks(const vector &tops, implNFA_t *limex, const u32 topsOffset) { DEBUG_PRINTF("topsOffset=%u\n", topsOffset); limex->topOffset = topsOffset; tableRow_t *topMasks = (tableRow_t *)((char *)limex + topsOffset); assert(ISALIGNED(topMasks)); for (size_t i = 0, end = tops.size(); i < end; i++) { maskSetBits(topMasks[i], tops[i]); } limex->topCount = verify_u32(tops.size()); } static void writeAccelSsse3Masks(const NFAStateSet &accelMask, implNFA_t *limex) { char *perm_base = (char *)&limex->accelPermute; char *comp_base = (char *)&limex->accelCompare; u32 num = 0; // index in accel table. for (size_t i = accelMask.find_first(); i != accelMask.npos; i = accelMask.find_next(i), ++num) { u32 state_id = verify_u32(i); DEBUG_PRINTF("accel num=%u, state=%u\n", num, state_id); // PSHUFB permute and compare masks size_t mask_idx = sizeof(u_128) * (state_id / 128U); DEBUG_PRINTF("mask_idx=%zu\n", mask_idx); u_128 *perm = (u_128 *)(perm_base + mask_idx); u_128 *comp = (u_128 *)(comp_base + mask_idx); maskSetByte(*perm, num, ((state_id % 128U) / 8U)); maskSetByte(*comp, num, ~(1U << (state_id % 8U))); } } static void writeAccel(const NFAStateSet &accelMask, const NFAStateSet &accelFriendsMask, const AccelAuxVector &accelAux, const vector &accelTable, implNFA_t *limex, const u32 accelTableOffset, const u32 accelAuxOffset) { DEBUG_PRINTF("accelTableOffset=%u, accelAuxOffset=%u\n", accelTableOffset, accelAuxOffset); // Write accel lookup table. limex->accelTableOffset = accelTableOffset; copy(accelTable.begin(), accelTable.end(), (u8 *)((char *)limex + accelTableOffset)); // Write accel aux structures. limex->accelAuxOffset = accelAuxOffset; AccelAux *auxTable = (AccelAux *)((char *)limex + accelAuxOffset); assert(ISALIGNED(auxTable)); copy(accelAux.begin(), accelAux.end(), auxTable); // Write LimEx structure members. limex->accelCount = verify_u32(accelTable.size()); // FIXME: accelAuxCount is unused? limex->accelAuxCount = verify_u32(accelAux.size()); // Write LimEx masks. maskSetBits(limex->accel, accelMask); maskSetBits(limex->accel_and_friends, accelFriendsMask); // We can use PSHUFB-based shuffles for models >= 128 states. These // require some additional masks in the bytecode. maskClear(limex->accelCompare); maskFill(limex->accelPermute, (char)0x80); if (NFATraits::maxStates >= 128) { writeAccelSsse3Masks(accelMask, limex); } } static void writeAccepts(const NFAStateSet &acceptMask, const NFAStateSet &acceptEodMask, const vector &accepts, const vector &acceptsEod, const vector &squash, implNFA_t *limex, const u32 acceptsOffset, const u32 acceptsEodOffset, const u32 squashOffset, const u32 reportListOffset) { char *limex_base = (char *)limex; DEBUG_PRINTF("acceptsOffset=%u, acceptsEodOffset=%u, squashOffset=%u\n", acceptsOffset, acceptsEodOffset, squashOffset); // LimEx masks (in structure) maskSetBits(limex->accept, acceptMask); maskSetBits(limex->acceptAtEOD, acceptEodMask); // Transforms the indices (report list, squash mask) into offsets // relative to the base of the limex. auto transform_offset_fn = [&](NFAAccept a) { if (!a.single_report) { a.reports = reportListOffset + a.reports * sizeof(ReportID); } a.squash = squashOffset + a.squash * sizeof(tableRow_t); return a; }; // Write accept table. limex->acceptOffset = acceptsOffset; limex->acceptCount = verify_u32(accepts.size()); DEBUG_PRINTF("NFA has %zu accepts\n", accepts.size()); NFAAccept *acceptsTable = (NFAAccept *)(limex_base + acceptsOffset); assert(ISALIGNED(acceptsTable)); transform(accepts.begin(), accepts.end(), acceptsTable, transform_offset_fn); // Write eod accept table. limex->acceptEodOffset = acceptsEodOffset; limex->acceptEodCount = verify_u32(acceptsEod.size()); DEBUG_PRINTF("NFA has %zu EOD accepts\n", acceptsEod.size()); NFAAccept *acceptsEodTable = (NFAAccept *)(limex_base + acceptsEodOffset); assert(ISALIGNED(acceptsEodTable)); transform(acceptsEod.begin(), acceptsEod.end(), acceptsEodTable, transform_offset_fn); // Write squash mask table. limex->squashCount = verify_u32(squash.size()); limex->squashOffset = squashOffset; DEBUG_PRINTF("NFA has %zu report squash masks\n", squash.size()); tableRow_t *mask = (tableRow_t *)(limex_base + squashOffset); assert(ISALIGNED(mask)); for (size_t i = 0, end = squash.size(); i < end; i++) { maskSetBits(mask[i], squash[i]); } } static void writeRepeats(const vector, size_t>> &repeats, vector &repeatOffsets, implNFA_t *limex, const u32 repeatOffsetsOffset, const u32 repeatOffset) { const u32 num_repeats = verify_u32(repeats.size()); DEBUG_PRINTF("repeatOffsetsOffset=%u, repeatOffset=%u\n", repeatOffsetsOffset, repeatOffset); repeatOffsets.resize(num_repeats); u32 offset = repeatOffset; for (u32 i = 0; i < num_repeats; i++) { repeatOffsets[i] = offset; assert(repeats[i].first); memcpy((char *)limex + offset, repeats[i].first.get(), repeats[i].second); offset += repeats[i].second; } // Write repeat offset lookup table. assert(ISALIGNED_N((char *)limex + repeatOffsetsOffset, alignof(u32))); copy_bytes((char *)limex + repeatOffsetsOffset, repeatOffsets); limex->repeatOffset = repeatOffsetsOffset; limex->repeatCount = num_repeats; } static void writeReportList(const vector &reports, implNFA_t *limex, const u32 reportListOffset) { DEBUG_PRINTF("reportListOffset=%u\n", reportListOffset); assert(ISALIGNED_N((char *)limex + reportListOffset, alignof(ReportID))); copy_bytes((char *)limex + reportListOffset, reports); } static aligned_unique_ptr generateNfa(const build_info &args) { if (args.num_states > NFATraits::maxStates) { return nullptr; } // Build bounded repeat structures. vector, size_t>> repeats; u32 repeats_full_state = 0; u32 repeats_stream_state = 0; buildRepeats(args, repeats, &repeats_full_state, &repeats_stream_state); size_t repeatSize = 0; for (size_t i = 0; i < repeats.size(); i++) { repeatSize += repeats[i].second; } // We track report lists that have already been written into the global // list in case we can reuse them. unordered_map, u32> reports_cache; ue2::unordered_set exceptional; u32 shiftCount = findBestNumOfVarShifts(args); assert(shiftCount); u32 maxShift = findMaxVarShift(args, shiftCount); findExceptionalTransitions(args, exceptional, maxShift); map> exceptionMap; vector reportList; u32 exceptionCount = buildExceptionMap(args, reports_cache, exceptional, exceptionMap, reportList); assert(exceptionCount <= args.num_states); // Build reach table and character mapping. vector reach; vector reachMap; buildReachMapping(args, reach, reachMap); // Build top masks. vector tops; buildTopMasks(args, tops); // Build all our accept info. NFAStateSet acceptMask, acceptEodMask; vector accepts, acceptsEod; vector squash; buildAccepts(args, reports_cache, acceptMask, acceptEodMask, accepts, acceptsEod, reportList, squash); // Build all our accel info. NFAStateSet accelMask, accelFriendsMask; AccelAuxVector accelAux; vector accelTable; buildAccel(args, accelMask, accelFriendsMask, accelAux, accelTable); // Compute the offsets in the bytecode for this LimEx NFA for all of // our structures. First, the NFA and LimEx structures. All other // offsets are relative to the start of the LimEx struct, starting with // the reach table. u32 offset = sizeof(implNFA_t); const u32 reachOffset = offset; offset += sizeof(tableRow_t) * reach.size(); const u32 topsOffset = offset; offset += sizeof(tableRow_t) * tops.size(); const u32 accelTableOffset = offset; offset += sizeof(u8) * accelTable.size(); offset = ROUNDUP_N(offset, alignof(AccelAux)); const u32 accelAuxOffset = offset; offset += sizeof(AccelAux) * accelAux.size(); offset = ROUNDUP_N(offset, alignof(NFAAccept)); const u32 acceptsOffset = offset; offset += sizeof(NFAAccept) * accepts.size(); const u32 acceptsEodOffset = offset; offset += sizeof(NFAAccept) * acceptsEod.size(); offset = ROUNDUP_CL(offset); const u32 squashOffset = offset; offset += sizeof(tableRow_t) * squash.size(); offset = ROUNDUP_CL(offset); const u32 exceptionsOffset = offset; offset += sizeof(exception_t) * exceptionCount; const u32 reportListOffset = offset; offset += sizeof(ReportID) * reportList.size(); const u32 repeatOffsetsOffset = offset; offset += sizeof(u32) * args.repeats.size(); offset = ROUNDUP_CL(offset); const u32 repeatsOffset = offset; offset += repeatSize; // Now we can allocate space for the NFA and get to work on layout. size_t nfaSize = sizeof(NFA) + offset; DEBUG_PRINTF("nfa size %zu\n", nfaSize); auto nfa = aligned_zmalloc_unique(nfaSize); assert(nfa); // otherwise we would have thrown std::bad_alloc implNFA_t *limex = (implNFA_t *)getMutableImplNfa(nfa.get()); assert(ISALIGNED(limex)); writeReachMapping(reach, reachMap, limex, reachOffset); writeTopMasks(tops, limex, topsOffset); writeAccel(accelMask, accelFriendsMask, accelAux, accelTable, limex, accelTableOffset, accelAuxOffset); writeAccepts(acceptMask, acceptEodMask, accepts, acceptsEod, squash, limex, acceptsOffset, acceptsEodOffset, squashOffset, reportListOffset); limex->shiftCount = shiftCount; writeShiftMasks(args, limex); // Determine the state required for our state vector. findStateSize(args, limex); writeReportList(reportList, limex, reportListOffset); // Repeat structures and offset table. vector repeatOffsets; writeRepeats(repeats, repeatOffsets, limex, repeatOffsetsOffset, repeatsOffset); writeExceptions(exceptionMap, repeatOffsets, limex, exceptionsOffset, reportListOffset); writeLimexMasks(args, limex); allocState(nfa.get(), repeats_full_state, repeats_stream_state); nfa->type = dtype; nfa->length = verify_u32(nfaSize); nfa->nPositions = args.num_states; if (!args.zombies.empty()) { setNfaFlag(nfa.get(), NFA_ZOMBIE); } if (!acceptsEod.empty()) { setNfaFlag(nfa.get(), NFA_ACCEPTS_EOD); } return nfa; } static int score(const build_info &args) { // LimEx NFAs are available in sizes from 32 to 512-bit. size_t num_states = args.num_states; size_t sz = findContainerSize(num_states); if (sz < 32) { sz = 32; } if (args.cc.grey.nfaForceSize) { sz = args.cc.grey.nfaForceSize; } if (sz != NFATraits::maxStates) { return -1; // fail, size not appropriate } // We are of the right size, calculate a score based on the number // of exceptions and the number of shifts used by this LimEx. int score; u32 shiftCount = findBestNumOfVarShifts(args, &score); if (shiftCount == 0) { return -1; } return score; } }; template struct generateNfa { static aligned_unique_ptr call(const build_info &args) { return Factory::generateNfa(args); } }; template struct scoreNfa { static int call(const build_info &args) { return Factory::score(args); } }; #define MAKE_LIMEX_TRAITS(mlt_size) \ template<> struct NFATraits { \ typedef LimExNFA##mlt_size implNFA_t; \ typedef u_##mlt_size tableRow_t; \ typedef NFAException##mlt_size exception_t; \ static const size_t maxStates = mlt_size; \ static const size_t scratch_state_size = mlt_size == 64 ? sizeof(m128) \ : sizeof(tableRow_t); \ }; MAKE_LIMEX_TRAITS(32) MAKE_LIMEX_TRAITS(64) MAKE_LIMEX_TRAITS(128) MAKE_LIMEX_TRAITS(256) MAKE_LIMEX_TRAITS(384) MAKE_LIMEX_TRAITS(512) } // namespace #ifndef NDEBUG // Some sanity tests, called by an assertion in generate(). static UNUSED bool isSane(const NGHolder &h, const map> &tops, const ue2::unordered_map &state_ids, u32 num_states) { ue2::unordered_set seen; ue2::unordered_set top_starts; for (const auto &vv : tops | map_values) { insert(&top_starts, vv); } for (auto v : vertices_range(h)) { if (!contains(state_ids, v)) { DEBUG_PRINTF("no entry for vertex %zu in state map\n", h[v].index); return false; } const u32 i = state_ids.at(v); if (i == NO_STATE) { continue; } DEBUG_PRINTF("checking vertex %zu (state %u)\n", h[v].index, i); if (i >= num_states || contains(seen, i)) { DEBUG_PRINTF("vertex %u/%u has invalid state\n", i, num_states); return false; } seen.insert(i); // All our states should be reachable and have a state assigned. if (h[v].char_reach.none()) { DEBUG_PRINTF("vertex %zu has empty reachability\n", h[v].index); return false; } // Every state that isn't a start state (or top, in triggered NFAs) // must have at least one predecessor that is not itself. if (v != h.start && v != h.startDs && !contains(top_starts, v) && !proper_in_degree(v, h)) { DEBUG_PRINTF("vertex %zu has no pred\n", h[v].index); return false; } } if (seen.size() != num_states) { return false; } return true; } #endif // NDEBUG static u32 max_state(const ue2::unordered_map &state_ids) { u32 rv = 0; for (const auto &m : state_ids) { DEBUG_PRINTF("state %u\n", m.second); if (m.second != NO_STATE) { rv = max(m.second, rv); } } DEBUG_PRINTF("max %u\n", rv); return rv; } aligned_unique_ptr generate(NGHolder &h, const ue2::unordered_map &states, const vector &repeats, const map &reportSquashMap, const map &squashMap, const map> &tops, const set &zombies, bool do_accel, bool stateCompression, u32 hint, const CompileContext &cc) { const u32 num_states = max_state(states) + 1; DEBUG_PRINTF("total states: %u\n", num_states); if (!cc.grey.allowLimExNFA) { DEBUG_PRINTF("limex not allowed\n"); return nullptr; } // If you ask for a particular type, it had better be an NFA. assert(hint == INVALID_NFA || hint <= LAST_LIMEX_NFA); DEBUG_PRINTF("hint=%u\n", hint); // Sanity check the input data. assert(isSane(h, tops, states, num_states)); // Build arguments used in the rest of this file. build_info arg(h, states, repeats, reportSquashMap, squashMap, tops, zombies, do_accel, stateCompression, cc, num_states); // Acceleration analysis. fillAccelInfo(arg); vector> scores; if (hint != INVALID_NFA) { // The caller has told us what to (attempt to) build. scores.emplace_back(0, (NFAEngineType)hint); } else { for (size_t i = 0; i <= LAST_LIMEX_NFA; i++) { NFAEngineType ntype = (NFAEngineType)i; int score = DISPATCH_BY_LIMEX_TYPE(ntype, scoreNfa, arg); if (score >= 0) { DEBUG_PRINTF("%s scores %d\n", nfa_type_name(ntype), score); scores.emplace_back(score, ntype); } } } if (scores.empty()) { DEBUG_PRINTF("No NFA returned a valid score for this case.\n"); return nullptr; } // Sort acceptable models in priority order, lowest score first. sort(scores.begin(), scores.end()); for (const auto &elem : scores) { assert(elem.first >= 0); NFAEngineType limex_model = elem.second; auto nfa = DISPATCH_BY_LIMEX_TYPE(limex_model, generateNfa, arg); if (nfa) { DEBUG_PRINTF("successful build with NFA engine: %s\n", nfa_type_name(limex_model)); return nfa; } } DEBUG_PRINTF("NFA build failed.\n"); return nullptr; } u32 countAccelStates(NGHolder &h, const ue2::unordered_map &states, const vector &repeats, const map &reportSquashMap, const map &squashMap, const map> &tops, const set &zombies, const CompileContext &cc) { const u32 num_states = max_state(states) + 1; DEBUG_PRINTF("total states: %u\n", num_states); if (!cc.grey.allowLimExNFA) { DEBUG_PRINTF("limex not allowed\n"); return 0; } // Sanity check the input data. assert(isSane(h, tops, states, num_states)); const bool do_accel = true; const bool state_compression = false; // Build arguments used in the rest of this file. build_info bi(h, states, repeats, reportSquashMap, squashMap, tops, zombies, do_accel, state_compression, cc, num_states); // Acceleration analysis. nfaFindAccelSchemes(bi.h, bi.br_cyclic, &bi.accel.accel_map); u32 num_accel = verify_u32(bi.accel.accel_map.size()); DEBUG_PRINTF("found %u accel states\n", num_accel); return num_accel; } } // namespace ue2 hyperscan-4.4.1/src/nfa/mcclellancompile_util.cpp0000644000175000017500000002466513055426554022713 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "mcclellancompile_util.h" #include "rdfa.h" #include "util/container.h" #include "util/ue2_containers.h" #include "ue2common.h" #include #include using namespace std; namespace ue2 { #define INIT_STATE 1 static u32 count_dots(const raw_dfa &raw) { assert(raw.start_anchored == INIT_STATE); u32 i = INIT_STATE; for (; i < raw.states.size() && i != raw.start_floating; i++) { DEBUG_PRINTF("checking %u\n", i); assert(raw.states[i].reports.empty()); assert(raw.states[i].reports_eod.empty()); for (symbol_t s = 0; s < raw.getImplAlphaSize(); s++) { DEBUG_PRINTF("%hu -> %hu\n", s, raw.states[i].next[s]); if (raw.states[i].next[s] != i + 1) { goto validate; } } if (!raw.states[raw.states[i].next[0]].reports.empty() || !raw.states[raw.states[i].next[0]].reports_eod.empty()) { goto validate; } DEBUG_PRINTF("got dot\n"); } validate: u32 dot_count = i - INIT_STATE; /* we need to check that no later state has a transition into these leading * dots */ for (; i < raw.states.size(); i++) { for (symbol_t s = 0; s < raw.getImplAlphaSize(); s++) { DEBUG_PRINTF("%hu -> %hu\n", s, raw.states[i].next[s]); dstate_id_t n = raw.states[i].next[s]; if (n != DEAD_STATE && n <= dot_count) { return 0; } } } return dot_count; } static void prune_leading_states(raw_dfa &raw, u32 count) { if (!count) { return; } for (u32 i = INIT_STATE + count; i < raw.states.size(); i++) { dstate &curr = raw.states[i - count]; curr = raw.states[i]; if (curr.daddy > count) { curr.daddy -= count; } else { curr.daddy = DEAD_STATE; } for (u32 j = 0; j < raw.alpha_size; j++) { assert(curr.next[j] == DEAD_STATE || curr.next[j] > count); if (curr.next[j]) { curr.next[j] -= count; } } } raw.states.erase(raw.states.end() - count, raw.states.end()); } u32 remove_leading_dots(raw_dfa &raw) { u32 count = count_dots(raw); prune_leading_states(raw, count); DEBUG_PRINTF("removed %u leading dots\n", count); return count; } static never_inline u32 calc_min_dist_from_bob(raw_dfa &raw, vector *dist_in) { vector &dist = *dist_in; dist.clear(); dist.resize(raw.states.size(), ~0U); assert(raw.start_anchored != DEAD_STATE); deque to_visit; to_visit.push_back(raw.start_anchored); dist[raw.start_anchored] = 0; u32 last_d = 0; while (!to_visit.empty()) { dstate_id_t s = to_visit.front(); DEBUG_PRINTF("inspecting %u\n", s); to_visit.pop_front(); assert(s != DEAD_STATE); u32 d = dist[s]; assert(d >= last_d); assert(d != ~0U); for (u32 j = 0; j < raw.alpha_size; j++) { dstate_id_t t = raw.states[s].next[j]; if (t == DEAD_STATE) { continue; } if (dist[t] == ~0U) { to_visit.push_back(t); dist[t] = d + 1; } else { assert(dist[t] <= d + 1); } } last_d = d; } return last_d; } static void find_in_edges(const raw_dfa &raw, vector > *in_edges) { in_edges->clear(); in_edges->resize(raw.states.size()); ue2::unordered_set seen; for (u32 s = 1; s < raw.states.size(); s++) { seen.clear(); for (u32 j = 0; j < raw.alpha_size; j++) { dstate_id_t t = raw.states[s].next[j]; if (contains(seen, t)) { continue; } seen.insert(t); (*in_edges)[t].push_back(s); } } } static void calc_min_dist_to_accept(const raw_dfa &raw, const vector > &in_edges, vector *accept_dist) { vector &dist = *accept_dist; dist.clear(); dist.resize(raw.states.size(), ~0U); /* for reporting states to start from */ deque to_visit; for (u32 s = 0; s < raw.states.size(); s++) { if (!raw.states[s].reports.empty() || !raw.states[s].reports_eod.empty()) { to_visit.push_back(s); dist[s] = 0; } } /* bfs */ UNUSED u32 last_d = 0; while (!to_visit.empty()) { dstate_id_t s = to_visit.front(); to_visit.pop_front(); assert(s != DEAD_STATE); u32 d = dist[s]; assert(d >= last_d); assert(d != ~0U); for (vector::const_iterator it = in_edges[s].begin(); it != in_edges[s].end(); ++it) { dstate_id_t t = *it; if (t == DEAD_STATE) { continue; } if (dist[t] == ~0U) { to_visit.push_back(t); dist[t] = d + 1; } else { assert(dist[t] <= d + 1); } } last_d = d; } } bool prune_overlong(raw_dfa &raw, u32 max_offset) { DEBUG_PRINTF("pruning to at most %u\n", max_offset); vector bob_dist; u32 max_min_dist_bob = calc_min_dist_from_bob(raw, &bob_dist); if (max_min_dist_bob <= max_offset) { return false; } vector > in_edges; find_in_edges(raw, &in_edges); vector accept_dist; calc_min_dist_to_accept(raw, in_edges, &accept_dist); in_edges.clear(); /* look over the states and filter out any which cannot reach a report * states before max_offset */ vector new_ids(raw.states.size()); vector new_states; u32 count = 1; new_states.push_back(raw.states[DEAD_STATE]); for (u32 s = DEAD_STATE + 1; s < raw.states.size(); s++) { if (bob_dist[s] + accept_dist[s] > max_offset) { DEBUG_PRINTF("pruned %u: bob %u, report %u\n", s, bob_dist[s], accept_dist[s]); new_ids[s] = DEAD_STATE; } else { new_ids[s] = count++; new_states.push_back(raw.states[s]); assert(new_states.size() == count); assert(new_ids[s] <= s); } } /* swap states */ DEBUG_PRINTF("pruned %zu -> %u\n", raw.states.size(), count); raw.states.swap(new_states); new_states.clear(); /* update edges and daddys to refer to the new ids */ for (u32 s = DEAD_STATE + 1; s < raw.states.size(); s++) { for (u32 j = 0; j < raw.alpha_size; j++) { dstate_id_t old_t = raw.states[s].next[j]; raw.states[s].next[j] = new_ids[old_t]; } raw.states[s].daddy = new_ids[raw.states[s].daddy]; } /* update specials */ raw.start_floating = new_ids[raw.start_floating]; raw.start_anchored = new_ids[raw.start_anchored]; return true; } set all_reports(const raw_dfa &rdfa) { set all; for (const auto &ds : rdfa.states) { insert(&all, ds.reports); insert(&all, ds.reports_eod); } return all; } bool has_eod_accepts(const raw_dfa &rdfa) { for (const auto &ds : rdfa.states) { if (!ds.reports_eod.empty()) { return true; } } return false; } bool has_non_eod_accepts(const raw_dfa &rdfa) { for (const auto &ds : rdfa.states) { if (!ds.reports.empty()) { return true; } } return false; } size_t hash_dfa_no_reports(const raw_dfa &rdfa) { using boost::hash_combine; using boost::hash_range; size_t v = 0; hash_combine(v, rdfa.alpha_size); hash_combine(v, hash_range(begin(rdfa.alpha_remap), end(rdfa.alpha_remap))); for (const auto &ds : rdfa.states) { hash_combine(v, hash_range(begin(ds.next), end(ds.next))); } return v; } size_t hash_dfa(const raw_dfa &rdfa) { using boost::hash_combine; size_t v = 0; hash_combine(v, hash_dfa_no_reports(rdfa)); hash_combine(v, all_reports(rdfa)); return v; } static bool can_die_early(const raw_dfa &raw, dstate_id_t s, map &visited, u32 age_limit) { if (contains(visited, s) && visited[s] >= age_limit) { /* we have already visited (or are in the process of visiting) here with * a looser limit. */ return false; } visited[s] = age_limit; if (s == DEAD_STATE) { return true; } if (age_limit == 0) { return false; } for (const auto &next : raw.states[s].next) { if (can_die_early(raw, next, visited, age_limit - 1)) { return true; } } return false; } bool can_die_early(const raw_dfa &raw, u32 age_limit) { map visited; return can_die_early(raw, raw.start_anchored, visited, age_limit); } } // namespace ue2 hyperscan-4.4.1/src/nfa/limex_compile.h0000644000175000017500000000767113055426554020644 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Main NFA build code. */ #ifndef LIMEX_COMPILE_H #define LIMEX_COMPILE_H #include #include #include #include "ue2common.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_squash.h" // for NFAStateSet #include "util/alloc.h" #include "util/ue2_containers.h" struct NFA; namespace ue2 { struct BoundedRepeatData; struct CompileContext; /** \brief Construct a LimEx NFA from an NGHolder. * * \param g Input NFA graph. Must have state IDs assigned. * \param repeats Bounded repeat information, if any. * \param reportSquashMap Single-match mode squash map. * \param squashMap More general squash map. * \param tops Tops and their start vertices, * \param zombies The set of zombifying states. * \param do_accel Calculate acceleration schemes. * \param stateCompression Allow (and calculate masks for) state compression. * \param hint If not INVALID_NFA, this allows a particular LimEx NFA model to be requested. * \param cc Compile context. * \return a built NFA, or nullptr if no NFA could be constructed for this * graph. */ aligned_unique_ptr generate(NGHolder &g, const ue2::unordered_map &states, const std::vector &repeats, const std::map &reportSquashMap, const std::map &squashMap, const std::map> &tops, const std::set &zombies, bool do_accel, bool stateCompression, u32 hint, const CompileContext &cc); /** * \brief For a given graph, count the number of accelerable states it has. * * Note that this number may be greater than the number that are actually * implementable. */ u32 countAccelStates(NGHolder &h, const ue2::unordered_map &states, const std::vector &repeats, const std::map &reportSquashMap, const std::map &squashMap, const std::map> &tops, const std::set &zombies, const CompileContext &cc); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/multiaccel_compilehelper.cpp0000644000175000017500000003451013055426554023373 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "multiaccel_compilehelper.h" using namespace std; using namespace ue2; #ifdef DEBUG static const char* state_to_str[] = { "FIRST_RUN", "SECOND_RUN", "WAITING_FOR_GRAB", "FIRST_TAIL", "SECOND_TAIL", "STOPPED", "INVALID" }; static const char* type_to_str[] = { "SHIFT", "SHIFTGRAB", "DOUBLESHIFT", "DOUBLESHIFTGRAB", "LONG", "LONGGRAB", "NONE" }; static void dumpMultiaccelState(const accel_data &d) { DEBUG_PRINTF("type: %s state: %s len1: %u tlen1: %u len2: %u tlen2: %u\n", type_to_str[(unsigned) d.type], state_to_str[(unsigned) d.state], d.len1, d.tlen1, d.len2, d.tlen2); } #endif /* stop all the matching. this may render most schemes invalid. */ static void stop(accel_data &d) { switch (d.state) { case STATE_STOPPED: case STATE_INVALID: break; case STATE_FIRST_TAIL: case STATE_SECOND_RUN: /* * Shift matchers are special case, because they have "tails". * When shift matcher reaches a mid/endpoint, tail mode is * activated, which looks for more matches to extend the match. * * For example, consider pattern /a{5}ba{3}/. Under normal circumstances, * long-grab matcher will be picked for this pattern (matching a run of a's, * followed by a not-a), because doubleshift matcher would be confused by * consecutive a's and would parse the pattern as a.{0}a.{0}a (two shifts * by 1) and throw out the rest of the pattern. * * With tails, we defer ending the run until we actually run out of * matching characters, so the above pattern will now be parsed by * doubleshift matcher as /a.{3}a.{3}a/ (two shifts by 4). * * So if we are stopping shift matchers, we should check if we aren't in * the process of matching first tail or second run. If we are, we can't * finish the second run as we are stopping, but we can try and split * the first tail instead to obtain a valid second run. */ if ((d.type == MultibyteAccelInfo::MAT_DSHIFT || d.type == MultibyteAccelInfo::MAT_DSHIFTGRAB) && d.tlen1 == 0) { // can't split an empty void... d.state = STATE_INVALID; break; } d.len2 = 0; d.state = STATE_STOPPED; break; case STATE_SECOND_TAIL: d.state = STATE_STOPPED; break; case STATE_WAITING_FOR_GRAB: case STATE_FIRST_RUN: if (d.type == MultibyteAccelInfo::MAT_LONG) { d.state = STATE_STOPPED; } else { d.state = STATE_INVALID; } break; } } static void validate(accel_data &d, unsigned max_len) { // try and fit in all our tails if (d.len1 + d.tlen1 + d.len2 + d.tlen2 < max_len && d.len2 > 0) { // case 1: everything fits in d.len1 += d.tlen1; d.len2 += d.tlen2; d.tlen1 = 0; d.tlen2 = 0; } else if (d.len1 + d.tlen1 + d.len2 < max_len && d.len2 > 0) { // case 2: everything but the second tail fits in d.len1 += d.tlen1; d.tlen1 = 0; // try going for a partial tail if (d.tlen2 != 0) { int new_tlen2 = max_len - 1 - d.len1 - d.len2; if (new_tlen2 > 0) { d.len2 += new_tlen2; } d.tlen2 = 0; } } else if (d.len1 + d.tlen1 < max_len) { // case 3: first run and its tail fits in if (d.type == MultibyteAccelInfo::MAT_DSHIFT || d.type == MultibyteAccelInfo::MAT_DSHIFTGRAB) { // split the tail into a second run d.len2 = d.tlen1; } else { d.len1 += d.tlen1; d.len2 = 0; } d.tlen1 = 0; d.tlen2 = 0; } else if (d.len1 < max_len) { // case 4: nothing but the first run fits in // try going for a partial tail if (d.tlen1 != 0) { int new_tlen1 = max_len - 1 - d.len1; if (new_tlen1 > 0) { d.len1 += new_tlen1; } d.tlen1 = 0; } d.len2 = 0; d.tlen2 = 0; } // if we removed our second run, doubleshift matchers are no longer valid if ((d.type == MultibyteAccelInfo::MAT_DSHIFT || d.type == MultibyteAccelInfo::MAT_DSHIFTGRAB) && d.len2 == 0) { d.state = STATE_INVALID; } else if ((d.type == MultibyteAccelInfo::MAT_LONG) && d.len1 >= max_len) { // long matchers can just stop whenever they want to d.len1 = max_len - 1; } // now, general sanity checks if ((d.len1 + d.tlen1 + d.len2 + d.tlen2) >= max_len) { d.state = STATE_INVALID; } if ((d.len1 + d.tlen1 + d.len2 + d.tlen2) < MULTIACCEL_MIN_LEN) { d.state = STATE_INVALID; } } static void match(accel_data &d, const CharReach &ref_cr, const CharReach &cur_cr) { switch (d.type) { case MultibyteAccelInfo::MAT_LONG: { /* * For long matcher, we want lots of consecutive same-or-subset * char-reaches */ if ((ref_cr & cur_cr) == cur_cr) { d.len1++; } else { d.state = STATE_STOPPED; } } break; case MultibyteAccelInfo::MAT_LONGGRAB: { /* * For long-grab matcher, we want lots of consecutive same-or-subset * char-reaches with a negative match in the end. */ if ((ref_cr & cur_cr) == cur_cr) { d.len1++; } else if (!(ref_cr & cur_cr).any()) { /* we grabbed, stop immediately */ d.state = STATE_STOPPED; } else { /* our run-n-grab was interrupted; mark as invalid */ d.state = STATE_INVALID; } } break; case MultibyteAccelInfo::MAT_SHIFTGRAB: { /* * For shift-grab matcher, we want two matches separated by anything; * however the second vertex *must* be a negative (non-overlapping) match. * * Shiftgrab matcher is identical to shift except for presence of grab. */ if (d.state == STATE_WAITING_FOR_GRAB) { if ((ref_cr & cur_cr).any()) { d.state = STATE_INVALID; } else { d.state = STATE_FIRST_RUN; d.len1++; } return; } } /* no break, falling through */ case MultibyteAccelInfo::MAT_SHIFT: { /* * For shift-matcher, we want two matches separated by anything. */ if (ref_cr == cur_cr) { // keep matching tail switch (d.state) { case STATE_FIRST_RUN: d.state = STATE_FIRST_TAIL; break; case STATE_FIRST_TAIL: d.tlen1++; break; default: // shouldn't happen assert(0); } } else { switch (d.state) { case STATE_FIRST_RUN: // simply advance d.len1++; break; case STATE_FIRST_TAIL: // we found a non-matching char after tail, so stop d.state = STATE_STOPPED; break; default: // shouldn't happen assert(0); } } } break; case MultibyteAccelInfo::MAT_DSHIFTGRAB: { /* * For double shift-grab matcher, we want two matches separated by * either negative matches or dots; however the second vertex *must* * be a negative match. * * Doubleshiftgrab matcher is identical to doubleshift except for * presence of grab. */ if (d.state == STATE_WAITING_FOR_GRAB) { if ((ref_cr & cur_cr).any()) { d.state = STATE_INVALID; } else { d.state = STATE_FIRST_RUN; d.len1++; } return; } } /* no break, falling through */ case MultibyteAccelInfo::MAT_DSHIFT: { /* * For double shift matcher, we want three matches, each separated * by a lot of anything. * * Doubleshift matcher is complicated by presence of tails. */ if (ref_cr == cur_cr) { // decide if we are activating second shift or matching tails switch (d.state) { case STATE_FIRST_RUN: d.state = STATE_FIRST_TAIL; d.len2 = 1; // we're now ready for our second run break; case STATE_FIRST_TAIL: d.tlen1++; break; case STATE_SECOND_RUN: d.state = STATE_SECOND_TAIL; break; case STATE_SECOND_TAIL: d.tlen2++; break; default: // shouldn't happen assert(0); } } else { switch (d.state) { case STATE_FIRST_RUN: d.len1++; break; case STATE_FIRST_TAIL: // start second run d.state = STATE_SECOND_RUN; d.len2++; break; case STATE_SECOND_RUN: d.len2++; break; case STATE_SECOND_TAIL: // stop d.state = STATE_STOPPED; break; default: // shouldn't happen assert(0); } } } break; default: // shouldn't happen assert(0); break; } } MultiaccelCompileHelper::MultiaccelCompileHelper(const CharReach &ref_cr, u32 off, unsigned max_length) : cr(ref_cr), offset(off), max_len(max_length) { int accel_num = (int) MultibyteAccelInfo::MAT_MAX; accels.resize(accel_num); // mark everything as valid for (int i = 0; i < accel_num; i++) { accel_data &ad = accels[i]; ad.len1 = 1; ad.type = (MultibyteAccelInfo::multiaccel_type) i; /* for shift-grab matchers, we are waiting for the grab right at the start */ if (ad.type == MultibyteAccelInfo::MAT_SHIFTGRAB || ad.type == MultibyteAccelInfo::MAT_DSHIFTGRAB) { ad.state = STATE_WAITING_FOR_GRAB; } else { ad.state = STATE_FIRST_RUN; } } } bool MultiaccelCompileHelper::canAdvance() { for (const accel_data &ad : accels) { if (ad.state != STATE_STOPPED && ad.state != STATE_INVALID) { return true; } } return false; } void MultiaccelCompileHelper::advance(const CharReach &cur_cr) { for (accel_data &ad : accels) { if (ad.state == STATE_STOPPED || ad.state == STATE_INVALID) { continue; } match(ad, cr, cur_cr); #ifdef DEBUG dumpMultiaccelState(ad); #endif } } MultibyteAccelInfo MultiaccelCompileHelper::getBestScheme() { int best_len = 0; accel_data best; DEBUG_PRINTF("Stopping multiaccel compile\n"); for (accel_data &ad : accels) { // stop our matching stop(ad); validate(ad, max_len); #ifdef DEBUG dumpMultiaccelState(ad); #endif // skip invalid schemes if (ad.state == STATE_INVALID) { continue; } DEBUG_PRINTF("Marking as viable\n"); // TODO: relative strengths of accel schemes? maybe e.g. a shorter // long match would in some cases be preferable to a longer // double shift match (for example, depending on length)? int as_len = ad.len1 + ad.len2; if (as_len >= best_len) { DEBUG_PRINTF("Marking as best\n"); best_len = as_len; best = ad; } } // if we found at least one accel scheme, return it if (best.state != STATE_INVALID) { #ifdef DEBUG DEBUG_PRINTF("Picked best multiaccel state:\n"); dumpMultiaccelState(best); #endif MultibyteAccelInfo info; info.cr = cr; info.offset = offset; info.len1 = best.len1; info.len2 = best.len2; info.type = best.type; return info; } return MultibyteAccelInfo(); } hyperscan-4.4.1/src/nfa/nfa_api_queue.h0000644000175000017500000002302013055426554020601 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 NFA_API_QUEUE_H #define NFA_API_QUEUE_H #ifdef __cplusplus extern "C" { #endif #include "ue2common.h" #include "callback.h" /** Size of mq::items, max elements on a queue. */ #define MAX_MQE_LEN 10 /** Queue events */ /** Queue event: begin scanning. Note: stateless engines will start from this * location. */ #define MQE_START 0U /** Queue event: stop scanning. */ #define MQE_END 1U /** Queue event: enable start and start-dot-star. */ #define MQE_TOP 2U /** Queue event: first event corresponding to a numbered TOP. Additional tops * (in multi-top engines) use the event values from MQE_TOP_FIRST to * MQE_INVALID - 1. */ #define MQE_TOP_FIRST 4U /** Invalid queue event */ #define MQE_INVALID (~0U) /** Queue item */ struct mq_item { u32 type; /**< event type, from MQE_* */ s64a location; /**< relative to the start of the current buffer */ u64a som; /**< pattern start-of-match corresponding to a top, only used * by som engines. */ }; // Forward decl. struct NFA; /** * Queue of events to control engine execution. mq::cur is index of first * valid event, mq::end is one past the index of last valid event. */ struct mq { const struct NFA *nfa; /**< nfa corresponding to the queue */ u32 cur; /**< index of the first valid item in the queue */ u32 end; /**< index one past the last valid item in the queue */ char *state; /**< uncompressed stream state; lives in scratch */ char *streamState; /**< * real stream state; used to access structures which * not duplicated the scratch state (bounded repeats, * etc) */ u64a offset; /**< base offset of the buffer */ const u8 *buffer; /**< buffer to scan */ size_t length; /**< length of buffer */ const u8 *history; /**< * history buffer; (logically) immediately before the * main buffer */ size_t hlength; /**< length of the history buffer */ struct hs_scratch *scratch; /**< global scratch space */ char report_current; /**< * report_current matches at starting offset through * callback. If true, the queue must be located at a * point where MO_MATCHES_PENDING was returned */ NfaCallback cb; /**< callback to trigger on matches */ void *context; /**< context to pass along with a callback */ struct mq_item items[MAX_MQE_LEN]; /**< queue items */ }; /** * Pushes an (event, location, som) item onto a queue. If it is identical to the * previous item on the queue, it is not added to the queue. * @param q queue * @param e event * @param som som marker * @param loc event location */ static really_inline void pushQueueSom(struct mq * restrict q, u32 e, s64a loc, u64a som) { DEBUG_PRINTF("pushing %u@%lld -> %u [som = %llu]\n", e, loc, q->end, som); assert(q->end < MAX_MQE_LEN); assert(e < MQE_INVALID); /* stop gcc getting too smart for its own good */ /* assert(!q->end || q->items[q->end - 1].location <= loc); */ assert(q->end || e == MQE_START); // Avoid duplicate items on the queue. if (q->end) { struct mq_item *item = &q->items[q->end - 1]; if (item->type == e && item->location == loc) { DEBUG_PRINTF("dropping duplicate item\n"); LIMIT_TO_AT_MOST(&item->som, som); /* take lower som */ return; } } u32 end = q->end; struct mq_item *item = &q->items[end]; item->type = e; item->location = loc; item->som = som; q->end = end + 1; } /** * Pushes an (event, location) item onto a queue. If it is identical to the * previous item on the queue, it is not added to the queue. * @param q queue * @param e event * @param loc event location */ static really_inline void pushQueue(struct mq * restrict q, u32 e, s64a loc) { pushQueueSom(q, e, loc, 0); } /** * Pushes an (event, location) item onto a queue. * This version of @ref pushQueue does not check to ensure that the item being * added is not already on the queue. Used for events other than tops. */ static really_inline void pushQueueNoMerge(struct mq * restrict q, u32 e, s64a loc) { DEBUG_PRINTF("pushing %u@%lld -> %u\n", e, loc, q->end); assert(q->end < MAX_MQE_LEN); assert(e < MQE_INVALID); /* stop gcc getting too smart for its own good */ /* assert(!q->end || q->items[q->end - 1].location <= loc); */ assert(q->end || e == MQE_START); #ifndef NDEBUG // We assert that the event is different from its predecessor. If it's a // dupe, you should have used the ordinary pushQueue call. if (q->end) { UNUSED struct mq_item *prev = &q->items[q->end - 1]; assert(prev->type != e || prev->location != loc); } #endif u32 end = q->end; struct mq_item *item = &q->items[end]; item->type = e; item->location = loc; item->som = 0; q->end = end + 1; } /** \brief Returns the type of the current queue event. */ static really_inline u32 q_cur_type(const struct mq *q) { assert(q->cur < q->end); assert(q->cur < MAX_MQE_LEN); return q->items[q->cur].type; } /** \brief Returns the location (relative to the beginning of the current data * buffer) of the current queue event. */ static really_inline s64a q_cur_loc(const struct mq *q) { assert(q->cur < q->end); assert(q->cur < MAX_MQE_LEN); return q->items[q->cur].location; } /** \brief Returns the type of the last event in the queue. */ static really_inline u32 q_last_type(const struct mq *q) { assert(q->cur < q->end); assert(q->end > 0); assert(q->end <= MAX_MQE_LEN); return q->items[q->end - 1].type; } /** \brief Returns the location (relative to the beginning of the current data * buffer) of the last event in the queue. */ static really_inline s64a q_last_loc(const struct mq *q) { assert(q->cur < q->end); assert(q->end > 0); assert(q->end <= MAX_MQE_LEN); return q->items[q->end - 1].location; } /** \brief Returns the absolute stream offset of the current queue event. */ static really_inline u64a q_cur_offset(const struct mq *q) { assert(q->cur < q->end); assert(q->cur < MAX_MQE_LEN); return q->offset + (u64a)q->items[q->cur].location; } /** * \brief Removes all events in the queue before the given location. */ static really_inline void q_skip_forward_to(struct mq *q, s64a min_loc) { assert(q->cur < q->end); assert(q->cur < MAX_MQE_LEN); assert(q->items[q->cur].type == MQE_START); if (q_cur_loc(q) >= min_loc) { DEBUG_PRINTF("all events >= loc %lld\n", min_loc); return; } const u32 start_loc = q->cur; do { DEBUG_PRINTF("remove item with loc=%lld\n", q_cur_loc(q)); q->cur++; } while (q->cur < q->end && q_cur_loc(q) < min_loc); if (q->cur > start_loc) { // Move original MQE_START item forward. q->cur--; q->items[q->cur] = q->items[start_loc]; } } #ifdef DEBUG // Dump the contents of the given queue. static never_inline UNUSED void debugQueue(const struct mq *q) { DEBUG_PRINTF("q=%p, nfa=%p\n", q, q->nfa); DEBUG_PRINTF("q offset=%llu, buf={%p, len=%zu}, history={%p, len=%zu}\n", q->offset, q->buffer, q->length, q->history, q->hlength); DEBUG_PRINTF("q cur=%u, end=%u\n", q->cur, q->end); for (u32 cur = q->cur; cur < q->end; cur++) { const char *type = "UNKNOWN"; u32 e = q->items[cur].type; switch (e) { case MQE_START: type = "MQE_START"; break; case MQE_END: type = "MQE_END"; break; case MQE_TOP: type = "MQE_TOP"; break; case MQE_INVALID: type = "MQE_INVALID"; break; default: assert(e >= MQE_TOP_FIRST && e < MQE_INVALID); type = "MQE_TOP_N"; break; } DEBUG_PRINTF("\tq[%u] %lld %u:%s\n", cur, q->items[cur].location, q->items[cur].type, type); } } #endif // DEBUG #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/castle.h0000644000175000017500000000541013055426554017256 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 NFA_CASTLE_H #define NFA_CASTLE_H #ifdef __cplusplus extern "C" { #endif #include "ue2common.h" struct mq; struct NFA; char nfaExecCastle_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecCastle_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecCastle_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecCastle_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecCastle_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecCastle_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecCastle_queueInitState(const struct NFA *n, struct mq *q); char nfaExecCastle_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecCastle_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecCastle_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecCastle_testEOD NFA_API_NO_IMPL #define nfaExecCastle_B_Reverse NFA_API_NO_IMPL #define nfaExecCastle_zombie_status NFA_API_ZOMBIE_NO_IMPL #ifdef __cplusplus } #endif // __cplusplus #endif hyperscan-4.4.1/src/nfa/multiaccel_long.h0000644000175000017500000001004013055426554021137 0ustar sleuthkidsleuthkid/* * 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_ */ hyperscan-4.4.1/src/nfa/nfa_api_dispatch.c0000644000175000017500000003072613055426554021262 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file \brief Dispatches NFA engine API calls to the appropriate engines */ #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "ue2common.h" // Engine implementations. #include "castle.h" #include "gough.h" #include "lbr.h" #include "limex.h" #include "mcclellan.h" #include "mcsheng.h" #include "mpv.h" #include "sheng.h" #include "tamarama.h" #define DISPATCH_CASE(dc_ltype, dc_ftype, dc_func_call) \ case dc_ltype: \ return nfaExec##dc_ftype##dc_func_call; \ break // general framework calls #define DISPATCH_BY_NFA_TYPE(dbnt_func) \ switch (nfa->type) { \ DISPATCH_CASE(LIMEX_NFA_32, LimEx32, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_64, LimEx64, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_128, LimEx128, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_256, LimEx256, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_384, LimEx384, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_512, LimEx512, dbnt_func); \ DISPATCH_CASE(MCCLELLAN_NFA_8, McClellan8, dbnt_func); \ DISPATCH_CASE(MCCLELLAN_NFA_16, McClellan16, dbnt_func); \ DISPATCH_CASE(GOUGH_NFA_8, Gough8, dbnt_func); \ DISPATCH_CASE(GOUGH_NFA_16, Gough16, dbnt_func); \ DISPATCH_CASE(MPV_NFA, Mpv, dbnt_func); \ DISPATCH_CASE(LBR_NFA_DOT, LbrDot, dbnt_func); \ DISPATCH_CASE(LBR_NFA_VERM, LbrVerm, dbnt_func); \ DISPATCH_CASE(LBR_NFA_NVERM, LbrNVerm, dbnt_func); \ DISPATCH_CASE(LBR_NFA_SHUF, LbrShuf, dbnt_func); \ DISPATCH_CASE(LBR_NFA_TRUF, LbrTruf, dbnt_func); \ DISPATCH_CASE(CASTLE_NFA, Castle, dbnt_func); \ DISPATCH_CASE(SHENG_NFA, Sheng, dbnt_func); \ DISPATCH_CASE(TAMARAMA_NFA, Tamarama, dbnt_func); \ DISPATCH_CASE(MCSHENG_NFA_8, McSheng8, dbnt_func); \ DISPATCH_CASE(MCSHENG_NFA_16, McSheng16, dbnt_func); \ default: \ assert(0); \ } char nfaCheckFinalState(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context) { assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); // Caller should avoid calling us if we can never produce matches. assert(nfaAcceptsEod(nfa)); DISPATCH_BY_NFA_TYPE(_testEOD(nfa, state, streamState, offset, callback, context)); return 0; } char nfaQueueInitState(const struct NFA *nfa, struct mq *q) { assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); DISPATCH_BY_NFA_TYPE(_queueInitState(nfa, q)); return 0; } static really_inline char nfaQueueExec_i(const struct NFA *nfa, struct mq *q, s64a end) { DISPATCH_BY_NFA_TYPE(_Q(nfa, q, end)); return 0; } static really_inline char nfaQueueExec2_i(const struct NFA *nfa, struct mq *q, s64a end) { DISPATCH_BY_NFA_TYPE(_Q2(nfa, q, end)); return 0; } char nfaQueueExec_raw(const struct NFA *nfa, struct mq *q, s64a end) { return nfaQueueExec_i(nfa, q, end); } char nfaQueueExec2_raw(const struct NFA *nfa, struct mq *q, s64a end) { return nfaQueueExec2_i(nfa, q, end); } static really_inline char nfaQueueExecRose_i(const struct NFA *nfa, struct mq *q, ReportID report) { DISPATCH_BY_NFA_TYPE(_QR(nfa, q, report)); return 0; } /** Returns 0 if this NFA cannot possibly match (due to width constraints etc) * and the caller should return 0. May also edit the queue. */ static really_inline char nfaQueueCanMatch(const struct NFA *nfa, struct mq *q, s64a end, char *q_trimmed) { assert(q_trimmed); assert(q->end - q->cur >= 2); assert(end >= 0); DEBUG_PRINTF("q->offset=%llu, end=%lld\n", q->offset, end); DEBUG_PRINTF("maxBiAnchoredWidth=%u, maxOffset=%u\n", nfa->maxBiAnchoredWidth, nfa->maxOffset); if (nfa->maxBiAnchoredWidth && (end + q->offset > nfa->maxBiAnchoredWidth)) { DEBUG_PRINTF("stream too long: o %llu l %zu max: %hhu\n", q->offset, q->length, nfa->maxBiAnchoredWidth); return 0; } if (nfa->maxOffset) { if (q->offset >= nfa->maxOffset) { DEBUG_PRINTF("stream is past maxOffset\n"); return 0; } if (q->offset + end > nfa->maxOffset) { s64a maxEnd = nfa->maxOffset - q->offset; DEBUG_PRINTF("me %lld off %llu len = %lld\n", maxEnd, q->offset, end); while (q->end > q->cur && q->items[q->end - 1].location > maxEnd) { *q_trimmed = 1; DEBUG_PRINTF("killing item %u %lld %u\n", q->end, q->items[q->end - 1].location, q->items[q->end - 1].type); q->items[q->end - 1].location = maxEnd; q->items[q->end - 1].type = MQE_END; if (q->end - q->cur < 2 ||q->items[q->end - 2].location <= maxEnd) { break; } q->end--; } if (q->end - q->cur < 2) { /* nothing left on q */ DEBUG_PRINTF("queue empty\n"); return 0; } } #ifdef DEBUG if (*q_trimmed) { debugQueue(q); } #endif } return 1; } char nfaQueueExec(const struct NFA *nfa, struct mq *q, s64a end) { DEBUG_PRINTF("nfa=%p end=%lld\n", nfa, end); #ifdef DEBUG debugQueue(q); #endif assert(q && q->context && q->state); assert(end >= 0); assert(q->cur < q->end); assert(q->end <= MAX_MQE_LEN); assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); assert(end < q->items[q->end - 1].location || q->items[q->end - 1].type == MQE_END); if (q->items[q->cur].location > end) { return 1; } char q_trimmed = 0; assert(end <= (s64a)q->length || !q->hlength); /* due to reverse accel in block mode some queues may work on a truncated * buffer */ if (end > (s64a)q->length) { end = q->length; q_trimmed = 1; } if (!nfaQueueCanMatch(nfa, q, end, &q_trimmed)) { if (q->report_current) { nfaReportCurrentMatches(nfa, q); q->report_current = 0; } return 0; } char rv = nfaQueueExec_i(nfa, q, end); #ifdef DEBUG debugQueue(q); #endif assert(!q->report_current); DEBUG_PRINTF("returned rv=%d, q_trimmed=%d\n", rv, q_trimmed); return rv && !q_trimmed; } char nfaQueueExecToMatch(const struct NFA *nfa, struct mq *q, s64a end) { DEBUG_PRINTF("nfa=%p end=%lld\n", nfa, end); #ifdef DEBUG debugQueue(q); #endif assert(q); assert(end >= 0); assert(q->state); assert(q->cur < q->end); assert(q->end <= MAX_MQE_LEN); assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); assert(end < q->items[q->end - 1].location || q->items[q->end - 1].type == MQE_END); char q_trimmed_ra = 0; assert(end <= (s64a)q->length || !q->hlength); /* due to reverse accel in block mode some queues may work on a truncated * buffer */ if (q->items[q->cur].location > end) { return 1; } if (end > (s64a)q->length) { end = q->length; q_trimmed_ra = 1; } char q_trimmed = 0; if (!nfaQueueCanMatch(nfa, q, end, &q_trimmed)) { if (q->report_current) { nfaReportCurrentMatches(nfa, q); q->report_current = 0; } return 0; } char rv = nfaQueueExec2_i(nfa, q, end); assert(!q->report_current); DEBUG_PRINTF("returned rv=%d, q_trimmed=%d\n", rv, q_trimmed); if (rv == MO_MATCHES_PENDING) { if (q_trimmed) { // We need to "fix" the queue so that subsequent operations must // trim it as well. assert(q->end > 0); assert(nfa->maxOffset); q->items[q->end - 1].location = nfa->maxOffset + 1; } return rv; } return rv && !q_trimmed && !q_trimmed_ra; } char nfaReportCurrentMatches(const struct NFA *nfa, struct mq *q) { DISPATCH_BY_NFA_TYPE(_reportCurrent(nfa, q)); return 0; } char nfaInAcceptState(const struct NFA *nfa, ReportID report, struct mq *q) { DISPATCH_BY_NFA_TYPE(_inAccept(nfa, report, q)); return 0; } char nfaInAnyAcceptState(const struct NFA *nfa, struct mq *q) { DISPATCH_BY_NFA_TYPE(_inAnyAccept(nfa, q)); return 0; } char nfaQueueExecRose(const struct NFA *nfa, struct mq *q, ReportID r) { DEBUG_PRINTF("nfa=%p\n", nfa); #ifdef DEBUG debugQueue(q); #endif assert(q && !q->context && q->state); assert(q->cur <= q->end); assert(q->end <= MAX_MQE_LEN); assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); assert(!q->report_current); return nfaQueueExecRose_i(nfa, q, r); } char nfaBlockExecReverse(const struct NFA *nfa, u64a offset, const u8 *buf, size_t buflen, const u8 *hbuf, size_t hlen, NfaCallback callback, void *context) { assert(nfa); assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); DISPATCH_BY_NFA_TYPE(_B_Reverse(nfa, offset, buf, buflen, hbuf, hlen, callback, context)); return 0; } char nfaQueueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc) { assert(nfa && q); assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); DISPATCH_BY_NFA_TYPE(_queueCompressState(nfa, q, loc)); return 0; } char nfaExpandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key) { assert(nfa && dest && src); assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); DISPATCH_BY_NFA_TYPE(_expandState(nfa, dest, src, offset, key)); return 0; } char nfaInitCompressedState(const struct NFA *nfa, u64a offset, void *state, u8 key) { assert(nfa && state); assert(ISALIGNED_CL(nfa) && ISALIGNED_CL(getImplNfa(nfa))); DISPATCH_BY_NFA_TYPE(_initCompressedState(nfa, offset, state, key)); return 0; } enum nfa_zombie_status nfaGetZombieStatus(const struct NFA *nfa, struct mq *q, s64a loc) { DISPATCH_BY_NFA_TYPE(_zombie_status(nfa, q, loc)); return NFA_ZOMBIE_NO; } hyperscan-4.4.1/src/nfa/castle_internal.h0000644000175000017500000001245113055426554021155 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Castle: multi-tenant repeat engine, data structures. */ #ifndef NFA_CASTLE_INTERNAL_H #define NFA_CASTLE_INTERNAL_H #include "ue2common.h" #include "repeat_internal.h" struct SubCastle { ReportID report; //!< report to raise on match u32 fullStateOffset; //!< offset within full state (scratch) u32 streamStateOffset; //!< offset within stream state u32 repeatInfoOffset; //!< offset of RepeatInfo structure // relative to the start of SubCastle u32 exclusiveId; //!< exclusive group id of this SubCastle, // set to the number of SubCastles in Castle // if it is not exclusive }; #define CASTLE_DOT 0 #define CASTLE_VERM 1 #define CASTLE_NVERM 2 #define CASTLE_SHUFTI 3 #define CASTLE_TRUFFLE 4 enum ExclusiveType { NOT_EXCLUSIVE, //!< no subcastles are exclusive EXCLUSIVE, //!< a subset of subcastles are exclusive PURE_EXCLUSIVE //!< all subcastles are exclusive }; /** * \brief Castle engine structure. * * A Castle is a collection of repeats that all share the same character * reachability. * * The whole engine is laid out in memory as: * * - struct NFA * - struct Castle * - struct SubCastle[numRepeats] * - tables for sparse model repeats * - sparse iterator for subcastles that may be stale * * Castle stores an "active repeats" multibit in stream state, followed by the * packed repeat state for each SubCastle. If there are both exclusive and * non-exclusive SubCastle groups, we use an active id for each exclusive group * and a multibit for the non-exclusive group. We also store an "active * exclusive groups" multibit for exclusive groups. If all SubCastles are mutual * exclusive, we remove "active repeats" multibit from stream state. * * Castle stream state: * * * * |---| * * | | active subengine id for exclusive group 1 * * |---| * * | | active subengine id for exclusive group 2(if necessary) * * |---| * * ... * * |---| * * | | "active repeats" multibit for non-exclusive subcastles * * | | (if not all subcastles are exclusive) * * |---| * * | | active multibit for exclusive groups * * | | * * |---| * * ||-|| common pool of stream state for exclusive group 1 * * ||-|| * * |---| * * ||-|| common pool of stream state for exclusive group 2(if necessary) * * ||-|| * * |---| * * ... * * |---| * * | | stream state for each non-exclusive subcastles * * ... * * | | * * |---| * * In full state (stored in scratch space) it stores a temporary multibit over * the repeats (used by \ref castleMatchLoop), followed by the repeat control * blocks for each SubCastle. */ struct ALIGN_AVX_DIRECTIVE Castle { u32 numRepeats; //!< number of repeats in Castle u32 numGroups; //!< number of exclusive groups u8 type; //!< tells us which scanning mechanism (below) to use u8 exclusive; //!< tells us if there are mutual exclusive SubCastles u8 activeIdxSize; //!< number of bytes in stream state to store // active SubCastle id for exclusive mode u32 activeOffset; //!< offset to active multibit for non-exclusive // SubCastles u32 staleIterOffset; //!< offset to a sparse iterator to check for stale // sub castles u32 groupIterOffset; //!< offset to a iterator to check the aliveness of // exclusive groups union { struct { char c; } verm; struct { m128 mask_lo; m128 mask_hi; } shuf; struct { m128 mask1; m128 mask2; } truffle; } u; }; #endif // NFA_CASTLE_INTERNAL_H hyperscan-4.4.1/src/nfa/mcsheng_dump.cpp0000644000175000017500000002764413055426554021024 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "mcsheng_dump.h" #include "accel.h" #include "accel_dump.h" #include "nfa_dump_internal.h" #include "nfa_internal.h" #include "mcsheng_internal.h" #include "rdfa.h" #include "ue2common.h" #include "util/charreach.h" #include "util/dump_charclass.h" #include "util/dump_util.h" #include "util/unaligned.h" #include #include #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { static const mstate_aux *getAux(const NFA *n, dstate_id_t i) { auto *m = (const mcsheng *)getImplNfa(n); auto *aux_base = (const mstate_aux *)((const char *)n + m->aux_offset); const mstate_aux *aux = aux_base + i; assert((const char *)aux < (const char *)n + m->length); return aux; } static void next_states(const NFA *n, u16 s, u16 *t) { const mcsheng *m = (const mcsheng *)getImplNfa(n); const mstate_aux *aux = getAux(n, s); const u32 as = m->alphaShift; assert(s != DEAD_STATE); if (s < m->sheng_end) { for (u16 c = 0; c < N_CHARS; c++) { u8 sheng_s = s - 1; auto trans_for_c = (const char *)&m->sheng_masks[c]; assert(sheng_s < sizeof(m128)); u8 raw_succ = trans_for_c[sheng_s]; if (raw_succ == m->sheng_end - 1) { t[c] = DEAD_STATE; } else if (raw_succ < m->sheng_end) { t[c] = raw_succ + 1; } else { t[c] = raw_succ; } } } else if (n->type == MCSHENG_NFA_8) { const u8 *succ_table = (const u8 *)((const char *)m + sizeof(mcsheng)); for (u16 c = 0; c < N_CHARS; c++) { u32 normal_id = s - m->sheng_end; t[c] = succ_table[(normal_id << as) + m->remap[c]]; } } else { u16 base_s = s; const char *winfo_base = (const char *)n + m->sherman_offset; const char *state_base = winfo_base + SHERMAN_FIXED_SIZE * (s - m->sherman_limit); if (s >= m->sherman_limit) { base_s = unaligned_load_u16(state_base + SHERMAN_DADDY_OFFSET); assert(base_s >= m->sheng_end); } const u16 *succ_table = (const u16 *)((const char *)m + sizeof(mcsheng)); for (u16 c = 0; c < N_CHARS; c++) { u32 normal_id = base_s - m->sheng_end; t[c] = succ_table[(normal_id << as) + m->remap[c]]; } if (s >= m->sherman_limit) { UNUSED char type = *(state_base + SHERMAN_TYPE_OFFSET); assert(type == SHERMAN_STATE); u8 len = *(const u8 *)(SHERMAN_LEN_OFFSET + state_base); const char *chars = state_base + SHERMAN_CHARS_OFFSET; const u16 *states = (const u16 *)(state_base + SHERMAN_STATES_OFFSET(len)); for (u8 i = 0; i < len; i++) { for (u16 c = 0; c < N_CHARS; c++) { if (m->remap[c] == chars[i]) { t[c] = unaligned_load_u16((const u8*)&states[i]); } } } } for (u16 c = 0; c < N_CHARS; c++) { t[c] &= STATE_MASK; } } t[TOP] = aux->top & STATE_MASK; } static void describeEdge(FILE *f, const mcsheng *m, const u16 *t, u16 i) { for (u16 s = 0; s < N_CHARS; s++) { if (!t[s]) { continue; } u16 ss; for (ss = 0; ss < s; ss++) { if (t[s] == t[ss]) { break; } } if (ss != s) { continue; } CharReach reach; for (ss = s; ss < 256; ss++) { if (t[s] == t[ss]) { reach.set(ss); } } fprintf(f, "%u -> %u [ ", i, t[s]); if (i < m->sheng_end && t[s] < m->sheng_end) { fprintf(f, "color = red, fontcolor = red "); } fprintf(f, "label = \""); describeClass(f, reach, 5, CC_OUT_DOT); fprintf(f, "\" ];\n"); } } static void dumpAccelDot(FILE *f, u16 i, const union AccelAux *accel) { switch(accel->accel_type) { case ACCEL_NONE: break; case ACCEL_VERM: case ACCEL_VERM_NOCASE: case ACCEL_DVERM: case ACCEL_DVERM_NOCASE: fprintf(f, "%u [ color = forestgreen style=diagonals];\n", i); break; case ACCEL_SHUFTI: case ACCEL_DSHUFTI: case ACCEL_TRUFFLE: fprintf(f, "%u [ color = darkgreen style=diagonals ];\n", i); break; default: fprintf(f, "%u [ color = yellow style=diagonals ];\n", i); break; } } static void describeNode(const NFA *n, const mcsheng *m, u16 i, FILE *f) { const mstate_aux *aux = getAux(n, i); bool isSherman = m->sherman_limit && i >= m->sherman_limit; fprintf(f, "%u [ width = 1, fixedsize = true, fontsize = 12, " "label = \"%u%s\" ]; \n", i, i, isSherman ? "w":""); if (aux->accel_offset) { dumpAccelDot(f, i, (const union AccelAux *) ((const char *)m + aux->accel_offset)); } if (i && i < m->sheng_end) { fprintf(f, "%u [color = red, fontcolor = red]; \n", i); } if (aux->accept_eod) { fprintf(f, "%u [ color = darkorchid ];\n", i); } if (aux->accept) { fprintf(f, "%u [ shape = doublecircle ];\n", i); } if (aux->top && aux->top != i) { fprintf(f, "%u -> %u [color = darkgoldenrod weight=0.1 ]\n", i, aux->top); } if (i == m->start_anchored) { fprintf(f, "STARTA -> %u [color = blue ]\n", i); } if (i == m->start_floating) { fprintf(f, "STARTF -> %u [color = red ]\n", i); } if (isSherman) { const char *winfo_base = (const char *)n + m->sherman_offset; const char *state_base = winfo_base + SHERMAN_FIXED_SIZE * (i - m->sherman_limit); assert(state_base < (const char *)m + m->length - sizeof(NFA)); UNUSED u8 type = *(const u8 *)(state_base + SHERMAN_TYPE_OFFSET); assert(type == SHERMAN_STATE); fprintf(f, "%u [ fillcolor = lightblue style=filled ];\n", i); u16 daddy = *(const u16 *)(state_base + SHERMAN_DADDY_OFFSET); if (daddy) { fprintf(f, "%u -> %u [ color=royalblue style=dashed weight=0.1]\n", i, daddy); } } if (i && i < m->sheng_end) { fprintf(f, "subgraph cluster_sheng { %u } \n", i); } } static void dumpDotPreambleDfa(FILE *f) { dumpDotPreamble(f); // DFA specific additions. fprintf(f, "STARTF [style=invis];\n"); fprintf(f, "STARTA [style=invis];\n"); fprintf(f, "0 [style=invis];\n"); fprintf(f, "subgraph cluster_sheng { style = dashed }\n"); } static void dump_dot_16(const NFA *nfa, FILE *f) { auto *m = (const mcsheng *)getImplNfa(nfa); dumpDotPreambleDfa(f); for (u16 i = 1; i < m->state_count; i++) { describeNode(nfa, m, i, f); u16 t[ALPHABET_SIZE]; next_states(nfa, i, t); describeEdge(f, m, t, i); } fprintf(f, "}\n"); } static void dump_dot_8(const NFA *nfa, FILE *f) { auto m = (const mcsheng *)getImplNfa(nfa); dumpDotPreambleDfa(f); for (u16 i = 1; i < m->state_count; i++) { describeNode(nfa, m, i, f); u16 t[ALPHABET_SIZE]; next_states(nfa, i, t); describeEdge(f, m, t, i); } fprintf(f, "}\n"); } static void dumpAccelMasks(FILE *f, const mcsheng *m, const mstate_aux *aux) { fprintf(f, "\n"); fprintf(f, "Acceleration\n"); fprintf(f, "------------\n"); for (u16 i = 0; i < m->state_count; i++) { if (!aux[i].accel_offset) { continue; } auto accel = (const AccelAux *)((const char *)m + aux[i].accel_offset); fprintf(f, "%05hu ", i); dumpAccelInfo(f, *accel); } } static void describeAlphabet(FILE *f, const mcsheng *m) { map rev; for (u16 i = 0; i < N_CHARS; i++) { rev[m->remap[i]].clear(); } for (u16 i = 0; i < N_CHARS; i++) { rev[m->remap[i]].set(i); } map::const_iterator it; fprintf(f, "\nAlphabet\n"); for (it = rev.begin(); it != rev.end(); ++it) { fprintf(f, "%3hhu: ", it->first); describeClass(f, it->second, 10240, CC_OUT_TEXT); fprintf(f, "\n"); } fprintf(f, "\n"); } static void dumpCommonHeader(FILE *f, const mcsheng *m) { fprintf(f, "report: %u, states: %u, length: %u\n", m->arb_report, m->state_count, m->length); fprintf(f, "astart: %hu, fstart: %hu\n", m->start_anchored, m->start_floating); fprintf(f, "single accept: %d, has_accel: %d\n", !!(int)m->flags & MCSHENG_FLAG_SINGLE, m->has_accel); fprintf(f, "sheng_end: %hu\n", m->sheng_end); fprintf(f, "sheng_accel_limit: %hu\n", m->sheng_accel_limit); } static void dump_text_16(const NFA *nfa, FILE *f) { auto *m = (const mcsheng *)getImplNfa(nfa); auto *aux = (const mstate_aux *)((const char *)nfa + m->aux_offset); fprintf(f, "mcsheng 16\n"); dumpCommonHeader(f, m); fprintf(f, "sherman_limit: %d, sherman_end: %d\n", (int)m->sherman_limit, (int)m->sherman_end); fprintf(f, "\n"); describeAlphabet(f, m); dumpAccelMasks(f, m, aux); fprintf(f, "\n"); dumpTextReverse(nfa, f); } static void dump_text_8(const NFA *nfa, FILE *f) { auto m = (const mcsheng *)getImplNfa(nfa); auto aux = (const mstate_aux *)((const char *)nfa + m->aux_offset); fprintf(f, "mcsheng 8\n"); dumpCommonHeader(f, m); fprintf(f, "accel_limit: %hu, accept_limit %hu\n", m->accel_limit_8, m->accept_limit_8); fprintf(f, "\n"); describeAlphabet(f, m); dumpAccelMasks(f, m, aux); fprintf(f, "\n"); dumpTextReverse(nfa, f); } void nfaExecMcSheng16_dump(const NFA *nfa, const string &base) { assert(nfa->type == MCSHENG_NFA_16); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); dump_text_16(nfa, f); fclose(f); f = fopen_or_throw((base + ".dot").c_str(), "w"); dump_dot_16(nfa, f); fclose(f); } void nfaExecMcSheng8_dump(const NFA *nfa, const string &base) { assert(nfa->type == MCSHENG_NFA_8); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); dump_text_8(nfa, f); fclose(f); f = fopen_or_throw((base + ".dot").c_str(), "w"); dump_dot_8(nfa, f); fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfa/castle_dump.cpp0000644000175000017500000001054713055426554020645 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Castle: multi-tenant repeat engine, dump code. */ #include "config.h" #include "castle_dump.h" #include "castle_internal.h" #include "nfa_dump_internal.h" #include "nfa_internal.h" #include "shufticompile.h" #include "trufflecompile.h" #include "util/charreach.h" #include "util/dump_util.h" #include "util/dump_charclass.h" #ifndef DUMP_SUPPORT #error No dump support! #endif /* Note: No dot files for castle */ using namespace std; namespace ue2 { static void dumpTextSubCastle(const SubCastle &sub, FILE *f) { const RepeatInfo *info = (const RepeatInfo *)((const char *)&sub + sub.repeatInfoOffset); fprintf(f, " repeat model: %s\n", repeatTypeName(info->type)); fprintf(f, " repeat bounds: {%u, %u}\n", info->repeatMin, info->repeatMax); fprintf(f, " min period: %u\n", info->minPeriod); fprintf(f, " report: %u\n", sub.report); fprintf(f, " full state offset: %u\n", sub.fullStateOffset); fprintf(f, " stream state offset: %u\n", sub.streamStateOffset); fprintf(f, "\n"); } void nfaExecCastle_dump(const struct NFA *nfa, const string &base) { const Castle *c = (const Castle *)getImplNfa(nfa); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); fprintf(f, "Castle multi-tenant repeat engine\n"); fprintf(f, "\n"); fprintf(f, "Number of repeat tenants: %u\n", c->numRepeats); fprintf(f, "Scan type: "); switch (c->type) { case CASTLE_DOT: fprintf(f, "dot\n"); break; case CASTLE_VERM: fprintf(f, "verm, scanning for 0x%02x\n", c->u.verm.c); break; case CASTLE_NVERM: fprintf(f, "negated verm, scanning for 0x%02x\n", c->u.verm.c); break; case CASTLE_SHUFTI: { const CharReach cr = shufti2cr((const u8 *)&c->u.shuf.mask_lo, (const u8 *)&c->u.shuf.mask_hi); fprintf(f, "shufti, scanning for %s (%zu chars)\n", describeClass(cr).c_str(), cr.count()); break; } case CASTLE_TRUFFLE: { const CharReach cr = truffle2cr((const u8 *)&c->u.truffle.mask1, (const u8 *)&c->u.truffle.mask2); fprintf(f, "truffle, scanning for %s (%zu chars)\n", describeClass(cr).c_str(), cr.count()); break; } default: fprintf(f, "unknown type %u\n", c->type); break; } fprintf(f, "Stale Iter Offset: %u\n", c->staleIterOffset); fprintf(f, "\n"); dumpTextReverse(nfa, f); fprintf(f, "\n"); const SubCastle *sub = (const SubCastle *)((const char *)c + sizeof(Castle)); for (u32 i = 0; i < c->numRepeats; i++) { fprintf(f, "Sub %u:\n", i); dumpTextSubCastle(sub[i], f); } fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfa/limex_state_impl.h0000644000175000017500000001306013055426554021342 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA stream state handling. */ #include "util/join.h" #include "util/partial_store.h" #include "util/state_compress.h" #include #if !defined(SIZE) || !defined(STATE_T) || !defined(LOAD_FROM_ENG) # error Must define SIZE, STATE_T, LOAD_FROM_ENG in includer. #endif #define IMPL_NFA_T JOIN(struct LimExNFA, SIZE) #define COMMON_T JOIN(NFACommon, SIZE) #define REACHMASK_FN JOIN(moNfaReachMask, SIZE) #define COMPRESS_FN JOIN(moNfaCompressState, SIZE) #define EXPAND_FN JOIN(moNfaExpandState, SIZE) #define COMPRESSED_STORE_FN JOIN(store_compressed_, STATE_T) #define COMPRESSED_LOAD_FN JOIN(load_compressed_, STATE_T) #define PARTIAL_STORE_FN JOIN(partial_store_, STATE_T) #define PARTIAL_LOAD_FN JOIN(partial_load_, STATE_T) #define OR_STATE JOIN(or_, STATE_T) #define AND_STATE JOIN(and_, STATE_T) #define ISZERO_STATE JOIN(isZero_, STATE_T) static really_inline const ENG_STATE_T *get_reach_table(const IMPL_NFA_T *limex) { const ENG_STATE_T *reach = (const ENG_STATE_T *)((const char *)limex + sizeof(*limex)); assert(ISALIGNED_N(reach, alignof(ENG_STATE_T))); return reach; } static really_inline STATE_T REACHMASK_FN(const IMPL_NFA_T *limex, const u8 key) { const ENG_STATE_T *reach = get_reach_table(limex); return LOAD_FROM_ENG(&reach[limex->reachMap[key]]); } static really_inline void COMPRESS_FN(const IMPL_NFA_T *limex, u8 *dest, const STATE_T *src, u8 key) { assert(ISALIGNED_N(src, alignof(STATE_T))); STATE_T a_src = *src; DEBUG_PRINTF("compress state: %p -> %p\n", src, dest); if (!(limex->flags & LIMEX_FLAG_COMPRESS_STATE)) { // No key-based compression, just a partial store. DEBUG_PRINTF("store state into %u bytes\n", limex->stateSize); PARTIAL_STORE_FN(dest, a_src, limex->stateSize); } else { DEBUG_PRINTF("compress state, key=%hhx\n", key); STATE_T reachmask = REACHMASK_FN(limex, key); // Masked compression means that we mask off the initDs states and // provide a shortcut for the all-zeroes case. Note that these must be // switched on in the EXPAND call below. if (limex->flags & LIMEX_FLAG_COMPRESS_MASKED) { STATE_T s = AND_STATE(LOAD_FROM_ENG(&limex->compressMask), a_src); if (ISZERO_STATE(s)) { DEBUG_PRINTF("after compression mask, all states are zero\n"); memset(dest, 0, limex->stateSize); return; } STATE_T mask = AND_STATE(LOAD_FROM_ENG(&limex->compressMask), reachmask); COMPRESSED_STORE_FN(dest, &s, &mask, limex->stateSize); } else { COMPRESSED_STORE_FN(dest, src, &reachmask, limex->stateSize); } } } static really_inline void EXPAND_FN(const IMPL_NFA_T *limex, STATE_T *dest, const u8 *src, u8 key) { assert(ISALIGNED_N(dest, alignof(STATE_T))); DEBUG_PRINTF("expand state: %p -> %p\n", src, dest); if (!(limex->flags & LIMEX_FLAG_COMPRESS_STATE)) { // No key-based compression, just a partial load. DEBUG_PRINTF("load state from %u bytes\n", limex->stateSize); *dest = PARTIAL_LOAD_FN(src, limex->stateSize); } else { DEBUG_PRINTF("expand state, key=%hhx\n", key); STATE_T reachmask = REACHMASK_FN(limex, key); if (limex->flags & LIMEX_FLAG_COMPRESS_MASKED) { STATE_T mask = AND_STATE(LOAD_FROM_ENG(&limex->compressMask), reachmask); COMPRESSED_LOAD_FN(dest, src, &mask, limex->stateSize); *dest = OR_STATE(LOAD_FROM_ENG(&limex->initDS), *dest); } else { COMPRESSED_LOAD_FN(dest, src, &reachmask, limex->stateSize); } } } #undef IMPL_NFA_T #undef COMMON_T #undef REACHMASK_FN #undef COMPRESS_FN #undef EXPAND_FN #undef COMPRESSED_STORE_FN #undef COMPRESSED_LOAD_FN #undef PARTIAL_STORE_FN #undef PARTIAL_LOAD_FN #undef OR_STATE #undef AND_STATE #undef ISZERO_STATE hyperscan-4.4.1/src/nfa/lbr_common_impl.h0000644000175000017500000003672113055426554021164 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Large Bounded Repeat (LBR) engine: runtime impl X-macros. */ #include "util/join.h" #define ENGINE_EXEC_NAME JOIN(nfaExecLbr, ENGINE_ROOT_NAME) #define EXEC_FN JOIN(lbrExec, ENGINE_ROOT_NAME) #define FWDSCAN_FN JOIN(lbrFwdScan, ENGINE_ROOT_NAME) #define REVSCAN_FN JOIN(lbrRevScan, ENGINE_ROOT_NAME) char JOIN(ENGINE_EXEC_NAME, _queueCompressState)(const struct NFA *nfa, const struct mq *q, s64a loc) { assert(nfa && q); assert(isLbrType(nfa->type)); DEBUG_PRINTF("entry, q->offset=%llu, loc=%lld\n", q->offset, loc); const struct lbr_common *l = getImplNfa(nfa); const struct lbr_state *lstate = (const struct lbr_state *)q->state; u64a offset = q->offset + loc; lbrCompressState(l, offset, lstate, q->streamState); return 0; } char JOIN(ENGINE_EXEC_NAME, _expandState)(const struct NFA *nfa, void *dest, const void *src, u64a offset, UNUSED u8 key) { assert(nfa); assert(isLbrType(nfa->type)); DEBUG_PRINTF("entry, offset=%llu\n", offset); const struct lbr_common *l = getImplNfa(nfa); struct lbr_state *lstate = (struct lbr_state *)dest; lbrExpandState(l, offset, src, lstate); return 0; } char JOIN(ENGINE_EXEC_NAME, _reportCurrent)(const struct NFA *nfa, struct mq *q) { assert(nfa && q); assert(isLbrType(nfa->type)); const struct lbr_common *l = getImplNfa(nfa); u64a offset = q_cur_offset(q); DEBUG_PRINTF("firing match %u at %llu\n", l->report, offset); q->cb(0, offset, l->report, q->context); return 0; } char JOIN(ENGINE_EXEC_NAME, _inAccept)(const struct NFA *nfa, ReportID report, struct mq *q) { assert(nfa && q); assert(isLbrType(nfa->type)); DEBUG_PRINTF("entry\n"); const struct lbr_common *l = getImplNfa(nfa); const struct RepeatInfo *info = getRepeatInfo(l); const struct lbr_state *lstate = (const struct lbr_state *)q->state; if (repeatIsDead(info, lstate)) { DEBUG_PRINTF("repeat is dead\n"); return 0; } u64a offset = q->offset + q_last_loc(q); return lbrInAccept(l, lstate, q->streamState, offset, report); } char JOIN(ENGINE_EXEC_NAME, _inAnyAccept)(const struct NFA *nfa, struct mq *q) { assert(nfa && q); assert(isLbrType(nfa->type)); DEBUG_PRINTF("entry\n"); const struct lbr_common *l = getImplNfa(nfa); return JOIN(ENGINE_EXEC_NAME, _inAccept)(nfa, l->report, q); } char JOIN(ENGINE_EXEC_NAME, _queueInitState)(const struct NFA *nfa, struct mq *q) { assert(nfa && q); assert(isLbrType(nfa->type)); DEBUG_PRINTF("entry\n"); const struct lbr_common *l = getImplNfa(nfa); const struct RepeatInfo *info = getRepeatInfo(l); assert(q->state); struct lbr_state *lstate = (struct lbr_state *)q->state; assert(ISALIGNED(lstate)); lstate->lastEscape = 0; clearRepeat(info, lstate); return 0; } char JOIN(ENGINE_EXEC_NAME, _initCompressedState)(const struct NFA *nfa, u64a offset, void *state, UNUSED u8 key) { assert(nfa && state); assert(isLbrType(nfa->type)); DEBUG_PRINTF("entry\n"); const struct lbr_common *l = getImplNfa(nfa); const struct RepeatInfo *info = getRepeatInfo(l); struct lbr_state lstate; // temp control block on stack. clearRepeat(info, &lstate); lbrTop(l, &lstate, state, offset); lbrCompressState(l, offset, &lstate, state); return 1; // LBR is alive } // FIXME: this function could be much simpler for a Dot LBR, as all it needs to // do is find the next top. static really_inline char JOIN(ENGINE_EXEC_NAME, _TopScan)(const struct NFA *nfa, struct mq *q, s64a end) { const struct lbr_common *l = getImplNfa(nfa); const struct RepeatInfo *info = getRepeatInfo(l); const u64a offset = q->offset; struct lbr_state *lstate = (struct lbr_state *)q->state; assert(ISALIGNED(lstate)); assert(repeatIsDead(info, lstate)); assert(q->cur < q->end); DEBUG_PRINTF("entry, end=%lld, offset=%llu, lastEscape=%llu\n", end, offset, lstate->lastEscape); while (1) { // Find the next top with location >= the last escape we saw. for (; q->cur < q->end && q_cur_loc(q) <= end; q->cur++) { u32 event = q_cur_type(q); if ((event == MQE_TOP || event == MQE_TOP_FIRST) && q_cur_offset(q) >= lstate->lastEscape) { goto found_top; } DEBUG_PRINTF("skip event type=%u offset=%lld\n", event, q_cur_offset(q)); } // No more tops, we're done. break; found_top:; assert(q->cur < q->end); u64a sp = q_cur_offset(q); u64a first_match = sp + info->repeatMin; DEBUG_PRINTF("first possible match is at %llu\n", first_match); u64a ep = MIN(MIN(end, (s64a)q->length) + offset, first_match); if (ep > sp && sp >= offset) { size_t eloc; DEBUG_PRINTF("rev b%llu e%llu/%zu\n", sp - offset, ep - offset, q->length); assert(ep - offset <= q->length); if (REVSCAN_FN(nfa, q->buffer, sp - offset, ep - offset, &eloc)) { DEBUG_PRINTF("escape found at %llu\n", offset + eloc); lstate->lastEscape = eloc; q->cur++; continue; } } lbrTop(l, lstate, q->streamState, sp); return 1; } DEBUG_PRINTF("exhausted queue\n"); return 0; } static really_inline char JOIN(ENGINE_EXEC_NAME, _Q_i)(const struct NFA *nfa, struct mq *q, s64a end, enum MatchMode mode) { assert(nfa && q); assert(isLbrType(nfa->type)); const struct lbr_common *l = getImplNfa(nfa); const struct RepeatInfo *info = getRepeatInfo(l); struct lbr_state *lstate = (struct lbr_state *)q->state; assert(ISALIGNED(lstate)); if (q->report_current) { DEBUG_PRINTF("report_current: fire match at %llu\n", q_cur_offset(q)); int rv = q->cb(0, q_cur_offset(q), l->report, q->context); q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } if (q->cur == q->end) { return 1; } assert(q->cur + 1 < q->end); /* require at least two items */ assert(q_cur_type(q) == MQE_START); u64a sp = q_cur_offset(q); q->cur++; DEBUG_PRINTF("sp=%llu, abs_end=%llu\n", sp, end + q->offset); while (q->cur < q->end) { DEBUG_PRINTF("q item type=%d offset=%llu\n", q_cur_type(q), q_cur_offset(q)); assert(sp >= q->offset); // not in history if (repeatIsDead(info, lstate)) { DEBUG_PRINTF("repeat is currently dead, skipping scan\n"); goto scan_done; } u64a ep = q_cur_offset(q); ep = MIN(ep, q->offset + end); if (sp < ep) { size_t eloc = 0; char escape_found = 0; DEBUG_PRINTF("scanning from sp=%llu to ep=%llu\n", sp, ep); assert(sp >= q->offset && ep >= q->offset); if (FWDSCAN_FN(nfa, q->buffer, sp - q->offset, ep - q->offset, &eloc)) { escape_found = 1; ep = q->offset + eloc; DEBUG_PRINTF("escape found at %llu\n", ep); assert(ep >= sp); } assert(sp <= ep); if (mode == STOP_AT_MATCH) { size_t mloc; if (lbrFindMatch(l, sp, ep, lstate, q->streamState, &mloc)) { DEBUG_PRINTF("storing match at %llu\n", sp + mloc); q->cur--; assert(q->cur < MAX_MQE_LEN); q->items[q->cur].type = MQE_START; q->items[q->cur].location = (s64a)(sp - q->offset) + mloc; return MO_MATCHES_PENDING; } } else { assert(mode == CALLBACK_OUTPUT); char rv = lbrMatchLoop(l, sp, ep, lstate, q->streamState, q->cb, q->context); if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } assert(rv == MO_CONTINUE_MATCHING); } if (escape_found) { DEBUG_PRINTF("clearing repeat due to escape\n"); clearRepeat(info, lstate); } } scan_done: if (q_cur_loc(q) > end) { q->cur--; assert(q->cur < MAX_MQE_LEN); q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; return MO_ALIVE; } if (repeatIsDead(info, lstate)) { if (!JOIN(ENGINE_EXEC_NAME, _TopScan)(nfa, q, end)) { assert(repeatIsDead(info, lstate)); if (q->cur < q->end && q_cur_loc(q) > end) { q->cur--; assert(q->cur < MAX_MQE_LEN); q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; return MO_ALIVE; } return 0; } DEBUG_PRINTF("cur offset = %llu\n", q_cur_offset(q)); } else { switch (q_cur_type(q)) { case MQE_TOP: case MQE_TOP_FIRST: lbrTop(l, lstate, q->streamState, q_cur_offset(q)); break; case MQE_START: case MQE_END: break; default: DEBUG_PRINTF("unhandled event %d!\n", q_cur_type(q)); assert(0); break; } } sp = q_cur_offset(q); q->cur++; } return lbrIsAlive(l, lstate, q->streamState, sp); } char JOIN(ENGINE_EXEC_NAME, _Q)(const struct NFA *nfa, struct mq *q, s64a end) { DEBUG_PRINTF("entry, offset=%llu, end=%lld\n", q->offset, end); return JOIN(ENGINE_EXEC_NAME, _Q_i)(nfa, q, end, CALLBACK_OUTPUT); } char JOIN(ENGINE_EXEC_NAME, _Q2)(const struct NFA *nfa, struct mq *q, s64a end) { DEBUG_PRINTF("entry, offset=%llu, end=%lld\n", q->offset, end); return JOIN(ENGINE_EXEC_NAME, _Q_i)(nfa, q, end, STOP_AT_MATCH); } static really_inline void JOIN(ENGINE_EXEC_NAME, _StreamSilent)(const struct NFA *nfa, struct mq *q, const u8 *buf, size_t length) { const struct lbr_common *l = getImplNfa(nfa); const struct RepeatInfo *info = getRepeatInfo(l); struct lbr_state *lstate = (struct lbr_state *)q->state; assert(ISALIGNED(lstate)); assert(!repeatIsDead(info, lstate)); // This call doesn't produce matches, so we elide the lbrMatchLoop call // entirely and just do escape scans to maintain the repeat. size_t eloc = 0; char escaped = FWDSCAN_FN(nfa, buf, 0, length, &eloc); if (escaped) { assert(eloc < length); DEBUG_PRINTF("escape found at %zu, clearing repeat\n", eloc); clearRepeat(info, lstate); } } // Rose infix path. char JOIN(ENGINE_EXEC_NAME, _QR)(const struct NFA *nfa, struct mq *q, ReportID report) { assert(nfa && q); assert(isLbrType(nfa->type)); if (q->cur == q->end) { return 1; } assert(q->cur + 1 < q->end); /* require at least two items */ assert(q_cur_type(q) == MQE_START); u64a sp = q_cur_offset(q); q->cur++; DEBUG_PRINTF("sp=%llu\n", sp); const struct lbr_common *l = getImplNfa(nfa); const struct RepeatInfo *info = getRepeatInfo(l); struct lbr_state *lstate = (struct lbr_state *)q->state; assert(ISALIGNED(lstate)); const s64a lastLoc = q_last_loc(q); while (q->cur < q->end) { DEBUG_PRINTF("q item type=%d offset=%llu\n", q_cur_type(q), q_cur_offset(q)); if (repeatIsDead(info, lstate)) { DEBUG_PRINTF("repeat is dead\n"); goto scan_done; } u64a ep = q_cur_offset(q); if (sp < q->offset) { DEBUG_PRINTF("HISTORY BUFFER SCAN\n"); assert(q->offset - sp <= q->hlength); u64a local_ep = MIN(q->offset, ep); const u8 *ptr = q->history + q->hlength + sp - q->offset; JOIN(ENGINE_EXEC_NAME, _StreamSilent)(nfa, q, ptr, local_ep - sp); sp = local_ep; } if (repeatIsDead(info, lstate)) { DEBUG_PRINTF("repeat is dead\n"); goto scan_done; } if (sp < ep) { DEBUG_PRINTF("MAIN BUFFER SCAN\n"); assert(ep - q->offset <= q->length); const u8 *ptr = q->buffer + sp - q->offset; JOIN(ENGINE_EXEC_NAME, _StreamSilent)(nfa, q, ptr, ep - sp); } if (repeatIsDead(info, lstate)) { scan_done: if (!JOIN(ENGINE_EXEC_NAME, _TopScan)(nfa, q, lastLoc)) { assert(repeatIsDead(info, lstate)); assert(q->cur == q->end); return 0; } } else { switch (q_cur_type(q)) { case MQE_TOP: case MQE_TOP_FIRST: lbrTop(l, lstate, q->streamState, q_cur_offset(q)); break; case MQE_START: case MQE_END: break; default: DEBUG_PRINTF("unhandled event %d!\n", q_cur_type(q)); assert(0); break; } } sp = q_cur_offset(q); q->cur++; } if (repeatIsDead(info, lstate)) { DEBUG_PRINTF("repeat is dead\n"); return 0; } if (lbrInAccept(l, lstate, q->streamState, sp, report)) { return MO_MATCHES_PENDING; } return lbrIsActive(l, lstate, q->streamState, sp); } #undef ENGINE_EXEC_NAME #undef EXEC_FN #undef FWDSCAN_FN #undef REVSCAN_FN #undef ENGINE_ROOT_NAME hyperscan-4.4.1/src/nfa/multiaccel_shift.h0000644000175000017500000001011013055426554021313 0ustar sleuthkidsleuthkid/* * 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_ */ hyperscan-4.4.1/src/nfa/trufflecompile.cpp0000644000175000017500000000676113055426554021370 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Truffle compiler * * truffle is always able to represent an entire character class, providing a * backstop to other acceleration engines. */ #include "trufflecompile.h" #include "ue2common.h" #include "util/charreach.h" #include "util/simd_types.h" #include "util/dump_mask.h" using namespace std; namespace ue2 { /* * To represent an entire charclass (256 chars), truffle uses two 128 bit * masks - the first is for chars that do not have the high bit/bit 7 set, * i.e. chars {0..127}. The second mask is for chars with bit 7 set. * * Each char to be represented is split into the low nibble (bits {0..3}) and * bits {4,5,6} - the low nibble is the offset into the mask and the value of * bits 456 is the bit that is set at that offset. */ void truffleBuildMasks(const CharReach &cr, u8 *shuf_mask_lo_highclear, u8 *shuf_mask_lo_highset) { memset(shuf_mask_lo_highset, 0, sizeof(m128)); memset(shuf_mask_lo_highclear, 0, sizeof(m128)); for (size_t v = cr.find_first(); v != CharReach::npos; v = cr.find_next(v)) { DEBUG_PRINTF("adding 0x%02x to %s\n", (u8)v, (v & 0x80) ? "highset" : "highclear"); u8 *change_mask = (v & 0x80) ? shuf_mask_lo_highset : shuf_mask_lo_highclear; u8 low_nibble = v & 0xf; u8 bits_456 = (v & 0x70) >> 4; change_mask[low_nibble] |= 1 << bits_456; } } /* * Reconstruct the charclass that the truffle masks represent */ CharReach truffle2cr(const u8 *highclear, const u8 *highset) { CharReach cr; for (u8 i = 0; i < 16; i++) { u32 bits_456 = highclear[i]; while (bits_456) { u32 pos = findAndClearLSB_32(&bits_456); assert(pos < 8); cr.set(pos << 4 | i); } bits_456 = highset[i]; while (bits_456) { u32 pos = findAndClearLSB_32(&bits_456); assert(pos < 8); cr.set(0x80 | pos << 4 | i); } } return cr; } } // namespc hyperscan-4.4.1/src/nfa/lbr_internal.h0000644000175000017500000000520613055426554020461 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Large Bounded Repeat (LBR): data structures. */ #ifndef LBR_INTERNAL_H #define LBR_INTERNAL_H #ifdef __cplusplus extern "C" { #endif #include "repeat_internal.h" /** \brief Common LBR header. */ struct lbr_common { u32 repeatInfoOffset; //!< offset of RepeatInfo structure relative // to the start of lbr_common ReportID report; //!< report to raise on match }; struct lbr_dot { struct lbr_common common; }; struct lbr_verm { struct lbr_common common; char c; //!< escape char }; struct lbr_shuf { struct lbr_common common; m128 mask_lo; //!< shufti lo mask for escape chars m128 mask_hi; //!< shufti hi mask for escape chars }; struct lbr_truf { struct lbr_common common; m128 mask1; m128 mask2; }; /** \brief Uncompressed ("full") state structure used by the LBR. This is * stored in scratch, not in stream state. */ struct lbr_state { u64a lastEscape; //!< \brief offset of last escape seen. union RepeatControl ctrl; //!< \brief repeat control block. */ }; #ifdef __cplusplus } #endif #endif // LBR_INTERNAL_H hyperscan-4.4.1/src/nfa/limex_simd512.c0000644000175000017500000000417713055426554020371 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief LimEx NFA: 512-bit SIMD runtime implementations. */ //#define DEBUG_INPUT //#define DEBUG_EXCEPTIONS #include "limex.h" #include "accel.h" #include "limex_internal.h" #include "nfa_internal.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" // Common code #include "limex_runtime.h" #define SIZE 512 #define STATE_T m512 #define ENG_STATE_T m512 #define LOAD_FROM_ENG load_m512 #include "limex_exceptional.h" #include "limex_state_impl.h" #define INLINE_ATTR really_inline #include "limex_common_impl.h" #include "limex_runtime_impl.h" hyperscan-4.4.1/src/nfa/limex_runtime.h0000644000175000017500000001662713055426554020700 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file \brief Limex Execution Engine Or: How I Learned To Stop Worrying And Love The Preprocessor This file includes utility functions which do not depend on the size of the state or shift masks directly. */ #ifndef LIMEX_RUNTIME_H #define LIMEX_RUNTIME_H #include "limex_accel.h" #include "limex_context.h" #include "limex_internal.h" #include "nfa_api_util.h" #include "nfa_internal.h" #include "util/uniform_ops.h" //////////////////////////////////////////////////////////////////////////// // LimEx NFA implementation code - common macros //////////////////////////////////////////////////////////////////////////// #ifdef DEBUG_INPUT #include #define DUMP_INPUT(index) DEBUG_PRINTF("input %p i=%zu: %02hhx (%c)\n", \ &input[index], index, input[index], \ isprint(input[index]) ? input[index] : ' ') #else #define DUMP_INPUT(index) do { } while(0) #endif #define NO_OUTPUT 0 #define CALLBACK_OUTPUT 1 #define FIRST_BYTE 16 enum CacheResult { DO_NOT_CACHE_RESULT, CACHE_RESULT, DO_NOT_CACHE_RESULT_AND_FLUSH_BR_ENTRIES }; struct proto_cache { char br; const ReportID *reports; }; #define PE_RV_HALT 1 #ifdef STATE_ON_STACK #define pass_state s #else #define pass_state &s #endif #ifdef ESTATE_ON_STACK #define pass_estate estate #else #define pass_estate &estate #endif static really_inline int limexRunReports(const ReportID *reports, NfaCallback callback, void *context, u64a offset) { assert(reports); assert(callback); for (; *reports != MO_INVALID_IDX; ++reports) { DEBUG_PRINTF("firing report for id %u at offset %llu\n", *reports, offset); int rv = callback(0, offset, *reports, context); if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } return MO_CONTINUE_MATCHING; // continue } static really_inline int limexRunAccept(const char *limex_base, const struct NFAAccept *accept, NfaCallback callback, void *context, u64a offset) { if (accept->single_report) { const ReportID report = accept->reports; DEBUG_PRINTF("firing single report for id %u at offset %llu\n", report, offset); return callback(0, offset, report, context); } const ReportID *reports = (const ReportID *)(limex_base + accept->reports); return limexRunReports(reports, callback, context, offset); } static really_inline int limexAcceptHasReport(const char *limex_base, const struct NFAAccept *accept, ReportID report) { if (accept->single_report) { return accept->reports == report; } const ReportID *reports = (const ReportID *)(limex_base + accept->reports); assert(*reports != MO_INVALID_IDX); do { if (*reports == report) { return 1; } reports++; } while (*reports != MO_INVALID_IDX); return 0; } /** \brief Return a (correctly typed) pointer to the exception table. */ #define getExceptionTable(exc_type, lim) \ ((const exc_type *)((const char *)(lim) + (lim)->exceptionOffset)) /** \brief Return a pointer to the ordinary accepts table. */ #define getAcceptTable(lim) \ ((const struct NFAAccept *)((const char *)(lim) + (lim)->acceptOffset)) /** \brief Return a pointer to the EOD accepts table. */ #define getAcceptEodTable(lim) \ ((const struct NFAAccept *)((const char *)(lim) + (lim)->acceptEodOffset)) #define MAKE_GET_NFA_REPEAT_INFO(size) \ static really_inline const struct NFARepeatInfo *getNfaRepeatInfo##size( \ const struct LimExNFA##size *limex, unsigned num) { \ assert(num < limex->repeatCount); \ \ const char *base = (const char *)limex; \ const u32 *repeatOffset = (const u32 *)(base + limex->repeatOffset); \ assert(ISALIGNED(repeatOffset)); \ \ const struct NFARepeatInfo *info = \ (const struct NFARepeatInfo *)(base + repeatOffset[num]); \ assert(ISALIGNED(info)); \ return info; \ } MAKE_GET_NFA_REPEAT_INFO(32) MAKE_GET_NFA_REPEAT_INFO(64) MAKE_GET_NFA_REPEAT_INFO(128) MAKE_GET_NFA_REPEAT_INFO(256) MAKE_GET_NFA_REPEAT_INFO(384) MAKE_GET_NFA_REPEAT_INFO(512) static really_inline const struct RepeatInfo *getRepeatInfo(const struct NFARepeatInfo *info) { const struct RepeatInfo *repeat = (const struct RepeatInfo *)((const char *)info + sizeof(*info)); assert(ISALIGNED(repeat)); return repeat; } static really_inline union RepeatControl *getRepeatControlBase(char *state, size_t nfa_state_size) { union RepeatControl *ctrl_base = (union RepeatControl *)(state + ROUNDUP_N(nfa_state_size, alignof(union RepeatControl))); assert(ISALIGNED(ctrl_base)); return ctrl_base; } static really_inline const union RepeatControl *getRepeatControlBaseConst(const char *state, size_t nfa_state_size) { const union RepeatControl *ctrl_base = (const union RepeatControl *)(state + ROUNDUP_N(nfa_state_size, alignof(union RepeatControl))); assert(ISALIGNED(ctrl_base)); return ctrl_base; } #endif hyperscan-4.4.1/src/nfa/goughcompile_internal.h0000644000175000017500000001631413055426554022366 0ustar sleuthkidsleuthkid/* * 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 GOUGHCOMPILE_INTERNAL_H #define GOUGHCOMPILE_INTERNAL_H #include "gough_internal.h" #include "mcclellancompile.h" #include "ue2common.h" #include "util/charreach.h" #include "util/order_check.h" #include "util/ue2_containers.h" #include #include #include #include #include #include namespace ue2 { struct Grey; struct GoughSSAVar; struct GoughSSAVarJoin; struct GoughVertexProps { GoughVertexProps() {} explicit GoughVertexProps(u32 state_in) : state_id(state_in) {} u32 state_id = ~0U; std::vector > vars; /* owns variables */ std::vector > reports; /**< report som, som variable */ std::vector > reports_eod; }; struct GoughEdgeProps { GoughEdgeProps(void) : top(false) {} bool top; CharReach reach; std::vector > vars; /* owns variables */ }; struct GoughGraphProps { boost::adjacency_list_traits::vertex_descriptor initial_vertex; /* for triggered nfas, dead state; * for others start anchored or start floating */ }; typedef boost::adjacency_list GoughGraph; typedef GoughGraph::vertex_descriptor GoughVertex; typedef GoughGraph::edge_descriptor GoughEdge; struct gough_edge_id { gough_edge_id(const GoughGraph &g, const GoughEdge &e) : src(g[source(e, g)].state_id), dest(g[target(e, g)].state_id), first_char(g[e].reach.find_first()) {} bool operator<(const gough_edge_id &b) const { const gough_edge_id &a = *this; ORDER_CHECK(src); ORDER_CHECK(dest); ORDER_CHECK(first_char); return false; } const u32 src; const u32 dest; const u32 first_char; /* ~0U if only top */ }; struct GoughSSAVarWithInputs; struct GoughSSAVarMin; struct GoughSSAVarJoin; struct GoughSSAVar : boost::noncopyable { GoughSSAVar(void) : seen(false), slot(INVALID_SLOT) {} virtual ~GoughSSAVar(); const ue2::flat_set &get_inputs() const { return inputs; } const ue2::flat_set &get_outputs() const { return outputs; } virtual void replace_input(GoughSSAVar *old_v, GoughSSAVar *new_v) = 0; virtual void generate(std::vector *out) const = 0; bool seen; /* for temp use by remove_dead alg */ u32 slot; void clear_outputs(); /** remove all inputs and outputs of the vertex, call before * removing vertex */ virtual void clear_all() { clear_outputs(); } protected: ue2::flat_set inputs; ue2::flat_set outputs; friend struct GoughSSAVarWithInputs; friend struct GoughSSAVarMin; friend struct GoughSSAVarJoin; }; struct GoughSSAVarNew : public GoughSSAVar { explicit GoughSSAVarNew(u32 adjust_in) : adjust(adjust_in) {} void replace_input(GoughSSAVar *, GoughSSAVar *) override { assert(0); } void generate(std::vector *out) const override; const u32 adjust; }; struct GoughSSAVarWithInputs : public GoughSSAVar { GoughSSAVarWithInputs(void) {} void replace_input(GoughSSAVar *old_v, GoughSSAVar *new_v) override = 0; virtual void clear_inputs() = 0; void clear_all() override; protected: virtual void remove_input_raw(GoughSSAVar *v) = 0; friend struct GoughSSAVar; }; struct GoughSSAVarMin : public GoughSSAVarWithInputs { GoughSSAVarMin(void) {} void generate(std::vector *out) const override; void clear_inputs() override; void replace_input(GoughSSAVar *old_v, GoughSSAVar *new_v) override; virtual void add_input(GoughSSAVar *v) { inputs.insert(v); v->outputs.insert(this); } protected: void remove_input_raw(GoughSSAVar *v) override; }; struct GoughSSAVarJoin : public GoughSSAVarWithInputs { GoughSSAVarJoin(void) {} /* dummy; all joins at a point must be generated simultaneously */ void generate(std::vector *out) const override; GoughSSAVar *get_input(const GoughEdge &prev) const; void clear_inputs() override; void replace_input(GoughSSAVar *old_v, GoughSSAVar *new_v) override; void add_input(GoughSSAVar *v, GoughEdge prev); const ue2::flat_set &get_edges_for_input(GoughSSAVar *input) const; const std::map > &get_input_map() const; protected: void remove_input_raw(GoughSSAVar *v) override; private: std::map> input_map; }; struct gough_accel_state_info { u32 margin; bool two_byte; gough_accel_state_info(u32 margin_in, bool two_byte_in) : margin(margin_in), two_byte(two_byte_in) { } }; u32 assign_slots(GoughGraph &g, const Grey &grey); void find_allowed_accel_states(const GoughGraph &g, const std::map > &blocks, std::map *out); bool find_normal_self_loop(GoughVertex v, const GoughGraph &g, GoughEdge *out); } // namespace ue2 // Note: C structure, can't be in namespace ue2 static inline bool operator==(const gough_ins &a, const gough_ins &b) { return a.op == b.op && a.dest == b.dest && a.src == b.src; } static inline bool operator<(const gough_ins &a, const gough_ins &b) { return std::tie(a.op, a.src, a.dest) < std::tie(b.op, b.src, b.dest); } #endif hyperscan-4.4.1/src/nfa/mcclellan.h0000644000175000017500000001237313055426554017743 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MCCLELLAN_H #define MCCLELLAN_H #include "callback.h" #include "ue2common.h" struct mq; struct NFA; // 8-bit McClellan char nfaExecMcClellan8_testEOD(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); char nfaExecMcClellan8_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecMcClellan8_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecMcClellan8_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecMcClellan8_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecMcClellan8_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecMcClellan8_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecMcClellan8_queueInitState(const struct NFA *n, struct mq *q); char nfaExecMcClellan8_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecMcClellan8_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecMcClellan8_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecMcClellan8_B_Reverse NFA_API_NO_IMPL #define nfaExecMcClellan8_zombie_status NFA_API_ZOMBIE_NO_IMPL // 16-bit McClellan char nfaExecMcClellan16_testEOD(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); char nfaExecMcClellan16_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecMcClellan16_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecMcClellan16_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecMcClellan16_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecMcClellan16_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecMcClellan16_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecMcClellan16_queueInitState(const struct NFA *n, struct mq *q); char nfaExecMcClellan16_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecMcClellan16_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecMcClellan16_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecMcClellan16_B_Reverse NFA_API_NO_IMPL #define nfaExecMcClellan16_zombie_status NFA_API_ZOMBIE_NO_IMPL /** * Simple streaming mode calls: * - always uses the anchored start state regardless if top is set regardless of * start_off * - never checks eod */ void nfaExecMcClellan8_SimpStream(const struct NFA *nfa, char *state, const u8 *buf, char top, size_t start_off, size_t len, NfaCallback cb, void *ctxt); void nfaExecMcClellan16_SimpStream(const struct NFA *nfa, char *state, const u8 *buf, char top, size_t start_off, size_t len, NfaCallback cb, void *ctxt); /** * Simple block mode calls: * - always uses the anchored start state regardless of initial start */ char nfaExecMcClellan8_B(const struct NFA *n, u64a offset, const u8 *buffer, size_t length, NfaCallback cb, void *context); char nfaExecMcClellan16_B(const struct NFA *n, u64a offset, const u8 *buffer, size_t length, NfaCallback cb, void *context); #endif hyperscan-4.4.1/src/nfa/gough_internal.h0000644000175000017500000001012113055426554021003 0ustar sleuthkidsleuthkid/* * 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 GOUGH_INTERNAL_H #define GOUGH_INTERNAL_H #include "accel.h" #include "mcclellan_internal.h" #include "ue2common.h" #define INVALID_SLOT (~0U) #define GOUGH_INS_END 0 #define GOUGH_INS_MOV 1 #define GOUGH_INS_NEW 2 #define GOUGH_INS_MIN 3 /* todo: add instructions targeting acc reg? */ struct gough_ins { u32 op; /* u32 to avoid padding */ u32 dest; u32 src; /* for GOUGH_INS_NEW, this specifies the adjustment to apply to the * current offset */ }; /* * HAPPY FUN ASCII ART TIME * * ---- * | | struct NFA * ---- * ~~~~ normal(ish) mcclellan engine * ~~~~ * ~~~~ * ~~~~ * ~~~~ * ~~~~ * ~~~~ * ~~~~ * ---- = m->haig_offset * | | } struct gough_info * ---- * | | } * | | } edge prog table -> provides the offset of the start of the program * | | } to run when the edge is taken. 0 indicates no * | | } work to do * ---- = h->top_prog_offset * | | } * | | } top prog table -> provides the offset of the start of the program * | | } to run when a top is taken from this state. 0 * | | } indicates nothing to do * ---- = h->prog_base_offset * | | } * | | } programs to run * | | } * | | } * ---- */ struct gough_info { u32 top_prog_offset; /**< offset to the base of the top prog table */ u32 prog_base_offset; /**< not used at runtime */ u32 stream_som_loc_count; /**< number of som locs in the stream state */ u8 stream_som_loc_width; /**< number of bytes per som loc */ }; static really_inline const struct gough_info *get_gough(const struct mcclellan *m) { assert(m->haig_offset); const char *n = (const char *)m - sizeof(struct NFA); return (const struct gough_info *)(n + m->haig_offset); } static really_inline const u32 *get_gough_top_offsets(const struct mcclellan *m) { const struct gough_info *g = get_gough(m); if (!g->top_prog_offset) { return NULL; } const char *n = (const char *)m - sizeof(struct NFA); return (const u32 *)(n + g->top_prog_offset); } /* Gough state representation in scratch. * * During execution, gough tracks a number of variables containing potential * starts of match. These are all stored in a large array of u64a slots. */ struct gough_som_info { u64a slots[1]; /* 'flexible' member array */ }; struct gough_report { ReportID r; u32 som; /* som slot to report */ }; struct gough_report_list { u32 count; struct gough_report report[]; }; struct gough_accel { union AccelAux accel; u8 margin_dist; u32 prog_offset; }; #endif hyperscan-4.4.1/src/nfa/dfa_build_strat.h0000644000175000017500000000515413055426554021136 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 DFA_BUILD_STRAT_H #define DFA_BUILD_STRAT_H #include "rdfa.h" #include "ue2common.h" #include #include struct NFA; namespace ue2 { class ReportManager; struct raw_report_info { virtual ~raw_report_info(); virtual u32 getReportListSize() const = 0; /* in bytes */ virtual size_t size() const = 0; /* number of lists */ virtual void fillReportLists(NFA *n, size_t base_offset, std::vector &ro /* out */) const = 0; }; class dfa_build_strat { public: explicit dfa_build_strat(const ReportManager &rm_in) : rm(rm_in) {} virtual ~dfa_build_strat(); virtual raw_dfa &get_raw() const = 0; virtual std::unique_ptr gatherReports( std::vector &reports /* out */, std::vector &reports_eod /* out */, u8 *isSingleReport /* out */, ReportID *arbReport /* out */) const = 0; protected: const ReportManager &rm; }; } // namespace ue2 #endif // DFA_BUILD_STRAT_H hyperscan-4.4.1/src/nfa/tamarama_dump.h0000644000175000017500000000341113055426554020612 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 TAMARAMA_DUMP_H #define TAMARAMA_DUMP_H #if defined(DUMP_SUPPORT) #include struct NFA; namespace ue2 { void nfaExecTamarama_dump(const NFA *nfa, const std::string &base); } // namespace ue2 #endif // DUMP_SUPPORT #endif hyperscan-4.4.1/src/nfa/mcsheng.c0000644000175000017500000013364713055426554017440 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "mcsheng.h" #include "accel.h" #include "mcsheng_internal.h" #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "util/bitutils.h" #include "util/compare.h" #include "util/simd_utils.h" #include "ue2common.h" enum MatchMode { CALLBACK_OUTPUT, STOP_AT_MATCH, NO_MATCHES }; static really_inline const struct mstate_aux *get_aux(const struct mcsheng *m, u32 s) { const char *nfa = (const char *)m - sizeof(struct NFA); const struct mstate_aux *aux = s + (const struct mstate_aux *)(nfa + m->aux_offset); assert(ISALIGNED(aux)); return aux; } static really_inline u32 mcshengEnableStarts(const struct mcsheng *m, u32 s) { const struct mstate_aux *aux = get_aux(m, s); DEBUG_PRINTF("enabling starts %u->%hu\n", s, aux->top); return aux->top; } static really_inline u32 doSherman16(const char *sherman_state, u8 cprime, const u16 *succ_table, u32 as) { assert(ISALIGNED_N(sherman_state, 16)); u8 len = *(const u8 *)(sherman_state + SHERMAN_LEN_OFFSET); if (len) { m128 ss_char = load128(sherman_state); m128 cur_char = set16x8(cprime); u32 z = movemask128(eq128(ss_char, cur_char)); /* remove header cruft: type 1, len 1, daddy 2*/ z &= ~0xf; z &= (1U << (len + 4)) - 1; if (z) { u32 i = ctz32(z & ~0xf) - 4; u32 s_out = unaligned_load_u16((const u8 *)sherman_state + SHERMAN_STATES_OFFSET(len) + sizeof(u16) * i); DEBUG_PRINTF("found sherman match at %u/%u for c'=%hhu s=%u\n", i, len, cprime, s_out); return s_out; } } u32 daddy = *(const u16 *)(sherman_state + SHERMAN_DADDY_OFFSET); return succ_table[(daddy << as) + cprime]; } static really_inline char doComplexReport(NfaCallback cb, void *ctxt, const struct mcsheng *m, u32 s, u64a loc, char eod, u32 *cached_accept_state, u32 *cached_accept_id) { DEBUG_PRINTF("reporting state = %u, loc=%llu, eod %hhu\n", s & STATE_MASK, loc, eod); if (!eod && s == *cached_accept_state) { if (cb(0, loc, *cached_accept_id, ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } const struct mstate_aux *aux = get_aux(m, s); size_t offset = eod ? aux->accept_eod : aux->accept; assert(offset); const struct report_list *rl = (const void *)((const char *)m + offset - sizeof(struct NFA)); assert(ISALIGNED(rl)); DEBUG_PRINTF("report list size %u\n", rl->count); u32 count = rl->count; if (!eod && count == 1) { *cached_accept_state = s; *cached_accept_id = rl->report[0]; DEBUG_PRINTF("reporting %u\n", rl->report[0]); if (cb(0, loc, rl->report[0], ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } for (u32 i = 0; i < count; i++) { DEBUG_PRINTF("reporting %u\n", rl->report[i]); if (cb(0, loc, rl->report[i], ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } } return MO_CONTINUE_MATCHING; /* continue execution */ } #define SHENG_CHUNK 8 static really_inline u32 doSheng(const struct mcsheng *m, const u8 **c_inout, const u8 *soft_c_end, const u8 *hard_c_end, u32 s_in, char do_accel) { assert(s_in < m->sheng_end); assert(s_in); /* should not already be dead */ assert(soft_c_end <= hard_c_end); DEBUG_PRINTF("s_in = %u (adjusted %u)\n", s_in, s_in - 1); m128 s = set16x8(s_in - 1); const u8 *c = *c_inout; const u8 *c_end = hard_c_end - SHENG_CHUNK + 1; if (!do_accel) { c_end = MIN(soft_c_end, hard_c_end - SHENG_CHUNK + 1); } const m128 *masks = m->sheng_masks; u8 sheng_limit = m->sheng_end - 1; /* - 1: no dead state */ u8 sheng_stop_limit = do_accel ? m->sheng_accel_limit : sheng_limit; /* When we use movd to get a u32 containing our state, it will have 4 lanes * all duplicating the state. We can create versions of our limits with 4 * copies to directly compare against, this prevents us generating code to * extract a single copy of the state from the u32 for checking. */ u32 sheng_stop_limit_x4 = sheng_stop_limit * 0x01010101; #if defined(HAVE_PEXT) && defined(ARCH_64_BIT) u32 sheng_limit_x4 = sheng_limit * 0x01010101; m128 simd_stop_limit = set4x32(sheng_stop_limit_x4); m128 accel_delta = set16x8(sheng_limit - sheng_stop_limit); DEBUG_PRINTF("end %hu, accel %hhu --> limit %hhu\n", sheng_limit, m->sheng_accel_limit, sheng_stop_limit); #endif #define SHENG_SINGLE_ITER do { \ m128 shuffle_mask = masks[*(c++)]; \ s = pshufb(shuffle_mask, s); \ u32 s_gpr_x4 = movd(s); /* convert to u8 */ \ DEBUG_PRINTF("c %hhu (%c) --> s %hhu\n", c[-1], c[-1], s_gpr); \ if (s_gpr_x4 >= sheng_stop_limit_x4) { \ s_gpr = s_gpr_x4; \ goto exit; \ } \ } while (0) u8 s_gpr; while (c < c_end) { #if defined(HAVE_PEXT) && defined(ARCH_64_BIT) /* This version uses pext for efficently bitbashing out scaled * versions of the bytes to process from a u64a */ u64a data_bytes = unaligned_load_u64a(c); u64a cc0 = pdep64(data_bytes, 0xff0); /* extract scaled low byte */ data_bytes &= ~0xffULL; /* clear low bits for scale space */ m128 shuffle_mask0 = load128((const char *)masks + cc0); s = pshufb(shuffle_mask0, s); m128 s_max = s; m128 s_max0 = s_max; DEBUG_PRINTF("c %02llx --> s %hhu\n", cc0 >> 4, movd(s)); #define SHENG_SINGLE_UNROLL_ITER(iter) \ assert(iter); \ u64a cc##iter = pext64(data_bytes, mcsheng_pext_mask[iter]); \ assert(cc##iter == (u64a)c[iter] << 4); \ m128 shuffle_mask##iter = load128((const char *)masks + cc##iter); \ s = pshufb(shuffle_mask##iter, s); \ if (do_accel && iter == 7) { \ /* in the final iteration we also have to check against accel */ \ m128 s_temp = sadd_u8_m128(s, accel_delta); \ s_max = max_u8_m128(s_max, s_temp); \ } else { \ s_max = max_u8_m128(s_max, s); \ } \ m128 s_max##iter = s_max; \ DEBUG_PRINTF("c %02llx --> s %hhu max %hhu\n", cc##iter >> 4, \ movd(s), movd(s_max)); SHENG_SINGLE_UNROLL_ITER(1); SHENG_SINGLE_UNROLL_ITER(2); SHENG_SINGLE_UNROLL_ITER(3); SHENG_SINGLE_UNROLL_ITER(4); SHENG_SINGLE_UNROLL_ITER(5); SHENG_SINGLE_UNROLL_ITER(6); SHENG_SINGLE_UNROLL_ITER(7); if (movd(s_max7) >= sheng_limit_x4) { DEBUG_PRINTF("exit found\n"); /* Explicitly check the last byte as it is more likely as it also * checks for acceleration. */ if (movd(s_max6) < sheng_limit_x4) { c += SHENG_CHUNK; s_gpr = movq(s); assert(s_gpr >= sheng_stop_limit); goto exit; } /* use shift-xor to create a register containing all of the max * values */ m128 blended = rshift64_m128(s_max0, 56); blended = xor128(blended, rshift64_m128(s_max1, 48)); blended = xor128(blended, rshift64_m128(s_max2, 40)); blended = xor128(blended, rshift64_m128(s_max3, 32)); blended = xor128(blended, rshift64_m128(s_max4, 24)); blended = xor128(blended, rshift64_m128(s_max5, 16)); blended = xor128(blended, rshift64_m128(s_max6, 8)); blended = xor128(blended, s); blended = xor128(blended, rshift64_m128(blended, 8)); DEBUG_PRINTF("blended %016llx\n", movq(blended)); m128 final = min_u8_m128(blended, simd_stop_limit); m128 cmp = sub_u8_m128(final, simd_stop_limit); u64a stops = ~movemask128(cmp); assert(stops); u32 earliest = ctz32(stops); DEBUG_PRINTF("stops %02llx, earliest %u\n", stops, earliest); assert(earliest < 8); c += earliest + 1; s_gpr = movq(blended) >> (earliest * 8); assert(s_gpr >= sheng_stop_limit); goto exit; } else { c += SHENG_CHUNK; } #else SHENG_SINGLE_ITER; SHENG_SINGLE_ITER; SHENG_SINGLE_ITER; SHENG_SINGLE_ITER; SHENG_SINGLE_ITER; SHENG_SINGLE_ITER; SHENG_SINGLE_ITER; SHENG_SINGLE_ITER; #endif } assert(c_end - c < SHENG_CHUNK); if (c < soft_c_end) { assert(soft_c_end - c < SHENG_CHUNK); switch (soft_c_end - c) { case 7: SHENG_SINGLE_ITER; case 6: SHENG_SINGLE_ITER; case 5: SHENG_SINGLE_ITER; case 4: SHENG_SINGLE_ITER; case 3: SHENG_SINGLE_ITER; case 2: SHENG_SINGLE_ITER; case 1: SHENG_SINGLE_ITER; } } assert(c >= soft_c_end); s_gpr = movd(s); exit: assert(c <= hard_c_end); DEBUG_PRINTF("%zu from end; s %hhu\n", c_end - c, s_gpr); assert(c >= soft_c_end || s_gpr >= sheng_stop_limit); /* undo state adjustment to match mcclellan view */ if (s_gpr == sheng_limit) { s_gpr = 0; } else if (s_gpr < sheng_limit) { s_gpr++; } *c_inout = c; return s_gpr; } static really_inline const char *findShermanState(UNUSED const struct mcsheng *m, const char *sherman_base_offset, u32 sherman_base, u32 s) { const char *rv = sherman_base_offset + SHERMAN_FIXED_SIZE * (s - sherman_base); assert(rv < (const char *)m + m->length - sizeof(struct NFA)); UNUSED u8 type = *(const u8 *)(rv + SHERMAN_TYPE_OFFSET); assert(type == SHERMAN_STATE); return rv; } static really_inline const u8 *run_mcsheng_accel(const struct mcsheng *m, const struct mstate_aux *aux, u32 s, const u8 **min_accel_offset, const u8 *c, const u8 *c_end) { DEBUG_PRINTF("skipping\n"); u32 accel_offset = aux[s].accel_offset; assert(aux[s].accel_offset); assert(accel_offset >= m->aux_offset); assert(!m->sherman_offset || accel_offset < m->sherman_offset); const union AccelAux *aaux = (const void *)((const char *)m + accel_offset); const u8 *c2 = run_accel(aaux, c, c_end); if (c2 < *min_accel_offset + BAD_ACCEL_DIST) { *min_accel_offset = c2 + BIG_ACCEL_PENALTY; } else { *min_accel_offset = c2 + SMALL_ACCEL_PENALTY; } if (*min_accel_offset >= c_end - ACCEL_MIN_LEN) { *min_accel_offset = c_end; } DEBUG_PRINTF("advanced %zd, next accel chance in %zd/%zd\n", c2 - c, *min_accel_offset - c2, c_end - c2); return c2; } static really_inline u32 doNormal16(const struct mcsheng *m, const u8 **c_inout, const u8 *end, u32 s, char do_accel, enum MatchMode mode) { const u8 *c = *c_inout; const u16 *succ_table = (const u16 *)((const char *)m + sizeof(struct mcsheng)); assert(ISALIGNED_N(succ_table, 2)); u32 sheng_end = m->sheng_end; u32 sherman_base = m->sherman_limit; const char *sherman_base_offset = (const char *)m - sizeof(struct NFA) + m->sherman_offset; u32 as = m->alphaShift; /* Adjust start of succ table so we can index into using state id (rather * than adjust to normal id). As we will not be processing states with low * state ids, we will not be accessing data before the succ table. Note: due * to the size of the sheng tables, the succ_table pointer will still be * inside the engine.*/ succ_table -= sheng_end << as; s &= STATE_MASK; while (c < end && s >= sheng_end) { u8 cprime = m->remap[*c]; DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx (s=%u)\n", *c, ourisprint(*c) ? *c : '?', cprime, s); if (s < sherman_base) { DEBUG_PRINTF("doing normal\n"); assert(s < m->state_count); s = succ_table[(s << as) + cprime]; } else { const char *sherman_state = findShermanState(m, sherman_base_offset, sherman_base, s); DEBUG_PRINTF("doing sherman (%u)\n", s); s = doSherman16(sherman_state, cprime, succ_table, as); } DEBUG_PRINTF("s: %u (%u)\n", s, s & STATE_MASK); c++; if (do_accel && (s & ACCEL_FLAG)) { break; } if (mode != NO_MATCHES && (s & ACCEPT_FLAG)) { break; } s &= STATE_MASK; } *c_inout = c; return s; } static really_inline char mcshengExec16_i(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **c_final, enum MatchMode mode) { assert(ISALIGNED_N(state, 2)); if (!len) { if (mode == STOP_AT_MATCH) { *c_final = buf; } return MO_ALIVE; } u32 s = *state; const u8 *c = buf; const u8 *c_end = buf + len; const u8 sheng_end = m->sheng_end; const struct mstate_aux *aux = (const struct mstate_aux *)((const char *)m + m->aux_offset - sizeof(struct NFA)); s &= STATE_MASK; u32 cached_accept_id = 0; u32 cached_accept_state = 0; DEBUG_PRINTF("s: %u, len %zu\n", s, len); const u8 *min_accel_offset = c; if (!m->has_accel || len < ACCEL_MIN_LEN) { min_accel_offset = c_end; goto without_accel; } goto with_accel; without_accel: do { assert(c < min_accel_offset); int do_accept; if (!s) { goto exit; } else if (s < sheng_end) { s = doSheng(m, &c, min_accel_offset, c_end, s, 0); do_accept = mode != NO_MATCHES && get_aux(m, s)->accept; } else { s = doNormal16(m, &c, min_accel_offset, s, 0, mode); do_accept = mode != NO_MATCHES && (s & ACCEPT_FLAG); } if (do_accept) { if (mode == STOP_AT_MATCH) { *state = s & STATE_MASK; *c_final = c - 1; return MO_MATCHES_PENDING; } u64a loc = (c - 1) - buf + offAdj + 1; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); if (cb(0, loc, m->arb_report, ctxt) == MO_HALT_MATCHING) { return MO_DEAD; /* termination requested */ } } else if (doComplexReport(cb, ctxt, m, s & STATE_MASK, loc, 0, &cached_accept_state, &cached_accept_id) == MO_HALT_MATCHING) { return MO_DEAD; } } assert(c <= c_end); /* sheng is fuzzy for min_accel_offset */ } while (c < min_accel_offset); if (c == c_end) { goto exit; } with_accel: do { assert(c < c_end); int do_accept; if (!s) { goto exit; } else if (s < sheng_end) { if (s > m->sheng_accel_limit) { c = run_mcsheng_accel(m, aux, s, &min_accel_offset, c, c_end); if (c == c_end) { goto exit; } else { goto without_accel; } } s = doSheng(m, &c, c_end, c_end, s, 1); do_accept = mode != NO_MATCHES && get_aux(m, s)->accept; } else { if (s & ACCEL_FLAG) { DEBUG_PRINTF("skipping\n"); s &= STATE_MASK; c = run_mcsheng_accel(m, aux, s, &min_accel_offset, c, c_end); if (c == c_end) { goto exit; } else { goto without_accel; } } s = doNormal16(m, &c, c_end, s, 1, mode); do_accept = mode != NO_MATCHES && (s & ACCEPT_FLAG); } if (do_accept) { if (mode == STOP_AT_MATCH) { *state = s & STATE_MASK; *c_final = c - 1; return MO_MATCHES_PENDING; } u64a loc = (c - 1) - buf + offAdj + 1; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); if (cb(0, loc, m->arb_report, ctxt) == MO_HALT_MATCHING) { return MO_DEAD; /* termination requested */ } } else if (doComplexReport(cb, ctxt, m, s & STATE_MASK, loc, 0, &cached_accept_state, &cached_accept_id) == MO_HALT_MATCHING) { return MO_DEAD; } } assert(c <= c_end); } while (c < c_end); exit: s &= STATE_MASK; if (mode == STOP_AT_MATCH) { *c_final = c_end; } *state = s; return MO_ALIVE; } static never_inline char mcshengExec16_i_cb(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcshengExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, CALLBACK_OUTPUT); } static never_inline char mcshengExec16_i_sam(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcshengExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, STOP_AT_MATCH); } static never_inline char mcshengExec16_i_nm(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcshengExec16_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, NO_MATCHES); } static really_inline char mcshengExec16_i_ni(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point, enum MatchMode mode) { if (mode == CALLBACK_OUTPUT) { return mcshengExec16_i_cb(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } else if (mode == STOP_AT_MATCH) { return mcshengExec16_i_sam(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } else { assert (mode == NO_MATCHES); return mcshengExec16_i_nm(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } } static really_inline u32 doNormal8(const struct mcsheng *m, const u8 **c_inout, const u8 *end, u32 s, char do_accel, enum MatchMode mode) { const u8 *c = *c_inout; u32 sheng_end = m->sheng_end; u32 accel_limit = m->accel_limit_8; u32 accept_limit = m->accept_limit_8; const u32 as = m->alphaShift; const u8 *succ_table = (const u8 *)((const char *)m + sizeof(struct mcsheng)); /* Adjust start of succ table so we can index into using state id (rather * than adjust to normal id). As we will not be processing states with low * state ids, we will not be accessing data before the succ table. Note: due * to the size of the sheng tables, the succ_table pointer will still be * inside the engine.*/ succ_table -= sheng_end << as; assert(s >= sheng_end); while (c < end && s >= sheng_end) { u8 cprime = m->remap[*c]; DEBUG_PRINTF("c: %02hhx '%c' cp:%02hhx\n", *c, ourisprint(*c) ? *c : '?', cprime); s = succ_table[(s << as) + cprime]; DEBUG_PRINTF("s: %u\n", s); c++; if (do_accel) { if (s >= accel_limit) { break; } } else { if (mode != NO_MATCHES && s >= accept_limit) { break; } } } *c_inout = c; return s; } static really_inline char mcshengExec8_i(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **c_final, enum MatchMode mode) { if (!len) { *c_final = buf; return MO_ALIVE; } u32 s = *state; const u8 *c = buf; const u8 *c_end = buf + len; const u8 sheng_end = m->sheng_end; const struct mstate_aux *aux = (const struct mstate_aux *)((const char *)m + m->aux_offset - sizeof(struct NFA)); u32 accept_limit = m->accept_limit_8; u32 cached_accept_id = 0; u32 cached_accept_state = 0; DEBUG_PRINTF("accel %hu, accept %u\n", m->accel_limit_8, accept_limit); DEBUG_PRINTF("s: %u, len %zu\n", s, len); const u8 *min_accel_offset = c; if (!m->has_accel || len < ACCEL_MIN_LEN) { min_accel_offset = c_end; goto without_accel; } goto with_accel; without_accel: do { assert(c < min_accel_offset); if (!s) { goto exit; } else if (s < sheng_end) { s = doSheng(m, &c, min_accel_offset, c_end, s, 0); } else { s = doNormal8(m, &c, min_accel_offset, s, 0, mode); assert(c <= min_accel_offset); } if (mode != NO_MATCHES && s >= accept_limit) { if (mode == STOP_AT_MATCH) { DEBUG_PRINTF("match - pausing\n"); *state = s; *c_final = c - 1; return MO_MATCHES_PENDING; } u64a loc = (c - 1) - buf + offAdj + 1; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); if (cb(0, loc, m->arb_report, ctxt) == MO_HALT_MATCHING) { return MO_DEAD; } } else if (doComplexReport(cb, ctxt, m, s, loc, 0, &cached_accept_state, &cached_accept_id) == MO_HALT_MATCHING) { return MO_DEAD; } } assert(c <= c_end); /* sheng is fuzzy for min_accel_offset */ } while (c < min_accel_offset); if (c == c_end) { goto exit; } with_accel: do { u32 accel_limit = m->accel_limit_8; assert(c < c_end); if (!s) { goto exit; } else if (s < sheng_end) { if (s > m->sheng_accel_limit) { c = run_mcsheng_accel(m, aux, s, &min_accel_offset, c, c_end); if (c == c_end) { goto exit; } else { goto without_accel; } } s = doSheng(m, &c, c_end, c_end, s, 1); } else { if (s >= accel_limit && aux[s].accel_offset) { c = run_mcsheng_accel(m, aux, s, &min_accel_offset, c, c_end); if (c == c_end) { goto exit; } else { goto without_accel; } } s = doNormal8(m, &c, c_end, s, 1, mode); } if (mode != NO_MATCHES && s >= accept_limit) { if (mode == STOP_AT_MATCH) { DEBUG_PRINTF("match - pausing\n"); *state = s; *c_final = c - 1; return MO_MATCHES_PENDING; } u64a loc = (c - 1) - buf + offAdj + 1; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); if (cb(0, loc, m->arb_report, ctxt) == MO_HALT_MATCHING) { return MO_DEAD; } } else if (doComplexReport(cb, ctxt, m, s, loc, 0, &cached_accept_state, &cached_accept_id) == MO_HALT_MATCHING) { return MO_DEAD; } } assert(c <= c_end); } while (c < c_end); exit: *state = s; if (mode == STOP_AT_MATCH) { *c_final = c_end; } return MO_ALIVE; } static never_inline char mcshengExec8_i_cb(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcshengExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, CALLBACK_OUTPUT); } static never_inline char mcshengExec8_i_sam(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcshengExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, STOP_AT_MATCH); } static never_inline char mcshengExec8_i_nm(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point) { return mcshengExec8_i(m, state, buf, len, offAdj, cb, ctxt, single, final_point, NO_MATCHES); } static really_inline char mcshengExec8_i_ni(const struct mcsheng *m, u32 *state, const u8 *buf, size_t len, u64a offAdj, NfaCallback cb, void *ctxt, char single, const u8 **final_point, enum MatchMode mode) { if (mode == CALLBACK_OUTPUT) { return mcshengExec8_i_cb(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } else if (mode == STOP_AT_MATCH) { return mcshengExec8_i_sam(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } else { assert(mode == NO_MATCHES); return mcshengExec8_i_nm(m, state, buf, len, offAdj, cb, ctxt, single, final_point); } } static really_inline char mcshengCheckEOD(const struct NFA *nfa, u32 s, u64a offset, NfaCallback cb, void *ctxt) { const struct mcsheng *m = getImplNfa(nfa); const struct mstate_aux *aux = get_aux(m, s); if (!aux->accept_eod) { return MO_CONTINUE_MATCHING; } return doComplexReport(cb, ctxt, m, s, offset, 1, NULL, NULL); } static really_inline char nfaExecMcSheng16_Q2i(const struct NFA *n, u64a offset, const u8 *buffer, const u8 *hend, NfaCallback cb, void *context, struct mq *q, char single, s64a end, enum MatchMode mode) { assert(n->type == MCSHENG_NFA_16); const struct mcsheng *m = getImplNfa(n); s64a sp; assert(ISALIGNED_N(q->state, 2)); u32 s = *(u16 *)q->state; if (q->report_current) { assert(s); assert(get_aux(m, s)->accept); int rv; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); rv = cb(0, q_cur_offset(q), m->arb_report, context); } else { u32 cached_accept_id = 0; u32 cached_accept_state = 0; rv = doComplexReport(cb, context, m, s, q_cur_offset(q), 0, &cached_accept_state, &cached_accept_id); } q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_DEAD; } } sp = q_cur_loc(q); q->cur++; const u8 *cur_buf = sp < 0 ? hend : buffer; assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur - 1].location > end) { DEBUG_PRINTF("this is as far as we go\n"); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u16 *)q->state = s; return MO_ALIVE; } while (1) { assert(q->cur < q->end); s64a ep = q->items[q->cur].location; if (mode != NO_MATCHES) { ep = MIN(ep, end); } assert(ep >= sp); s64a local_ep = ep; if (sp < 0) { local_ep = MIN(0, ep); } /* do main buffer region */ const u8 *final_look; char rv = mcshengExec16_i_ni(m, &s, cur_buf + sp, local_ep - sp, offset + sp, cb, context, single, &final_look, mode); if (rv == MO_DEAD) { *(u16 *)q->state = 0; return MO_DEAD; } if (mode == STOP_AT_MATCH && rv == MO_MATCHES_PENDING) { DEBUG_PRINTF("this is as far as we go\n"); DEBUG_PRINTF("state %u final_look %zd\n", s, final_look - cur_buf); assert(q->cur); assert(final_look != cur_buf + local_ep); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = final_look - cur_buf + 1; /* due to * early -1 */ *(u16 *)q->state = s; return MO_MATCHES_PENDING; } assert(rv == MO_ALIVE); assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur].location > end) { DEBUG_PRINTF("this is as far as we go\n"); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u16 *)q->state = s; return MO_ALIVE; } sp = local_ep; if (sp == 0) { cur_buf = buffer; } if (sp != ep) { continue; } switch (q->items[q->cur].type) { case MQE_TOP: assert(sp + offset || !s); if (sp + offset == 0) { s = m->start_anchored; break; } s = mcshengEnableStarts(m, s); break; case MQE_END: *(u16 *)q->state = s; q->cur++; return s ? MO_ALIVE : MO_DEAD; default: assert(!"invalid queue event"); } q->cur++; } } static really_inline char nfaExecMcSheng8_Q2i(const struct NFA *n, u64a offset, const u8 *buffer, const u8 *hend, NfaCallback cb, void *context, struct mq *q, char single, s64a end, enum MatchMode mode) { assert(n->type == MCSHENG_NFA_8); const struct mcsheng *m = getImplNfa(n); s64a sp; u32 s = *(u8 *)q->state; if (q->report_current) { assert(s); assert(s >= m->accept_limit_8); int rv; if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); rv = cb(0, q_cur_offset(q), m->arb_report, context); } else { u32 cached_accept_id = 0; u32 cached_accept_state = 0; rv = doComplexReport(cb, context, m, s, q_cur_offset(q), 0, &cached_accept_state, &cached_accept_id); } q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_DEAD; } } sp = q_cur_loc(q); q->cur++; const u8 *cur_buf = sp < 0 ? hend : buffer; if (mode != NO_MATCHES && q->items[q->cur - 1].location > end) { DEBUG_PRINTF("this is as far as we go\n"); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u8 *)q->state = s; return MO_ALIVE; } while (1) { DEBUG_PRINTF("%s @ %llu\n", q->items[q->cur].type == MQE_TOP ? "TOP" : q->items[q->cur].type == MQE_END ? "END" : "???", q->items[q->cur].location + offset); assert(q->cur < q->end); s64a ep = q->items[q->cur].location; if (mode != NO_MATCHES) { ep = MIN(ep, end); } assert(ep >= sp); s64a local_ep = ep; if (sp < 0) { local_ep = MIN(0, ep); } const u8 *final_look; char rv = mcshengExec8_i_ni(m, &s, cur_buf + sp, local_ep - sp, offset + sp, cb, context, single, &final_look, mode); if (rv == MO_HALT_MATCHING) { *(u8 *)q->state = 0; return MO_DEAD; } if (mode == STOP_AT_MATCH && rv == MO_MATCHES_PENDING) { DEBUG_PRINTF("this is as far as we go\n"); DEBUG_PRINTF("state %u final_look %zd\n", s, final_look - cur_buf); assert(q->cur); assert(final_look != cur_buf + local_ep); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = final_look - cur_buf + 1; /* due to * early -1 */ *(u8 *)q->state = s; return MO_MATCHES_PENDING; } assert(rv == MO_ALIVE); assert(q->cur); if (mode != NO_MATCHES && q->items[q->cur].location > end) { DEBUG_PRINTF("this is as far as we go\n"); assert(q->cur); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; *(u8 *)q->state = s; return MO_ALIVE; } sp = local_ep; if (sp == 0) { cur_buf = buffer; } if (sp != ep) { continue; } switch (q->items[q->cur].type) { case MQE_TOP: assert(sp + offset || !s); if (sp + offset == 0) { s = (u8)m->start_anchored; break; } s = mcshengEnableStarts(m, s); break; case MQE_END: *(u8 *)q->state = s; q->cur++; return s ? MO_ALIVE : MO_DEAD; default: assert(!"invalid queue event"); } q->cur++; } } char nfaExecMcSheng8_Q(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCSHENG_NFA_8); const struct mcsheng *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; return nfaExecMcSheng8_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCSHENG_FLAG_SINGLE, end, CALLBACK_OUTPUT); } char nfaExecMcSheng16_Q(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCSHENG_NFA_16); const struct mcsheng *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; return nfaExecMcSheng16_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCSHENG_FLAG_SINGLE, end, CALLBACK_OUTPUT); } char nfaExecMcSheng8_reportCurrent(const struct NFA *n, struct mq *q) { const struct mcsheng *m = getImplNfa(n); NfaCallback cb = q->cb; void *ctxt = q->context; u32 s = *(u8 *)q->state; u8 single = m->flags & MCSHENG_FLAG_SINGLE; u64a offset = q_cur_offset(q); assert(q_cur_type(q) == MQE_START); assert(s); if (s >= m->accept_limit_8) { if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); cb(0, offset, m->arb_report, ctxt); } else { u32 cached_accept_id = 0; u32 cached_accept_state = 0; doComplexReport(cb, ctxt, m, s, offset, 0, &cached_accept_state, &cached_accept_id); } } return 0; } char nfaExecMcSheng16_reportCurrent(const struct NFA *n, struct mq *q) { const struct mcsheng *m = getImplNfa(n); NfaCallback cb = q->cb; void *ctxt = q->context; u32 s = *(u16 *)q->state; const struct mstate_aux *aux = get_aux(m, s); u8 single = m->flags & MCSHENG_FLAG_SINGLE; u64a offset = q_cur_offset(q); assert(q_cur_type(q) == MQE_START); DEBUG_PRINTF("state %u\n", s); assert(s); if (aux->accept) { if (single) { DEBUG_PRINTF("reporting %u\n", m->arb_report); cb(0, offset, m->arb_report, ctxt); } else { u32 cached_accept_id = 0; u32 cached_accept_state = 0; doComplexReport(cb, ctxt, m, s, offset, 0, &cached_accept_state, &cached_accept_id); } } return 0; } static char mcshengHasAccept(const struct mcsheng *m, const struct mstate_aux *aux, ReportID report) { assert(m && aux); if (!aux->accept) { return 0; } const struct report_list *rl = (const struct report_list *) ((const char *)m + aux->accept - sizeof(struct NFA)); assert(ISALIGNED_N(rl, 4)); DEBUG_PRINTF("report list has %u entries\n", rl->count); for (u32 i = 0; i < rl->count; i++) { if (rl->report[i] == report) { return 1; } } return 0; } char nfaExecMcSheng8_inAccept(const struct NFA *n, ReportID report, struct mq *q) { assert(n && q); const struct mcsheng *m = getImplNfa(n); u8 s = *(u8 *)q->state; DEBUG_PRINTF("checking accepts for %hhu\n", s); return mcshengHasAccept(m, get_aux(m, s), report); } char nfaExecMcSheng8_inAnyAccept(const struct NFA *n, struct mq *q) { assert(n && q); const struct mcsheng *m = getImplNfa(n); u8 s = *(u8 *)q->state; DEBUG_PRINTF("checking accepts for %hhu\n", s); return !!get_aux(m, s)->accept; } char nfaExecMcSheng16_inAccept(const struct NFA *n, ReportID report, struct mq *q) { assert(n && q); const struct mcsheng *m = getImplNfa(n); u16 s = *(u16 *)q->state; DEBUG_PRINTF("checking accepts for %hu\n", s); return mcshengHasAccept(m, get_aux(m, s), report); } char nfaExecMcSheng16_inAnyAccept(const struct NFA *n, struct mq *q) { assert(n && q); const struct mcsheng *m = getImplNfa(n); u16 s = *(u16 *)q->state; DEBUG_PRINTF("checking accepts for %hu\n", s); return !!get_aux(m, s)->accept; } char nfaExecMcSheng8_Q2(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCSHENG_NFA_8); const struct mcsheng *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; return nfaExecMcSheng8_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCSHENG_FLAG_SINGLE, end, STOP_AT_MATCH); } char nfaExecMcSheng16_Q2(const struct NFA *n, struct mq *q, s64a end) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCSHENG_NFA_16); const struct mcsheng *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; return nfaExecMcSheng16_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCSHENG_FLAG_SINGLE, end, STOP_AT_MATCH); } char nfaExecMcSheng8_QR(const struct NFA *n, struct mq *q, ReportID report) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCSHENG_NFA_8); const struct mcsheng *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; char rv = nfaExecMcSheng8_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCSHENG_FLAG_SINGLE, 0 /* end */, NO_MATCHES); if (rv && nfaExecMcSheng8_inAccept(n, report, q)) { return MO_MATCHES_PENDING; } else { return rv; } } char nfaExecMcSheng16_QR(const struct NFA *n, struct mq *q, ReportID report) { u64a offset = q->offset; const u8 *buffer = q->buffer; NfaCallback cb = q->cb; void *context = q->context; assert(n->type == MCSHENG_NFA_16); const struct mcsheng *m = getImplNfa(n); const u8 *hend = q->history + q->hlength; char rv = nfaExecMcSheng16_Q2i(n, offset, buffer, hend, cb, context, q, m->flags & MCSHENG_FLAG_SINGLE, 0 /* end */, NO_MATCHES); if (rv && nfaExecMcSheng16_inAccept(n, report, q)) { return MO_MATCHES_PENDING; } else { return rv; } } char nfaExecMcSheng8_initCompressedState(const struct NFA *nfa, u64a offset, void *state, UNUSED u8 key) { const struct mcsheng *m = getImplNfa(nfa); u8 s = offset ? m->start_floating : m->start_anchored; if (s) { *(u8 *)state = s; return 1; } return 0; } char nfaExecMcSheng16_initCompressedState(const struct NFA *nfa, u64a offset, void *state, UNUSED u8 key) { const struct mcsheng *m = getImplNfa(nfa); u16 s = offset ? m->start_floating : m->start_anchored; if (s) { unaligned_store_u16(state, s); return 1; } return 0; } char nfaExecMcSheng8_testEOD(const struct NFA *nfa, const char *state, UNUSED const char *streamState, u64a offset, NfaCallback callback, void *context) { return mcshengCheckEOD(nfa, *(const u8 *)state, offset, callback, context); } char nfaExecMcSheng16_testEOD(const struct NFA *nfa, const char *state, UNUSED const char *streamState, u64a offset, NfaCallback callback, void *context) { assert(ISALIGNED_N(state, 2)); return mcshengCheckEOD(nfa, *(const u16 *)state, offset, callback, context); } char nfaExecMcSheng8_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) { assert(nfa->scratchStateSize == 1); *(u8 *)q->state = 0; return 0; } char nfaExecMcSheng16_queueInitState(UNUSED const struct NFA *nfa, struct mq *q) { assert(nfa->scratchStateSize == 2); assert(ISALIGNED_N(q->state, 2)); *(u16 *)q->state = 0; return 0; } char nfaExecMcSheng8_queueCompressState(UNUSED const struct NFA *nfa, const struct mq *q, UNUSED s64a loc) { void *dest = q->streamState; const void *src = q->state; assert(nfa->scratchStateSize == 1); assert(nfa->streamStateSize == 1); *(u8 *)dest = *(const u8 *)src; return 0; } char nfaExecMcSheng8_expandState(UNUSED const struct NFA *nfa, void *dest, const void *src, UNUSED u64a offset, UNUSED u8 key) { assert(nfa->scratchStateSize == 1); assert(nfa->streamStateSize == 1); *(u8 *)dest = *(const u8 *)src; return 0; } char nfaExecMcSheng16_queueCompressState(UNUSED const struct NFA *nfa, const struct mq *q, UNUSED s64a loc) { void *dest = q->streamState; const void *src = q->state; assert(nfa->scratchStateSize == 2); assert(nfa->streamStateSize == 2); assert(ISALIGNED_N(src, 2)); unaligned_store_u16(dest, *(const u16 *)(src)); return 0; } char nfaExecMcSheng16_expandState(UNUSED const struct NFA *nfa, void *dest, const void *src, UNUSED u64a offset, UNUSED u8 key) { assert(nfa->scratchStateSize == 2); assert(nfa->streamStateSize == 2); assert(ISALIGNED_N(dest, 2)); *(u16 *)dest = unaligned_load_u16(src); return 0; } hyperscan-4.4.1/src/nfa/limex_limits.h0000644000175000017500000000332113055426554020501 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 LIMEX_LIMITS_H #define LIMEX_LIMITS_H #define NFA_MAX_STATES 512 /**< max states in an NFA */ #define NFA_MAX_ACCEL_STATES 8 /**< max accel states in a NFA */ #endif hyperscan-4.4.1/src/nfa/shengdump.cpp0000644000175000017500000001761213055426554020337 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "shengdump.h" #include "accel_dump.h" #include "nfa_dump_internal.h" #include "nfa_internal.h" #include "sheng_internal.h" #include "rdfa.h" #include "ue2common.h" #include "util/charreach.h" #include "util/dump_charclass.h" #include "util/dump_util.h" #include "util/simd_types.h" #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { static const sstate_aux *get_aux(const NFA *n, dstate_id_t i) { assert(n && isShengType(n->type)); const sheng *s = (const sheng *)getImplNfa(n); const sstate_aux *aux_base = (const sstate_aux *)((const char *)n + s->aux_offset); const sstate_aux *aux = aux_base + i; assert((const char *)aux < (const char *)s + s->length); return aux; } static void dumpHeader(FILE *f, const sheng *s) { fprintf(f, "number of states: %u, DFA engine size: %u\n", s->n_states, s->length); fprintf(f, "aux base offset: %u, reports base offset: %u, " "accel offset: %u\n", s->aux_offset, s->report_offset, s->accel_offset); fprintf(f, "anchored start state: %u, floating start state: %u\n", s->anchored & SHENG_STATE_MASK, s->floating & SHENG_STATE_MASK); fprintf(f, "has accel: %u can die: %u single report: %u\n", !!(s->flags & SHENG_FLAG_HAS_ACCEL), !!(s->flags & SHENG_FLAG_CAN_DIE), !!(s->flags & SHENG_FLAG_SINGLE_REPORT)); } static void dumpAux(FILE *f, u32 state, const sstate_aux *aux) { fprintf(f, "state id: %u, reports offset: %u, EOD reports offset: %u, " "accel offset: %u, top: %u\n", state, aux->accept, aux->accept_eod, aux->accel, aux->top & SHENG_STATE_MASK); } static void dumpReports(FILE *f, const report_list *rl) { fprintf(f, "reports count: %u\n", rl->count); for (u32 i = 0; i < rl->count; i++) { fprintf(f, " report: %u, report ID: %u\n", i, rl->report[i]); } } static void dumpMasks(FILE *f, const sheng *s) { for (u32 chr = 0; chr < 256; chr++) { u8 buf[16]; m128 shuffle_mask = s->shuffle_masks[chr]; memcpy(buf, &shuffle_mask, sizeof(m128)); fprintf(f, "%3u: ", chr); for (u32 pos = 0; pos < 16; pos++) { u8 c = buf[pos]; if (c & SHENG_STATE_FLAG_MASK) { fprintf(f, "%2u* ", c & SHENG_STATE_MASK); } else { fprintf(f, "%2u ", c & SHENG_STATE_MASK); } } fprintf(f, "\n"); } } static void nfaExecSheng_dumpText(const NFA *nfa, FILE *f) { assert(nfa->type == SHENG_NFA); const sheng *s = (const sheng *)getImplNfa(nfa); fprintf(f, "sheng DFA\n"); dumpHeader(f, s); for (u32 state = 0; state < s->n_states; state++) { const sstate_aux *aux = get_aux(nfa, state); dumpAux(f, state, aux); if (aux->accept) { fprintf(f, "report list:\n"); const report_list *rl = (const report_list *)((const char *)nfa + aux->accept); dumpReports(f, rl); } if (aux->accept_eod) { fprintf(f, "EOD report list:\n"); const report_list *rl = (const report_list *)((const char *)nfa + aux->accept_eod); dumpReports(f, rl); } if (aux->accel) { fprintf(f, "accel:\n"); const AccelAux *accel = (const AccelAux *)((const char *)nfa + aux->accel); dumpAccelInfo(f, *accel); } } fprintf(f, "\n"); dumpMasks(f, s); fprintf(f, "\n"); } static void dumpDotPreambleDfa(FILE *f) { dumpDotPreamble(f); // DFA specific additions. fprintf(f, "STARTF [style=invis];\n"); fprintf(f, "STARTA [style=invis];\n"); fprintf(f, "0 [style=invis];\n"); } static void describeNode(const NFA *n, const sheng *s, u16 i, FILE *f) { const sstate_aux *aux = get_aux(n, i); fprintf(f, "%u [ width = 1, fixedsize = true, fontsize = 12, " "label = \"%u\" ]; \n", i, i); if (aux->accept_eod) { fprintf(f, "%u [ color = darkorchid ];\n", i); } if (aux->accept) { fprintf(f, "%u [ shape = doublecircle ];\n", i); } if (aux->top && (aux->top & SHENG_STATE_MASK) != i) { fprintf(f, "%u -> %u [color = darkgoldenrod weight=0.1 ]\n", i, aux->top & SHENG_STATE_MASK); } if (i == (s->anchored & SHENG_STATE_MASK)) { fprintf(f, "STARTA -> %u [color = blue ]\n", i); } if (i == (s->floating & SHENG_STATE_MASK)) { fprintf(f, "STARTF -> %u [color = red ]\n", i); } } static void describeEdge(FILE *f, const u16 *t, u16 i) { for (u16 s = 0; s < N_CHARS; s++) { if (!t[s]) { continue; } u16 ss; for (ss = 0; ss < s; ss++) { if (t[s] == t[ss]) { break; } } if (ss != s) { continue; } CharReach reach; for (ss = s; ss < 256; ss++) { if (t[s] == t[ss]) { reach.set(ss); } } fprintf(f, "%u -> %u [ label = \"", i, t[s]); describeClass(f, reach, 5, CC_OUT_DOT); fprintf(f, "\" ];\n"); } } static void shengGetTransitions(const NFA *n, u16 state, u16 *t) { assert(isShengType(n->type)); const sheng *s = (const sheng *)getImplNfa(n); const sstate_aux *aux = get_aux(n, state); for (unsigned i = 0; i < N_CHARS; i++) { u8 buf[16]; m128 shuffle_mask = s->shuffle_masks[i]; memcpy(buf, &shuffle_mask, sizeof(m128)); t[i] = buf[state] & SHENG_STATE_MASK; } t[TOP] = aux->top & SHENG_STATE_MASK; } static void nfaExecSheng_dumpDot(const NFA *nfa, FILE *f) { assert(nfa->type == SHENG_NFA); const sheng *s = (const sheng *)getImplNfa(nfa); dumpDotPreambleDfa(f); for (u16 i = 1; i < s->n_states; i++) { describeNode(nfa, s, i, f); u16 t[ALPHABET_SIZE]; shengGetTransitions(nfa, i, t); describeEdge(f, t, i); } fprintf(f, "}\n"); } void nfaExecSheng_dump(const NFA *nfa, const string &base) { assert(nfa->type == SHENG_NFA); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); nfaExecSheng_dumpText(nfa, f); fclose(f); f = fopen_or_throw((base + ".dot").c_str(), "w"); nfaExecSheng_dumpDot(nfa, f); fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfa/shufti_common.h0000644000175000017500000001221313055426554020654 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 SHUFTI_COMMON_H_ #define SHUFTI_COMMON_H_ #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" #include "util/unaligned.h" /* * Common stuff for all versions of shufti (single, multi and multidouble) */ /** \brief Naive byte-by-byte implementation. */ static really_inline const u8 *shuftiFwdSlow(const u8 *lo, const u8 *hi, const u8 *buf, const u8 *buf_end) { assert(buf < buf_end); for (; buf < buf_end; ++buf) { u8 c = *buf; if (lo[c & 0xf] & hi[c >> 4]) { break; } } return buf; } #ifdef DEBUG #include #define DUMP_MSK(_t) \ static UNUSED \ void dumpMsk##_t(m##_t msk) { \ u8 * mskAsU8 = (u8 *)&msk; \ for (unsigned i = 0; i < sizeof(msk); i++) { \ u8 c = mskAsU8[i]; \ for (int j = 0; j < 8; j++) { \ if ((c >> (7-j)) & 0x1) \ printf("1"); \ else \ printf("0"); \ } \ printf(" "); \ } \ } \ static UNUSED \ void dumpMsk##_t##AsChars(m##_t msk) { \ u8 * mskAsU8 = (u8 *)&msk; \ for (unsigned i = 0; i < sizeof(msk); i++) { \ u8 c = mskAsU8[i]; \ if (isprint(c)) \ printf("%c",c); \ else \ printf("."); \ } \ } #endif #if !defined(__AVX2__) #ifdef DEBUG DUMP_MSK(128) #endif #define GET_LO_4(chars) and128(chars, low4bits) #define GET_HI_4(chars) rshift64_m128(andnot128(low4bits, chars), 4) static really_inline u32 block(m128 mask_lo, m128 mask_hi, m128 chars, const m128 low4bits, const m128 compare) { m128 c_lo = pshufb(mask_lo, GET_LO_4(chars)); m128 c_hi = pshufb(mask_hi, GET_HI_4(chars)); m128 t = and128(c_lo, c_hi); #ifdef DEBUG DEBUG_PRINTF(" chars: "); dumpMsk128AsChars(chars); printf("\n"); DEBUG_PRINTF(" char: "); dumpMsk128(chars); printf("\n"); DEBUG_PRINTF(" c_lo: "); dumpMsk128(c_lo); printf("\n"); DEBUG_PRINTF(" c_hi: "); dumpMsk128(c_hi); printf("\n"); DEBUG_PRINTF(" t: "); dumpMsk128(t); printf("\n"); #endif return movemask128(eq128(t, compare)); } #else #ifdef DEBUG DUMP_MSK(256) #endif #define GET_LO_4(chars) and256(chars, low4bits) #define GET_HI_4(chars) rshift64_m256(andnot256(low4bits, chars), 4) static really_inline u32 block(m256 mask_lo, m256 mask_hi, m256 chars, const m256 low4bits, const m256 compare) { m256 c_lo = vpshufb(mask_lo, GET_LO_4(chars)); m256 c_hi = vpshufb(mask_hi, GET_HI_4(chars)); m256 t = and256(c_lo, c_hi); #ifdef DEBUG DEBUG_PRINTF(" chars: "); dumpMsk256AsChars(chars); printf("\n"); DEBUG_PRINTF(" char: "); dumpMsk256(chars); printf("\n"); DEBUG_PRINTF(" c_lo: "); dumpMsk256(c_lo); printf("\n"); DEBUG_PRINTF(" c_hi: "); dumpMsk256(c_hi); printf("\n"); DEBUG_PRINTF(" t: "); dumpMsk256(t); printf("\n"); #endif return movemask256(eq256(t, compare)); } #endif #endif /* SHUFTI_COMMON_H_ */ hyperscan-4.4.1/src/nfa/mpv_dump.h0000644000175000017500000000340113055426554017630 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MPVDUMP_H #define MPVDUMP_H #if defined(DUMP_SUPPORT) #include struct NFA; namespace ue2 { void nfaExecMpv_dump(const struct NFA *nfa, const std::string &base); } // namespace ue2 #endif #endif // MPVDUMP_H hyperscan-4.4.1/src/nfa/castlecompile.cpp0000644000175000017500000007576413055426554021205 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Castle: multi-tenant repeat engine, compiler code. */ #include "castlecompile.h" #include "castle_internal.h" #include "limex_limits.h" #include "nfa_internal.h" #include "repeatcompile.h" #include "shufticompile.h" #include "trufflecompile.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng_equivalence.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_redundancy.h" #include "nfagraph/ng_util.h" #include "util/alloc.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph.h" #include "util/make_unique.h" #include "util/multibit_build.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include "util/verify_types.h" #include "grey.h" #include #include #include #include using namespace std; using boost::adaptors::map_keys; using boost::adaptors::map_values; namespace ue2 { #define CLIQUE_GRAPH_MAX_SIZE 1000 static u32 depth_to_u32(const depth &d) { assert(d.is_reachable()); if (d.is_infinite()) { return REPEAT_INF; } u32 d_val = d; assert(d_val < REPEAT_INF); return d_val; } static void writeCastleScanEngine(const CharReach &cr, Castle *c) { if (cr.all()) { c->type = CASTLE_DOT; return; } if (cr.count() == 1) { c->type = CASTLE_NVERM; c->u.verm.c = cr.find_first(); return; } const CharReach negated(~cr); if (negated.count() == 1) { c->type = CASTLE_VERM; c->u.verm.c = negated.find_first(); return; } if (shuftiBuildMasks(negated, (u8 *)&c->u.shuf.mask_lo, (u8 *)&c->u.shuf.mask_hi) != -1) { c->type = CASTLE_SHUFTI; return; } c->type = CASTLE_TRUFFLE; truffleBuildMasks(negated, (u8 *)(u8 *)&c->u.truffle.mask1, (u8 *)&c->u.truffle.mask2); } static bool literalOverlap(const vector &a, const vector &b, const size_t dist) { for (size_t i = 0; i < b.size(); i++) { if (i > dist) { return true; } size_t overlap_len = b.size() - i; if (overlap_len <= a.size()) { if (matches(a.end() - overlap_len, a.end(), b.begin(), b.end() - i)) { return false; } } else { assert(overlap_len > a.size()); if (matches(a.begin(), a.end(), b.end() - i - a.size(), b.end() - i)) { return false; } } } return b.size() > dist; } struct CliqueVertexProps { CliqueVertexProps() {} explicit CliqueVertexProps(u32 state_in) : stateId(state_in) {} u32 stateId = ~0U; }; typedef boost::adjacency_list CliqueGraph; typedef CliqueGraph::vertex_descriptor CliqueVertex; static void getNeighborInfo(const CliqueGraph &g, vector &neighbor, const CliqueVertex &cv, const set &group) { u32 id = g[cv].stateId; ue2::unordered_set neighborId; // find neighbors for cv for (const auto &v : adjacent_vertices_range(cv, g)) { if (g[v].stateId != id && contains(group, g[v].stateId)){ neighbor.push_back(g[v].stateId); neighborId.insert(g[v].stateId); DEBUG_PRINTF("Neighbor:%u\n", g[v].stateId); } } } static void findCliqueGroup(CliqueGraph &cg, vector &clique) { stack> gStack; // Create mapping between vertex and id map vertexMap; vector init; for (const auto &v : vertices_range(cg)) { vertexMap[cg[v].stateId] = v; init.push_back(cg[v].stateId); } gStack.push(init); // Get the vertex to start from CliqueGraph::vertex_iterator vi, ve; tie(vi, ve) = vertices(cg); while (!gStack.empty()) { vector g = gStack.top(); gStack.pop(); // Choose a vertex from the graph u32 id = g[0]; const CliqueVertex &n = vertexMap.at(id); clique.push_back(id); // Corresponding vertex in the original graph vector neighbor; set subgraphId(g.begin(), g.end()); getNeighborInfo(cg, neighbor, n, subgraphId); // Get graph consisting of neighbors for left branch if (!neighbor.empty()) { gStack.push(neighbor); } } } template bool graph_empty(const Graph &g) { typename Graph::vertex_iterator vi, ve; tie(vi, ve) = vertices(g); return vi == ve; } static vector removeClique(CliqueGraph &cg) { vector> cliquesVec(1); DEBUG_PRINTF("graph size:%zu\n", num_vertices(cg)); findCliqueGroup(cg, cliquesVec[0]); while (!graph_empty(cg)) { const vector &c = cliquesVec.back(); vector dead; for (const auto &v : vertices_range(cg)) { if (find(c.begin(), c.end(), cg[v].stateId) != c.end()) { dead.push_back(v); } } for (const auto &v : dead) { clear_vertex(v, cg); remove_vertex(v, cg); } if (graph_empty(cg)) { break; } vector clique; findCliqueGroup(cg, clique); cliquesVec.push_back(clique); } // get the independent set with max size size_t max = 0; size_t id = 0; for (size_t j = 0; j < cliquesVec.size(); ++j) { if (cliquesVec[j].size() > max) { max = cliquesVec[j].size(); id = j; } } DEBUG_PRINTF("clique size:%zu\n", cliquesVec[id].size()); return cliquesVec[id]; } // if the location of any reset character in one literal are after // the end locations where it overlaps with other literals, // then the literals are mutual exclusive static bool findExclusivePair(const size_t id1, const size_t id2, const size_t lower, const vector> &min_reset_dist, const vector>> &triggers) { const auto &triggers1 = triggers[id1]; const auto &triggers2 = triggers[id2]; for (size_t i = 0; i < triggers1.size(); ++i) { for (size_t j = 0; j < triggers2.size(); ++j) { if (!literalOverlap(triggers1[i], triggers2[j], min_reset_dist[id2 - lower][j]) || !literalOverlap(triggers2[j], triggers1[i], min_reset_dist[id1 - lower][i])) { return false; } } } return true; } static vector> checkExclusion(u32 &streamStateSize, const CharReach &cr, const vector>> &triggers, enum ExclusiveType &exclusive, const size_t numRepeats) { vector> groups; size_t trigSize = triggers.size(); DEBUG_PRINTF("trigSize %zu\n", trigSize); size_t lower = 0; size_t total = 0; while (lower < trigSize) { vector vertices; unique_ptr cg = make_unique(); vector> min_reset_dist; size_t upper = min(lower + CLIQUE_GRAPH_MAX_SIZE, trigSize); // get min reset distance for each repeat for (size_t i = lower; i < upper; i++) { CliqueVertex v = add_vertex(CliqueVertexProps(i), *cg); vertices.push_back(v); const vector &tmp_dist = minResetDistToEnd(triggers[i], cr); min_reset_dist.push_back(tmp_dist); } // find exclusive pair for each repeat for (size_t i = lower; i < upper; i++) { CliqueVertex s = vertices[i - lower]; for (size_t j = i + 1; j < upper; j++) { if (findExclusivePair(i, j, lower, min_reset_dist, triggers)) { CliqueVertex d = vertices[j - lower]; add_edge(s, d, *cg); } } } // find the largest exclusive group auto clique = removeClique(*cg); size_t cliqueSize = clique.size(); if (cliqueSize > 1) { groups.push_back(clique); exclusive = EXCLUSIVE; total += cliqueSize; } lower += CLIQUE_GRAPH_MAX_SIZE; } DEBUG_PRINTF("clique size %zu, num of repeats %zu\n", total, numRepeats); if (total == numRepeats) { exclusive = PURE_EXCLUSIVE; streamStateSize = 0; }; return groups; } namespace { struct ExclusiveInfo { /** Mapping between top and exclusive group id */ map groupId; /** Number of exclusive groups */ u32 numGroups = 0; }; } static void buildSubcastles(const CastleProto &proto, vector &subs, vector &infos, vector &patchSize, const vector> &repeatInfoPair, u32 &scratchStateSize, u32 &streamStateSize, u32 &tableSize, vector &tables, u32 &sparseRepeats, const ExclusiveInfo &exclusiveInfo, vector &may_stale, const ReportManager &rm) { const bool remap_reports = has_managed_reports(proto.kind); u32 i = 0; const auto &groupId = exclusiveInfo.groupId; const auto &numGroups = exclusiveInfo.numGroups; vector maxStreamSize(numGroups, 0); for (auto it = proto.repeats.begin(), ite = proto.repeats.end(); it != ite; ++it, ++i) { const PureRepeat &pr = it->second; depth min_period = repeatInfoPair[i].first; bool is_reset = repeatInfoPair[i].second; enum RepeatType rtype = chooseRepeatType(pr.bounds.min, pr.bounds.max, min_period, is_reset, true); RepeatStateInfo rsi(rtype, pr.bounds.min, pr.bounds.max, min_period); DEBUG_PRINTF("sub %u: selected %s model for %s repeat\n", i, repeatTypeName(rtype), pr.bounds.str().c_str()); SubCastle &sub = subs[i]; RepeatInfo &info = infos[i]; info.packedCtrlSize = rsi.packedCtrlSize; u32 subStreamStateSize = verify_u32(rsi.packedCtrlSize + rsi.stateSize); // Handle stream/scratch space alloc for exclusive case differently. if (contains(groupId, i)) { u32 id = groupId.at(i); maxStreamSize[id] = max(maxStreamSize[id], subStreamStateSize); // SubCastle full/stream state offsets are written in for the group // below. } else { sub.fullStateOffset = scratchStateSize; sub.streamStateOffset = streamStateSize; scratchStateSize += verify_u32(sizeof(RepeatControl)); streamStateSize += subStreamStateSize; } if (pr.bounds.max.is_finite()) { may_stale.push_back(i); } info.type = verify_u8(rtype); info.repeatMin = depth_to_u32(pr.bounds.min); info.repeatMax = depth_to_u32(pr.bounds.max); info.stateSize = rsi.stateSize; info.horizon = rsi.horizon; info.minPeriod = min_period.is_finite() ? (u32)min_period : ~0U; assert(rsi.packedFieldSizes.size() <= ARRAY_LENGTH(info.packedFieldSizes)); copy(rsi.packedFieldSizes.begin(), rsi.packedFieldSizes.end(), info.packedFieldSizes); info.patchCount = rsi.patchCount; info.patchSize = rsi.patchSize; info.encodingSize = rsi.encodingSize; info.patchesOffset = rsi.patchesOffset; assert(pr.reports.size() == 1); ReportID id = *pr.reports.begin(); sub.report = remap_reports ? rm.getProgramOffset(id) : id; if (rtype == REPEAT_SPARSE_OPTIMAL_P) { for (u32 j = 0; j < rsi.patchSize; j++) { tables.push_back(rsi.table[j]); } sparseRepeats++; patchSize[i] = rsi.patchSize; tableSize += rsi.patchSize; } } vector scratchOffset(numGroups, 0); vector streamOffset(numGroups, 0); for (const auto &j : groupId) { u32 top = j.first; u32 id = j.second; SubCastle &sub = subs[top]; if (!scratchOffset[id]) { sub.fullStateOffset = scratchStateSize; sub.streamStateOffset = streamStateSize; scratchOffset[id] = scratchStateSize; streamOffset[id] = streamStateSize; scratchStateSize += verify_u32(sizeof(RepeatControl)); streamStateSize += maxStreamSize[id]; } else { sub.fullStateOffset = scratchOffset[id]; sub.streamStateOffset = streamOffset[id]; } } } aligned_unique_ptr buildCastle(const CastleProto &proto, const map>> &triggers, const CompileContext &cc, const ReportManager &rm) { assert(cc.grey.allowCastle); const size_t numRepeats = proto.repeats.size(); assert(numRepeats > 0 && numRepeats <= proto.max_occupancy); const CharReach &cr = proto.reach(); DEBUG_PRINTF("reach %s, %zu repeats\n", describeClass(cr).c_str(), numRepeats); vector subs(numRepeats); memset(&subs[0], 0, sizeof(SubCastle) * numRepeats); vector infos(numRepeats); memset(&infos[0], 0, sizeof(RepeatInfo) * numRepeats); vector patchSize(numRepeats); memset(&patchSize[0], 0, sizeof(u64a) * numRepeats); vector tables; // We start with enough stream state to store the active bitfield. u32 streamStateSize = mmbit_size(numRepeats); // We have a copy of the stream state in scratch for castleMatchLoop. u32 scratchStateSize = ROUNDUP_N(streamStateSize, alignof(RepeatControl)); depth minWidth(depth::infinity()); depth maxWidth(0); u32 i = 0; ExclusiveInfo exclusiveInfo; vector>> candidateTriggers; vector candidateRepeats; vector> repeatInfoPair; for (auto it = proto.repeats.begin(), ite = proto.repeats.end(); it != ite; ++it, ++i) { const u32 top = it->first; const PureRepeat &pr = it->second; assert(pr.reach == cr); assert(pr.reports.size() == 1); if (top != i) { // Tops have not been remapped? assert(0); throw std::logic_error("Tops not remapped"); } minWidth = min(minWidth, pr.bounds.min); maxWidth = max(maxWidth, pr.bounds.max); bool is_reset = false; depth min_period = depth::infinity(); // If we've got a top in the castle without any trigger information, it // possibly means that we've got a repeat that we can't trigger. We do // need to cope with it though. if (contains(triggers, top)) { min_period = minPeriod(triggers.at(top), cr, &is_reset); } if (min_period > pr.bounds.max) { DEBUG_PRINTF("trigger is longer than repeat; only need one offset\n"); is_reset = true; } repeatInfoPair.push_back(make_pair(min_period, is_reset)); candidateTriggers.push_back(triggers.at(top)); candidateRepeats.push_back(i); } // Case 1: exclusive repeats enum ExclusiveType exclusive = NOT_EXCLUSIVE; u32 activeIdxSize = 0; u32 groupIterOffset = 0; if (cc.grey.castleExclusive) { auto cliqueGroups = checkExclusion(streamStateSize, cr, candidateTriggers, exclusive, numRepeats); for (const auto &group : cliqueGroups) { // mutual exclusive repeats group found, // update state sizes activeIdxSize = calcPackedBytes(numRepeats + 1); streamStateSize += activeIdxSize; // replace with top values for (const auto &val : group) { const u32 top = candidateRepeats[val]; exclusiveInfo.groupId[top] = exclusiveInfo.numGroups; } exclusiveInfo.numGroups++; } if (exclusive) { groupIterOffset = streamStateSize; streamStateSize += mmbit_size(exclusiveInfo.numGroups); } DEBUG_PRINTF("num of groups:%u\n", exclusiveInfo.numGroups); } candidateRepeats.clear(); DEBUG_PRINTF("reach %s exclusive %u\n", describeClass(cr).c_str(), exclusive); u32 tableSize = 0; u32 sparseRepeats = 0; vector may_stale; /* sub castles that may go stale */ buildSubcastles(proto, subs, infos, patchSize, repeatInfoPair, scratchStateSize, streamStateSize, tableSize, tables, sparseRepeats, exclusiveInfo, may_stale, rm); DEBUG_PRINTF("%zu subcastles may go stale\n", may_stale.size()); vector stale_iter; if (!may_stale.empty()) { mmbBuildSparseIterator(stale_iter, may_stale, numRepeats); } size_t total_size = sizeof(NFA) + // initial NFA structure sizeof(Castle) + // Castle structure sizeof(SubCastle) * subs.size() + // SubCastles themselves sizeof(RepeatInfo) * subs.size() + // RepeatInfo structure sizeof(u64a) * tableSize + // table size for // REPEAT_SPARSE_OPTIMAL_P sizeof(u64a) * sparseRepeats; // paddings for // REPEAT_SPARSE_OPTIMAL_P tables total_size = ROUNDUP_N(total_size, alignof(mmbit_sparse_iter)); total_size += byte_length(stale_iter); // stale sparse iter aligned_unique_ptr nfa = aligned_zmalloc_unique(total_size); nfa->type = verify_u8(CASTLE_NFA); nfa->length = verify_u32(total_size); nfa->nPositions = verify_u32(subs.size()); nfa->streamStateSize = streamStateSize; nfa->scratchStateSize = scratchStateSize; nfa->minWidth = verify_u32(minWidth); nfa->maxWidth = maxWidth.is_finite() ? verify_u32(maxWidth) : 0; char * const base_ptr = (char *)nfa.get() + sizeof(NFA); char *ptr = base_ptr; Castle *c = (Castle *)ptr; c->numRepeats = verify_u32(subs.size()); c->numGroups = exclusiveInfo.numGroups; c->exclusive = verify_s8(exclusive); c->activeIdxSize = verify_u8(activeIdxSize); c->activeOffset = verify_u32(c->numGroups * activeIdxSize); c->groupIterOffset = groupIterOffset; writeCastleScanEngine(cr, c); ptr += sizeof(Castle); SubCastle *subCastles = ((SubCastle *)(ROUNDUP_PTR(ptr, alignof(u32)))); copy(subs.begin(), subs.end(), subCastles); u32 length = 0; u32 tableIdx = 0; for (i = 0; i < numRepeats; i++) { u32 offset = sizeof(SubCastle) * (numRepeats - i) + length; SubCastle *sub = &subCastles[i]; sub->repeatInfoOffset = offset; ptr = (char *)sub + offset; memcpy(ptr, &infos[i], sizeof(RepeatInfo)); if (patchSize[i]) { RepeatInfo *info = (RepeatInfo *)ptr; u64a *table = ((u64a *)(ROUNDUP_PTR(((char *)(info) + sizeof(*info)), alignof(u64a)))); copy(tables.begin() + tableIdx, tables.begin() + tableIdx + patchSize[i], table); u32 diff = (char *)table - (char *)info + sizeof(u64a) * patchSize[i]; info->length = diff; length += diff; tableIdx += patchSize[i]; } else { length += sizeof(RepeatInfo); } // set exclusive group info if (contains(exclusiveInfo.groupId, i)) { sub->exclusiveId = exclusiveInfo.groupId[i]; } else { sub->exclusiveId = numRepeats; } } ptr = base_ptr + total_size - sizeof(NFA) - byte_length(stale_iter); assert(ptr + byte_length(stale_iter) == base_ptr + total_size - sizeof(NFA)); if (!stale_iter.empty()) { c->staleIterOffset = verify_u32(ptr - base_ptr); copy_bytes(ptr, stale_iter); ptr += byte_length(stale_iter); } return nfa; } set all_reports(const CastleProto &proto) { set reports; for (const ReportID &report : proto.report_map | map_keys) { reports.insert(report); } return reports; } depth findMinWidth(const CastleProto &proto) { depth min_width(depth::infinity()); for (const PureRepeat &pr : proto.repeats | map_values) { min_width = min(min_width, pr.bounds.min); } return min_width; } depth findMaxWidth(const CastleProto &proto) { depth max_width(0); for (const PureRepeat &pr : proto.repeats | map_values) { max_width = max(max_width, pr.bounds.max); } return max_width; } depth findMinWidth(const CastleProto &proto, u32 top) { if (!contains(proto.repeats, top)) { assert(0); // should not happen return depth::infinity(); } return proto.repeats.at(top).bounds.min; } depth findMaxWidth(const CastleProto &proto, u32 top) { if (!contains(proto.repeats, top)) { assert(0); // should not happen return depth(0); } return proto.repeats.at(top).bounds.max; } CastleProto::CastleProto(nfa_kind k, const PureRepeat &pr) : kind(k) { assert(pr.reach.any()); assert(pr.reports.size() == 1); u32 top = 0; repeats.emplace(top, pr); for (const auto &report : pr.reports) { report_map[report].insert(top); } } const CharReach &CastleProto::reach() const { assert(!repeats.empty()); return repeats.begin()->second.reach; } u32 CastleProto::add(const PureRepeat &pr) { assert(repeats.size() < max_occupancy); assert(pr.reach == reach()); assert(pr.reports.size() == 1); u32 top = next_top++; DEBUG_PRINTF("selected unused top %u\n", top); assert(!contains(repeats, top)); repeats.emplace(top, pr); for (const auto &report : pr.reports) { report_map[report].insert(top); } return top; } void CastleProto::erase(u32 top) { DEBUG_PRINTF("erase top %u\n", top); assert(contains(repeats, top)); repeats.erase(top); for (auto &m : report_map) { m.second.erase(top); } } u32 CastleProto::merge(const PureRepeat &pr) { assert(repeats.size() <= max_occupancy); assert(pr.reach == reach()); assert(pr.reports.size() == 1); // First, see if this repeat is already in this castle. for (const auto &m : repeats) { if (m.second == pr) { DEBUG_PRINTF("repeat already present, with top %u\n", m.first); return m.first; } } if (repeats.size() == max_occupancy) { DEBUG_PRINTF("this castle is full\n"); return max_occupancy; } return add(pr); } bool mergeCastle(CastleProto &c1, const CastleProto &c2, map &top_map) { assert(&c1 != &c2); assert(c1.kind == c2.kind); DEBUG_PRINTF("c1 has %zu repeats, c2 has %zu repeats\n", c1.repeats.size(), c2.repeats.size()); if (c1.reach() != c2.reach()) { DEBUG_PRINTF("different reach!\n"); return false; } if (c1.repeats.size() + c2.repeats.size() > c1.max_occupancy) { DEBUG_PRINTF("too many repeats to merge\n"); return false; } top_map.clear(); for (const auto &m : c2.repeats) { const u32 top = m.first; const PureRepeat &pr = m.second; DEBUG_PRINTF("top %u\n", top); u32 new_top = c1.add(pr); top_map[top] = new_top; DEBUG_PRINTF("adding repeat: map %u->%u\n", top, new_top); } assert(c1.repeats.size() <= c1.max_occupancy); return true; } void remapCastleTops(CastleProto &proto, map &top_map) { map out; top_map.clear(); for (const auto &m : proto.repeats) { const u32 top = m.first; const PureRepeat &pr = m.second; u32 new_top = out.size(); out.emplace(new_top, pr); top_map[top] = new_top; } proto.repeats.swap(out); // Remap report map. proto.report_map.clear(); for (const auto &m : proto.repeats) { const u32 top = m.first; const PureRepeat &pr = m.second; for (const auto &report : pr.reports) { proto.report_map[report].insert(top); } } assert(proto.repeats.size() <= proto.max_occupancy); } namespace { struct HasReport { explicit HasReport(ReportID r) : report(r) {} bool operator()(const pair &a) const { return contains(a.second.reports, report); } private: ReportID report; }; } bool is_equal(const CastleProto &c1, ReportID report1, const CastleProto &c2, ReportID report2) { assert(!c1.repeats.empty()); assert(!c2.repeats.empty()); assert(c1.kind == c2.kind); if (c1.reach() != c2.reach()) { DEBUG_PRINTF("different reach\n"); return false; } map::const_iterator it = c1.repeats.begin(), ite = c1.repeats.end(), jt = c2.repeats.begin(), jte = c2.repeats.end(); for (;; ++it, ++jt) { it = find_if(it, ite, HasReport(report1)); jt = find_if(jt, jte, HasReport(report2)); if (it == ite && jt == jte) { DEBUG_PRINTF("success, cases are equivalent!\n"); return true; } if (it == ite || jt == jte) { DEBUG_PRINTF("no match for one repeat\n"); break; } if (it->first != jt->first) { DEBUG_PRINTF("different tops\n"); break; } const PureRepeat &r1 = it->second; const PureRepeat &r2 = jt->second; assert(r1.reach == c1.reach()); assert(r2.reach == c1.reach()); if (r1.bounds != r2.bounds) { DEBUG_PRINTF("different bounds\n"); break; } } return false; } bool is_equal(const CastleProto &c1, const CastleProto &c2) { assert(!c1.repeats.empty()); assert(!c2.repeats.empty()); assert(c1.kind == c2.kind); if (c1.reach() != c2.reach()) { DEBUG_PRINTF("different reach\n"); return false; } return c1.repeats == c2.repeats; } bool requiresDedupe(const CastleProto &proto, const ue2::flat_set &reports) { for (const auto &report : reports) { auto it = proto.report_map.find(report); if (it == end(proto.report_map)) { continue; } if (it->second.size() > 1) { DEBUG_PRINTF("castle proto %p has dupe report %u\n", &proto, report); return true; } } return false; } static void addToHolder(NGHolder &g, u32 top, const PureRepeat &pr) { DEBUG_PRINTF("top %u -> repeat %s\n", top, pr.bounds.str().c_str()); NFAVertex u = g.start; // Mandatory repeats to min bound. u32 min_bound = pr.bounds.min; // always finite if (min_bound == 0) { // Vacuous case, we can only do this once. assert(!edge(g.start, g.accept, g).second); NFAEdge e = add_edge(g.start, g.accept, g); g[e].tops.insert(top); g[u].reports.insert(pr.reports.begin(), pr.reports.end()); min_bound = 1; } for (u32 i = 0; i < min_bound; i++) { NFAVertex v = add_vertex(g); g[v].char_reach = pr.reach; NFAEdge e = add_edge(u, v, g); if (u == g.start) { g[e].tops.insert(top); } u = v; } NFAVertex head = u; // Optional repeats to max bound. if (pr.bounds.max.is_finite()) { assert(pr.bounds.max > depth(0)); const u32 max_bound = pr.bounds.max; for (u32 i = 0; i < max_bound - min_bound; i++) { NFAVertex v = add_vertex(g); g[v].char_reach = pr.reach; if (head != u) { add_edge(head, v, g); } NFAEdge e = add_edge(u, v, g); if (u == g.start) { g[e].tops.insert(top); } u = v; } } else { assert(pr.bounds.max.is_infinite()); add_edge(u, u, g); } // Connect to accept. add_edge(u, g.accept, g); g[u].reports.insert(pr.reports.begin(), pr.reports.end()); if (u != head) { add_edge(head, g.accept, g); g[head].reports.insert(pr.reports.begin(), pr.reports.end()); } } static bool hasZeroMinBound(const CastleProto &proto) { const depth zero(0); for (const PureRepeat &pr : proto.repeats | map_values) { if (pr.bounds.min == zero) { return true; } } return false; } unique_ptr makeHolder(const CastleProto &proto, const CompileContext &cc) { assert(!proto.repeats.empty()); // Vacuous edges are only doable in the NGHolder if we are a single-top // Castle. if (hasZeroMinBound(proto)) { if (proto.repeats.size() != 1 || proto.repeats.begin()->first != 0) { DEBUG_PRINTF("can't build multi-top vacuous holder\n"); return nullptr; } } auto g = ue2::make_unique(proto.kind); for (const auto &m : proto.repeats) { addToHolder(*g, m.first, m.second); } //dumpGraph("castle_holder.dot", *g); // Sanity checks. assert(allMatchStatesHaveReports(*g)); assert(!has_parallel_edge(*g)); reduceGraphEquivalences(*g, cc); removeRedundancy(*g, SOM_NONE); return g; } } // namespace ue2 hyperscan-4.4.1/src/nfa/castlecompile.h0000644000175000017500000001267713055426554020644 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Castle: multi-tenant repeat engine, compiler code. */ #ifndef NFA_CASTLECOMPILE_H #define NFA_CASTLECOMPILE_H #include "nfa_kind.h" #include "ue2common.h" #include "nfagraph/ng_repeat.h" #include "util/alloc.h" #include "util/depth.h" #include "util/ue2_containers.h" #include #include #include #include struct NFA; namespace ue2 { class CharReach; class NGHolder; class ReportManager; struct CompileContext; /** * \brief Prototype for a Castle engine: contains at least one CastleRepeat. * * Currently, all repeats in a Castle must have the same character * reachability. * * A CastleProto is converted into a single NFA, with each top triggering a * unique repeat. A CastleProto can contain at most CastleProto::max_occupancy * elements. */ struct CastleProto { static constexpr size_t max_occupancy = 65536; // arbitrary limit CastleProto(nfa_kind k, const PureRepeat &pr); const CharReach &reach() const; /** \brief Add a new repeat. */ u32 add(const PureRepeat &pr); /** \brief Remove a repeat. */ void erase(u32 top); /** * \brief Merge in the given repeat, returning the top used. * * If the repeat already exists in this castle, we will re-use (and return) * the old top. If it doesn't, it will be added and assigned a new top. * Returns \ref max_occupancy if capacity would be exceeded. */ u32 merge(const PureRepeat &pr); /** \brief Mapping from unique top id to repeat. */ std::map repeats; /** \brief Mapping from report to associated tops. */ ue2::unordered_map> report_map; /** * \brief Next top id to use. Repeats may be removed without top remapping, * so we track this explicitly instead of using repeats.size(). */ u32 next_top = 1; /** \brief Kind for this engine. */ nfa_kind kind; }; std::set all_reports(const CastleProto &proto); depth findMinWidth(const CastleProto &proto); depth findMaxWidth(const CastleProto &proto); depth findMinWidth(const CastleProto &proto, u32 top); depth findMaxWidth(const CastleProto &proto, u32 top); /** * \brief Remap tops to be contiguous. * * Remap the tops in the given CastleProto so that they're contiguous in the * range [0 .. N-1]. */ void remapCastleTops(CastleProto &proto, std::map &top_map); /** * \brief Construct an NFA from a CastleProto. * * NOTE: Tops must be contiguous, i.e. \ref remapCastleTops must have been run * first. */ ue2::aligned_unique_ptr buildCastle(const CastleProto &proto, const std::map>> &triggers, const CompileContext &cc, const ReportManager &rm); /** * \brief Merge two CastleProto prototypes together, if possible. * * Returns true if merge of all repeats in c2 into c1 succeeds, and fills * mapping with the repeat indices. */ bool mergeCastle(CastleProto &c1, const CastleProto &c2, std::map &top_map); /** * \brief True if the two castles are identical with respect to the reports * given; i.e. the same tops lead to the same repeats, just with report1 in c1 * and report2 in c2. * * Repeats leading to other reports are ignored. */ bool is_equal(const CastleProto &c1, ReportID report1, const CastleProto &c2, ReportID report2); /** * \brief True if the two castles given are identical. */ bool is_equal(const CastleProto &c1, const CastleProto &c2); /** * \brief True if the given castle contains more than a single instance of any * of the reports in the given set. */ bool requiresDedupe(const CastleProto &proto, const ue2::flat_set &reports); /** * \brief Build an NGHolder from a CastleProto. */ std::unique_ptr makeHolder(const CastleProto &castle, const CompileContext &cc); } // namespace ue2 #endif // NFA_CASTLECOMPILE_H hyperscan-4.4.1/src/nfa/lbr.h0000644000175000017500000001611613055426554016567 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 LBR_H #define LBR_H #include "ue2common.h" struct mq; struct NFA; #ifdef __cplusplus extern "C" { #endif // LBR Dot char nfaExecLbrDot_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrDot_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrDot_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecLbrDot_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecLbrDot_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecLbrDot_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecLbrDot_queueInitState(const struct NFA *n, struct mq *q); char nfaExecLbrDot_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecLbrDot_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecLbrDot_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecLbrDot_testEOD NFA_API_NO_IMPL #define nfaExecLbrDot_B_Reverse NFA_API_NO_IMPL #define nfaExecLbrDot_zombie_status NFA_API_ZOMBIE_NO_IMPL // LBR Verm char nfaExecLbrVerm_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrVerm_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrVerm_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecLbrVerm_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecLbrVerm_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecLbrVerm_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecLbrVerm_queueInitState(const struct NFA *n, struct mq *q); char nfaExecLbrVerm_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecLbrVerm_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecLbrVerm_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecLbrVerm_testEOD NFA_API_NO_IMPL #define nfaExecLbrVerm_B_Reverse NFA_API_NO_IMPL #define nfaExecLbrVerm_zombie_status NFA_API_ZOMBIE_NO_IMPL // LBR Negated Verm char nfaExecLbrNVerm_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrNVerm_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrNVerm_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecLbrNVerm_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecLbrNVerm_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecLbrNVerm_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecLbrNVerm_queueInitState(const struct NFA *n, struct mq *q); char nfaExecLbrNVerm_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecLbrNVerm_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecLbrNVerm_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecLbrNVerm_testEOD NFA_API_NO_IMPL #define nfaExecLbrNVerm_B_Reverse NFA_API_NO_IMPL #define nfaExecLbrNVerm_zombie_status NFA_API_ZOMBIE_NO_IMPL // LBR Shuf char nfaExecLbrShuf_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrShuf_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrShuf_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecLbrShuf_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecLbrShuf_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecLbrShuf_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecLbrShuf_queueInitState(const struct NFA *n, struct mq *q); char nfaExecLbrShuf_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecLbrShuf_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecLbrShuf_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecLbrShuf_testEOD NFA_API_NO_IMPL #define nfaExecLbrShuf_B_Reverse NFA_API_NO_IMPL #define nfaExecLbrShuf_zombie_status NFA_API_ZOMBIE_NO_IMPL // LBR Truffle char nfaExecLbrTruf_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrTruf_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecLbrTruf_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecLbrTruf_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecLbrTruf_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecLbrTruf_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecLbrTruf_queueInitState(const struct NFA *n, struct mq *q); char nfaExecLbrTruf_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecLbrTruf_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecLbrTruf_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecLbrTruf_testEOD NFA_API_NO_IMPL #define nfaExecLbrTruf_B_Reverse NFA_API_NO_IMPL #define nfaExecLbrTruf_zombie_status NFA_API_ZOMBIE_NO_IMPL #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/nfa_kind.h0000644000175000017500000001022513055426554017554 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** * \file * \brief Data structures and helper functions used to describe the purpose of * a particular NFA engine at build time. */ #ifndef NFA_KIND_H #define NFA_KIND_H #include "ue2common.h" #include namespace ue2 { /** \brief Specify the use-case for an nfa engine. */ enum nfa_kind { NFA_PREFIX, //!< rose prefix NFA_INFIX, //!< rose infix NFA_SUFFIX, //!< rose suffix NFA_OUTFIX, //!< "outfix" nfa not triggered by external events NFA_OUTFIX_RAW, //!< "outfix", but with unmanaged reports NFA_REV_PREFIX, //! reverse running prefixes (for som) NFA_EAGER_PREFIX, //!< rose prefix that is also run up to matches }; /** \brief True if this kind of engine is triggered by a top event. */ inline bool is_triggered(enum nfa_kind k) { switch (k) { case NFA_INFIX: case NFA_SUFFIX: case NFA_REV_PREFIX: return true; default: return false; } } /** * \brief True if this kind of engine generates actively checks for accept * states either to halt matching or to raise a callback. Only these engines * generated with this property should call nfaQueueExec() or * nfaQueueExecToMatch(). */ inline bool generates_callbacks(enum nfa_kind k) { switch (k) { case NFA_SUFFIX: case NFA_OUTFIX: case NFA_OUTFIX_RAW: case NFA_REV_PREFIX: case NFA_EAGER_PREFIX: return true; default: return false; } } /** * \brief True if this kind of engine has its state inspected to see if it is in * an accept state. Engines generated with this property will commonly call * nfaQueueExecRose(), nfaInAcceptState(), and nfaInAnyAcceptState(). */ inline bool inspects_states_for_accepts(enum nfa_kind k) { switch (k) { case NFA_PREFIX: case NFA_INFIX: case NFA_EAGER_PREFIX: return true; default: return false; } } /** * \brief True if this kind of engine has reports that are managed by the \ref * ReportManager. */ inline bool has_managed_reports(enum nfa_kind k) { switch (k) { case NFA_SUFFIX: case NFA_OUTFIX: return true; default: return false; } } #if defined(DEBUG) || defined(DUMP_SUPPORT) inline std::string to_string(nfa_kind k) { switch (k) { case NFA_PREFIX: return "PREFIX"; case NFA_INFIX: return "INFIX"; case NFA_SUFFIX: return "SUFFIX"; case NFA_OUTFIX: return "OUTFIX"; case NFA_REV_PREFIX: return "REV_PREFIX"; case NFA_OUTFIX_RAW: return "OUTFIX_RAW"; case NFA_EAGER_PREFIX: return "EAGER_PREFIX"; } assert(0); return "?"; } #endif } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/callback.h0000644000175000017500000000617213055426554017545 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA Callback definitions, used at runtime. */ #ifndef NFA_CALLBACK_H #define NFA_CALLBACK_H #include "ue2common.h" /** \brief The type for an NFA callback. * * This is a function that takes as arguments the current start and end offsets * where the match occurs, the id of the match and the context pointer that was * passed into the NFA API function that executed the NFA. * * The start offset is the "start of match" (SOM) offset for the match. It is * only provided by engines that natively support SOM tracking (e.g. Gough). * * The end offset will be the offset after the character that caused the match. * Thus, if we have a buffer containing 'abc', then a pattern that matches an * empty string will have an offset of 0, a pattern that matches 'a' will have * an offset of 1, and a pattern that matches 'abc' will have an offset of 3, * which will be a value that is 'beyond' the size of the buffer. That is, if * we have n characters in the buffer, there are n+1 different potential * offsets for matches. * * This function should return an int - currently the possible return values * are 0, which means 'stop running the engine' or non-zero, which means * 'continue matching'. */ typedef int (*NfaCallback)(u64a start, u64a end, ReportID id, void *context); /** * standard \ref NfaCallback return value indicating that engine execution * should continue. (any non-zero value will serve this purpose) */ #define MO_CONTINUE_MATCHING 1 /** * \ref NfaCallback return value indicating that engine execution should halt. */ #define MO_HALT_MATCHING 0 #endif // NFA_CALLBACK_H hyperscan-4.4.1/src/nfa/mpvcompile.cpp0000644000175000017500000003271613055426554020522 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "mpvcompile.h" #include "mpv_internal.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "shufticompile.h" #include "trufflecompile.h" #include "util/alloc.h" #include "util/multibit_build.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/verify_types.h" #include #include #include #include using namespace std; using boost::adaptors::map_values; using boost::adaptors::map_keys; namespace ue2 { namespace { struct pcomp { bool operator()(const raw_puff &a, const raw_puff &b) const { return tie(a.repeats, a.unbounded, a.simple_exhaust, a.report) < tie(b.repeats, b.unbounded, b.simple_exhaust, b.report); } }; struct ClusterKey { explicit ClusterKey(const raw_puff &src) : trigger_event(MQE_INVALID), reach(src.reach), auto_restart(src.auto_restart) {} ClusterKey(u32 event, const raw_puff &src) : trigger_event(event), reach(src.reach), auto_restart(src.auto_restart) {} u32 trigger_event; CharReach reach; bool auto_restart; bool operator<(const ClusterKey &b) const { const ClusterKey &a = *this; ORDER_CHECK(trigger_event); /* want triggered puffs first */ ORDER_CHECK(auto_restart); ORDER_CHECK(reach); return false; } }; } // namespace static void writePuffette(mpv_puffette *out, const raw_puff &rp, const ReportManager &rm) { DEBUG_PRINTF("outputting %u %d %u to %p\n", rp.repeats, (int)rp.unbounded, rp.report, out); out->repeats = rp.repeats; out->unbounded = rp.unbounded; out->simple_exhaust = rp.simple_exhaust; out->report = rm.getProgramOffset(rp.report); } static void writeSentinel(mpv_puffette *out) { DEBUG_PRINTF("outputting sentinel to %p\n", out); memset(out, 0, sizeof(*out)); out->report = INVALID_REPORT; } static void writeDeadPoint(mpv_kilopuff *out, const vector &puffs) { for (const auto &puff : puffs) { if (puff.unbounded) { /* mpv can never die */ out->dead_point = MPV_DEAD_VALUE; return; } } out->dead_point = puffs.back().repeats + 1; } static size_t calcSize(const map> &raw, const vector &counters) { size_t len = sizeof(NFA) + sizeof(mpv); len += sizeof(mpv_kilopuff) * raw.size(); /* need a kilopuff for each distinct reach */ len += sizeof(mpv_counter_info) * counters.size(); len += sizeof(mpv_puffette); /* initial sent */ for (const vector &puffs : raw | map_values) { len += sizeof(mpv_puffette) * puffs.size(); len += sizeof(mpv_puffette); /* terminal sent */ } return len; } static void populateClusters(const vector &puffs_in, const vector &triggered_puffs, map> *raw) { map> &puff_clusters = *raw; u32 e = MQE_TOP_FIRST; for (const auto &puff : triggered_puffs) { puff_clusters[ClusterKey(e, puff)].push_back(puff); e++; } for (const auto &puff : puffs_in) { puff_clusters[ClusterKey(puff)].push_back(puff); } for (vector &puffs : puff_clusters | map_values) { sort(puffs.begin(), puffs.end(), pcomp()); } } static void writeKiloPuff(const map>::const_iterator &it, const ReportManager &rm, u32 counter_offset, mpv *m, mpv_kilopuff *kp, mpv_puffette **pa) { const CharReach &reach = it->first.reach; const vector &puffs = it->second; kp->auto_restart = it->first.auto_restart; if (reach.all()) { kp->type = MPV_DOT; } else if (reach.count() == 255) { kp->type = MPV_VERM; size_t unset = (~reach).find_first(); assert(unset != CharReach::npos); kp->u.verm.c = (char)unset; } else if (reach.count() == 1) { kp->type = MPV_NVERM; size_t set = reach.find_first(); assert(set != CharReach::npos); kp->u.verm.c = (char)set; } else if (shuftiBuildMasks(~reach, (u8 *)&kp->u.shuf.mask_lo, (u8 *)&kp->u.shuf.mask_hi) != -1) { kp->type = MPV_SHUFTI; } else { kp->type = MPV_TRUFFLE; truffleBuildMasks(~reach, (u8 *)&kp->u.truffle.mask1, (u8 *)&kp->u.truffle.mask2); } kp->count = verify_u32(puffs.size()); kp->counter_offset = counter_offset; /* start of real puffette array */ kp->puffette_offset = verify_u32((char *)*pa - (char *)m); for (size_t i = 0; i < puffs.size(); i++) { assert(!it->first.auto_restart || puffs[i].unbounded); writePuffette(*pa + i, puffs[i], rm); } *pa += puffs.size(); writeSentinel(*pa); ++*pa; writeDeadPoint(kp, puffs); } static void writeCoreNfa(NFA *nfa, u32 len, u32 min_width, u32 max_counter, u32 streamStateSize, u32 scratchStateSize) { assert(nfa); nfa->length = len; nfa->nPositions = max_counter - 1; nfa->type = MPV_NFA; nfa->streamStateSize = streamStateSize; assert(16 >= sizeof(mpv_decomp_kilo)); nfa->scratchStateSize = scratchStateSize; nfa->minWidth = min_width; } static void findCounterSize(map>::const_iterator kp_it, map>::const_iterator kp_ite, u64a *max_counter_out, u32 *counter_size) { u32 max_counter = 0; /* max counter that we may need to know about is one more than largest repeat */ for (; kp_it != kp_ite; ++kp_it) { max_counter = MAX(max_counter, kp_it->second.back().repeats + 1); } if (max_counter < (1U << 8)) { *counter_size = 1; } else if (max_counter < (1U << 16)) { *counter_size = 2; } else if (max_counter < (1U << 24)) { *counter_size = 3; } else { *counter_size = 4; } *max_counter_out = max_counter; } static void fillCounterInfo(mpv_counter_info *out, u32 *curr_decomp_offset, u32 *curr_comp_offset, const map> &kilopuffs, map>::const_iterator kp_it, map>::const_iterator kp_ite) { out->kilo_begin = distance(kilopuffs.begin(), kp_it); out->kilo_end = distance(kilopuffs.begin(), kp_ite); findCounterSize(kp_it, kp_ite, &out->max_counter, &out->counter_size); out->counter_offset = *curr_decomp_offset; *curr_decomp_offset += sizeof(u64a); *curr_comp_offset += out->counter_size; } static void fillCounterInfos(vector *out, u32 *curr_decomp_offset, u32 *curr_comp_offset, const map> &kilopuffs) { /* first the triggered puffs */ map>::const_iterator it = kilopuffs.begin(); while (it != kilopuffs.end() && it->first.trigger_event != MQE_INVALID) { assert(!it->first.auto_restart); assert(it->first.trigger_event == MQE_TOP_FIRST + distance(kilopuffs.begin(), it)); out->push_back(mpv_counter_info()); map>::const_iterator it_o = it; ++it; fillCounterInfo(&out->back(), curr_decomp_offset, curr_comp_offset, kilopuffs, it_o, it); } /* we may have 2 sets of non triggered puffs: * 1) always started with no auto_restart * 2) always started with auto_restart */ map>::const_iterator trig_ite = it; while (it != kilopuffs.end() && !it->first.auto_restart) { assert(it->first.trigger_event == MQE_INVALID); ++it; } if (it != trig_ite) { out->push_back(mpv_counter_info()); fillCounterInfo(&out->back(), curr_decomp_offset, curr_comp_offset, kilopuffs, kilopuffs.begin(), it); } while (it != kilopuffs.end() && it->first.auto_restart) { assert(it->first.trigger_event == MQE_INVALID); out->push_back(mpv_counter_info()); map>::const_iterator it_o = it; ++it; fillCounterInfo(&out->back(), curr_decomp_offset, curr_comp_offset, kilopuffs, it_o, it); } } static const mpv_counter_info &findCounter(const vector &counters, u32 i) { for (const auto &counter : counters) { if (i >= counter.kilo_begin && i < counter.kilo_end) { return counter; } } assert(0); return counters.front(); } aligned_unique_ptr mpvCompile(const vector &puffs_in, const vector &triggered_puffs, const ReportManager &rm) { assert(!puffs_in.empty() || !triggered_puffs.empty()); u32 puffette_count = puffs_in.size() + triggered_puffs.size(); map> puff_clusters; populateClusters(puffs_in, triggered_puffs, &puff_clusters); u32 curr_comp_offset = 0; u32 curr_decomp_offset = sizeof(mpv_decomp_state); curr_decomp_offset += 16 * puff_clusters.size(); vector counters; fillCounterInfos(&counters, &curr_decomp_offset, &curr_comp_offset, puff_clusters); u32 pq_offset = curr_decomp_offset; curr_decomp_offset += sizeof(mpv_pq_item) * puff_clusters.size(); u32 rl_offset = curr_decomp_offset; curr_decomp_offset += sizeof(ReportID) * puffette_count; u32 reporter_offset = curr_decomp_offset; curr_decomp_offset += mmbit_size(puff_clusters.size()); u32 active_offset = curr_comp_offset; curr_comp_offset += mmbit_size(puff_clusters.size()); u32 len = calcSize(puff_clusters, counters); DEBUG_PRINTF("%u puffs, len = %u\n", puffette_count, len); aligned_unique_ptr nfa = aligned_zmalloc_unique(len); mpv_puffette *pa_base = (mpv_puffette *) ((char *)nfa.get() + sizeof(NFA) + sizeof(mpv) + sizeof(mpv_kilopuff) * puff_clusters.size() + sizeof(mpv_counter_info) * counters.size()); mpv_puffette *pa = pa_base; writeSentinel(pa); ++pa; /* skip init sentinel */ u32 min_repeat = ~0U; u32 max_counter = 0; /* max counter that we may need to know about is one more than largest repeat */ for (const vector &puffs : puff_clusters | map_values) { max_counter = max(max_counter, puffs.back().repeats + 1); min_repeat = min(min_repeat, puffs.front().repeats); } mpv *m = (mpv *)getMutableImplNfa(nfa.get()); m->kilo_count = verify_u32(puff_clusters.size()); m->counter_count = verify_u32(counters.size()); m->puffette_count = puffette_count; m->pq_offset = pq_offset; m->reporter_offset = reporter_offset; m->report_list_offset = rl_offset; m->active_offset = active_offset; m->top_kilo_begin = verify_u32(triggered_puffs.size()); m->top_kilo_end = verify_u32(puff_clusters.size()); mpv_kilopuff *kp_begin = (mpv_kilopuff *)(m + 1); mpv_kilopuff *kp = kp_begin; for (auto it = puff_clusters.begin(); it != puff_clusters.end(); ++it) { writeKiloPuff(it, rm, findCounter(counters, kp - kp_begin).counter_offset, m, kp, &pa); ++kp; } assert((char *)pa == (char *)nfa.get() + len); mpv_counter_info *out_ci = (mpv_counter_info *)kp; for (const auto &counter : counters) { *out_ci = counter; ++out_ci; } assert((char *)out_ci == (char *)pa_base); writeCoreNfa(nfa.get(), len, min_repeat, max_counter, curr_comp_offset, curr_decomp_offset); return nfa; } } // namespace ue2 hyperscan-4.4.1/src/nfa/limex_shuffle.h0000644000175000017500000000520113055426554020633 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Naive dynamic shuffles. * * These are written with the assumption that the provided masks are sparsely * populated and never contain more than 32 on bits. Other implementations will * be faster and actually correct if these assumptions don't hold true. */ #ifndef LIMEX_SHUFFLE_H #define LIMEX_SHUFFLE_H #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" static really_inline u32 packedExtract128(m128 s, const m128 permute, const m128 compare) { m128 shuffled = pshufb(s, permute); m128 compared = and128(shuffled, compare); u16 rv = ~movemask128(eq128(compared, shuffled)); return (u32)rv; } #if defined(__AVX2__) static really_inline u32 packedExtract256(m256 s, const m256 permute, const m256 compare) { // vpshufb doesn't cross lanes, so this is a bit of a cheat m256 shuffled = vpshufb(s, permute); m256 compared = and256(shuffled, compare); u32 rv = ~movemask256(eq256(compared, shuffled)); // stitch the lane-wise results back together return (u32)((rv >> 16) | (rv & 0xffffU)); } #endif // AVX2 #endif // LIMEX_SHUFFLE_H hyperscan-4.4.1/src/nfa/sheng.h0000644000175000017500000000570613055426554017117 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 SHENG_H_ #define SHENG_H_ #include "callback.h" #include "ue2common.h" struct mq; struct NFA; #define nfaExecSheng_B_Reverse NFA_API_NO_IMPL #define nfaExecSheng_zombie_status NFA_API_ZOMBIE_NO_IMPL char nfaExecSheng_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecSheng_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecSheng_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecSheng_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecSheng_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecSheng_queueInitState(const struct NFA *nfa, struct mq *q); char nfaExecSheng_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecSheng_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); char nfaExecSheng_initCompressedState(const struct NFA *nfa, u64a offset, void *state, u8 key); char nfaExecSheng_testEOD(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); char nfaExecSheng_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecSheng_B(const struct NFA *n, u64a offset, const u8 *buffer, size_t length, NfaCallback cb, void *context); #endif /* SHENG_H_ */ hyperscan-4.4.1/src/nfa/lbr_dump.h0000644000175000017500000000403413055426554017610 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 LBR_DUMP_H #define LBR_DUMP_H #ifdef DUMP_SUPPORT #include struct NFA; namespace ue2 { void nfaExecLbrDot_dump(const struct NFA *nfa, const std::string &base); void nfaExecLbrVerm_dump(const struct NFA *nfa, const std::string &base); void nfaExecLbrNVerm_dump(const struct NFA *nfa, const std::string &base); void nfaExecLbrShuf_dump(const struct NFA *nfa, const std::string &base); void nfaExecLbrTruf_dump(const struct NFA *nfa, const std::string &base); } // namespace ue2 #endif #endif hyperscan-4.4.1/src/nfa/multitruffle.h0000644000175000017500000000604213055426554020527 0ustar sleuthkidsleuthkid/* * 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 MULTITRUFFLE_H #define MULTITRUFFLE_H /** \file * \brief Multitruffle: multibyte version of Truffle. * * Utilises the SSSE3 pshufb shuffle instruction */ #include "util/simd_types.h" #ifdef __cplusplus extern "C" { #endif const u8 *long_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *longgrab_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *shift_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *shiftgrab_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *doubleshift_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len, const u8 run2_len); const u8 *doubleshiftgrab_truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len, const u8 run2_len); #ifdef __cplusplus } #endif #endif /* MULTITRUFFLE_H */ hyperscan-4.4.1/src/nfa/shengcompile.h0000644000175000017500000000574013055426554020466 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 SHENGCOMPILE_H_ #define SHENGCOMPILE_H_ #include "accel_dfa_build_strat.h" #include "rdfa.h" #include "util/alloc.h" #include "util/charreach.h" #include "util/ue2_containers.h" struct NFA; namespace ue2 { class ReportManager; struct CompileContext; struct raw_dfa; class sheng_build_strat : public accel_dfa_build_strat { public: sheng_build_strat(raw_dfa &rdfa_in, const ReportManager &rm_in) : accel_dfa_build_strat(rm_in), rdfa(rdfa_in) {} raw_dfa &get_raw() const override { return rdfa; } std::unique_ptr gatherReports( std::vector &reports /* out */, std::vector &reports_eod /* out */, u8 *isSingleReport /* out */, ReportID *arbReport /* out */) const override; size_t accelSize(void) const override; u32 max_allowed_offset_accel() const override; u32 max_stop_char() const override; u32 max_floating_stop_char() const override; private: raw_dfa &rdfa; }; aligned_unique_ptr shengCompile(raw_dfa &raw, const CompileContext &cc, const ReportManager &rm, std::set *accel_states = nullptr); struct sheng_escape_info { CharReach outs; CharReach outs2_single; flat_set> outs2; bool outs2_broken = false; }; bool has_accel_sheng(const NFA *nfa); } // namespace ue2 #endif /* SHENGCOMPILE_H_ */ hyperscan-4.4.1/src/nfa/accelcompile.cpp0000644000175000017500000004360013055426554020761 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "accel.h" #include "accelcompile.h" #include "shufticompile.h" #include "trufflecompile.h" #include "nfagraph/ng_limex_accel.h" /* for constants */ #include "util/bitutils.h" #include "util/verify_types.h" #include #include #include using namespace std; namespace ue2 { static void buildAccelSingle(const AccelInfo &info, AccelAux *aux) { assert(aux->accel_type == ACCEL_NONE); if (info.single_stops.all()) { return; } size_t outs = info.single_stops.count(); DEBUG_PRINTF("%zu outs\n", outs); assert(outs && outs < 256); u32 offset = info.single_offset; if (outs == 1) { aux->accel_type = ACCEL_VERM; aux->verm.offset = offset; aux->verm.c = info.single_stops.find_first(); DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c); return; } if (outs == 2 && info.single_stops.isCaselessChar()) { aux->accel_type = ACCEL_VERM_NOCASE; aux->verm.offset = offset; aux->verm.c = info.single_stops.find_first() & CASE_CLEAR; DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n", aux->verm.c); return; } DEBUG_PRINTF("attempting shufti for %zu chars\n", outs); if (-1 != shuftiBuildMasks(info.single_stops, (u8 *)&aux->shufti.lo, (u8 *)&aux->shufti.hi)) { aux->accel_type = ACCEL_SHUFTI; aux->shufti.offset = offset; DEBUG_PRINTF("shufti built OK\n"); return; } else { DEBUG_PRINTF("shufti build failed, falling through\n"); } if (outs <= ACCEL_MAX_STOP_CHAR) { DEBUG_PRINTF("building Truffle for %zu chars\n", outs); aux->accel_type = ACCEL_TRUFFLE; aux->truffle.offset = offset; truffleBuildMasks(info.single_stops, (u8 *)&aux->truffle.mask1, (u8 *)&aux->truffle.mask2); return; } DEBUG_PRINTF("unable to accelerate case with %zu outs\n", outs); } bool buildDvermMask(const flat_set> &escape_set, u8 *m1_out, u8 *m2_out) { u8 a1 = 0xff; u8 a2 = 0xff; u8 b1 = 0xff; u8 b2 = 0xff; for (const auto &e : escape_set) { DEBUG_PRINTF("%0hhx %0hhx\n", e.first, e.second); a1 &= e.first; b1 &= ~e.first; a2 &= e.second; b2 &= ~e.second; } u8 m1 = a1 | b1; u8 m2 = a2 | b2; u32 holes1 = 8 - popcount32(m1); u32 holes2 = 8 - popcount32(m2); DEBUG_PRINTF("aaaa %0hhx %0hhx\n", a1, a2); DEBUG_PRINTF("bbbb %0hhx %0hhx\n", b1, b2); DEBUG_PRINTF("mask %0hhx %0hhx\n", m1, m2); assert(holes1 <= 8 && holes2 <= 8); assert(escape_set.size() <= 1U << (holes1 + holes2)); if (escape_set.size() != 1U << (holes1 + holes2)) { return false; } if (m1_out) { *m1_out = m1; } if (m2_out) { *m2_out = m2; } return true; } static bool isCaselessDouble(const flat_set> &stop) { // test for vector containing if (stop.size() != 4) { return false; } const u8 a = stop.begin()->first & CASE_CLEAR; const u8 b = stop.begin()->second & CASE_CLEAR; flat_set>::const_iterator it, ite; for (it = stop.begin(), ite = stop.end(); it != ite; ++it) { if ((it->first & CASE_CLEAR) != a || (it->second & CASE_CLEAR) != b) { return false; } } return true; } static void buildAccelDouble(const AccelInfo &info, AccelAux *aux) { size_t outs1 = info.double_stop1.count(); size_t outs2 = info.double_stop2.size(); u8 offset = verify_u8(info.double_offset); DEBUG_PRINTF("outs1=%zu, outs2=%zu\n", outs1, outs2); assert(aux->accel_type == ACCEL_NONE); if (!outs2) { /* no double byte accel available */ return; } // double-byte accel if (outs1 == 0 && outs2 == 1) { aux->accel_type = ACCEL_DVERM; aux->dverm.offset = offset; aux->dverm.c1 = info.double_stop2.begin()->first; aux->dverm.c2 = info.double_stop2.begin()->second; DEBUG_PRINTF("building double-vermicelli caseful for 0x%02hhx%02hhx\n", aux->dverm.c1, aux->dverm.c2); return; } if (outs1 == 0 && isCaselessDouble(info.double_stop2)) { aux->accel_type = ACCEL_DVERM_NOCASE; aux->dverm.offset = offset; aux->dverm.c1 = info.double_stop2.begin()->first & CASE_CLEAR; aux->dverm.c2 = info.double_stop2.begin()->second & CASE_CLEAR; DEBUG_PRINTF("building double-vermicelli caseless for 0x%02hhx%02hhx\n", aux->dverm.c1, aux->dverm.c2); return; } if (outs1 == 0) { u8 m1; u8 m2; if (buildDvermMask(info.double_stop2, &m1, &m2)) { aux->accel_type = ACCEL_DVERM_MASKED; aux->dverm.offset = offset; aux->dverm.c1 = info.double_stop2.begin()->first & m1; aux->dverm.c2 = info.double_stop2.begin()->second & m2; aux->dverm.m1 = m1; aux->dverm.m2 = m2; DEBUG_PRINTF("building maskeddouble-vermicelli for 0x%02hhx%02hhx\n", aux->dverm.c1, aux->dverm.c2); return; } } if (outs1 < outs2 && outs1 <= 2) { // Heuristic from UE-438. DEBUG_PRINTF("building double-shufti for %zu one-byte and %zu" " two-byte literals\n", outs1, outs2); aux->accel_type = ACCEL_DSHUFTI; aux->dshufti.offset = offset; if (shuftiBuildDoubleMasks( info.double_stop1, info.double_stop2, (u8 *)&aux->dshufti.lo1, (u8 *)&aux->dshufti.hi1, (u8 *)&aux->dshufti.lo2, (u8 *)&aux->dshufti.hi2)) { return; } } // drop back to attempt single-byte accel DEBUG_PRINTF("dropping back to single-byte acceleration\n"); aux->accel_type = ACCEL_NONE; } static void buildAccelMulti(const AccelInfo &info, AccelAux *aux) { if (info.ma_type == MultibyteAccelInfo::MAT_NONE) { DEBUG_PRINTF("no multimatch for us :("); return; } u32 offset = info.multiaccel_offset; const CharReach &stops = info.multiaccel_stops; assert(aux->accel_type == ACCEL_NONE); if (stops.all()) { return; } size_t outs = stops.count(); DEBUG_PRINTF("%zu outs\n", outs); assert(outs && outs < 256); switch (info.ma_type) { case MultibyteAccelInfo::MAT_LONG: if (outs == 1) { aux->accel_type = ACCEL_MLVERM; aux->mverm.offset = offset; aux->mverm.c = stops.find_first(); aux->mverm.len = info.ma_len1; DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c); return; } if (outs == 2 && stops.isCaselessChar()) { aux->accel_type = ACCEL_MLVERM_NOCASE; aux->mverm.offset = offset; aux->mverm.c = stops.find_first() & CASE_CLEAR; aux->mverm.len = info.ma_len1; DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n", aux->verm.c); return; } break; case MultibyteAccelInfo::MAT_LONGGRAB: if (outs == 1) { aux->accel_type = ACCEL_MLGVERM; aux->mverm.offset = offset; aux->mverm.c = stops.find_first(); aux->mverm.len = info.ma_len1; DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c); return; } if (outs == 2 && stops.isCaselessChar()) { aux->accel_type = ACCEL_MLGVERM_NOCASE; aux->mverm.offset = offset; aux->mverm.c = stops.find_first() & CASE_CLEAR; aux->mverm.len = info.ma_len1; DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n", aux->verm.c); return; } break; case MultibyteAccelInfo::MAT_SHIFT: if (outs == 1) { aux->accel_type = ACCEL_MSVERM; aux->mverm.offset = offset; aux->mverm.c = stops.find_first(); aux->mverm.len = info.ma_len1; DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c); return; } if (outs == 2 && stops.isCaselessChar()) { aux->accel_type = ACCEL_MSVERM_NOCASE; aux->mverm.offset = offset; aux->mverm.c = stops.find_first() & CASE_CLEAR; aux->mverm.len = info.ma_len1; DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n", aux->verm.c); return; } break; case MultibyteAccelInfo::MAT_SHIFTGRAB: if (outs == 1) { aux->accel_type = ACCEL_MSGVERM; aux->mverm.offset = offset; aux->mverm.c = stops.find_first(); aux->mverm.len = info.ma_len1; DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c); return; } if (outs == 2 && stops.isCaselessChar()) { aux->accel_type = ACCEL_MSGVERM_NOCASE; aux->mverm.offset = offset; aux->mverm.c = stops.find_first() & CASE_CLEAR; aux->mverm.len = info.ma_len1; DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n", aux->verm.c); return; } break; case MultibyteAccelInfo::MAT_DSHIFT: if (outs == 1) { aux->accel_type = ACCEL_MDSVERM; aux->mdverm.offset = offset; aux->mdverm.c = stops.find_first(); aux->mdverm.len1 = info.ma_len1; aux->mdverm.len2 = info.ma_len2; DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c); return; } if (outs == 2 && stops.isCaselessChar()) { aux->accel_type = ACCEL_MDSVERM_NOCASE; aux->mverm.offset = offset; aux->mverm.c = stops.find_first() & CASE_CLEAR; aux->mdverm.len1 = info.ma_len1; aux->mdverm.len2 = info.ma_len2; DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n", aux->verm.c); return; } break; case MultibyteAccelInfo::MAT_DSHIFTGRAB: if (outs == 1) { aux->accel_type = ACCEL_MDSGVERM; aux->mdverm.offset = offset; aux->mdverm.c = stops.find_first(); aux->mdverm.len1 = info.ma_len1; aux->mdverm.len2 = info.ma_len2; DEBUG_PRINTF("building vermicelli caseful for 0x%02hhx\n", aux->verm.c); return; } if (outs == 2 && stops.isCaselessChar()) { aux->accel_type = ACCEL_MDSGVERM_NOCASE; aux->mverm.offset = offset; aux->mverm.c = stops.find_first() & CASE_CLEAR; aux->mdverm.len1 = info.ma_len1; aux->mdverm.len2 = info.ma_len2; DEBUG_PRINTF("building vermicelli caseless for 0x%02hhx\n", aux->verm.c); return; } break; default: // shouldn't happen assert(0); return; } DEBUG_PRINTF("attempting shufti for %zu chars\n", outs); switch (info.ma_type) { case MultibyteAccelInfo::MAT_LONG: if (shuftiBuildMasks(stops, (u8 *)&aux->mshufti.lo, (u8 *)&aux->mshufti.hi) == -1) { break; } aux->accel_type = ACCEL_MLSHUFTI; aux->mshufti.offset = offset; aux->mshufti.len = info.ma_len1; return; case MultibyteAccelInfo::MAT_LONGGRAB: if (shuftiBuildMasks(stops, (u8 *)&aux->mshufti.lo, (u8 *)&aux->mshufti.hi) == -1) { break; } aux->accel_type = ACCEL_MLGSHUFTI; aux->mshufti.offset = offset; aux->mshufti.len = info.ma_len1; return; case MultibyteAccelInfo::MAT_SHIFT: if (shuftiBuildMasks(stops, (u8 *)&aux->mshufti.lo, (u8 *)&aux->mshufti.hi) == -1) { break; } aux->accel_type = ACCEL_MSSHUFTI; aux->mshufti.offset = offset; aux->mshufti.len = info.ma_len1; return; case MultibyteAccelInfo::MAT_SHIFTGRAB: if (shuftiBuildMasks(stops, (u8 *)&aux->mshufti.lo, (u8 *)&aux->mshufti.hi) == -1) { break; } aux->accel_type = ACCEL_MSGSHUFTI; aux->mshufti.offset = offset; aux->mshufti.len = info.ma_len1; return; case MultibyteAccelInfo::MAT_DSHIFT: if (shuftiBuildMasks(stops, (u8 *)&aux->mdshufti.lo, (u8 *)&aux->mdshufti.hi) == -1) { break; } aux->accel_type = ACCEL_MDSSHUFTI; aux->mdshufti.offset = offset; aux->mdshufti.len1 = info.ma_len1; aux->mdshufti.len2 = info.ma_len2; return; case MultibyteAccelInfo::MAT_DSHIFTGRAB: if (shuftiBuildMasks(stops, (u8 *)&aux->mdshufti.lo, (u8 *)&aux->mdshufti.hi) == -1) { break; } aux->accel_type = ACCEL_MDSGSHUFTI; aux->mdshufti.offset = offset; aux->mdshufti.len1 = info.ma_len1; aux->mdshufti.len2 = info.ma_len2; return; default: // shouldn't happen assert(0); return; } DEBUG_PRINTF("shufti build failed, falling through\n"); if (outs <= ACCEL_MAX_STOP_CHAR) { DEBUG_PRINTF("building Truffle for %zu chars\n", outs); switch (info.ma_type) { case MultibyteAccelInfo::MAT_LONG: aux->accel_type = ACCEL_MLTRUFFLE; aux->mtruffle.offset = offset; aux->mtruffle.len = info.ma_len1; truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1, (u8 *)&aux->mtruffle.mask2); break; case MultibyteAccelInfo::MAT_LONGGRAB: aux->accel_type = ACCEL_MLGTRUFFLE; aux->mtruffle.offset = offset; aux->mtruffle.len = info.ma_len1; truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1, (u8 *)&aux->mtruffle.mask2); break; case MultibyteAccelInfo::MAT_SHIFT: aux->accel_type = ACCEL_MSTRUFFLE; aux->mtruffle.offset = offset; aux->mtruffle.len = info.ma_len1; truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1, (u8 *)&aux->mtruffle.mask2); break; case MultibyteAccelInfo::MAT_SHIFTGRAB: aux->accel_type = ACCEL_MSGTRUFFLE; aux->mtruffle.offset = offset; aux->mtruffle.len = info.ma_len1; truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1, (u8 *)&aux->mtruffle.mask2); break; case MultibyteAccelInfo::MAT_DSHIFT: aux->accel_type = ACCEL_MDSTRUFFLE; aux->mdtruffle.offset = offset; aux->mdtruffle.len1 = info.ma_len1; aux->mdtruffle.len2 = info.ma_len2; truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1, (u8 *)&aux->mdtruffle.mask2); break; case MultibyteAccelInfo::MAT_DSHIFTGRAB: aux->accel_type = ACCEL_MDSGTRUFFLE; aux->mdtruffle.offset = offset; aux->mdtruffle.len1 = info.ma_len1; aux->mdtruffle.len2 = info.ma_len2; truffleBuildMasks(stops, (u8 *)&aux->mtruffle.mask1, (u8 *)&aux->mdtruffle.mask2); break; default: // shouldn't happen assert(0); return; } return; } DEBUG_PRINTF("unable to accelerate multibyte case with %zu outs\n", outs); } bool buildAccelAux(const AccelInfo &info, AccelAux *aux) { assert(aux->accel_type == ACCEL_NONE); if (info.single_stops.none()) { DEBUG_PRINTF("picked red tape\n"); aux->accel_type = ACCEL_RED_TAPE; aux->generic.offset = info.single_offset; } if (aux->accel_type == ACCEL_NONE) { buildAccelMulti(info, aux); } if (aux->accel_type == ACCEL_NONE) { buildAccelDouble(info, aux); } if (aux->accel_type == ACCEL_NONE) { buildAccelSingle(info, aux); } assert(aux->accel_type == ACCEL_NONE || aux->generic.offset == info.single_offset || aux->generic.offset == info.double_offset); return aux->accel_type != ACCEL_NONE; } } // namespace ue2 hyperscan-4.4.1/src/nfa/multiaccel_doubleshiftgrab.h0000644000175000017500000001250513055426554023354 0ustar sleuthkidsleuthkid/* * 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_ */ hyperscan-4.4.1/src/nfa/accel.c0000644000175000017500000002767713055426554017070 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "accel.h" #include "shufti.h" #include "truffle.h" #include "vermicelli.h" #include "multishufti.h" #include "multitruffle.h" #include "multivermicelli.h" #include "ue2common.h" const u8 *run_accel(const union AccelAux *accel, const u8 *c, const u8 *c_end) { assert(ISALIGNED_N(accel, alignof(union AccelAux))); const u8 *rv; switch (accel->accel_type) { case ACCEL_NONE: DEBUG_PRINTF("accel none %p %p\n", c, c_end); return c; case ACCEL_VERM: DEBUG_PRINTF("accel verm %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = vermicelliExec(accel->verm.c, 0, c, c_end); break; case ACCEL_VERM_NOCASE: DEBUG_PRINTF("accel verm nc %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = vermicelliExec(accel->verm.c, 1, c, c_end); break; case ACCEL_DVERM: DEBUG_PRINTF("accel dverm %p %p\n", c, c_end); if (c + 16 + 1 >= c_end) { return c; } /* need to stop one early to get an accurate end state */ rv = vermicelliDoubleExec(accel->dverm.c1, accel->dverm.c2, 0, c, c_end - 1); break; case ACCEL_DVERM_NOCASE: DEBUG_PRINTF("accel dverm nc %p %p\n", c, c_end); if (c + 16 + 1 >= c_end) { return c; } /* need to stop one early to get an accurate end state */ rv = vermicelliDoubleExec(accel->dverm.c1, accel->dverm.c2, 1, c, c_end - 1); break; case ACCEL_DVERM_MASKED: DEBUG_PRINTF("accel dverm masked %p %p\n", c, c_end); if (c + 16 + 1 >= c_end) { return c; } /* need to stop one early to get an accurate end state */ rv = vermicelliDoubleMaskedExec(accel->dverm.c1, accel->dverm.c2, accel->dverm.m1, accel->dverm.m2, c, c_end - 1); break; case ACCEL_SHUFTI: DEBUG_PRINTF("accel shufti %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shuftiExec(accel->shufti.lo, accel->shufti.hi, c, c_end); break; case ACCEL_TRUFFLE: DEBUG_PRINTF("accel Truffle %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = truffleExec(accel->truffle.mask1, accel->truffle.mask2, c, c_end); break; case ACCEL_DSHUFTI: DEBUG_PRINTF("accel dshufti %p %p\n", c, c_end); if (c + 15 + 1 >= c_end) { return c; } /* need to stop one early to get an accurate end state */ rv = shuftiDoubleExec(accel->dshufti.lo1, accel->dshufti.hi1, accel->dshufti.lo2, accel->dshufti.hi2, c, c_end - 1); break; case ACCEL_RED_TAPE: DEBUG_PRINTF("accel red tape %p %p\n", c, c_end); rv = c_end; break; /* multibyte matchers */ case ACCEL_MLVERM: DEBUG_PRINTF("accel mlverm %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = long_vermicelliExec(accel->mverm.c, 0, c, c_end, accel->mverm.len); break; case ACCEL_MLVERM_NOCASE: DEBUG_PRINTF("accel mlverm nc %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = long_vermicelliExec(accel->mverm.c, 1, c, c_end, accel->mverm.len); break; case ACCEL_MLGVERM: DEBUG_PRINTF("accel mlgverm %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = longgrab_vermicelliExec(accel->mverm.c, 0, c, c_end, accel->mverm.len); break; case ACCEL_MLGVERM_NOCASE: DEBUG_PRINTF("accel mlgverm nc %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = longgrab_vermicelliExec(accel->mverm.c, 1, c, c_end, accel->mverm.len); break; case ACCEL_MSVERM: DEBUG_PRINTF("accel msverm %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shift_vermicelliExec(accel->mverm.c, 0, c, c_end, accel->mverm.len); break; case ACCEL_MSVERM_NOCASE: DEBUG_PRINTF("accel msverm nc %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shift_vermicelliExec(accel->mverm.c, 1, c, c_end, accel->mverm.len); break; case ACCEL_MSGVERM: DEBUG_PRINTF("accel msgverm %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shiftgrab_vermicelliExec(accel->mverm.c, 0, c, c_end, accel->mverm.len); break; case ACCEL_MSGVERM_NOCASE: DEBUG_PRINTF("accel msgverm nc %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shiftgrab_vermicelliExec(accel->mverm.c, 1, c, c_end, accel->mverm.len); break; case ACCEL_MDSVERM: DEBUG_PRINTF("accel mdsverm %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = doubleshift_vermicelliExec(accel->mdverm.c, 0, c, c_end, accel->mdverm.len1, accel->mdverm.len2); break; case ACCEL_MDSVERM_NOCASE: DEBUG_PRINTF("accel mdsverm nc %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = doubleshift_vermicelliExec(accel->mdverm.c, 1, c, c_end, accel->mdverm.len1, accel->mdverm.len2); break; case ACCEL_MDSGVERM: DEBUG_PRINTF("accel mdsgverm %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = doubleshiftgrab_vermicelliExec(accel->mdverm.c, 0, c, c_end, accel->mdverm.len1, accel->mdverm.len2); break; case ACCEL_MDSGVERM_NOCASE: DEBUG_PRINTF("accel mdsgverm nc %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = doubleshiftgrab_vermicelliExec(accel->mdverm.c, 1, c, c_end, accel->mdverm.len1, accel->mdverm.len2); break; case ACCEL_MLSHUFTI: DEBUG_PRINTF("accel mlshufti %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = long_shuftiExec(accel->mshufti.lo, accel->mshufti.hi, c, c_end, accel->mshufti.len); break; case ACCEL_MLGSHUFTI: DEBUG_PRINTF("accel mlgshufti %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = longgrab_shuftiExec(accel->mshufti.lo, accel->mshufti.hi, c, c_end, accel->mshufti.len); break; case ACCEL_MSSHUFTI: DEBUG_PRINTF("accel msshufti %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shift_shuftiExec(accel->mshufti.lo, accel->mshufti.hi, c, c_end, accel->mshufti.len); break; case ACCEL_MSGSHUFTI: DEBUG_PRINTF("accel msgshufti %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shiftgrab_shuftiExec(accel->mshufti.lo, accel->mshufti.hi, c, c_end, accel->mshufti.len); break; case ACCEL_MDSSHUFTI: DEBUG_PRINTF("accel mdsshufti %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = doubleshift_shuftiExec(accel->mdshufti.lo, accel->mdshufti.hi, c, c_end, accel->mdshufti.len1, accel->mdshufti.len2); break; case ACCEL_MDSGSHUFTI: DEBUG_PRINTF("accel msgshufti %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = doubleshiftgrab_shuftiExec(accel->mdshufti.lo, accel->mdshufti.hi, c, c_end, accel->mdshufti.len1, accel->mdshufti.len2); break; case ACCEL_MLTRUFFLE: DEBUG_PRINTF("accel mltruffle %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = long_truffleExec(accel->mtruffle.mask1, accel->mtruffle.mask2, c, c_end, accel->mtruffle.len); break; case ACCEL_MLGTRUFFLE: DEBUG_PRINTF("accel mlgtruffle %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = longgrab_truffleExec(accel->mtruffle.mask1, accel->mtruffle.mask2, c, c_end, accel->mtruffle.len); break; case ACCEL_MSTRUFFLE: DEBUG_PRINTF("accel mstruffle %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shift_truffleExec(accel->mtruffle.mask1, accel->mtruffle.mask2, c, c_end, accel->mtruffle.len); break; case ACCEL_MSGTRUFFLE: DEBUG_PRINTF("accel msgtruffle %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = shiftgrab_truffleExec(accel->mtruffle.mask1, accel->mtruffle.mask2, c, c_end, accel->mtruffle.len); break; case ACCEL_MDSTRUFFLE: DEBUG_PRINTF("accel mdstruffle %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = doubleshift_truffleExec(accel->mdtruffle.mask1, accel->mdtruffle.mask2, c, c_end, accel->mdtruffle.len1, accel->mdtruffle.len2); break; case ACCEL_MDSGTRUFFLE: DEBUG_PRINTF("accel mdsgtruffle %p %p\n", c, c_end); if (c + 15 >= c_end) { return c; } rv = doubleshiftgrab_truffleExec(accel->mdtruffle.mask1, accel->mdtruffle.mask2, c, c_end, accel->mdtruffle.len1, accel->mdtruffle.len2); break; default: assert(!"not here"); return c; } DEBUG_PRINTF("adjusting for offset %u\n", accel->generic.offset); /* adjust offset to take into account the offset */ rv = MAX(c + accel->generic.offset, rv); rv -= accel->generic.offset; DEBUG_PRINTF("advanced %zd\n", rv - c); return rv; } hyperscan-4.4.1/src/nfa/multiaccel_doubleshift.h0000644000175000017500000001152213055426554022516 0ustar sleuthkidsleuthkid/* * 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_ */ hyperscan-4.4.1/src/nfa/nfa_internal.h0000644000175000017500000001772413055426554020456 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file \brief Declarations for the main NFA engine types and structures. */ #ifndef NFA_INTERNAL_H #define NFA_INTERNAL_H #ifdef __cplusplus extern "C" { #endif #include "ue2common.h" // Constants #define MO_INVALID_IDX 0xffffffff /**< index meaning value is invalid */ // Flags (used in NFA::flags) #define NFA_ACCEPTS_EOD 1U /**< can produce matches on EOD. */ #define NFA_ZOMBIE 2U /**< supports zombies */ // Common data structures for NFAs enum NFAEngineType { LIMEX_NFA_32, LIMEX_NFA_64, LIMEX_NFA_128, LIMEX_NFA_256, LIMEX_NFA_384, LIMEX_NFA_512, MCCLELLAN_NFA_8, /**< magic pseudo nfa */ MCCLELLAN_NFA_16, /**< magic pseudo nfa */ GOUGH_NFA_8, /**< magic pseudo nfa */ GOUGH_NFA_16, /**< magic pseudo nfa */ MPV_NFA, /**< magic pseudo nfa */ LBR_NFA_DOT, /**< magic pseudo nfa */ LBR_NFA_VERM, /**< magic pseudo nfa */ LBR_NFA_NVERM, /**< magic pseudo nfa */ LBR_NFA_SHUF, /**< magic pseudo nfa */ LBR_NFA_TRUF, /**< magic pseudo nfa */ CASTLE_NFA, /**< magic pseudo nfa */ SHENG_NFA, /**< magic pseudo nfa */ TAMARAMA_NFA, /**< magic nfa container */ MCSHENG_NFA_8, /**< magic pseudo nfa */ MCSHENG_NFA_16, /**< magic pseudo nfa */ /** \brief bogus NFA - not used */ INVALID_NFA }; /** \brief header for the NFA implementation. */ struct ALIGN_CL_DIRECTIVE NFA { u32 flags; /** \brief The size in bytes of the NFA engine. The engine is * serialized to the extent that copying length bytes back into a * 16-byte aligned memory location yields a structure that has the same * behaviour as the original engine. */ u32 length; /** \brief Active implementation used by this NFAEngineType */ u8 type; u8 rAccelType; u8 rAccelOffset; u8 maxBiAnchoredWidth; /**< if non zero, max width of the block */ union { u8 c; u16 dc; u8 array[2]; } rAccelData; u32 queueIndex; /**< index of the associated queue in scratch */ /** \brief The number of valid positions/states for this NFA. Debug only */ u32 nPositions; /** \brief Size of the state required in scratch space. * * This state has less strict size requirements (as it doesn't go in stream * state) and does not persist between stream writes. */ u32 scratchStateSize; /** \brief Size of the state required in stream state. * * This encompasses all state stored by the engine that must persist between * stream writes. */ u32 streamStateSize; u32 maxWidth; /**< longest possible match in this NFA, 0 if unbounded */ u32 minWidth; /**< minimum bytes required to match this NFA */ u32 maxOffset; /**< non zero: maximum offset this pattern can match at */ /* Note: implementation (e.g. a LimEx) directly follows struct in memory */ } ; // Accessor macro for the implementation NFA: we do things this way to avoid // type-punning warnings. #define getImplNfa(nfa) \ ((const void *)((const char *)(nfa) + sizeof(struct NFA))) // Non-const version of the above, used at compile time. #define getMutableImplNfa(nfa) ((char *)(nfa) + sizeof(struct NFA)) static really_inline u32 nfaAcceptsEod(const struct NFA *nfa) { return nfa->flags & NFA_ACCEPTS_EOD; } static really_inline u32 nfaSupportsZombie(const struct NFA *nfa) { return nfa->flags & NFA_ZOMBIE; } /** \brief True if the given type (from NFA::type) is a McClellan DFA. */ static really_inline int isMcClellanType(u8 t) { return t == MCCLELLAN_NFA_8 || t == MCCLELLAN_NFA_16; } /** \brief True if the given type (from NFA::type) is a Sheng-McClellan hybrid * DFA. */ static really_inline int isShengMcClellanType(u8 t) { return t == MCSHENG_NFA_8 || t == MCSHENG_NFA_16; } /** \brief True if the given type (from NFA::type) is a Gough DFA. */ static really_inline int isGoughType(u8 t) { return t == GOUGH_NFA_8 || t == GOUGH_NFA_16; } /** \brief True if the given type (from NFA::type) is a Sheng DFA. */ static really_inline int isShengType(u8 t) { return t == SHENG_NFA; } /** * \brief True if the given type (from NFA::type) is a McClellan, Gough or * Sheng DFA. */ static really_inline int isDfaType(u8 t) { return isMcClellanType(t) || isGoughType(t) || isShengType(t) || isShengMcClellanType(t); } static really_inline int isBigDfaType(u8 t) { return t == MCCLELLAN_NFA_16 || t == MCSHENG_NFA_16 || t == GOUGH_NFA_16; } static really_inline int isSmallDfaType(u8 t) { return isDfaType(t) && !isBigDfaType(t); } /** \brief True if the given type (from NFA::type) is an NFA. */ static really_inline int isNfaType(u8 t) { switch (t) { case LIMEX_NFA_32: case LIMEX_NFA_64: case LIMEX_NFA_128: case LIMEX_NFA_256: case LIMEX_NFA_384: case LIMEX_NFA_512: return 1; default: break; } return 0; } /** \brief True if the given type (from NFA::type) is an LBR. */ static really_inline int isLbrType(u8 t) { return t == LBR_NFA_DOT || t == LBR_NFA_VERM || t == LBR_NFA_NVERM || t == LBR_NFA_SHUF || t == LBR_NFA_TRUF; } /** \brief True if the given type (from NFA::type) is a container engine. */ static really_inline int isContainerType(u8 t) { return t == TAMARAMA_NFA; } static really_inline int isMultiTopType(u8 t) { return !isDfaType(t) && !isLbrType(t); } /** Macros used in place of unimplemented NFA API functions for a given * engine. */ #if !defined(_WIN32) /* Use for functions that return an integer. */ #define NFA_API_NO_IMPL(...) \ ({ \ assert(!"not implemented for this engine!"); \ 0; /* return value, for places that need it */ \ }) /* Use for _zombie_status functions. */ #define NFA_API_ZOMBIE_NO_IMPL(...) \ ({ \ assert(!"not implemented for this engine!"); \ NFA_ZOMBIE_NO; \ }) #else /* Simpler implementation for compilers that don't like the GCC extension used * above. */ #define NFA_API_NO_IMPL(...) 0 #define NFA_API_ZOMBIE_NO_IMPL(...) NFA_ZOMBIE_NO #endif #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/nfa_build_util.h0000644000175000017500000000437313055426554020772 0ustar sleuthkidsleuthkid/* * 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 NFA_BUILD_UTIL_H #define NFA_BUILD_UTIL_H #include "ue2common.h" #include "nfa_internal.h" #include struct NFA; namespace ue2 { #ifdef DUMP_SUPPORT /* provided for debugging functions */ const char *nfa_type_name(NFAEngineType type); std::string describe(const NFA &nfa); #endif // For a given NFA, retrieve the alignment required by its uncompressed state. u32 state_alignment(const NFA &nfa); /* returns true if the nfa is considered 'fast'. TODO: work out what we mean by * fast. */ bool is_fast(const NFA &n); bool has_bounded_repeats_other_than_firsts(const NFA &n); bool has_bounded_repeats(const NFA &n); bool has_accel(const NFA &n); bool requires_decompress_key(const NFA &n); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/goughcompile.cpp0000644000175000017500000012624713055426554021034 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "goughcompile.h" #include "accel.h" #include "goughcompile_dump.h" #include "goughcompile_internal.h" #include "gough_internal.h" #include "grey.h" #include "mcclellancompile.h" #include "nfa_internal.h" #include "util/alloc.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include "util/verify_types.h" #include "ue2common.h" #include #include #include using namespace std; using boost::adaptors::map_keys; using boost::adaptors::map_values; using boost::vertex_index; namespace ue2 { void raw_som_dfa::stripExtraEodReports(void) { /* if a state generates a given report as a normal accept - then it does * not also need to generate an eod report for it */ for (vector::iterator it = state_som.begin(); it != state_som.end(); ++it) { for (const som_report &sr : it->reports) { it->reports_eod.erase(sr); } dstate &norm = states[it - state_som.begin()]; norm.reports_eod.clear(); for (const som_report &sr : it->reports_eod) { norm.reports_eod.insert(sr.report); } } } namespace { class gough_build_strat : public mcclellan_build_strat { public: gough_build_strat( raw_som_dfa &r, const GoughGraph &g, const ReportManager &rm_in, const map &accel_info) : mcclellan_build_strat(r, rm_in), rdfa(r), gg(g), accel_gough_info(accel_info) {} unique_ptr gatherReports(vector &reports /* out */, vector &reports_eod /* out */, u8 *isSingleReport /* out */, ReportID *arbReport /* out */) const override; AccelScheme find_escape_strings(dstate_id_t this_idx) const override; size_t accelSize(void) const override { return sizeof(gough_accel); } void buildAccel(dstate_id_t this_idx, const AccelScheme &info, void *accel_out) override; u32 max_allowed_offset_accel() const override { return 0; } raw_som_dfa &rdfa; const GoughGraph ≫ map accel_gough_info; map built_accel; }; } GoughSSAVar::~GoughSSAVar() { } void GoughSSAVar::clear_outputs() { for (GoughSSAVarWithInputs *var : outputs) { var->remove_input_raw(this); } outputs.clear(); } void GoughSSAVarWithInputs::clear_all() { clear_inputs(); clear_outputs(); } void GoughSSAVarMin::clear_inputs() { for (GoughSSAVar *var : inputs) { assert(contains(var->outputs, this)); var->outputs.erase(this); } inputs.clear(); } void GoughSSAVarMin::replace_input(GoughSSAVar *old_v, GoughSSAVar *new_v) { assert(contains(inputs, old_v)); inputs.erase(old_v); old_v->outputs.erase(this); inputs.insert(new_v); new_v->outputs.insert(this); } static void translateRawReports(UNUSED GoughGraph &cfg, UNUSED const raw_som_dfa &raw, const flat_map &joins_at_s, UNUSED GoughVertex s, const set &reports_in, vector > *reports_out) { for (const som_report &sr : reports_in) { DEBUG_PRINTF("state %u: report %u slot %d\n", cfg[s].state_id, sr.report, sr.slot); GoughSSAVar *var = nullptr; if (sr.slot == CREATE_NEW_SOM) { assert(!generates_callbacks(raw.kind)); } else { var = joins_at_s.at(sr.slot); } reports_out->push_back(make_pair(sr.report, var)); } } static void makeCFG_reports(GoughGraph &cfg, const raw_som_dfa &raw, const vector > &joins, const vector &vertices) { for (u32 i = 1; i < raw.states.size(); ++i) { GoughVertex s = vertices[i]; const flat_map &joins_at_s = joins[get(vertex_index, cfg, s)]; translateRawReports(cfg, raw, joins_at_s, s, raw.state_som[i].reports, &cfg[s].reports); translateRawReports(cfg, raw, joins_at_s, s, raw.state_som[i].reports_eod, &cfg[s].reports_eod); } } static never_inline void makeCFG_top_edge(GoughGraph &cfg, const vector &vertices, const vector > &joins, u32 trigger_slot, const som_tran_info &src_slots, const som_tran_info &dest_slot_pred, dstate_id_t i, dstate_id_t n, const GoughEdge &e) { GoughVertex s = vertices[i]; GoughVertex t = vertices[n]; const flat_map &joins_at_s = joins[get(vertex_index, cfg, s)]; const flat_map &joins_at_t = joins[get(vertex_index, cfg, t)]; DEBUG_PRINTF("top for %u -> %u\n", i, n); for (som_tran_info::const_iterator it = dest_slot_pred.begin(); it != dest_slot_pred.end(); ++it) { /* for ordering, need to ensure that new values feeding directly * into mins come first */ u32 slot_id = it->first; shared_ptr vnew; if (slot_id == trigger_slot) { vnew = make_shared(0U); cfg[e].vars.push_back(vnew); } else { assert(contains(src_slots, slot_id)); } GoughSSAVar *final_var; if (vnew && !contains(src_slots, slot_id)) { final_var = vnew.get(); DEBUG_PRINTF("bypassing min on join %u\n", slot_id); } else if (!vnew) { final_var = joins_at_s.at(slot_id); DEBUG_PRINTF("bypassing min on join %u\n", slot_id); } else { assert(vnew); assert(contains(src_slots, slot_id)); shared_ptr vmin = make_shared(); cfg[e].vars.push_back(vmin); final_var = vmin.get(); DEBUG_PRINTF("slot %u gets a new value\n", slot_id); vmin->add_input(vnew.get()); DEBUG_PRINTF("slot %u is constant\n", slot_id); vmin->add_input(joins_at_s.at(slot_id)); } /* wire to destination target */ GoughSSAVarJoin *vk = joins_at_t.at(slot_id); vk->add_input(final_var, e); } } static never_inline void makeCFG_edge(GoughGraph &cfg, const map &som_creators, const vector &vertices, const vector > &joins, const som_tran_info &src_slots, const som_tran_info &dest_slot_pred, dstate_id_t i, dstate_id_t n, const GoughEdge &e) { GoughVertex s = vertices[i]; GoughVertex t = vertices[n]; const flat_map &joins_at_s = joins[get(vertex_index, cfg, s)]; const flat_map &joins_at_t = joins[get(vertex_index, cfg, t)]; map > vnew_by_adj; for (som_tran_info::const_iterator it = dest_slot_pred.begin(); it != dest_slot_pred.end(); ++it) { /* for ordering, need to ensure that new values feeding directly * into mins come first */ u32 slot_id = it->first; if (contains(som_creators, slot_id) && !som_creators.at(slot_id)) { continue; } shared_ptr vnew; const vector &inputs = it->second; u32 useful_input_count = 0; u32 first_useful_input = ~0U; for (const u32 &input_slot : inputs) { if (!contains(src_slots, input_slot)) { continue; } DEBUG_PRINTF("%u is useful\n", input_slot); if (!vnew || !contains(som_creators, input_slot)) { useful_input_count++; if (useful_input_count == 1) { first_useful_input = input_slot; } } if (contains(som_creators, input_slot)) { u32 adjust = som_creators.at(input_slot); if (vnew && vnew->adjust >= adjust) { DEBUG_PRINTF("skipping %u as domininated by adj%u\n", adjust, vnew->adjust); continue; /* deeper starts can be seen to statically dominate */ } if (contains(vnew_by_adj, adjust)) { vnew = vnew_by_adj[adjust]; } else { vnew = make_shared(adjust); cfg[e].vars.push_back(vnew); vnew_by_adj[adjust] = vnew; } assert(vnew); } } /* If we have a new start of match (with no offset or 1 byte offset) and * other variables coming in, the new will always be dominated by the * existing variables (as they must be at least one byte into the match) * -- and so can be dropped. */ if (vnew && vnew->adjust < 2 && useful_input_count > 1) { useful_input_count--; vnew.reset(); /* need to reestablish the first useful input */ for (const u32 &input_slot : inputs) { if (!contains(src_slots, input_slot)) { continue; } if (!contains(som_creators, input_slot)) { first_useful_input = input_slot; } } } GoughSSAVar *final_var; if (useful_input_count == 1) { if (vnew) { final_var = vnew.get(); } else { assert(first_useful_input != ~0U); final_var = joins_at_s.at(first_useful_input); } DEBUG_PRINTF("bypassing min on join %u\n", slot_id); } else { shared_ptr vmin = make_shared(); cfg[e].vars.push_back(vmin); final_var = vmin.get(); if (vnew) { vmin->add_input(vnew.get()); } /* wire the normal inputs to the min */ for (const u32 &input_slot : inputs) { if (!contains(src_slots, input_slot)) { continue; } if (!contains(som_creators, input_slot)) { vmin->add_input(joins_at_s.at(input_slot)); } } assert(vmin->get_inputs().size() > 1); DEBUG_PRINTF("wire min to join %u\n", slot_id); } GoughSSAVarJoin *vk = joins_at_t.at(slot_id); assert(final_var); vk->add_input(final_var, e); } } static never_inline unique_ptr makeCFG(const raw_som_dfa &raw) { vector vertices; vertices.reserve(raw.states.size()); unique_ptr cfg = ue2::make_unique(); u32 min_state = !is_triggered(raw.kind); if (min_state) { vertices.push_back(GoughGraph::null_vertex()); /* skip dead state */ } vector > joins(raw.states.size()); for (u32 i = min_state; i < raw.states.size(); ++i) { GoughVertex v = add_vertex(GoughVertexProps(i), *cfg); vertices.push_back(v); /* create JOIN variables */ for (som_tran_info::const_iterator it = raw.state_som[i].preds.begin(); it != raw.state_som[i].preds.end(); ++it) { u32 slot_id = it->first; if (!contains(raw.new_som_nfa_states, slot_id) || raw.new_som_nfa_states.at(slot_id)) { (*cfg)[v].vars.push_back(make_shared()); joins[get(vertex_index, *cfg, v)][slot_id] = (*cfg)[v].vars.back().get(); DEBUG_PRINTF("dfa %u:: slot %u\n", i, slot_id); } } } u16 top_sym = raw.alpha_remap[TOP]; DEBUG_PRINTF("top: %hu, kind %d\n", top_sym, raw.kind); /* create edges, JOIN variables (on edge targets) */ map seen; for (u32 i = min_state; i < raw.states.size(); ++i) { seen.clear(); /* seen is really local to each state */ DEBUG_PRINTF("creating edges out of %u/%zu\n", i, raw.states.size()); GoughVertex s = vertices[i]; const vector &next = raw.states[i].next; for (u32 j = 0; j < next.size(); ++j) { if (!is_triggered(raw.kind) && j == top_sym) { continue; } dstate_id_t n = next[j]; DEBUG_PRINTF(" edge to %hu out on %u\n", n, j); assert(n < raw.states.size()); GoughVertex t = vertices[n]; if (j == top_sym) { GoughEdge e = add_edge(s, t, *cfg).first; (*cfg)[e].top = true; makeCFG_top_edge(*cfg, vertices, joins, raw.trigger_nfa_state, raw.state_som[i].preds, raw.state_som[n].preds, i, n, e); } else { if (contains(seen, n)) { const GoughEdge &e = seen[n]; (*cfg)[e].reach.set(j); continue; } GoughEdge e = add_edge(s, t, *cfg).first; (*cfg)[e].reach.set(j); seen[n] = e; makeCFG_edge(*cfg, raw.new_som_nfa_states, vertices, joins, raw.state_som[i].preds, raw.state_som[n].preds, i, n, e); } } } /* populate reports */ makeCFG_reports(*cfg, raw, joins, vertices); using boost::graph_bundle; if (is_triggered(raw.kind)) { (*cfg)[graph_bundle].initial_vertex = vertices[DEAD_STATE]; } else { (*cfg)[graph_bundle].initial_vertex = vertices[raw.start_anchored]; } return cfg; } static void copy_propagate_report_set(vector > &rep) { vector >::iterator it = rep.begin(); while (it != rep.end()) { GoughSSAVar *var = it->second; if (!var) { ++it; continue; } const flat_set &inputs = var->get_inputs(); if (inputs.size() != 1) { ++it; continue; } it->second = *inputs.begin(); /* note may result in dupes, filter later */ } } template void copy_propagate_update_vars(vector &vars, bool *changes) { for (u32 i = 0; i < vars.size(); i++) { GoughSSAVar *vp = vars[i].get(); const flat_set &inputs = vp->get_inputs(); /* no need to worry about data coming from self; ignore self loops */ GoughSSAVar *new_input = nullptr; if (inputs.size() == 1) { new_input = *inputs.begin(); } else if (inputs.size() == 2) { flat_set::const_iterator jt = inputs.begin(); GoughSSAVar *i_0 = *jt; GoughSSAVar *i_1 = *++jt; if (i_0 == vp) { new_input = i_1; } else if (i_1 == vp) { new_input = i_0; } } if (!new_input) { continue; } assert(new_input != vp); /* copy set as it will be modified by iteration */ const flat_set outputs = vp->get_outputs(); for (GoughSSAVar *curr : outputs) { curr->replace_input(vp, new_input); *changes = true; } } } static void copy_propagation(GoughGraph &g, const Grey &grey) { if (!grey.goughCopyPropagate) { return; } /* TODO order visit of variables sensibly */ bool changes = false; do { DEBUG_PRINTF("new iteration\n"); changes = false; for (auto v : vertices_range(g)) { copy_propagate_update_vars(g[v].vars, &changes); } for (const auto &e : edges_range(g)) { copy_propagate_update_vars(g[e].vars, &changes); } } while(changes); /* see if any reports can also be moved along */ for (auto v : vertices_range(g)) { copy_propagate_report_set(g[v].reports); copy_propagate_report_set(g[v].reports_eod); } } static void mark_live_reports(const vector > &reps, vector *queue) { for (const auto &r : reps) { GoughSSAVar *var = r.second; if (!var || var->seen) { continue; } var->seen = true; queue->push_back(var); } } static void remove_dead(GoughGraph &g) { vector queue; for (auto v : vertices_range(g)) { mark_live_reports(g[v].reports, &queue); mark_live_reports(g[v].reports_eod, &queue); } while (!queue.empty()) { GoughSSAVar *v = queue.back(); queue.pop_back(); for (GoughSSAVar *var : v->get_inputs()) { if (var->seen) { continue; } var->seen = true; queue.push_back(var); } } /* remove unused variables */ for (auto v : vertices_range(g)) { for (u32 i = 0; i < g[v].vars.size(); i++) { GoughSSAVar *var = g[v].vars[i].get(); if (var->seen) { continue; } var->clear_all(); g[v].vars.erase(g[v].vars.begin() + i); i--; } } for (const auto &e : edges_range(g)) { for (u32 i = 0; i < g[e].vars.size(); i++) { GoughSSAVar *var = g[e].vars[i].get(); if (var->seen) { continue; } var->clear_all(); g[e].vars.erase(g[e].vars.begin() + i); i--; } } } static gough_ins make_gough_ins(u8 op, u32 dest = INVALID_SLOT, u32 src = INVALID_SLOT) { assert(dest != INVALID_SLOT || op == GOUGH_INS_END); assert(src != INVALID_SLOT || op == GOUGH_INS_END || op == GOUGH_INS_NEW); gough_ins rv; rv.op = op; rv.dest = dest; rv.src = src; return rv; } void GoughSSAVarNew::generate(vector *out) const { assert(slot != INVALID_SLOT); out->push_back(make_gough_ins(GOUGH_INS_NEW, slot, adjust)); } #ifndef NDEBUG template bool contains_loose(const C &container, const K &key) { for (const auto &elem : container) { if (elem == key) { return true; } } return false; } #endif void GoughSSAVarMin::generate(vector *out) const { assert(slot != INVALID_SLOT); assert(!inputs.empty()); // assert(inputs.size() > 1); vector input_slots; /* for determinism */ bool first = true; for (const GoughSSAVar *var : inputs) { assert(contains_loose(var->outputs, this)); if (var->slot == slot) { /* if the destination is one of the sources, no need to move it */ first = false; } else { input_slots.push_back(var->slot); } } sort(input_slots.begin(), input_slots.end()); for (const u32 &input_slot : input_slots) { if (first) { out->push_back(make_gough_ins(GOUGH_INS_MOV, slot, input_slot)); first = false; } else { out->push_back(make_gough_ins(GOUGH_INS_MIN, slot, input_slot)); } } } void GoughSSAVarMin::remove_input_raw(GoughSSAVar *v) { assert(contains(inputs, v)); inputs.erase(v); } void GoughSSAVarJoin::generate(UNUSED vector *out) const { assert(0); } GoughSSAVar *GoughSSAVarJoin::get_input(const GoughEdge &prev) const { for (const auto &var_edge : input_map) { if (contains(var_edge.second, prev)) { return var_edge.first; } } assert(0); return nullptr; } const flat_set &GoughSSAVarJoin::get_edges_for_input( GoughSSAVar *input) const { return input_map.at(input); } const map > &GoughSSAVarJoin::get_input_map() const { return input_map; } void GoughSSAVarJoin::clear_inputs() { for (GoughSSAVar *var : input_map | map_keys) { assert(contains(var->outputs, this)); var->outputs.erase(this); } input_map.clear(); inputs.clear(); } void GoughSSAVarJoin::replace_input(GoughSSAVar *old_v, GoughSSAVar *new_v) { assert(contains(input_map, old_v)); assert(contains(inputs, old_v)); if (old_v == new_v) { assert(0); return; } insert(&input_map[new_v], input_map[old_v]); input_map.erase(old_v); inputs.erase(old_v); inputs.insert(new_v); old_v->outputs.erase(this); new_v->outputs.insert(this); } void GoughSSAVarJoin::add_input(GoughSSAVar *v, GoughEdge prev) { input_map[v].insert(prev); inputs.insert(v); v->outputs.insert(this); } void GoughSSAVarJoin::remove_input_raw(GoughSSAVar *v) { assert(contains(inputs, v)); assert(contains(input_map, v)); input_map.erase(v); inputs.erase(v); } static u32 highest_slot_used(const vector &program) { u32 rv = INVALID_SLOT; for (const gough_ins &ins : program) { if (rv == INVALID_SLOT) { rv = ins.dest; } else if (ins.dest != INVALID_SLOT) { ENSURE_AT_LEAST(&rv, ins.dest); } if (rv == INVALID_SLOT) { rv = ins.src; } else if (ins.src != INVALID_SLOT) { ENSURE_AT_LEAST(&rv, ins.src); } } assert(rv != INVALID_SLOT); return rv; } static u32 highest_slot_used(const map > &blocks) { u32 rv = INVALID_SLOT; for (const vector &ins_list : blocks | map_values) { u32 used = highest_slot_used(ins_list); if (rv == INVALID_SLOT) { rv = used; } else if (used != INVALID_SLOT) { ENSURE_AT_LEAST(&rv, used); } } return rv; } static void add_to_block(const vector > &vars, vector *out) { for (const auto &var : vars) { var->generate(out); } } namespace { struct edge_join_info { bool empty() const { return dest_to_src.empty(); } void insert(u32 src, u32 dest) { assert(!contains(dest_to_src, dest)); assert(src != dest); dest_to_src[dest] = src; src_to_dest[src].insert(dest); } void erase(u32 src, u32 dest) { assert(dest_to_src.at(dest) == src); dest_to_src.erase(dest); src_to_dest[src].erase(dest); if (src_to_dest[src].empty()) { src_to_dest.erase(src); } } bool is_src(u32 v) const { bool rv = contains(src_to_dest, v); assert(!rv || !src_to_dest.at(v).empty()); return rv; } bool is_dest(u32 v) const { return contains(dest_to_src, v); } void remap_src(u32 old_src, u32 new_src) { assert(is_src(old_src)); assert(!is_src(new_src)); for (const u32 &e : src_to_dest[old_src]) { assert(e != new_src); dest_to_src[e] = new_src; } src_to_dest[new_src].swap(src_to_dest[old_src]); src_to_dest.erase(old_src); assert(!is_src(old_src)); assert(is_src(new_src)); } /* returns an arbitrary unresolved entry */ void get_pending(u32 *src, u32 *dest) { assert(!empty()); *dest = dest_to_src.begin()->first; *src = dest_to_src.begin()->second; } const map &get_dest_mapping() const { return dest_to_src; } private: map > src_to_dest; map dest_to_src; }; } static void prep_joins_for_generation(const GoughGraph &g, GoughVertex v, map *edge_info) { DEBUG_PRINTF("writing out joins for %u\n", g[v].state_id); for (const auto &var : g[v].vars) { u32 dest_slot = var->slot; for (const auto &var_edges : var->get_input_map()) { u32 input = var_edges.first->slot; if (dest_slot == input) { continue; } for (const GoughEdge &incoming_edge : var_edges.second) { (*edge_info)[incoming_edge].insert(input, dest_slot); DEBUG_PRINTF("need %u<-%u\n", dest_slot, input); } } } } static void add_simple_joins(edge_join_info &eji, vector *out) { /* any slot whose value we don't need can be written to immediately */ const map &dest_to_src = eji.get_dest_mapping(); bool changed; do { changed = false; for (map::const_iterator it = dest_to_src.begin(); it != dest_to_src.end();) { u32 src = it->second; u32 dest = it->first; ++it; /* avoid iterator being invalidated */ if (eji.is_src(dest)) { continue; /* conflict; not simple (yet) */ } /* value of destination slot is not used by any remaining joins; * we can output this join immediately */ DEBUG_PRINTF("out %u<-%u\n", dest, src); out->push_back(make_gough_ins(GOUGH_INS_MOV, dest, src)); eji.erase(src, dest); if (eji.is_dest(src) && eji.is_src(src)) { /* we can unblock src being used as an output by shifting * across everybody using src as input to using dest (as == src * now) */ eji.remap_src(src, dest); } changed = true; } } while (changed); } static void add_joins_to_block(edge_join_info &eji, vector *out, u32 base_temp_slot) { /* joins happen concurrently: none of them should see the outputs of another * join happening due to the same entry of the vertex. If there are * conflicts we may have to handle things by using a temp output slot for * each join and then copying into the final slot. */ add_simple_joins(eji, out); while (!eji.empty()) { u32 split; u32 input_for_split; eji.get_pending(&input_for_split, &split); assert(eji.is_src(split)); /* otherwise should be handled by simple */ /* stash the initial value of the split register in a temp register */ u32 temp = base_temp_slot++; DEBUG_PRINTF("out %u<-%u\n", temp, split); out->push_back(make_gough_ins(GOUGH_INS_MOV, temp, split)); eji.remap_src(split, temp); /* update maps */ /* split can now be safely written out to as all the uses of it as an * input now refer to temp instead */ DEBUG_PRINTF("out %u<-%u\n", split, input_for_split); out->push_back(make_gough_ins(GOUGH_INS_MOV, split, input_for_split)); eji.erase(input_for_split, split); /* handle any uncovered simple cases */ add_simple_joins(eji, out); } } static void build_blocks(const GoughGraph &g, map > *blocks, u32 base_temp_slot) { for (const auto &e : edges_range(g)) { if (g[e].vars.empty()) { continue; } vector &block = (*blocks)[gough_edge_id(g, e)]; add_to_block(g[e].vars, &block); assert(!block.empty()); } for (const auto t : vertices_range(g)) { if (g[t].vars.empty()) { continue; } map eji; prep_joins_for_generation(g, t, &eji); for (auto &m : eji) { vector &block = (*blocks)[gough_edge_id(g, m.first)]; u32 cur_base = base_temp_slot; if (!block.empty()) { /* some temp slots may already be in use by short-lived vars */ ENSURE_AT_LEAST(&cur_base, highest_slot_used(block) + 1); } add_joins_to_block(m.second, &block, cur_base); if (block.empty()) { blocks->erase(gough_edge_id(g, m.first)); } } } for (vector &ins_list : *blocks | map_values) { assert(!ins_list.empty()); ins_list.push_back(make_gough_ins(GOUGH_INS_END)); } } static void copy_in_blocks(raw_som_dfa &raw, u8 alphaShift, const GoughGraph &cfg, const map > &blocks, u32 *edge_blocks, u32 *top_blocks, u32 base_offset, map, u32> *prog_offsets, vector *out) { u32 impl_alpha_size = 1U << alphaShift; UNUSED u32 top_sym = raw.alpha_remap[TOP]; assert(top_sym == raw.alpha_size - 1U); map, u32> &processed = *prog_offsets; for (const auto &e : edges_range(cfg)) { if (!contains(blocks, gough_edge_id(cfg, e))) { continue; } const vector &block = blocks.at(gough_edge_id(cfg, e)); u32 prog_offset; if (!contains(processed, block)) { prog_offset = base_offset + byte_length(*out); insert(out, out->end(), block); processed[block] = prog_offset; } else { prog_offset = processed[block]; } /* update edges */ u32 s_id = cfg[source(e, cfg)].state_id; UNUSED u32 t_id = cfg[target(e, cfg)].state_id; u32 impl_src_id = raw.states[s_id].impl_id; DEBUG_PRINTF("%u: writing out block for edge_%u_%u at %u:\n", impl_src_id, s_id, t_id,prog_offset); for (u32 j = cfg[e].reach.find_first(); j != CharReach::npos; j = cfg[e].reach.find_next(j)) { assert(raw.states[s_id].next[j] == t_id); u32 edge_index = impl_src_id * impl_alpha_size + j; DEBUG_PRINTF("\tsetting on %u, %u\n", j, edge_index); edge_blocks[edge_index] = prog_offset; } if (cfg[e].top) { assert(raw.states[s_id].next[top_sym] == t_id); DEBUG_PRINTF("\tsetting top on %u to block at %u\n", impl_src_id, prog_offset); top_blocks[impl_src_id] = prog_offset; } } } bool find_normal_self_loop(GoughVertex v, const GoughGraph &g, GoughEdge *out) { for (const auto &e : out_edges_range(v, g)) { if (target(e, g) != v) { continue; } if (g[e].top) { assert(g[e].reach.find_first() == CharReach::npos); continue; /* corresponds to a top, not a normal transition */ } *out = e; return true; } return false; } static never_inline void update_accel_prog_offset(const gough_build_strat &gbs, const map > &blocks, const map, u32> &prog_offsets) { map verts; for (auto v : vertices_range(gbs.gg)) { verts[gbs.gg[v].state_id] = v; } for (auto &m : gbs.built_accel) { gough_accel *ga = m.first; assert(!ga->prog_offset); GoughVertex v = verts[m.second]; GoughEdge e; UNUSED bool rv = find_normal_self_loop(v, gbs.gg, &e); assert(rv); if (!rv) { continue; } DEBUG_PRINTF("updating state %u accel with margin %hhu\n", gbs.gg[v].state_id, ga->margin_dist); if (contains(blocks, gough_edge_id(gbs.gg, e))) { const vector &block = blocks.at(gough_edge_id(gbs.gg, e)); ga->prog_offset = prog_offsets.at(block); DEBUG_PRINTF("prog offset %u\n", ga->prog_offset); } else { ga->margin_dist = 0; DEBUG_PRINTF("removing margin as no som\n"); } } } aligned_unique_ptr goughCompile(raw_som_dfa &raw, u8 somPrecision, const CompileContext &cc, const ReportManager &rm) { assert(somPrecision == 2 || somPrecision == 4 || somPrecision == 8 || !cc.streaming); if (!cc.grey.allowGough) { return nullptr; } DEBUG_PRINTF("hello world\n"); unique_ptr cfg = makeCFG(raw); dump(*cfg, "init", cc.grey); copy_propagation(*cfg, cc.grey); remove_dead(*cfg); dump(*cfg, "prop", cc.grey); u32 slot_count = assign_slots(*cfg, cc.grey); dump(*cfg, "slots", cc.grey); map > blocks; build_blocks(*cfg, &blocks, slot_count); DEBUG_PRINTF("%u slots\n", highest_slot_used(blocks) + 1); u32 scratch_slot_count = highest_slot_used(blocks) + 1; assert(slot_count <= scratch_slot_count); dump(*cfg, "final", cc.grey); dump_blocks(blocks, "final", cc.grey); gough_info gi; memset(&gi, 0, sizeof(gi)); map accel_allowed; find_allowed_accel_states(*cfg, blocks, &accel_allowed); gough_build_strat gbs(raw, *cfg, rm, accel_allowed); aligned_unique_ptr basic_dfa = mcclellanCompile_i(raw, gbs, cc); assert(basic_dfa); if (!basic_dfa) { return nullptr; } u8 alphaShift = ((const mcclellan *)getImplNfa(basic_dfa.get()))->alphaShift; u32 edge_count = (1U << alphaShift) * raw.states.size(); u32 curr_offset = ROUNDUP_N(basic_dfa->length, 4); u32 haig_offset = curr_offset; curr_offset += sizeof(gi); /* reserve space for edge->program mapping */ u32 edge_prog_offset = curr_offset; curr_offset += sizeof(u32) * edge_count; vector edge_blocks(edge_count); u32 top_prog_offset = 0; if (is_triggered(raw.kind)) { /* reserve space for edge->program mapping */ top_prog_offset = curr_offset; curr_offset += sizeof(u32) * raw.states.size(); } gi.top_prog_offset = top_prog_offset; vector top_blocks(raw.states.size()); /* reserve space for blocks */ u32 prog_base_offset = curr_offset; gi.prog_base_offset = prog_base_offset; vector temp_blocks; map, u32> prog_offsets; copy_in_blocks(raw, alphaShift, *cfg, blocks, &edge_blocks[0], &top_blocks[0], prog_base_offset, &prog_offsets, &temp_blocks); update_accel_prog_offset(gbs, blocks, prog_offsets); u32 total_prog_size = byte_length(temp_blocks); curr_offset += total_prog_size; gi.stream_som_loc_count = slot_count; gi.stream_som_loc_width = somPrecision; u32 gough_size = ROUNDUP_N(curr_offset, 16); aligned_unique_ptr gough_dfa = aligned_zmalloc_unique(gough_size); memcpy(gough_dfa.get(), basic_dfa.get(), basic_dfa->length); memcpy((char *)gough_dfa.get() + haig_offset, &gi, sizeof(gi)); if (gough_dfa->type == MCCLELLAN_NFA_16) { gough_dfa->type = GOUGH_NFA_16; } else { assert(gough_dfa->type == MCCLELLAN_NFA_8); gough_dfa->type = GOUGH_NFA_8; } /* update stream state requirements */ u32 base_state_size = gough_dfa->type == GOUGH_NFA_8 ? 1 : 2; gough_dfa->streamStateSize = base_state_size + slot_count * somPrecision; gough_dfa->scratchStateSize = (u32)(16 + scratch_slot_count * sizeof(u64a)); mcclellan *m = (mcclellan *)getMutableImplNfa(gough_dfa.get()); m->haig_offset = haig_offset; /* update nfa length, haig_info offset (leave mcclellan length alone) */ gough_dfa->length = gough_size; /* copy in blocks */ copy_bytes((u8 *)gough_dfa.get() + edge_prog_offset, edge_blocks); if (top_prog_offset) { copy_bytes((u8 *)gough_dfa.get() + top_prog_offset, top_blocks); } copy_bytes((u8 *)gough_dfa.get() + prog_base_offset, temp_blocks); return gough_dfa; } AccelScheme gough_build_strat::find_escape_strings(dstate_id_t this_idx) const { AccelScheme rv; if (!contains(accel_gough_info, this_idx)) { rv.cr = CharReach::dot(); rv.double_byte.clear(); return rv; } rv = mcclellan_build_strat::find_escape_strings(this_idx); assert(!rv.offset || rv.cr.all()); /* should have been limited by strat */ if (rv.offset) { rv.cr = CharReach::dot(); rv.double_byte.clear(); return rv; } if (rv.double_offset || !accel_gough_info.at(this_idx).two_byte) { rv.double_byte.clear(); } return rv; } void gough_build_strat::buildAccel(dstate_id_t this_idx, const AccelScheme &info, void *accel_out) { assert(mcclellan_build_strat::accelSize() == sizeof(AccelAux)); gough_accel *accel = (gough_accel *)accel_out; /* build a plain accelaux so we can work out where we can get to */ mcclellan_build_strat::buildAccel(this_idx, info, &accel->accel); DEBUG_PRINTF("state %hu is accel with type %hhu\n", this_idx, accel->accel.accel_type); if (accel->accel.accel_type == ACCEL_NONE) { return; } assert(!accel->accel.generic.offset); assert(contains(accel_gough_info, this_idx)); accel->margin_dist = verify_u8(accel_gough_info.at(this_idx).margin); built_accel[accel] = this_idx; DEBUG_PRINTF("state %hu is accel with margin %hhu\n", this_idx, accel->margin_dist); } namespace { struct raw_gough_report_list { set reports; raw_gough_report_list( const vector> &raw_reports, const ReportManager &rm, bool do_remap) { for (const auto &m : raw_reports) { ReportID r = do_remap ? rm.getProgramOffset(m.first) : m.first; u32 impl_slot = INVALID_SLOT; if (m.second) { impl_slot = m.second->slot; assert(impl_slot != INVALID_SLOT); } reports.emplace(r, impl_slot); } } bool operator<(const raw_gough_report_list &b) const { return reports < b.reports; } }; struct raw_gough_report_info_impl : public raw_report_info { vector rl; u32 getReportListSize() const override; size_t size() const override; void fillReportLists(NFA *n, size_t base_offset, vector &ro /* out */) const override; }; } unique_ptr gough_build_strat::gatherReports( vector &reports, vector &reports_eod, u8 *isSingleReport, ReportID *arbReport) const { DEBUG_PRINTF("gathering reports\n"); const bool remap_reports = has_managed_reports(rdfa.kind); auto ri = ue2::make_unique(); map rev; assert(!rdfa.states.empty()); vector verts(rdfa.states.size()); for (auto v : vertices_range(gg)) { verts[gg[v].state_id] = v; } for (u32 state_id = 0; state_id < verts.size(); state_id++) { assert(state_id < rdfa.states.size()); GoughVertex v = verts[state_id]; assert(v != GoughGraph::null_vertex() || !state_id); DEBUG_PRINTF("i = %zu [%zu]\n", reports.size(), gg[v].reports.size()); if (v == GoughGraph::null_vertex() || gg[v].reports.empty()) { reports.push_back(MO_INVALID_IDX); continue; } raw_gough_report_list rrl(gg[v].reports, rm, remap_reports); DEBUG_PRINTF("non empty r %zu\n", reports.size()); if (rev.find(rrl) != rev.end()) { reports.push_back(rev[rrl]); } else { DEBUG_PRINTF("adding to rl\n"); rev[rrl] = ri->size(); reports.push_back(ri->size()); ri->rl.push_back(rrl); } } for (auto v : verts) { if (v == GoughGraph::null_vertex() || gg[v].reports_eod.empty()) { reports_eod.push_back(MO_INVALID_IDX); continue; } DEBUG_PRINTF("non empty r eod\n"); raw_gough_report_list rrl(gg[v].reports_eod, rm, remap_reports); if (rev.find(rrl) != rev.end()) { reports_eod.push_back(rev[rrl]); continue; } DEBUG_PRINTF("adding to rl eod %zu\n", gg[v].reports_eod.size()); rev[rrl] = ri->size(); reports_eod.push_back(ri->size()); ri->rl.push_back(rrl); } /* TODO: support single report in gough */ *isSingleReport = 0; *arbReport = MO_INVALID_IDX; assert(!ri->rl.empty()); /* all components should be able to generate reports */ return move(ri); } u32 raw_gough_report_info_impl::getReportListSize() const { u32 sz = 0; for (const raw_gough_report_list &r : rl) { sz += sizeof(gough_report_list); sz += sizeof(gough_report) * r.reports.size(); } return sz; } size_t raw_gough_report_info_impl::size() const { return rl.size(); } void raw_gough_report_info_impl::fillReportLists(NFA *n, size_t base_offset, vector &ro) const { for (const raw_gough_report_list &r : rl) { ro.push_back(base_offset); gough_report_list *p = (gough_report_list *)((char *)n + base_offset); u32 i = 0; for (const som_report &sr : r.reports) { p->report[i].r = sr.report; p->report[i].som = sr.slot; i++; } p->count = verify_u32(r.reports.size()); base_offset += sizeof(gough_report_list); base_offset += sizeof(gough_report) * r.reports.size(); } } } // namespace ue2 hyperscan-4.4.1/src/nfa/sheng_internal.h0000644000175000017500000000441713055426554021011 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 SHENG_INTERNAL_H_ #define SHENG_INTERNAL_H_ #include "ue2common.h" #include "util/simd_types.h" #define SHENG_STATE_ACCEPT 0x10 #define SHENG_STATE_DEAD 0x20 #define SHENG_STATE_ACCEL 0x40 #define SHENG_STATE_MASK 0xF #define SHENG_STATE_FLAG_MASK 0x70 #define SHENG_FLAG_SINGLE_REPORT 0x1 #define SHENG_FLAG_CAN_DIE 0x2 #define SHENG_FLAG_HAS_ACCEL 0x4 struct report_list { u32 count; ReportID report[]; }; struct sstate_aux { u32 accept; u32 accept_eod; u32 accel; u32 top; }; struct sheng { m128 shuffle_masks[256]; u32 length; u32 aux_offset; u32 report_offset; u32 accel_offset; u8 n_states; u8 anchored; u8 floating; u8 flags; ReportID report; }; #endif /* SHENG_INTERNAL_H_ */ hyperscan-4.4.1/src/nfa/multishufti.c0000644000175000017500000000627313055426554020363 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Shufti: character class acceleration. * * Utilises the SSSE3 pshufb shuffle instruction */ #include "config.h" #include "ue2common.h" #include "multishufti.h" #include "multiaccel_common.h" #if !defined(__AVX2__) #define MATCH_ALGO long_ #include "multiaccel_long.h" #include "multishufti_sse.h" #undef MATCH_ALGO #define MATCH_ALGO longgrab_ #include "multiaccel_longgrab.h" #include "multishufti_sse.h" #undef MATCH_ALGO #define MATCH_ALGO shift_ #include "multiaccel_shift.h" #include "multishufti_sse.h" #undef MATCH_ALGO #define MATCH_ALGO shiftgrab_ #include "multiaccel_shiftgrab.h" #include "multishufti_sse.h" #undef MATCH_ALGO #define MULTIACCEL_DOUBLE #define MATCH_ALGO doubleshift_ #include "multiaccel_doubleshift.h" #include "multishufti_sse.h" #undef MATCH_ALGO #define MATCH_ALGO doubleshiftgrab_ #include "multiaccel_doubleshiftgrab.h" #include "multishufti_sse.h" #undef MATCH_ALGO #undef MULTIACCEL_DOUBLE #else #define MATCH_ALGO long_ #include "multiaccel_long.h" #include "multishufti_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO longgrab_ #include "multiaccel_longgrab.h" #include "multishufti_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO shift_ #include "multiaccel_shift.h" #include "multishufti_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO shiftgrab_ #include "multiaccel_shiftgrab.h" #include "multishufti_avx2.h" #undef MATCH_ALGO #define MULTIACCEL_DOUBLE #define MATCH_ALGO doubleshift_ #include "multiaccel_doubleshift.h" #include "multishufti_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO doubleshiftgrab_ #include "multiaccel_doubleshiftgrab.h" #include "multishufti_avx2.h" #undef MATCH_ALGO #undef MULTIACCEL_DOUBLE #endif hyperscan-4.4.1/src/nfa/mcsheng_compile.cpp0000644000175000017500000010372013055426554021475 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "mcsheng_compile.h" #include "accel.h" #include "accelcompile.h" #include "grey.h" #include "mcclellancompile.h" #include "mcclellancompile_util.h" #include "mcsheng_internal.h" #include "nfa_internal.h" #include "rdfa_graph.h" #include "shufticompile.h" #include "trufflecompile.h" #include "ue2common.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include "util/unaligned.h" #include "util/verify_types.h" #include #include #include #include #include #include #include #include #include #include using namespace std; using boost::adaptors::map_keys; namespace ue2 { namespace /* anon */ { #define MIN_SHENG_SIZE 6 #define INVALID_SHENG_ID 255 struct dstate_extra { u16 daddytaken = 0; bool shermanState = false; bool sheng_succ = false; u8 sheng_id = INVALID_SHENG_ID; }; struct dfa_info { accel_dfa_build_strat &strat; raw_dfa &raw; vector &states; vector extra; const u16 alpha_size; /* including special symbols */ const array &alpha_remap; vector rev_alpha; const u16 impl_alpha_size; u8 getAlphaShift() const; explicit dfa_info(accel_dfa_build_strat &s) : strat(s), raw(s.get_raw()), states(raw.states), extra(raw.states.size()), alpha_size(raw.alpha_size), alpha_remap(raw.alpha_remap), impl_alpha_size(raw.getImplAlphaSize()) { rev_alpha.resize(impl_alpha_size); for (u32 i = 0; i < N_CHARS; i++) { rev_alpha[alpha_remap[i]].set(i); } } dstate_id_t implId(dstate_id_t raw_id) const { return states[raw_id].impl_id; } bool is_sherman(dstate_id_t raw_id) const { return extra[raw_id].shermanState; } bool is_sheng(dstate_id_t raw_id) const { return extra[raw_id].sheng_id != INVALID_SHENG_ID; } bool is_sheng_succ(dstate_id_t raw_id) const { return extra[raw_id].sheng_succ; } /* states which use the normal transition/successor table */ bool is_normal(dstate_id_t raw_id) const { return raw_id != DEAD_STATE && !is_sheng(raw_id) && !is_sherman(raw_id); } size_t size(void) const { return states.size(); } }; u8 dfa_info::getAlphaShift() const { if (impl_alpha_size < 2) { return 1; } else { /* log2 round up */ return 32 - clz32(impl_alpha_size - 1); } } } // namespace static mstate_aux *getAux(NFA *n, dstate_id_t i) { mcsheng *m = (mcsheng *)getMutableImplNfa(n); mstate_aux *aux_base = (mstate_aux *)((char *)n + m->aux_offset); mstate_aux *aux = aux_base + i; assert((const char *)aux < (const char *)n + m->length); return aux; } static void createShuffleMasks(mcsheng *m, const dfa_info &info, dstate_id_t sheng_end, const map &accel_escape_info) { DEBUG_PRINTF("using first %hu states for a sheng\n", sheng_end); assert(sheng_end > DEAD_STATE + 1); assert(sheng_end <= sizeof(m128) + 1); vector> masks; masks.resize(info.alpha_size); /* -1 to avoid wasting a slot as we do not include dead state */ vector raw_ids; raw_ids.resize(sheng_end - 1); for (dstate_id_t s = DEAD_STATE + 1; s < info.states.size(); s++) { assert(info.implId(s)); /* should not map to DEAD_STATE */ if (info.is_sheng(s)) { raw_ids[info.extra[s].sheng_id] = s; } } for (u32 i = 0; i < info.alpha_size; i++) { if (i == info.alpha_remap[TOP]) { continue; } auto &mask = masks[i]; assert(sizeof(mask) == sizeof(m128)); mask.fill(0); for (dstate_id_t sheng_id = 0; sheng_id < sheng_end - 1; sheng_id++) { dstate_id_t raw_id = raw_ids[sheng_id]; dstate_id_t next_id = info.implId(info.states[raw_id].next[i]); if (next_id == DEAD_STATE) { next_id = sheng_end - 1; } else if (next_id < sheng_end) { next_id--; } DEBUG_PRINTF("%hu: %u->next %hu\n", sheng_id, i, next_id); mask[sheng_id] = verify_u8(next_id); } } for (u32 i = 0; i < N_CHARS; i++) { assert(info.alpha_remap[i] != info.alpha_remap[TOP]); memcpy((u8 *)&m->sheng_masks[i], (u8 *)masks[info.alpha_remap[i]].data(), sizeof(m128)); } m->sheng_end = sheng_end; m->sheng_accel_limit = sheng_end - 1; for (dstate_id_t s : raw_ids) { if (contains(accel_escape_info, s)) { LIMIT_TO_AT_MOST(&m->sheng_accel_limit, info.extra[s].sheng_id); } } } static void populateBasicInfo(size_t state_size, const dfa_info &info, u32 total_size, u32 aux_offset, u32 accel_offset, u32 accel_count, ReportID arb, bool single, NFA *nfa) { assert(state_size == sizeof(u16) || state_size == sizeof(u8)); nfa->length = total_size; nfa->nPositions = info.states.size(); nfa->scratchStateSize = verify_u32(state_size); nfa->streamStateSize = verify_u32(state_size); if (state_size == sizeof(u8)) { nfa->type = MCSHENG_NFA_8; } else { nfa->type = MCSHENG_NFA_16; } mcsheng *m = (mcsheng *)getMutableImplNfa(nfa); for (u32 i = 0; i < 256; i++) { m->remap[i] = verify_u8(info.alpha_remap[i]); } m->alphaShift = info.getAlphaShift(); m->length = total_size; m->aux_offset = aux_offset; m->accel_offset = accel_offset; m->arb_report = arb; m->state_count = verify_u16(info.size()); m->start_anchored = info.implId(info.raw.start_anchored); m->start_floating = info.implId(info.raw.start_floating); m->has_accel = accel_count ? 1 : 0; if (single) { m->flags |= MCSHENG_FLAG_SINGLE; } } static size_t calcShermanRegionSize(const dfa_info &info) { size_t rv = 0; for (size_t i = 0; i < info.size(); i++) { if (info.is_sherman(i)) { rv += SHERMAN_FIXED_SIZE; } } return ROUNDUP_16(rv); } static void fillInAux(mstate_aux *aux, dstate_id_t i, const dfa_info &info, const vector &reports, const vector &reports_eod, const vector &reportOffsets) { const dstate &raw_state = info.states[i]; aux->accept = raw_state.reports.empty() ? 0 : reportOffsets[reports[i]]; aux->accept_eod = raw_state.reports_eod.empty() ? 0 : reportOffsets[reports_eod[i]]; aux->top = info.implId(i ? raw_state.next[info.alpha_remap[TOP]] : info.raw.start_floating); } /* returns false on error */ static bool allocateImplId16(dfa_info &info, dstate_id_t sheng_end, dstate_id_t *sherman_base) { info.states[0].impl_id = 0; /* dead is always 0 */ vector norm; vector sherm; vector norm_sheng_succ; vector sherm_sheng_succ; if (info.size() > (1 << 16)) { DEBUG_PRINTF("too many states\n"); *sherman_base = 0; return false; } for (u32 i = 1; i < info.size(); i++) { if (info.is_sheng(i)) { continue; /* sheng impl ids have already been allocated */ } if (info.is_sherman(i)) { if (info.is_sheng_succ(i)) { sherm_sheng_succ.push_back(i); } else { sherm.push_back(i); } } else { if (info.is_sheng_succ(i)) { norm_sheng_succ.push_back(i); } else { norm.push_back(i); } } } dstate_id_t next_norm = sheng_end; for (dstate_id_t s : norm_sheng_succ) { info.states[s].impl_id = next_norm++; } if (next_norm + norm.size() + sherm_sheng_succ.size() > UINT8_MAX) { /* we need to give sheng_succs ids which fit into a u8 -- demote these * to normal states */ for (dstate_id_t s : sherm_sheng_succ) { info.states[s].impl_id = next_norm++; info.extra[s].shermanState = false; } sherm_sheng_succ.clear(); } for (dstate_id_t s : norm) { info.states[s].impl_id = next_norm++; } *sherman_base = next_norm; dstate_id_t next_sherman = next_norm; for (dstate_id_t s : sherm_sheng_succ) { info.states[s].impl_id = next_sherman++; } for (dstate_id_t s : sherm) { info.states[s].impl_id = next_sherman++; } /* Check to see if we haven't over allocated our states */ DEBUG_PRINTF("next sherman %u masked %u\n", next_sherman, (dstate_id_t)(next_sherman & STATE_MASK)); return (next_sherman - 1) == ((next_sherman - 1) & STATE_MASK); } typedef RdfaGraph::vertex_descriptor RdfaVertex; static bool mark_sheng_succs(const RdfaGraph &g, dfa_info &info, const flat_set &sheng_states) { u32 exit_count = 0; for (auto v : sheng_states) { dstate_id_t s = g[v].index; for (u32 i = 0; i != info.alpha_size; i++) { if (i == info.alpha_remap[TOP]) { continue; } dstate_id_t next = info.states[s].next[i]; if (!next || info.is_sheng(next) || info.is_sheng_succ(next)) { continue; } exit_count++; info.extra[next].sheng_succ = true; } } if (exit_count + sheng_states.size() < UINT8_MAX) { return true; } else { DEBUG_PRINTF("fail: unable to fit %u exits in byte", exit_count); return false; } } static CharReach get_edge_reach(dstate_id_t u, dstate_id_t v, const dfa_info &info) { CharReach rv; for (u32 i = 0; i < info.impl_alpha_size; i++) { if (info.raw.states[u].next[i] == v) { assert(info.rev_alpha[i].any()); rv |= info.rev_alpha[i]; } } assert(rv.any()); return rv; } #define MAX_SHENG_STATES 16 #define MAX_SHENG_LEAKINESS 0.05 /** * Returns the proportion of strings of length 'depth' which will leave the * sheng region when starting at state 'u'. */ static double leakiness(const RdfaGraph &g, dfa_info &info, const flat_set &sheng_states, RdfaVertex u, u32 depth, unordered_map, double> &cache) { double rv = 0; if (contains(cache, make_pair(u, depth))) { return cache[make_pair(u, depth)]; } for (RdfaVertex v : adjacent_vertices_range(u, g)) { if (g[v].index == DEAD_STATE) { continue; } double width = get_edge_reach(g[u].index, g[v].index, info).count(); width /= N_CHARS; double weight; if (!contains(sheng_states, v)) { weight = 1; } else if (depth > 1) { weight = leakiness(g, info, sheng_states, v, depth - 1, cache); } else { continue; /* weight = 0 */ } rv += width * weight; } cache[make_pair(u, depth)] = rv; DEBUG_PRINTF("%zu [%u] q = %g\n", g[u].index, depth, rv); return rv; } /** * Returns the proportion of 8 byte strings which will leave the sheng region * when starting at state 'u'. */ static double leakiness(const RdfaGraph &g, dfa_info &info, const flat_set &sheng_states, RdfaVertex u) { unordered_map, double> cache; double rv = leakiness(g, info, sheng_states, u, 8, cache); return rv; } static dstate_id_t find_sheng_states(dfa_info &info, map &accel_escape_info) { RdfaGraph g(info.raw); auto cyclics = find_vertices_in_cycles(g); auto base_cyclic = RdfaGraph::null_vertex(); for (const auto &v : cyclics) { if (g[v].index == DEAD_STATE) { continue; } DEBUG_PRINTF("considering cyclic %zu\n", g[v].index); /* get an estimate of stickness of the cyclic: assume any edges from * states with larger state ids are back edges */ CharReach est_back_reach; for (const auto &u : inv_adjacent_vertices_range(v, g)) { if (g[u].index < g[v].index) { continue; } est_back_reach |= get_edge_reach(g[u].index, g[v].index, info); } if (est_back_reach.count() < 30) { continue; } base_cyclic = v; break; } if (!base_cyclic) { return DEAD_STATE; } flat_set sheng_states; deque to_consider = { base_cyclic }; flat_set considered = { DEAD_STATE }; bool seen_back_edge = false; while (!to_consider.empty() && sheng_states.size() < MAX_SHENG_STATES) { auto v = to_consider.front(); to_consider.pop_front(); if (!considered.insert(g[v].index).second) { continue; } assert(!contains(sheng_states, v)); if (generates_callbacks(info.raw.kind) && !info.states[g[v].index].reports.empty()) { /* cannot raise callbacks from sheng region */ continue; } sheng_states.insert(v); for (const auto &t : adjacent_vertices_range(v, g)) { if (!contains(considered, g[t].index)) { to_consider.push_back(t); } if (t == base_cyclic) { seen_back_edge = true; } } } /* allocate normal ids */ dstate_id_t sheng_end = DEAD_STATE + 1; for (auto v : sheng_states) { dstate_id_t s = g[v].index; if (!contains(accel_escape_info, s)) { info.states[s].impl_id = sheng_end++; info.extra[s].sheng_id = info.states[s].impl_id - 1; } } /* allocate accel ids */ for (auto v : sheng_states) { dstate_id_t s = g[v].index; if (contains(accel_escape_info, s)) { assert(!info.states[s].impl_id); info.states[s].impl_id = sheng_end++; info.extra[s].sheng_id = info.states[s].impl_id - 1; } } if (sheng_states.size() < MIN_SHENG_SIZE) { DEBUG_PRINTF("sheng region too small\n"); return DEAD_STATE; } if (!seen_back_edge) { DEBUG_PRINTF("did not include cyclic\n"); return DEAD_STATE; } double leak = leakiness(g, info, sheng_states, base_cyclic); if (leak > MAX_SHENG_LEAKINESS) { DEBUG_PRINTF("too leaky (%g)\n", leak); return DEAD_STATE; } if (!mark_sheng_succs(g, info, sheng_states)) { return DEAD_STATE; } /* TODO: ensure sufficiently 'sticky' */ /* TODO: check not all states accel */ DEBUG_PRINTF("sheng_end = %hu\n", sheng_end); return sheng_end; } static void fill_in_aux_info(NFA *nfa, const dfa_info &info, const map &accel_escape_info, u32 accel_offset, UNUSED u32 accel_end_offset, const vector &reports, const vector &reports_eod, u32 report_base_offset, const raw_report_info &ri) { mcsheng *m = (mcsheng *)getMutableImplNfa(nfa); vector reportOffsets; ri.fillReportLists(nfa, report_base_offset, reportOffsets); for (u32 i = 0; i < info.size(); i++) { u16 impl_id = info.implId(i); mstate_aux *this_aux = getAux(nfa, impl_id); fillInAux(this_aux, i, info, reports, reports_eod, reportOffsets); if (contains(accel_escape_info, i)) { this_aux->accel_offset = accel_offset; accel_offset += info.strat.accelSize(); assert(accel_offset <= accel_end_offset); assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); info.strat.buildAccel(i, accel_escape_info.at(i), (void *)((char *)m + this_aux->accel_offset)); } } } static u16 get_edge_flags(NFA *nfa, dstate_id_t target_impl_id) { mstate_aux *aux = getAux(nfa, target_impl_id); u16 flags = 0; if (aux->accept) { flags |= ACCEPT_FLAG; } if (aux->accel_offset) { flags |= ACCEL_FLAG; } return flags; } static void fill_in_succ_table_16(NFA *nfa, const dfa_info &info, dstate_id_t sheng_end, UNUSED dstate_id_t sherman_base) { u16 *succ_table = (u16 *)((char *)nfa + sizeof(NFA) + sizeof(mcsheng)); u8 alphaShift = info.getAlphaShift(); assert(alphaShift <= 8); for (size_t i = 0; i < info.size(); i++) { if (!info.is_normal(i)) { assert(info.implId(i) < sheng_end || info.is_sherman(i)); continue; } assert(info.implId(i) < sherman_base); u16 normal_id = verify_u16(info.implId(i) - sheng_end); for (size_t s = 0; s < info.impl_alpha_size; s++) { dstate_id_t raw_succ = info.states[i].next[s]; u16 &entry = succ_table[((size_t)normal_id << alphaShift) + s]; entry = info.implId(raw_succ); entry |= get_edge_flags(nfa, entry); } } } #define MAX_SHERMAN_LIST_LEN 8 static void addIfEarlier(set &dest, dstate_id_t candidate, dstate_id_t max) { if (candidate < max) { dest.insert(candidate); } } static void addSuccessors(set &dest, const dstate &source, u16 alphasize, dstate_id_t curr_id) { for (symbol_t s = 0; s < alphasize; s++) { addIfEarlier(dest, source.next[s], curr_id); } } #define MAX_SHERMAN_SELF_LOOP 20 static void find_better_daddy(dfa_info &info, dstate_id_t curr_id, bool any_cyclic_near_anchored_state, const Grey &grey) { if (!grey.allowShermanStates) { return; } const u16 width = sizeof(u16); const u16 alphasize = info.impl_alpha_size; if (info.raw.start_anchored != DEAD_STATE && any_cyclic_near_anchored_state && curr_id < alphasize * 3) { /* crude attempt to prevent frequent states from being sherman'ed * depends on the fact that states are numbers are currently in bfs * order */ DEBUG_PRINTF("%hu is banned\n", curr_id); return; } if (info.raw.start_floating != DEAD_STATE && curr_id >= info.raw.start_floating && curr_id < info.raw.start_floating + alphasize * 3) { /* crude attempt to prevent frequent states from being sherman'ed * depends on the fact that states are numbers are currently in bfs * order */ DEBUG_PRINTF("%hu is banned (%hu)\n", curr_id, info.raw.start_floating); return; } const u16 full_state_size = width * alphasize; const u16 max_list_len = MIN(MAX_SHERMAN_LIST_LEN, (full_state_size - 2)/(width + 1)); u16 best_score = 0; dstate_id_t best_daddy = 0; dstate &currState = info.states[curr_id]; set hinted; /* set of states to search for a better daddy */ addIfEarlier(hinted, 0, curr_id); addIfEarlier(hinted, info.raw.start_anchored, curr_id); addIfEarlier(hinted, info.raw.start_floating, curr_id); dstate_id_t mydaddy = currState.daddy; if (mydaddy) { addIfEarlier(hinted, mydaddy, curr_id); addSuccessors(hinted, info.states[mydaddy], alphasize, curr_id); dstate_id_t mygranddaddy = info.states[mydaddy].daddy; if (mygranddaddy) { addIfEarlier(hinted, mygranddaddy, curr_id); addSuccessors(hinted, info.states[mygranddaddy], alphasize, curr_id); } } for (const dstate_id_t &donor : hinted) { assert(donor < curr_id); u32 score = 0; if (!info.is_normal(donor)) { continue; } const dstate &donorState = info.states[donor]; for (symbol_t s = 0; s < alphasize; s++) { if (currState.next[s] == donorState.next[s]) { score++; } } /* prefer lower ids to provide some stability amongst potential * siblings */ if (score > best_score || (score == best_score && donor < best_daddy)) { best_daddy = donor; best_score = score; if (score == alphasize) { break; } } } currState.daddy = best_daddy; info.extra[curr_id].daddytaken = best_score; DEBUG_PRINTF("%hu -> daddy %hu: %u/%u BF\n", curr_id, best_daddy, best_score, alphasize); if (best_daddy == DEAD_STATE) { return; /* No good daddy */ } if (best_score + max_list_len < alphasize) { return; /* ??? */ } assert(info.is_normal(currState.daddy)); u32 self_loop_width = 0; const dstate curr_raw = info.states[curr_id]; for (unsigned i = 0; i < N_CHARS; i++) { if (curr_raw.next[info.alpha_remap[i]] == curr_id) { self_loop_width++; } } if (self_loop_width > MAX_SHERMAN_SELF_LOOP) { DEBUG_PRINTF("%hu is banned wide self loop (%u)\n", curr_id, self_loop_width); return; } if (info.is_sheng(curr_id)) { return; } DEBUG_PRINTF("%hu is sherman\n", curr_id); info.extra[curr_id].shermanState = true; } static bool is_cyclic_near(const raw_dfa &raw, dstate_id_t root) { symbol_t alphasize = raw.getImplAlphaSize(); for (symbol_t s = 0; s < alphasize; s++) { dstate_id_t succ_id = raw.states[root].next[s]; if (succ_id == DEAD_STATE) { continue; } const dstate &succ = raw.states[succ_id]; for (symbol_t t = 0; t < alphasize; t++) { if (succ.next[t] == root || succ.next[t] == succ_id) { return true; } } } return false; } static void fill_in_sherman(NFA *nfa, dfa_info &info, UNUSED u16 sherman_limit) { char *nfa_base = (char *)nfa; mcsheng *m = (mcsheng *)getMutableImplNfa(nfa); char *sherman_table = nfa_base + m->sherman_offset; assert(ISALIGNED_16(sherman_table)); for (size_t i = 0; i < info.size(); i++) { if (!info.is_sherman(i)) { continue; } u16 fs = verify_u16(info.implId(i)); DEBUG_PRINTF("building sherman %zu impl %hu\n", i, fs); assert(fs >= sherman_limit); char *curr_sherman_entry = sherman_table + (fs - m->sherman_limit) * SHERMAN_FIXED_SIZE; assert(curr_sherman_entry <= nfa_base + m->length); u8 len = verify_u8(info.impl_alpha_size - info.extra[i].daddytaken); assert(len <= 9); dstate_id_t d = info.states[i].daddy; *(u8 *)(curr_sherman_entry + SHERMAN_TYPE_OFFSET) = SHERMAN_STATE; *(u8 *)(curr_sherman_entry + SHERMAN_LEN_OFFSET) = len; *(u16 *)(curr_sherman_entry + SHERMAN_DADDY_OFFSET) = info.implId(d); u8 *chars = (u8 *)(curr_sherman_entry + SHERMAN_CHARS_OFFSET); for (u16 s = 0; s < info.impl_alpha_size; s++) { if (info.states[i].next[s] != info.states[d].next[s]) { *(chars++) = (u8)s; } } u16 *states = (u16 *)(curr_sherman_entry + SHERMAN_STATES_OFFSET(len)); for (u16 s = 0; s < info.impl_alpha_size; s++) { if (info.states[i].next[s] != info.states[d].next[s]) { DEBUG_PRINTF("s overrider %hu dad %hu char next %hu\n", fs, info.implId(d), info.implId(info.states[i].next[s])); u16 entry_val = info.implId(info.states[i].next[s]); entry_val |= get_edge_flags(nfa, entry_val); unaligned_store_u16((u8 *)states++, entry_val); } } } } static aligned_unique_ptr mcshengCompile16(dfa_info &info, dstate_id_t sheng_end, const map &accel_escape_info, const Grey &grey) { DEBUG_PRINTF("building mcsheng 16\n"); vector reports; /* index in ri for the appropriate report list */ vector reports_eod; /* as above */ ReportID arb; u8 single; assert(info.getAlphaShift() <= 8); u16 total_daddy = 0; for (u32 i = 0; i < info.size(); i++) { find_better_daddy(info, i, is_cyclic_near(info.raw, info.raw.start_anchored), grey); total_daddy += info.extra[i].daddytaken; } DEBUG_PRINTF("daddy %hu/%zu states=%zu alpha=%hu\n", total_daddy, info.size() * info.impl_alpha_size, info.size(), info.impl_alpha_size); u16 sherman_limit; if (!allocateImplId16(info, sheng_end, &sherman_limit)) { DEBUG_PRINTF("failed to allocate state numbers, %zu states total\n", info.size()); return nullptr; } u16 count_real_states = sherman_limit - sheng_end; auto ri = info.strat.gatherReports(reports, reports_eod, &single, &arb); size_t tran_size = (1 << info.getAlphaShift()) * sizeof(u16) * count_real_states; size_t aux_size = sizeof(mstate_aux) * info.size(); size_t aux_offset = ROUNDUP_16(sizeof(NFA) + sizeof(mcsheng) + tran_size); size_t accel_size = info.strat.accelSize() * accel_escape_info.size(); size_t accel_offset = ROUNDUP_N(aux_offset + aux_size + ri->getReportListSize(), 32); size_t sherman_offset = ROUNDUP_16(accel_offset + accel_size); size_t sherman_size = calcShermanRegionSize(info); size_t total_size = sherman_offset + sherman_size; accel_offset -= sizeof(NFA); /* adj accel offset to be relative to m */ assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); aligned_unique_ptr nfa = aligned_zmalloc_unique(total_size); mcsheng *m = (mcsheng *)getMutableImplNfa(nfa.get()); populateBasicInfo(sizeof(u16), info, total_size, aux_offset, accel_offset, accel_escape_info.size(), arb, single, nfa.get()); createShuffleMasks(m, info, sheng_end, accel_escape_info); /* copy in the mc header information */ m->sherman_offset = sherman_offset; m->sherman_end = total_size; m->sherman_limit = sherman_limit; DEBUG_PRINTF("%hu sheng, %hu norm, %zu total\n", sheng_end, count_real_states, info.size()); fill_in_aux_info(nfa.get(), info, accel_escape_info, accel_offset, sherman_offset - sizeof(NFA), reports, reports_eod, aux_offset + aux_size, *ri); fill_in_succ_table_16(nfa.get(), info, sheng_end, sherman_limit); fill_in_sherman(nfa.get(), info, sherman_limit); return nfa; } static void fill_in_succ_table_8(NFA *nfa, const dfa_info &info, dstate_id_t sheng_end) { u8 *succ_table = (u8 *)nfa + sizeof(NFA) + sizeof(mcsheng); u8 alphaShift = info.getAlphaShift(); assert(alphaShift <= 8); for (size_t i = 0; i < info.size(); i++) { assert(!info.is_sherman(i)); if (!info.is_normal(i)) { assert(info.implId(i) < sheng_end); continue; } u8 normal_id = verify_u8(info.implId(i) - sheng_end); for (size_t s = 0; s < info.impl_alpha_size; s++) { dstate_id_t raw_succ = info.states[i].next[s]; succ_table[((size_t)normal_id << alphaShift) + s] = info.implId(raw_succ); } } } static void allocateImplId8(dfa_info &info, dstate_id_t sheng_end, const map &accel_escape_info, u16 *accel_limit, u16 *accept_limit) { info.states[0].impl_id = 0; /* dead is always 0 */ vector norm; vector accel; vector accept; assert(info.size() <= (1 << 8)); for (u32 i = 1; i < info.size(); i++) { if (info.is_sheng(i)) { continue; /* already allocated */ } else if (!info.states[i].reports.empty()) { accept.push_back(i); } else if (contains(accel_escape_info, i)) { accel.push_back(i); } else { norm.push_back(i); } } u32 j = sheng_end; for (const dstate_id_t &s : norm) { assert(j <= 256); DEBUG_PRINTF("mapping state %u to %u\n", s, j); info.states[s].impl_id = j++; } *accel_limit = j; for (const dstate_id_t &s : accel) { assert(j <= 256); DEBUG_PRINTF("mapping state %u to %u\n", s, j); info.states[s].impl_id = j++; } *accept_limit = j; for (const dstate_id_t &s : accept) { assert(j <= 256); DEBUG_PRINTF("mapping state %u to %u\n", s, j); info.states[s].impl_id = j++; } } static aligned_unique_ptr mcshengCompile8(dfa_info &info, dstate_id_t sheng_end, const map &accel_escape_info) { DEBUG_PRINTF("building mcsheng 8\n"); vector reports; vector reports_eod; ReportID arb; u8 single; auto ri = info.strat.gatherReports(reports, reports_eod, &single, &arb); size_t normal_count = info.size() - sheng_end; size_t tran_size = sizeof(u8) * (1 << info.getAlphaShift()) * normal_count; size_t aux_size = sizeof(mstate_aux) * info.size(); size_t aux_offset = ROUNDUP_16(sizeof(NFA) + sizeof(mcsheng) + tran_size); size_t accel_size = info.strat.accelSize() * accel_escape_info.size(); size_t accel_offset = ROUNDUP_N(aux_offset + aux_size + ri->getReportListSize(), 32); size_t total_size = accel_offset + accel_size; DEBUG_PRINTF("aux_size %zu\n", aux_size); DEBUG_PRINTF("aux_offset %zu\n", aux_offset); DEBUG_PRINTF("rl size %u\n", ri->getReportListSize()); DEBUG_PRINTF("accel_size %zu\n", accel_size); DEBUG_PRINTF("accel_offset %zu\n", accel_offset); DEBUG_PRINTF("total_size %zu\n", total_size); accel_offset -= sizeof(NFA); /* adj accel offset to be relative to m */ assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); aligned_unique_ptr nfa = aligned_zmalloc_unique(total_size); mcsheng *m = (mcsheng *)getMutableImplNfa(nfa.get()); allocateImplId8(info, sheng_end, accel_escape_info, &m->accel_limit_8, &m->accept_limit_8); populateBasicInfo(sizeof(u8), info, total_size, aux_offset, accel_offset, accel_escape_info.size(), arb, single, nfa.get()); createShuffleMasks(m, info, sheng_end, accel_escape_info); fill_in_aux_info(nfa.get(), info, accel_escape_info, accel_offset, total_size - sizeof(NFA), reports, reports_eod, aux_offset + aux_size, *ri); fill_in_succ_table_8(nfa.get(), info, sheng_end); DEBUG_PRINTF("rl size %zu\n", ri->size()); return nfa; } aligned_unique_ptr mcshengCompile(raw_dfa &raw, const CompileContext &cc, const ReportManager &rm) { if (!cc.grey.allowMcSheng) { return nullptr; } mcclellan_build_strat mbs(raw, rm); dfa_info info(mbs); bool using8bit = cc.grey.allowMcClellan8 && info.size() <= 256; if (!cc.streaming) { /* TODO: work out if we can do the strip in streaming * mode with our semantics */ raw.stripExtraEodReports(); } bool has_eod_reports = raw.hasEodReports(); map accel_escape_info = info.strat.getAccelInfo(cc.grey); dstate_id_t sheng_end = find_sheng_states(info, accel_escape_info); if (sheng_end <= DEAD_STATE + 1) { return nullptr; } aligned_unique_ptr nfa; if (!using8bit) { nfa = mcshengCompile16(info, sheng_end, accel_escape_info, cc.grey); } else { nfa = mcshengCompile8(info, sheng_end, accel_escape_info); } if (!nfa) { return nfa; } if (has_eod_reports) { nfa->flags |= NFA_ACCEPTS_EOD; } DEBUG_PRINTF("compile done\n"); return nfa; } bool has_accel_mcsheng(const NFA *) { return true; /* consider the sheng region as accelerated */ } } // namespace ue2 hyperscan-4.4.1/src/nfa/mpv_internal.h0000644000175000017500000001360113055426554020502 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MPV_INTERNAL_H #define MPV_INTERNAL_H #include "ue2common.h" #define MPV_DOT 0 #define MPV_VERM 1 #define MPV_SHUFTI 2 #define MPV_TRUFFLE 3 #define MPV_NVERM 4 struct mpv_puffette { u32 repeats; char unbounded; /** * \brief Report is simple-exhaustible. * * If this is true, we do best-effort suppression of runs of reports, only * delivering the first one. */ char simple_exhaust; ReportID report; }; struct mpv_kilopuff { u32 counter_offset; /**< offset (in full stream state) to the counter that * this kilopuff refers to */ u32 count; /**< number of real (non sentinel mpv puffettes) */ u32 puffette_offset; /**< relative to base of mpv, points past the 1st * sent */ u64a dead_point; u8 auto_restart; u8 type; /* MPV_DOT, MPV_VERM, etc */ union { struct { char c; } verm; struct { m128 mask_lo; m128 mask_hi; } shuf; struct { m128 mask1; m128 mask2; } truffle; } u; }; struct mpv_counter_info { u64a max_counter; /**< maximum value this counter needs to track */ u32 counter_size; /**< number of bytes to represent the counter in stream * state */ u32 counter_offset; /**< offset that this counter is stored at in the * full stream state */ u32 kilo_begin; /**< first kilo to turn on when the counter is started */ u32 kilo_end; /**< 1 + last kilo to turn on when the counter is started */ }; struct ALIGN_AVX_DIRECTIVE mpv { u32 kilo_count; /**< number of kilopuffs following */ u32 counter_count; /**< number of counters managed by the mpv */ u32 puffette_count; /**< total number of puffettes under all the kilos */ u32 pq_offset; /**< offset to the priority queue in the decompressed * state */ u32 reporter_offset; /**< offset to the reporter mmbit in the decompressed * state */ u32 report_list_offset; /**< offset to the report list scratch space in the * decompressed state */ u32 active_offset; /**< offset to the active kp mmbit in the compressed * state */ u32 top_kilo_begin; /**< first kilo to switch on when top arrives */ u32 top_kilo_end; /**< one past the last kilo to switch on when top * arrives */ }; struct mpv_decomp_kilo { u64a limit; const struct mpv_puffette *curr; }; /* note: size varies on different platforms */ struct mpv_decomp_state { u32 pq_size; char filled; u64a counter_adj; /**< progress not yet written to the real counters */ struct mpv_decomp_kilo active[]; }; /* --- * | | mpv * --- * | | * | | kilo_count * mpv_kilopuffs * | | * ... * | | * --- * | | * | | counter_count * mpv_counter_infos * | | * ... * | | * --- * | | sentinel mpv_puffette * --- * | | mpv_puffettes for 1st kilopuff * | | (mpv_puffettes are ordered by minimum number of repeats) * | | * --- * | | sentinel mpv_puffette * --- * | | mpv_puffettes for 2nd kilopuff * ... * | | * --- * | | sentinel mpv_puffette * --- */ /* * Stream State * [Compressed Counter 0] * [Compressed Counter 1] * ... * [Compressed Counter N] * [mmbit of active kilopuffs] * * Decompressed State * [header (limit pq_size)] * [ * [kilo 1 current reports] * ... * [kilo N current reports] * ] * [ * [Full Counter 0] * [Full Counter 1] * ... * [Full Counter N] * ] * [pq of kilo changes] * [scratch space for current report lists (total number of puffettes)] * [mmbit of kilopuffs with active reports] */ struct mpv_pq_item { u64a trigger_loc; u32 kilo; }; /* returns pointer to first non sentinel mpv_puff */ static really_inline const struct mpv_puffette *get_puff_array(const struct mpv *m, const struct mpv_kilopuff *kp) { return (const struct mpv_puffette *)((const char *)m + kp->puffette_offset); } static really_inline const struct mpv_counter_info *get_counter_info(const struct mpv *m) { return (const struct mpv_counter_info *)((const char *)(m + 1) + m->kilo_count * sizeof(struct mpv_kilopuff)); } #define MPV_DEAD_VALUE (~0ULL) #define INVALID_REPORT (~0U) #endif hyperscan-4.4.1/src/nfa/multivermicelli_avx2.h0000644000175000017500000002045613055426554022160 0ustar sleuthkidsleuthkid/* * 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. */ #include "util/bitutils.h" #include "util/simd_utils.h" #include "util/unaligned.h" #include "multiaccel_common.h" static really_inline const u8 *JOIN(MATCH_ALGO, vermUnalignNocase)(m256 chars, const u8 *buf, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { m256 casemask = set32x8(CASE_CLEAR); const u8 *ptr; m256 data = loadu256(buf); u32 z = movemask256(eq256(chars, and256(casemask, data))); ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (buf, z #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } static really_inline const u8 *JOIN(MATCH_ALGO, vermUnalign)(m256 chars, const u8 *buf, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8 *ptr; m256 data = loadu256(buf); u32 z = movemask256(eq256(chars, data)); ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (buf, z #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } /* * 32-byte pipeline */ static really_inline const u8 *JOIN(MATCH_ALGO, vermPipeline)(m256 chars, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8* ptr, *last_buf; u32 last_res; // pipeline prologue: scan first 32 bytes m256 data = load256(buf); u32 z = movemask256(eq256(chars, data)); last_res = z; last_buf = buf; buf += 32; // now, start the pipeline! assert((size_t)buf % 32 == 0); for (; buf + 31 < buf_end; buf += 32) { // scan more data data = load256(buf); z = movemask256(eq256(chars, data)); // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_buf = buf; last_res = z; } assert(buf <= buf_end && buf >= buf_end - 32); // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } /* * 32-byte caseless pipeline */ static really_inline const u8 *JOIN(MATCH_ALGO, vermPipelineNocase)(m256 chars, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { m256 casemask = set32x8(CASE_CLEAR); const u8* ptr, *last_buf; u32 last_res; // pipeline prologue: scan first 32 bytes m256 data = load256(buf); u32 z = movemask256(eq256(chars, and256(casemask, data))); last_res = z; last_buf = buf; buf += 32; // now, start the pipeline! assert((size_t)buf % 32 == 0); for (; buf + 31 < buf_end; buf += 32) { // scan more data data = load256(buf); z = movemask256(eq256(chars, and256(casemask, data))); // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_buf = buf; last_res = z; } assert(buf <= buf_end && buf >= buf_end - 32); // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } const u8 *JOIN(MATCH_ALGO, vermicelliExec)(char c, char nocase, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { DEBUG_PRINTF("verm scan %s\\x%02hhx over %zu bytes\n", nocase ? "nocase " : "", c, (size_t)(buf_end - buf)); assert(buf < buf_end); const u8 *ptr; // Handle small scans. if (buf_end - buf < 32) { for (; buf < buf_end; buf++) { char cur = (char)*buf; if (nocase) { cur &= CASE_CLEAR; } if (cur == c) { break; } } return buf; } m256 chars = set32x8(c); /* nocase already uppercase */ uintptr_t min = (uintptr_t)buf % 32; if (min) { ptr = nocase ? JOIN(MATCH_ALGO, vermUnalignNocase)(chars, buf, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ) : JOIN(MATCH_ALGO, vermUnalign)(chars, buf, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } buf += 32 - min; } if (buf_end - buf >= 32){ ptr = nocase ? JOIN(MATCH_ALGO, vermPipelineNocase)(chars, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ) : JOIN(MATCH_ALGO, vermPipeline)(chars, buf, buf_end, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } } // final unaligned scan ptr = nocase ? JOIN(MATCH_ALGO, vermUnalignNocase)(chars, buf_end - 32, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ) : JOIN(MATCH_ALGO, vermUnalign)(chars, buf_end - 32, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); // run our pipeline return ptr ? ptr : buf_end; } hyperscan-4.4.1/src/nfa/dfa_min.h0000644000175000017500000000336413055426554017406 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Build code for McClellan DFA. */ #ifndef DFA_MIN_H #define DFA_MIN_H namespace ue2 { struct raw_dfa; struct Grey; void minimize_hopcroft(raw_dfa &rdfa, const Grey &grey); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/limex_context.h0000644000175000017500000000735513055426554020677 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Runtime context structures (NFAContext128 and friends) for the NFA. */ #ifndef LIMEX_CONTEXT_H #define LIMEX_CONTEXT_H #include "ue2common.h" #include "callback.h" #include "util/simd_utils.h" // for m128 etc // Runtime context structures. /* Note: The size of the context structures may vary from platform to platform * (notably, for the Limex64 structure). As a result, information based on the * size and other detail of these structures should not be written into the * bytecode -- really, the details of the structure should not be accessed by * the ue2 compile side at all. */ #ifdef __cplusplus #error ue2 runtime only file #endif /* cached_estate/esucc etc... * * If the exception state matches the cached_estate we will apply * the or in the cached_esucc to the successor states rather than processing * the exceptions. * * If the current exception state is a superset of the cached_estate, the * cache is NOT used at all. * * The cache is updated when we see a different cacheable estate. */ #define GEN_CONTEXT_STRUCT(nsize, ntype) \ struct ALIGN_CL_DIRECTIVE NFAContext##nsize { \ ntype s; /**< state bitvector (on entry/exit) */ \ ntype local_succ; /**< used by exception handling for large models */ \ ntype cached_estate; /* inited to 0 */ \ ntype cached_esucc; \ char cached_br; /**< cached_estate contains a br state */ \ const ReportID *cached_reports; \ union RepeatControl *repeat_ctrl; \ char *repeat_state; \ NfaCallback callback; \ void *context; \ }; GEN_CONTEXT_STRUCT(32, u32) #ifdef ARCH_64_BIT GEN_CONTEXT_STRUCT(64, u64a) #else GEN_CONTEXT_STRUCT(64, m128) #endif GEN_CONTEXT_STRUCT(128, m128) GEN_CONTEXT_STRUCT(256, m256) GEN_CONTEXT_STRUCT(384, m384) GEN_CONTEXT_STRUCT(512, m512) #undef GEN_CONTEXT_STRUCT #endif hyperscan-4.4.1/src/nfa/goughcompile_accel.cpp0000644000175000017500000002257713055426554022164 0ustar sleuthkidsleuthkid/* * 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. */ #include "goughcompile_internal.h" #include "gough_internal.h" #include "grey.h" #include "mcclellancompile.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "ue2common.h" #include #include using namespace std; namespace ue2 { template void add_edge_if_not_selfloop(const typename Graph::vertex_descriptor &u, const typename Graph::vertex_descriptor &v, Graph &g) { if (u != v) { add_edge(u, v, g); } } static bool can_accel_over_selfloop(const GoughVertexProps &vp, const GoughEdge &e, const GoughEdgeProps &ep, u32 *margin) { if (vp.vars.empty() && ep.vars.empty()) { /* if we update no som information, then it is trivial to accelerate */ *margin = 0; return true; } /* if the effect of running a self loop stabilises after a small number of * iterations, it is possible to accelerate over the state and only then run * the block N times. To model this we create a graph which shows how the * value for a variable at the end of a self loop block is related to values * at the start */ typedef boost::adjacency_list basic_graph; typedef basic_graph::vertex_descriptor basic_vertex; basic_graph bg; map verts; /* create verts */ for (const auto &var : ep.vars) { verts[var.get()] = add_vertex(bg); } for (const auto &var : vp.vars) { verts[var.get()] = add_vertex(bg); } /* wire edges */ set done; for (const auto &var : ep.vars) { assert(contains(verts, var.get())); basic_vertex v = verts[var.get()]; for (GoughSSAVar *pred : var->get_inputs()) { if (!contains(verts, pred)) { continue; } basic_vertex u = verts[pred]; if (contains(done, u)) { /* u has already taken on new values this * iteration */ for (auto p : inv_adjacent_vertices_range(u, bg)) { add_edge_if_not_selfloop(p, v, bg); } } else { add_edge_if_not_selfloop(u, v, bg); } } done.insert(v); } for (const auto &var : vp.vars) { GoughSSAVar *pred = var->get_input(e); assert(contains(verts, var.get())); basic_vertex v = verts[var.get()]; if (!contains(verts, pred)) { continue; } basic_vertex u = verts[pred]; if (contains(done, u)) { /* u has already taken on new values this * iteration */ for (auto p : inv_adjacent_vertices_range(u, bg)) { add_edge_if_not_selfloop(p, v, bg); } } else { add_edge_if_not_selfloop(u, v, bg); } /* do not add v to done as all joins happen in parallel */ } /* check for loops - non self loops may prevent settling */ if (!is_dag(bg)) { DEBUG_PRINTF("can not %u accel as large loops\n", vp.state_id); return false; } *margin = num_vertices(bg); /* TODO: be less conservative */ if (*margin > 50) { return false; } return true; } static bool verify_neighbour(const GoughGraph &g, GoughVertex u, const map > &blocks, const set &succs, const vector &block_sl) { for (const auto &e : out_edges_range(u, g)) { if (!g[e].reach.any()) { /* ignore top edges */ continue; } GoughVertex t = target(e, g); if (!contains(succs, t)) { /* must be an escape string */ continue; } if (!contains(blocks, gough_edge_id(g, e))) { return false; } if (blocks.at(gough_edge_id(g, e)) != block_sl) { return false; } } return true; } static bool verify_neighbour_no_block(const GoughGraph &g, GoughVertex u, const map > &blocks, const set &succs) { for (const auto &e : out_edges_range(u, g)) { if (!g[e].reach.any()) { /* ignore top edges */ continue; } GoughVertex t = target(e, g); if (!contains(succs, t)) { /* must be an escape string */ continue; } if (contains(blocks, gough_edge_id(g, e))) { return false; } } return true; } /* Checks the som aspects of allowing two byte accel - it is expected that the * mcclellan logic will identify escape strings. * * For 2 byte acceleration to be correct we require that any non-escape sequence * characters xy from the accel state has the same effect as just the character * of y. * * The current way of ensuring this is to require: * (a) all edges out of the cyclic state behave identically to the cyclic self * loop edge * (b) edges out of the neighbouring state which do not correspond to escape * string behave identical to the cyclic state edges. * * TODO: these restrictions could be relaxed by looking at the effect on * relevant (live?) vars only, allowing additions to the escape string set, and * considering one byte escapes. */ static bool allow_two_byte_accel(const GoughGraph &g, const map > &blocks, GoughVertex v, const GoughEdge &self_loop) { if (contains(blocks, gough_edge_id(g, self_loop))) { DEBUG_PRINTF("edge plan on self loop\n"); const auto &block_sl = blocks.at(gough_edge_id(g, self_loop)); set succs; for (const auto &e : out_edges_range(v, g)) { if (g[e].reach.none()) { /* ignore top edges */ continue; } gough_edge_id ged(g, e); if (!contains(blocks, ged) || blocks.at(ged) != block_sl) { DEBUG_PRINTF("different out-edge behaviour\n"); return false; } succs.insert(target(e, g)); } for (auto w : adjacent_vertices_range(v, g)) { if (w != v && !verify_neighbour(g, w, blocks, succs, block_sl)) { return false; } } } else { DEBUG_PRINTF("no edge plan on self loop\n"); set succs; for (const auto &e : out_edges_range(v, g)) { if (g[e].reach.none()) { /* ignore top edges */ continue; } gough_edge_id ged(g, e); if (contains(blocks, ged)) { DEBUG_PRINTF("different out-edge behaviour\n"); return false; } succs.insert(target(e, g)); for (auto w : adjacent_vertices_range(v, g)) { if (w != v && !verify_neighbour_no_block(g, w, blocks, succs)) { return false; } } } } DEBUG_PRINTF("allowing two byte accel for %u\n", g[v].state_id); return true; } void find_allowed_accel_states(const GoughGraph &g, const map > &blocks, map *out) { for (auto v : vertices_range(g)) { GoughEdge e; if (!find_normal_self_loop(v, g, &e)) { continue; /* not accelerable */ } u32 margin = 0; if (!can_accel_over_selfloop(g[v], e, g[e], &margin)) { continue; /* not accelerable */ } bool tba = allow_two_byte_accel(g, blocks, v, e); out->emplace(g[v].state_id, gough_accel_state_info(margin, tba)); } } } // namespace ue2 hyperscan-4.4.1/src/nfa/mcsheng_compile.h0000644000175000017500000000375513055426554021151 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 MCSHENGCOMPILE_H #define MCSHENGCOMPILE_H #include "accel_dfa_build_strat.h" #include "rdfa.h" #include "ue2common.h" #include "util/alloc.h" #include "util/ue2_containers.h" #include struct NFA; namespace ue2 { class ReportManager; struct CompileContext; ue2::aligned_unique_ptr mcshengCompile(raw_dfa &raw, const CompileContext &cc, const ReportManager &rm); bool has_accel_mcsheng(const NFA *nfa); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/limex_64.c0000644000175000017500000000460013055426554017425 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief LimEx NFA: 128-bit SIMD runtime implementations. */ /* Limex64 is unusual on as on 32 bit platforms, at runtime it uses an m128 for * state calculations. */ //#define DEBUG_INPUT //#define DEBUG_EXCEPTIONS #include "limex.h" #include "accel.h" #include "limex_internal.h" #include "nfa_internal.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" // Common code #define STATE_ON_STACK #define ESTATE_ON_STACK #include "limex_runtime.h" #define SIZE 64 #define ENG_STATE_T u64a #ifdef ARCH_64_BIT #define STATE_T u64a #define LOAD_FROM_ENG load_u64a #else #define STATE_T m128 #define LOAD_FROM_ENG load_m128_from_u64a #endif #include "limex_exceptional.h" #include "limex_state_impl.h" #define INLINE_ATTR really_inline #include "limex_common_impl.h" #include "limex_runtime_impl.h" hyperscan-4.4.1/src/nfa/repeatcompile.cpp0000644000175000017500000003103313055426554021167 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Bounded repeat compile-time code. */ #include "repeatcompile.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/depth.h" #include "util/dump_charclass.h" #include "util/multibit_build.h" #include "util/verify_types.h" #include #include // memset #include using namespace std; namespace ue2 { /** \brief Calculate the number of slots required to store the given repeat in * a RANGE model. */ static u32 numRangeSlots(u32 repeatMin, u32 repeatMax) { assert(repeatMax > repeatMin); u32 d = repeatMax - repeatMin; u32 slots = 2 * ((repeatMax / d) + 1); return slots; } static u32 calcPackedBits(u64a val) { assert(val); if (val <= 1) { return 1; } u32 bits = lg2_64(val - 1) + 1U; /* lg2 rounds down */ DEBUG_PRINTF("packing %llu into %u bits\n", val, bits); return bits; } /* returns the min number of bytes required to represent val options */ u32 calcPackedBytes(u64a val) { u32 rv = (calcPackedBits(val) + 7U) / 8U; DEBUG_PRINTF("packing %llu into %u bytes\n", val, rv); return rv; } static u32 repeatRecurTable(struct RepeatStateInfo *info, const depth &repeatMax, const u32 minPeriod) { u32 repeatTmp = info->patchCount > 2 ? 64 : (u32)repeatMax; u32 repeat_index = repeatTmp < minPeriod ? repeatTmp : minPeriod; for (u32 i = 0; i <= repeat_index; i++) { info->table.push_back(i + 1); } for (u32 i = minPeriod + 1; i <= repeatTmp; i++) { info->table.push_back(info->table[i - 1] + info->table[i - minPeriod]); if (info->table[i] < info->table[i - 1]) { return i - 1; } } return 0; } static u32 findOptimalPatchSize(struct RepeatStateInfo *info, const depth &repeatMax, const u32 minPeriod, u32 rv) { u32 cnt = 0; u32 patch_bits = 0; u32 total_size = 0; u32 min = ~0U; u32 patch_len = 0; if (!rv) { rv = repeatMax; } for (u32 i = minPeriod; i <= rv; i++) { cnt = ((u32)repeatMax + (i - 1)) / i + 1; // no bit packing version patch_bits = calcPackedBits(info->table[i]); total_size = (patch_bits + 7U) / 8U * cnt; if (total_size < min) { patch_len = i; min = total_size; info->patchCount = cnt; } } return patch_len; } RepeatStateInfo::RepeatStateInfo(enum RepeatType type, const depth &repeatMin, const depth &repeatMax, u32 minPeriod) : stateSize(0), packedCtrlSize(0), horizon(0), patchCount(0), patchSize(0), encodingSize(0), patchesOffset(0) { assert(repeatMin <= repeatMax); assert(repeatMax.is_reachable()); assert(minPeriod || type != REPEAT_SPARSE_OPTIMAL_P); switch (type) { case REPEAT_FIRST: assert(repeatMin.is_finite()); stateSize = 0; // everything is in the control block. horizon = repeatMin; packedCtrlSize = calcPackedBytes(horizon + 1); break; case REPEAT_LAST: assert(repeatMax.is_finite()); stateSize = 0; // everything is in the control block. horizon = repeatMax + 1; packedCtrlSize = calcPackedBytes(horizon + 1); break; case REPEAT_RING: assert(repeatMax.is_finite()); stateSize = mmbit_size(repeatMax + 1); horizon = repeatMax * 2 + 1; /* TODO: investigate tightening */ // Packed offset member, plus two bytes for each ring index, reduced to // one byte each if they'll fit in eight bits. { u32 offset_len = calcPackedBytes(horizon + 1); u32 ring_indices_len = repeatMax < depth(254) ? 2 : 4; packedCtrlSize = offset_len + ring_indices_len; } break; case REPEAT_RANGE: assert(repeatMax.is_finite()); assert(repeatMin < repeatMax); stateSize = numRangeSlots(repeatMin, repeatMax) * sizeof(u16); horizon = repeatMax * 2 + 1; // Packed offset member, plus one byte for the number of range // elements. packedCtrlSize = calcPackedBytes(horizon + 1) + 1; break; case REPEAT_BITMAP: stateSize = 0; // everything is in the control block. horizon = 0; // unused packedCtrlSize = ROUNDUP_N(repeatMax + 1, 8) / 8; break; case REPEAT_SPARSE_OPTIMAL_P: assert(minPeriod); assert(repeatMax.is_finite()); { u32 rv = repeatRecurTable(this, repeatMax, minPeriod); u32 repeatTmp = 0; if ((u32)repeatMax < minPeriod) { repeatTmp = repeatMax; patchCount = 1; } else { // find optimal patch size repeatTmp = findOptimalPatchSize(this, repeatMax, minPeriod, rv); assert(patchCount < 65536); } DEBUG_PRINTF("repeat[%u %u], period=%u\n", (u32)repeatMin, (u32)repeatMax, minPeriod); u64a maxVal = table[repeatTmp]; encodingSize = calcPackedBytes(maxVal); patchSize = repeatTmp; assert(encodingSize <= 64); patchesOffset = mmbit_size(patchCount); stateSize = patchesOffset + encodingSize * patchCount; horizon = (repeatTmp * patchCount) * 2 + 1; u32 ring_indices_len = patchCount < depth(254) ? 2 : 4; packedCtrlSize = calcPackedBytes(horizon + 1) + ring_indices_len; } break; case REPEAT_TRAILER: assert(repeatMax.is_finite()); assert(repeatMin <= depth(64)); stateSize = 0; // everything is in the control block. horizon = repeatMax + 1; packedFieldSizes.resize(2); packedFieldSizes[0] = calcPackedBits(horizon + 1); packedFieldSizes[1] = repeatMin; packedCtrlSize = (packedFieldSizes[0] + packedFieldSizes[1] + 7U) / 8U; break; case REPEAT_ALWAYS: assert(repeatMin == 0ULL); assert(repeatMax.is_infinite()); stateSize = 0; // everything is in the control block. horizon = 0; packedCtrlSize = 0; break; } DEBUG_PRINTF("stateSize=%u, packedCtrlSize=%u, horizon=%u\n", stateSize, packedCtrlSize, horizon); assert(packedCtrlSize <= sizeof(RepeatControl)); } /** \brief Returns the packed control block size in bytes for a given bounded * repeat. */ static u32 packedSize(enum RepeatType type, const depth &repeatMin, const depth &repeatMax, u32 minPeriod) { RepeatStateInfo rsi(type, repeatMin, repeatMax, minPeriod); return rsi.packedCtrlSize; } /** \brief Returns the stream state size in bytes for a given bounded * repeat. */ static u32 streamStateSize(enum RepeatType type, const depth &repeatMin, const depth &repeatMax, u32 minPeriod) { RepeatStateInfo rsi(type, repeatMin, repeatMax, minPeriod); return rsi.stateSize; } enum RepeatType chooseRepeatType(const depth &repeatMin, const depth &repeatMax, u32 minPeriod, bool is_reset, bool has_external_guard) { if (repeatMax.is_infinite()) { if (has_external_guard && !repeatMin) { return REPEAT_ALWAYS; } else { return REPEAT_FIRST; } } if (repeatMin == depth(0) || is_reset) { return REPEAT_LAST; } // Cases with max < 64 can be handled with either bitmap or trailer. We use // whichever has smaller packed state. if (repeatMax < depth(64)) { u32 bitmap_len = packedSize(REPEAT_BITMAP, repeatMin, repeatMax, minPeriod); u32 trailer_len = packedSize(REPEAT_TRAILER, repeatMin, repeatMax, minPeriod); return bitmap_len <= trailer_len ? REPEAT_BITMAP : REPEAT_TRAILER; } if (repeatMin <= depth(64)) { return REPEAT_TRAILER; } u32 range_len = ~0U; if (repeatMax > repeatMin && numRangeSlots(repeatMin, repeatMax) <= REPEAT_RANGE_MAX_SLOTS) { assert(numRangeSlots(repeatMin, repeatMax) < 256); // stored in u8 range_len = streamStateSize(REPEAT_RANGE, repeatMin, repeatMax, minPeriod); } assert(repeatMax.is_finite()); u32 sparse_len = ~0U; if (minPeriod > 6) { sparse_len = streamStateSize(REPEAT_SPARSE_OPTIMAL_P, repeatMin, repeatMax, minPeriod); } if (range_len != ~0U || sparse_len != ~0U) { return range_len < sparse_len ? REPEAT_RANGE : REPEAT_SPARSE_OPTIMAL_P; } return REPEAT_RING; } bool matches(vector::const_iterator a_it, vector::const_iterator a_ite, vector::const_iterator b_it, UNUSED vector::const_iterator b_ite) { for (; a_it != a_ite; ++a_it, ++b_it) { assert(b_it != b_ite); if ((*a_it & *b_it).none()) { return false; } } assert(b_it == b_ite); return true; } static u32 minDistAfterA(const vector &a, const vector &b) { /* we do not count the case where b can end at the same position as a */ for (u32 i = 1; i < b.size(); i++) { u32 overlap_len = b.size() - i; if (overlap_len <= a.size()) { if (matches(a.end() - overlap_len, a.end(), b.begin(), b.end() - i)) { return i; } } else { assert(overlap_len > a.size()); if (matches(a.begin(), a.end(), b.end() - i - a.size(), b.end() - i)) { return i; } } } return b.size(); } vector minResetDistToEnd(const vector> &triggers, const CharReach &cr) { /* if a trigger does not reset the repeat, it gets a distance of trigger length */ vector out; for (const auto &trig : triggers) { size_t size = trig.size(); size_t i = 0; for (; i < size; i++) { if ((trig[size - i - 1] & cr).none()) { break; } } out.push_back(i); } return out; } #if defined(DEBUG) || defined(DUMP_SUPPORT) static UNUSED string dumpTrigger(const vector &trigger) { string s; for (const auto &cr : trigger) { s += describeClass(cr); } return s; } #endif u32 minPeriod(const vector> &triggers, const CharReach &cr, bool *can_reset) { assert(!triggers.empty()); u32 rv = ~0U; *can_reset = true; vector min_reset_dist = minResetDistToEnd(triggers, cr); for (const auto &trigger : triggers) { DEBUG_PRINTF("trigger: %s\n", dumpTrigger(trigger).c_str()); for (size_t j = 0; j < triggers.size(); j++) { u32 min_ext = minDistAfterA(trigger, triggers[j]); rv = min(rv, min_ext); if (min_ext <= min_reset_dist[j]) { *can_reset = false; } } } DEBUG_PRINTF("min period %u\n", rv); return rv; } } // namespace ue2 hyperscan-4.4.1/src/nfa/shufticompile.h0000644000175000017500000000506613055426554020665 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Shufti acceleration: compile code. */ #ifndef SHUFTI_COMPILE_H #define SHUFTI_COMPILE_H #include "ue2common.h" #include "util/charreach.h" #include "util/ue2_containers.h" #include namespace ue2 { /** \brief Single-byte variant. * * Returns -1 if unable to construct masks, otherwise returns number of bits * used in the mask. * * Note: always able to construct masks for 8 or fewer characters. */ int shuftiBuildMasks(const CharReach &chars, u8 *lo, u8 *hi); /** \brief Double-byte variant * * Returns false if we are unable to build the masks (too many buckets required) */ bool shuftiBuildDoubleMasks(const CharReach &onechar, const flat_set> &twochar, u8 *lo1, u8 *hi1, u8 *lo2, u8 *hi2); #ifdef DUMP_SUPPORT /** * \brief Dump code: returns a CharReach with the reach that would match this * shufti. */ CharReach shufti2cr(const u8 *lo, const u8 *hi); #endif // DUMP_SUPPORT } // namespace ue2 #endif // SHUFTI_COMPILE_H hyperscan-4.4.1/src/nfa/vermicelli_run.h0000644000175000017500000000711213055426554021023 0ustar sleuthkidsleuthkid/* * 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. */ #include "vermicelli.h" static really_inline const u8 *find_xverm_run(char c, char nocase, u32 repeat, UNUSED const u8 *buf, const u8 *buf_start, const u8 *buf_end, char negate) { DEBUG_PRINTF("looking for 0x%hhx{%u} in %p [%zd, %zd)\n", c, repeat, buf, buf_start - buf, buf_end - buf); /* TODO optimise on where it is easy to get a dense bitfield of character * matches */ if (repeat == 1) { return negate ? nvermicelliExec(c, nocase, buf_start, buf_end) : vermicelliExec(c, nocase, buf_start, buf_end); } while (1) { const u8 *s; if (negate) { s = nvermicelliExec(c, nocase, buf_start, buf_end); } else if (buf_end - buf_start >= VERM_BOUNDARY && !nocase) { s = vermicelliDoubleExec(c, c, nocase, buf_start, buf_end); if (s != buf_end && *s != c) { /* double verm is not certain to be * precise */ s = vermicelliExec(c, nocase, s, buf_end); } } else { s = vermicelliExec(c, nocase, buf_start, buf_end); } if (s == buf_end) { return s; } DEBUG_PRINTF("cand %zd\n", s - buf); const u8 *test_e = MIN(s + repeat, buf_end); const u8 *rv = negate ? vermicelliExec(c, nocase, s, test_e) : nvermicelliExec(c, nocase, s, test_e); assert(rv > buf_start); assert(rv <= buf_end); if (rv == test_e) { return s; } buf_start = rv; } } static really_inline const u8 *find_verm_run(char c, char nocase, u32 repeat, const u8 *buf, const u8 *buf_start, const u8 *buf_end) { return find_xverm_run(c, nocase, repeat, buf, buf_start, buf_end, 0); } static really_inline const u8 *find_nverm_run(char c, char nocase, u32 repeat, const u8 *buf, const u8 *buf_start, const u8 *buf_end) { return find_xverm_run(c, nocase, repeat, buf, buf_start, buf_end, 1); } hyperscan-4.4.1/src/nfa/lbr.c0000644000175000017500000003664213055426554016570 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ /** \file * \brief Large Bounded Repeat (LBR) engine: runtime code. */ #include "lbr.h" #include "lbr_internal.h" #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "repeat.h" #include "repeat_internal.h" #include "shufti.h" #include "truffle.h" #include "vermicelli.h" #include "util/partial_store.h" #include "util/unaligned.h" /** \brief Sentinel value used to indicate that a repeat is dead/empty/unused. * * */ #define REPEAT_DEAD 0xffffffffffffffffull enum MatchMode { CALLBACK_OUTPUT, STOP_AT_MATCH, }; static really_inline const struct RepeatInfo *getRepeatInfo(const struct lbr_common *l) { const struct RepeatInfo *repeatInfo = (const struct RepeatInfo *)((const char *)l + l->repeatInfoOffset); return repeatInfo; } static really_inline void lbrCompressState(const struct lbr_common *l, u64a offset, const struct lbr_state *lstate, char *stream_state) { assert(l && lstate && stream_state); assert(ISALIGNED(lstate)); const struct RepeatInfo *info = getRepeatInfo(l); repeatPack(stream_state, info, &lstate->ctrl, offset); } static really_inline void lbrExpandState(const struct lbr_common *l, u64a offset, const char *stream_state, struct lbr_state *lstate) { assert(l && stream_state && lstate); assert(ISALIGNED(lstate)); const struct RepeatInfo *info = getRepeatInfo(l); repeatUnpack(stream_state, info, offset, &lstate->ctrl); lstate->lastEscape = 0; } static really_inline void clearRepeat(const struct RepeatInfo *info, struct lbr_state *lstate) { assert(info && lstate); DEBUG_PRINTF("clear repeat at %p\n", lstate); switch ((enum RepeatType)info->type) { case REPEAT_RING: lstate->ctrl.ring.offset = REPEAT_DEAD; break; case REPEAT_RANGE: lstate->ctrl.range.offset = REPEAT_DEAD; break; case REPEAT_FIRST: case REPEAT_LAST: lstate->ctrl.offset.offset = REPEAT_DEAD; break; case REPEAT_BITMAP: lstate->ctrl.bitmap.offset = REPEAT_DEAD; break; case REPEAT_SPARSE_OPTIMAL_P: lstate->ctrl.ring.offset = REPEAT_DEAD; break; case REPEAT_TRAILER: lstate->ctrl.trailer.offset = REPEAT_DEAD; break; default: assert(0); break; } } static really_inline char repeatIsDead(const struct RepeatInfo *info, const struct lbr_state *lstate) { assert(info && lstate); switch ((enum RepeatType)info->type) { case REPEAT_RING: return lstate->ctrl.ring.offset == REPEAT_DEAD; case REPEAT_RANGE: return lstate->ctrl.range.offset == REPEAT_DEAD; case REPEAT_FIRST: case REPEAT_LAST: return lstate->ctrl.offset.offset == REPEAT_DEAD; case REPEAT_BITMAP: return lstate->ctrl.bitmap.offset == REPEAT_DEAD; case REPEAT_SPARSE_OPTIMAL_P: return lstate->ctrl.ring.offset == REPEAT_DEAD; case REPEAT_TRAILER: return lstate->ctrl.trailer.offset == REPEAT_DEAD; case REPEAT_ALWAYS: assert(!"REPEAT_ALWAYS should only be used by Castle"); return 0; } assert(0); return 1; } /** Returns true if the LBR can produce matches at offsets greater than the * given one. TODO: can this be combined with lbrIsActive? */ static really_inline char lbrIsAlive(const struct lbr_common *l, const struct lbr_state *lstate, const char *state, u64a offset) { assert(l && lstate && state); const struct RepeatInfo *info = getRepeatInfo(l); if (repeatIsDead(info, lstate)) { DEBUG_PRINTF("repeat is dead\n"); return 0; } if (info->repeatMax == REPEAT_INF) { DEBUG_PRINTF("active repeat with inf max bound, alive\n"); return 1; } assert(info->repeatMax < REPEAT_INF); const char *repeatState = state + info->packedCtrlSize; u64a lastTop = repeatLastTop(info, &lstate->ctrl, repeatState); if (offset < lastTop + info->repeatMax) { DEBUG_PRINTF("alive, as we can still produce matches after %llu\n", offset); return 1; } DEBUG_PRINTF("dead\n"); return 0; } /** Returns true if the LBR is matching at the given offset or it could produce * a match in the future. */ static really_inline char lbrIsActive(const struct lbr_common *l, const struct lbr_state *lstate, const char *state, u64a offset) { assert(l && lstate && state); const struct RepeatInfo *info = getRepeatInfo(l); assert(!repeatIsDead(info, lstate)); // Guaranteed by caller. const char *repeatState = state + info->packedCtrlSize; if (repeatHasMatch(info, &lstate->ctrl, repeatState, offset) == REPEAT_MATCH) { DEBUG_PRINTF("currently matching\n"); return 1; } u64a i = repeatNextMatch(info, &lstate->ctrl, repeatState, offset); if (i != 0) { DEBUG_PRINTF("active, next match is at %llu\n", i); return 1; } DEBUG_PRINTF("no more matches\n"); return 0; } static really_inline void lbrTop(const struct lbr_common *l, struct lbr_state *lstate, char *state, u64a offset) { assert(l && lstate && state); DEBUG_PRINTF("top at %llu\n", offset); const struct RepeatInfo *info = getRepeatInfo(l); char *repeatState = state + info->packedCtrlSize; char is_alive = !repeatIsDead(info, lstate); if (is_alive) { // Ignore duplicate TOPs. u64a last = repeatLastTop(info, &lstate->ctrl, repeatState); assert(last <= offset); if (last == offset) { return; } } repeatStore(info, &lstate->ctrl, repeatState, offset, is_alive); } static really_inline char lbrInAccept(const struct lbr_common *l, const struct lbr_state *lstate, const char *state, u64a offset, ReportID report) { assert(l && lstate && state); DEBUG_PRINTF("offset=%llu, report=%u\n", offset, report); if (report != l->report) { DEBUG_PRINTF("report=%u is not LBR report %u\n", report, l->report); return 0; } const struct RepeatInfo *info = getRepeatInfo(l); assert(!repeatIsDead(info, lstate)); // Guaranteed by caller. const char *repeatState = state + info->packedCtrlSize; return repeatHasMatch(info, &lstate->ctrl, repeatState, offset) == REPEAT_MATCH; } static really_inline char lbrFindMatch(const struct lbr_common *l, const u64a begin, const u64a end, const struct lbr_state *lstate, const char *state, size_t *mloc) { DEBUG_PRINTF("begin=%llu, end=%llu\n", begin, end); assert(begin <= end); if (begin == end) { return 0; } const struct RepeatInfo *info = getRepeatInfo(l); const char *repeatState = state + info->packedCtrlSize; u64a i = repeatNextMatch(info, &lstate->ctrl, repeatState, begin); if (i == 0) { DEBUG_PRINTF("no more matches\n"); return 0; } if (i > end) { DEBUG_PRINTF("next match at %llu is beyond the horizon\n", i); return 0; } DEBUG_PRINTF("stop at match at %llu\n", i); assert(mloc); *mloc = i - begin; return 1; } static really_inline char lbrMatchLoop(const struct lbr_common *l, const u64a begin, const u64a end, const struct lbr_state *lstate, const char *state, NfaCallback cb, void *ctx) { DEBUG_PRINTF("begin=%llu, end=%llu\n", begin, end); assert(begin <= end); if (begin == end) { return MO_CONTINUE_MATCHING; } const struct RepeatInfo *info = getRepeatInfo(l); const char *repeatState = state + info->packedCtrlSize; u64a i = begin; for (;;) { i = repeatNextMatch(info, &lstate->ctrl, repeatState, i); if (i == 0) { DEBUG_PRINTF("no more matches\n"); return MO_CONTINUE_MATCHING; } if (i > end) { DEBUG_PRINTF("next match at %llu is beyond the horizon\n", i); return MO_CONTINUE_MATCHING; } DEBUG_PRINTF("firing match at %llu\n", i); if (cb(0, i, l->report, ctx) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } assert(0); return MO_CONTINUE_MATCHING; } static really_inline char lbrRevScanDot(UNUSED const struct NFA *nfa, UNUSED const u8 *buf, UNUSED size_t begin, UNUSED size_t end, UNUSED size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_DOT); // Nothing can kill a dot! return 0; } static really_inline char lbrRevScanVerm(const struct NFA *nfa, const u8 *buf, size_t begin, size_t end, size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_VERM); const struct lbr_verm *l = getImplNfa(nfa); if (begin == end) { return 0; } const u8 *ptr = rvermicelliExec(l->c, 0, buf + begin, buf + end); if (ptr == buf + begin - 1) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); assert((char)*ptr == l->c); return 1; } static really_inline char lbrRevScanNVerm(const struct NFA *nfa, const u8 *buf, size_t begin, size_t end, size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_NVERM); const struct lbr_verm *l = getImplNfa(nfa); if (begin == end) { return 0; } const u8 *ptr = rnvermicelliExec(l->c, 0, buf + begin, buf + end); if (ptr == buf + begin - 1) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); assert((char)*ptr != l->c); return 1; } static really_inline char lbrRevScanShuf(const struct NFA *nfa, const u8 *buf, size_t begin, size_t end, size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_SHUF); const struct lbr_shuf *l = getImplNfa(nfa); if (begin == end) { return 0; } const u8 *ptr = rshuftiExec(l->mask_lo, l->mask_hi, buf + begin, buf + end); if (ptr == buf + begin - 1) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char lbrRevScanTruf(const struct NFA *nfa, const u8 *buf, size_t begin, size_t end, size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_TRUF); const struct lbr_truf *l = getImplNfa(nfa); if (begin == end) { return 0; } const u8 *ptr = rtruffleExec(l->mask1, l->mask2, buf + begin, buf + end); if (ptr == buf + begin - 1) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char lbrFwdScanDot(UNUSED const struct NFA *nfa, UNUSED const u8 *buf, UNUSED size_t begin, UNUSED size_t end, UNUSED size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_DOT); // Nothing can kill a dot! return 0; } static really_inline char lbrFwdScanVerm(const struct NFA *nfa, const u8 *buf, size_t begin, size_t end, size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_VERM); const struct lbr_verm *l = getImplNfa(nfa); if (begin == end) { return 0; } const u8 *ptr = vermicelliExec(l->c, 0, buf + begin, buf + end); if (ptr == buf + end) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); assert((char)*ptr == l->c); return 1; } static really_inline char lbrFwdScanNVerm(const struct NFA *nfa, const u8 *buf, size_t begin, size_t end, size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_NVERM); const struct lbr_verm *l = getImplNfa(nfa); if (begin == end) { return 0; } const u8 *ptr = nvermicelliExec(l->c, 0, buf + begin, buf + end); if (ptr == buf + end) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); assert((char)*ptr != l->c); return 1; } static really_inline char lbrFwdScanShuf(const struct NFA *nfa, const u8 *buf, size_t begin, size_t end, size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_SHUF); const struct lbr_shuf *l = getImplNfa(nfa); if (begin == end) { return 0; } const u8 *ptr = shuftiExec(l->mask_lo, l->mask_hi, buf + begin, buf + end); if (ptr == buf + end) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char lbrFwdScanTruf(const struct NFA *nfa, const u8 *buf, size_t begin, size_t end, size_t *loc) { assert(begin <= end); assert(nfa->type == LBR_NFA_TRUF); const struct lbr_truf *l = getImplNfa(nfa); if (begin == end) { return 0; } const u8 *ptr = truffleExec(l->mask1, l->mask2, buf + begin, buf + end); if (ptr == buf + end) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } #define ENGINE_ROOT_NAME Dot #include "lbr_common_impl.h" #define ENGINE_ROOT_NAME Verm #include "lbr_common_impl.h" #define ENGINE_ROOT_NAME NVerm #include "lbr_common_impl.h" #define ENGINE_ROOT_NAME Shuf #include "lbr_common_impl.h" #define ENGINE_ROOT_NAME Truf #include "lbr_common_impl.h" hyperscan-4.4.1/src/nfa/shufti.h0000644000175000017500000000432513055426554017311 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Shufti: character class acceleration. * * Utilises the SSSE3 pshufb shuffle instruction */ #ifndef SHUFTI_H #define SHUFTI_H #include "ue2common.h" #include "util/simd_utils.h" #ifdef __cplusplus extern "C" { #endif const u8 *shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end); // Returns (buf - 1) if not found. const u8 *rshuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end); const u8 *shuftiDoubleExec(m128 mask1_lo, m128 mask1_hi, m128 mask2_lo, m128 mask2_hi, const u8 *buf, const u8 *buf_end); #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/multiaccel_common.h0000644000175000017500000001504413055426554021501 0ustar sleuthkidsleuthkid/* * 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_ */ hyperscan-4.4.1/src/nfa/accel_dump.h0000644000175000017500000000347013055426554020103 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Acceleration: dump code. */ #ifndef ACCEL_DUMP_H #define ACCEL_DUMP_H #if defined(DUMP_SUPPORT) #include union AccelAux; namespace ue2 { void dumpAccelInfo(FILE *f, const AccelAux &accel); } // namespace ue2 #endif // DUMP_SUPPORT #endif // ACCEL_DUMP_H hyperscan-4.4.1/src/nfa/limex_native.c0000644000175000017500000001103113055426554020456 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief LimEx NFA: native GPR runtime implementations. */ //#define DEBUG //#define DEBUG_INPUT //#define DEBUG_EXCEPTIONS #include "limex.h" #include "accel.h" #include "limex_internal.h" #include "nfa_internal.h" #include "ue2common.h" #include "util/bitutils.h" // Common code #define STATE_ON_STACK #define ESTATE_ON_STACK #include "limex_runtime.h" // Other implementation code from X-Macro impl. #define SIZE 32 #define STATE_T u32 #define ENG_STATE_T u32 #define LOAD_FROM_ENG load_u32 #include "limex_state_impl.h" #define INLINE_ATTR really_inline #include "limex_common_impl.h" //////////////////////////////////////////////////////////////////////////// // LimEx NFA implementation code - general purpose registers //////////////////////////////////////////////////////////////////////////// // Process exceptional states #define STATE_ON_STACK #define ESTATE_ON_STACK #define RUN_EXCEPTION_FN_ONLY #include "limex_exceptional.h" static really_inline int processExceptional32(u32 s, u32 estate, UNUSED u32 diffmask, u32 *succ, const struct LimExNFA32 *limex, const struct NFAException32 *exceptions, u64a offset, struct NFAContext32 *ctx, char in_rev, char flags) { assert(estate != 0); // guaranteed by calling macro if (estate == ctx->cached_estate) { DEBUG_PRINTF("using cached succ from previous state\n"); *succ |= ctx->cached_esucc; if (ctx->cached_reports && (flags & CALLBACK_OUTPUT)) { DEBUG_PRINTF("firing cached reports from previous state\n"); if (unlikely(limexRunReports(ctx->cached_reports, ctx->callback, ctx->context, offset) == MO_HALT_MATCHING)) { return PE_RV_HALT; // halt; } } return 0; } u32 orig_estate = estate; // for caching u32 local_succ = 0; struct proto_cache new_cache = {0, NULL}; enum CacheResult cacheable = CACHE_RESULT; /* Note that only exception-states that consist of exceptions that _only_ * set successors (not fire accepts or squash states) are cacheable. */ do { u32 bit = findAndClearLSB_32(&estate); u32 idx = rank_in_mask32(limex->exceptionMask, bit); const struct NFAException32 *e = &exceptions[idx]; if (!runException32(e, s, succ, &local_succ, limex, offset, ctx, &new_cache, &cacheable, in_rev, flags)) { return PE_RV_HALT; } } while (estate != 0); *succ |= local_succ; if (cacheable == CACHE_RESULT) { ctx->cached_estate = orig_estate; ctx->cached_esucc = local_succ; ctx->cached_reports = new_cache.reports; ctx->cached_br = new_cache.br; } else if (cacheable == DO_NOT_CACHE_RESULT_AND_FLUSH_BR_ENTRIES) { if (ctx->cached_br) { ctx->cached_estate = 0U; } } return 0; } // 32-bit models. #include "limex_runtime_impl.h" hyperscan-4.4.1/src/nfa/multitruffle_avx2.h0000644000175000017500000001074313055426554021472 0ustar sleuthkidsleuthkid/* * 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. */ /* * Matches a byte in a charclass using three shuffles */ #include "config.h" #include "ue2common.h" #include "multiaccel_common.h" /* * include "block" function */ #include "truffle_common.h" /* * single-byte truffle fwd match function, should only be defined when not * compiling multiaccel */ static really_inline const u8 *JOIN(MATCH_ALGO, fwdBlock)(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset, m256 v, const u8 *buf, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { u64a z = (u64a) block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v); return (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])(buf, z ^ 0xFFFFFFFF #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); } const u8 *JOIN(MATCH_ALGO, truffleExec)(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { DEBUG_PRINTF("run_len %zu\n", buf_end - buf); const m256 wide_clear = set2x128(shuf_mask_lo_highclear); const m256 wide_set = set2x128(shuf_mask_lo_highset); assert(buf && buf_end); assert(buf < buf_end); const u8 *rv; if (buf_end - buf < 32) { return truffleMini(wide_clear, wide_set, buf, buf_end); } size_t min = (size_t)buf % 32; assert(buf_end - buf >= 32); // Preconditioning: most of the time our buffer won't be aligned. m256 chars = loadu256(buf); rv = JOIN(MATCH_ALGO, fwdBlock)(wide_clear, wide_set, chars, buf, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } buf += (32 - min); const u8 *last_block = buf_end - 32; while (buf < last_block) { m256 lchars = load256(buf); rv = JOIN(MATCH_ALGO, fwdBlock)(wide_clear, wide_set, lchars, buf, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } buf += 32; } // Use an unaligned load to mop up the last 32 bytes and get an accurate // picture to buf_end. assert(buf <= buf_end && buf >= buf_end - 32); chars = loadu256(buf_end - 32); rv = JOIN(MATCH_ALGO, fwdBlock)(wide_clear, wide_set, chars, buf_end - 32, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } return buf_end; } hyperscan-4.4.1/src/nfa/rdfa_graph.cpp0000644000175000017500000000473013055426554020437 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "rdfa_graph.h" #include "rdfa.h" #include "util/container.h" #include using namespace std; namespace ue2 { RdfaGraph::RdfaGraph(const raw_dfa &rdfa) { RdfaGraph &g = *this; vector verts; verts.reserve(rdfa.states.size()); for (dstate_id_t i = 0; i < rdfa.states.size(); i++) { verts.push_back(add_vertex(g)); assert(g[verts.back()].index == i); } symbol_t symbol_end = rdfa.alpha_size - 1; flat_set local_succs; for (dstate_id_t i = 0; i < rdfa.states.size(); i++) { local_succs.clear(); for (symbol_t s = 0; s < symbol_end; s++) { dstate_id_t next = rdfa.states[i].next[s]; if (contains(local_succs, next)) { continue; } DEBUG_PRINTF("%hu->%hu\n", i, next); add_edge(verts[i], verts[next], g); local_succs.insert(next); } } } } hyperscan-4.4.1/src/nfa/mcclellancompile.cpp0000644000175000017500000007767213055426554021664 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "mcclellancompile.h" #include "accel.h" #include "accelcompile.h" #include "grey.h" #include "mcclellan_internal.h" #include "mcclellancompile_util.h" #include "nfa_internal.h" #include "shufticompile.h" #include "trufflecompile.h" #include "ue2common.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/container.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include "util/unaligned.h" #include "util/verify_types.h" #include #include #include #include #include #include #include #include #include using namespace std; using boost::adaptors::map_keys; #define ACCEL_DFA_MAX_OFFSET_DEPTH 4 /** Maximum tolerated number of escape character from an accel state. * This is larger than nfa, as we don't have a budget and the nfa cheats on stop * characters for sets of states */ #define ACCEL_DFA_MAX_STOP_CHAR 160 /** Maximum tolerated number of escape character from a sds accel state. Larger * than normal states as accelerating sds is important. Matches NFA value */ #define ACCEL_DFA_MAX_FLOATING_STOP_CHAR 192 namespace ue2 { namespace /* anon */ { struct dstate_extra { u16 daddytaken = 0; bool shermanState = false; }; struct dfa_info { accel_dfa_build_strat &strat; raw_dfa &raw; vector &states; vector extra; const u16 alpha_size; /* including special symbols */ const array &alpha_remap; const u16 impl_alpha_size; u8 getAlphaShift() const; explicit dfa_info(accel_dfa_build_strat &s) : strat(s), raw(s.get_raw()), states(raw.states), extra(raw.states.size()), alpha_size(raw.alpha_size), alpha_remap(raw.alpha_remap), impl_alpha_size(raw.getImplAlphaSize()) {} dstate_id_t implId(dstate_id_t raw_id) const { return states[raw_id].impl_id; } bool is_sherman(dstate_id_t raw_id) const { return extra[raw_id].shermanState; } size_t size(void) const { return states.size(); } }; u8 dfa_info::getAlphaShift() const { if (impl_alpha_size < 2) { return 1; } else { /* log2 round up */ return 32 - clz32(impl_alpha_size - 1); } } } // namespace static mstate_aux *getAux(NFA *n, dstate_id_t i) { assert(isMcClellanType(n->type)); mcclellan *m = (mcclellan *)getMutableImplNfa(n); mstate_aux *aux_base = (mstate_aux *)((char *)n + m->aux_offset); mstate_aux *aux = aux_base + i; assert((const char *)aux < (const char *)n + m->length); return aux; } static void markEdges(NFA *n, u16 *succ_table, const dfa_info &info) { assert((size_t)succ_table % 2 == 0); assert(n->type == MCCLELLAN_NFA_16); u8 alphaShift = info.getAlphaShift(); u16 alphaSize = info.impl_alpha_size; mcclellan *m = (mcclellan *)getMutableImplNfa(n); /* handle the normal states */ for (u32 i = 0; i < m->sherman_limit; i++) { for (size_t j = 0; j < alphaSize; j++) { size_t c_prime = (i << alphaShift) + j; mstate_aux *aux = getAux(n, succ_table[c_prime]); if (aux->accept) { succ_table[c_prime] |= ACCEPT_FLAG; } if (aux->accel_offset) { succ_table[c_prime] |= ACCEL_FLAG; } } } /* handle the sherman states */ char *sherman_base_offset = (char *)n + m->sherman_offset; for (u16 j = m->sherman_limit; j < m->state_count; j++) { char *sherman_cur = findMutableShermanState(sherman_base_offset, m->sherman_limit, j); assert(*(sherman_cur + SHERMAN_TYPE_OFFSET) == SHERMAN_STATE); u8 len = *(u8 *)(sherman_cur + SHERMAN_LEN_OFFSET); u16 *succs = (u16 *)(sherman_cur + SHERMAN_STATES_OFFSET(len)); for (u8 i = 0; i < len; i++) { u16 succ_i = unaligned_load_u16((u8 *)&succs[i]); mstate_aux *aux = getAux(n, succ_i); if (aux->accept) { succ_i |= ACCEPT_FLAG; } if (aux->accel_offset) { succ_i |= ACCEL_FLAG; } unaligned_store_u16((u8 *)&succs[i], succ_i); } } } u32 mcclellan_build_strat::max_allowed_offset_accel() const { return ACCEL_DFA_MAX_OFFSET_DEPTH; } u32 mcclellan_build_strat::max_stop_char() const { return ACCEL_DFA_MAX_STOP_CHAR; } u32 mcclellan_build_strat::max_floating_stop_char() const { return ACCEL_DFA_MAX_FLOATING_STOP_CHAR; } static void populateBasicInfo(size_t state_size, const dfa_info &info, u32 total_size, u32 aux_offset, u32 accel_offset, u32 accel_count, ReportID arb, bool single, NFA *nfa) { assert(state_size == sizeof(u16) || state_size == sizeof(u8)); nfa->length = total_size; nfa->nPositions = info.states.size(); nfa->scratchStateSize = verify_u32(state_size); nfa->streamStateSize = verify_u32(state_size); if (state_size == sizeof(u8)) { nfa->type = MCCLELLAN_NFA_8; } else { nfa->type = MCCLELLAN_NFA_16; } mcclellan *m = (mcclellan *)getMutableImplNfa(nfa); for (u32 i = 0; i < 256; i++) { m->remap[i] = verify_u8(info.alpha_remap[i]); } m->alphaShift = info.getAlphaShift(); m->length = total_size; m->aux_offset = aux_offset; m->accel_offset = accel_offset; m->arb_report = arb; m->state_count = verify_u16(info.size()); m->start_anchored = info.implId(info.raw.start_anchored); m->start_floating = info.implId(info.raw.start_floating); m->has_accel = accel_count ? 1 : 0; if (single) { m->flags |= MCCLELLAN_FLAG_SINGLE; } } namespace { struct raw_report_list { flat_set reports; raw_report_list(const flat_set &reports_in, const ReportManager &rm, bool do_remap) { if (do_remap) { for (auto &id : reports_in) { reports.insert(rm.getProgramOffset(id)); } } else { reports = reports_in; } } bool operator<(const raw_report_list &b) const { return reports < b.reports; } }; struct raw_report_info_impl : public raw_report_info { vector rl; u32 getReportListSize() const override; size_t size() const override; void fillReportLists(NFA *n, size_t base_offset, std::vector &ro /* out */) const override; }; } unique_ptr mcclellan_build_strat::gatherReports( vector &reports, vector &reports_eod, u8 *isSingleReport, ReportID *arbReport) const { DEBUG_PRINTF("gathering reports\n"); const bool remap_reports = has_managed_reports(rdfa.kind); auto ri = ue2::make_unique(); map rev; for (const dstate &s : rdfa.states) { if (s.reports.empty()) { reports.push_back(MO_INVALID_IDX); continue; } raw_report_list rrl(s.reports, rm, remap_reports); DEBUG_PRINTF("non empty r\n"); if (rev.find(rrl) != rev.end()) { reports.push_back(rev[rrl]); } else { DEBUG_PRINTF("adding to rl %zu\n", ri->size()); rev[rrl] = ri->size(); reports.push_back(ri->size()); ri->rl.push_back(rrl); } } for (const dstate &s : rdfa.states) { if (s.reports_eod.empty()) { reports_eod.push_back(MO_INVALID_IDX); continue; } DEBUG_PRINTF("non empty r eod\n"); raw_report_list rrl(s.reports_eod, rm, remap_reports); if (rev.find(rrl) != rev.end()) { reports_eod.push_back(rev[rrl]); continue; } DEBUG_PRINTF("adding to rl eod %zu\n", s.reports_eod.size()); rev[rrl] = ri->size(); reports_eod.push_back(ri->size()); ri->rl.push_back(rrl); } assert(!ri->rl.empty()); /* all components should be able to generate reports */ if (!ri->rl.empty()) { *arbReport = *ri->rl.begin()->reports.begin(); } else { *arbReport = 0; } /* if we have only a single report id generated from all accepts (not eod) * we can take some short cuts */ set reps; for (u32 rl_index : reports) { if (rl_index == MO_INVALID_IDX) { continue; } assert(rl_index < ri->size()); insert(&reps, ri->rl[rl_index].reports); } if (reps.size() == 1) { *isSingleReport = 1; *arbReport = *reps.begin(); DEBUG_PRINTF("single -- %u\n", *arbReport); } else { *isSingleReport = 0; } return move(ri); } u32 raw_report_info_impl::getReportListSize() const { u32 rv = 0; for (const auto &reps : rl) { rv += sizeof(report_list); rv += sizeof(ReportID) * reps.reports.size(); } return rv; } size_t raw_report_info_impl::size() const { return rl.size(); } void raw_report_info_impl::fillReportLists(NFA *n, size_t base_offset, vector &ro) const { for (const auto &reps : rl) { ro.push_back(base_offset); report_list *p = (report_list *)((char *)n + base_offset); u32 i = 0; for (const ReportID report : reps.reports) { p->report[i++] = report; } p->count = verify_u32(reps.reports.size()); base_offset += sizeof(report_list); base_offset += sizeof(ReportID) * reps.reports.size(); } } static void fillAccelOut(const map &accel_escape_info, set *accel_states) { for (dstate_id_t i : accel_escape_info | map_keys) { accel_states->insert(i); } } static size_t calcShermanRegionSize(const dfa_info &info) { size_t rv = 0; for (size_t i = 0; i < info.size(); i++) { if (info.is_sherman(i)) { rv += SHERMAN_FIXED_SIZE; } } return ROUNDUP_16(rv); } static void fillInAux(mstate_aux *aux, dstate_id_t i, const dfa_info &info, const vector &reports, const vector &reports_eod, vector &reportOffsets) { const dstate &raw_state = info.states[i]; aux->accept = raw_state.reports.empty() ? 0 : reportOffsets[reports[i]]; aux->accept_eod = raw_state.reports_eod.empty() ? 0 : reportOffsets[reports_eod[i]]; aux->top = info.implId(i ? raw_state.next[info.alpha_remap[TOP]] : info.raw.start_floating); } /* returns false on error */ static bool allocateFSN16(dfa_info &info, dstate_id_t *sherman_base) { info.states[0].impl_id = 0; /* dead is always 0 */ vector norm; vector sherm; if (info.size() > (1 << 16)) { DEBUG_PRINTF("too many states\n"); *sherman_base = 0; return false; } for (u32 i = 1; i < info.size(); i++) { if (info.is_sherman(i)) { sherm.push_back(i); } else { norm.push_back(i); } } dstate_id_t next_norm = 1; for (const dstate_id_t &s : norm) { info.states[s].impl_id = next_norm++; } *sherman_base = next_norm; dstate_id_t next_sherman = next_norm; for (const dstate_id_t &s : sherm) { info.states[s].impl_id = next_sherman++; } /* Check to see if we haven't over allocated our states */ DEBUG_PRINTF("next sherman %u masked %u\n", next_sherman, (dstate_id_t)(next_sherman & STATE_MASK)); return (next_sherman - 1) == ((next_sherman - 1) & STATE_MASK); } static aligned_unique_ptr mcclellanCompile16(dfa_info &info, const CompileContext &cc, set *accel_states) { DEBUG_PRINTF("building mcclellan 16\n"); vector reports; /* index in ri for the appropriate report list */ vector reports_eod; /* as above */ ReportID arb; u8 single; u8 alphaShift = info.getAlphaShift(); assert(alphaShift <= 8); u16 count_real_states; if (!allocateFSN16(info, &count_real_states)) { DEBUG_PRINTF("failed to allocate state numbers, %zu states total\n", info.size()); return nullptr; } auto ri = info.strat.gatherReports(reports, reports_eod, &single, &arb); map accel_escape_info = info.strat.getAccelInfo(cc.grey); size_t tran_size = (1 << info.getAlphaShift()) * sizeof(u16) * count_real_states; size_t aux_size = sizeof(mstate_aux) * info.size(); size_t aux_offset = ROUNDUP_16(sizeof(NFA) + sizeof(mcclellan) + tran_size); size_t accel_size = info.strat.accelSize() * accel_escape_info.size(); size_t accel_offset = ROUNDUP_N(aux_offset + aux_size + ri->getReportListSize(), 32); size_t sherman_offset = ROUNDUP_16(accel_offset + accel_size); size_t sherman_size = calcShermanRegionSize(info); size_t total_size = sherman_offset + sherman_size; accel_offset -= sizeof(NFA); /* adj accel offset to be relative to m */ assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); aligned_unique_ptr nfa = aligned_zmalloc_unique(total_size); char *nfa_base = (char *)nfa.get(); populateBasicInfo(sizeof(u16), info, total_size, aux_offset, accel_offset, accel_escape_info.size(), arb, single, nfa.get()); vector reportOffsets; ri->fillReportLists(nfa.get(), aux_offset + aux_size, reportOffsets); u16 *succ_table = (u16 *)(nfa_base + sizeof(NFA) + sizeof(mcclellan)); mstate_aux *aux = (mstate_aux *)(nfa_base + aux_offset); mcclellan *m = (mcclellan *)getMutableImplNfa(nfa.get()); /* copy in the mc header information */ m->sherman_offset = sherman_offset; m->sherman_end = total_size; m->sherman_limit = count_real_states; /* do normal states */ for (size_t i = 0; i < info.size(); i++) { if (info.is_sherman(i)) { continue; } u16 fs = info.implId(i); mstate_aux *this_aux = getAux(nfa.get(), fs); assert(fs < count_real_states); for (size_t j = 0; j < info.impl_alpha_size; j++) { succ_table[(fs << alphaShift) + j] = info.implId(info.states[i].next[j]); } fillInAux(&aux[fs], i, info, reports, reports_eod, reportOffsets); if (contains(accel_escape_info, i)) { this_aux->accel_offset = accel_offset; accel_offset += info.strat.accelSize(); assert(accel_offset + sizeof(NFA) <= sherman_offset); assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); info.strat.buildAccel(i, accel_escape_info.at(i), (void *)((char *)m + this_aux->accel_offset)); } } /* do sherman states */ char *sherman_table = nfa_base + m->sherman_offset; assert(ISALIGNED_16(sherman_table)); for (size_t i = 0; i < info.size(); i++) { if (!info.is_sherman(i)) { continue; } u16 fs = verify_u16(info.implId(i)); mstate_aux *this_aux = getAux(nfa.get(), fs); assert(fs >= count_real_states); char *curr_sherman_entry = sherman_table + (fs - m->sherman_limit) * SHERMAN_FIXED_SIZE; assert(curr_sherman_entry <= nfa_base + m->length); fillInAux(this_aux, i, info, reports, reports_eod, reportOffsets); if (contains(accel_escape_info, i)) { this_aux->accel_offset = accel_offset; accel_offset += info.strat.accelSize(); assert(accel_offset + sizeof(NFA) <= sherman_offset); assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); info.strat.buildAccel(i, accel_escape_info.at(i), (void *)((char *)m + this_aux->accel_offset)); } u8 len = verify_u8(info.impl_alpha_size - info.extra[i].daddytaken); assert(len <= 9); dstate_id_t d = info.states[i].daddy; *(u8 *)(curr_sherman_entry + SHERMAN_TYPE_OFFSET) = SHERMAN_STATE; *(u8 *)(curr_sherman_entry + SHERMAN_LEN_OFFSET) = len; *(u16 *)(curr_sherman_entry + SHERMAN_DADDY_OFFSET) = info.implId(d); u8 *chars = (u8 *)(curr_sherman_entry + SHERMAN_CHARS_OFFSET); for (u16 s = 0; s < info.impl_alpha_size; s++) { if (info.states[i].next[s] != info.states[d].next[s]) { *(chars++) = (u8)s; } } u16 *states = (u16 *)(curr_sherman_entry + SHERMAN_STATES_OFFSET(len)); for (u16 s = 0; s < info.impl_alpha_size; s++) { if (info.states[i].next[s] != info.states[d].next[s]) { DEBUG_PRINTF("s overrider %hu dad %hu char next %hu\n", fs, info.implId(d), info.implId(info.states[i].next[s])); unaligned_store_u16((u8 *)states++, info.implId(info.states[i].next[s])); } } } markEdges(nfa.get(), succ_table, info); if (accel_states && nfa) { fillAccelOut(accel_escape_info, accel_states); } return nfa; } static void fillInBasicState8(const dfa_info &info, mstate_aux *aux, u8 *succ_table, const vector &reportOffsets, const vector &reports, const vector &reports_eod, u32 i) { dstate_id_t j = info.implId(i); u8 alphaShift = info.getAlphaShift(); assert(alphaShift <= 8); for (size_t s = 0; s < info.impl_alpha_size; s++) { dstate_id_t raw_succ = info.states[i].next[s]; succ_table[(j << alphaShift) + s] = info.implId(raw_succ); } aux[j].accept = 0; aux[j].accept_eod = 0; if (!info.states[i].reports.empty()) { DEBUG_PRINTF("i=%u r[i]=%u\n", i, reports[i]); assert(reports[i] != MO_INVALID_IDX); aux[j].accept = reportOffsets[reports[i]]; } if (!info.states[i].reports_eod.empty()) { DEBUG_PRINTF("i=%u re[i]=%u\n", i, reports_eod[i]); aux[j].accept_eod = reportOffsets[reports_eod[i]]; } dstate_id_t raw_top = i ? info.states[i].next[info.alpha_remap[TOP]] : info.raw.start_floating; aux[j].top = info.implId(raw_top); } static void allocateFSN8(dfa_info &info, const map &accel_escape_info, u16 *accel_limit, u16 *accept_limit) { info.states[0].impl_id = 0; /* dead is always 0 */ vector norm; vector accel; vector accept; assert(info.size() <= (1 << 8)); for (u32 i = 1; i < info.size(); i++) { if (!info.states[i].reports.empty()) { accept.push_back(i); } else if (contains(accel_escape_info, i)) { accel.push_back(i); } else { norm.push_back(i); } } u32 j = 1; /* dead is already at 0 */ for (const dstate_id_t &s : norm) { assert(j <= 256); DEBUG_PRINTF("mapping state %u to %u\n", s, j); info.states[s].impl_id = j++; } *accel_limit = j; for (const dstate_id_t &s : accel) { assert(j <= 256); DEBUG_PRINTF("mapping state %u to %u\n", s, j); info.states[s].impl_id = j++; } *accept_limit = j; for (const dstate_id_t &s : accept) { assert(j <= 256); DEBUG_PRINTF("mapping state %u to %u\n", s, j); info.states[s].impl_id = j++; } } static aligned_unique_ptr mcclellanCompile8(dfa_info &info, const CompileContext &cc, set *accel_states) { DEBUG_PRINTF("building mcclellan 8\n"); vector reports; vector reports_eod; ReportID arb; u8 single; auto ri = info.strat.gatherReports(reports, reports_eod, &single, &arb); map accel_escape_info = info.strat.getAccelInfo(cc.grey); size_t tran_size = sizeof(u8) * (1 << info.getAlphaShift()) * info.size(); size_t aux_size = sizeof(mstate_aux) * info.size(); size_t aux_offset = ROUNDUP_16(sizeof(NFA) + sizeof(mcclellan) + tran_size); size_t accel_size = info.strat.accelSize() * accel_escape_info.size(); size_t accel_offset = ROUNDUP_N(aux_offset + aux_size + ri->getReportListSize(), 32); size_t total_size = accel_offset + accel_size; DEBUG_PRINTF("aux_size %zu\n", aux_size); DEBUG_PRINTF("aux_offset %zu\n", aux_offset); DEBUG_PRINTF("rl size %u\n", ri->getReportListSize()); DEBUG_PRINTF("accel_size %zu\n", accel_size); DEBUG_PRINTF("accel_offset %zu\n", accel_offset); DEBUG_PRINTF("total_size %zu\n", total_size); accel_offset -= sizeof(NFA); /* adj accel offset to be relative to m */ assert(ISALIGNED_N(accel_offset, alignof(union AccelAux))); aligned_unique_ptr nfa = aligned_zmalloc_unique(total_size); char *nfa_base = (char *)nfa.get(); mcclellan *m = (mcclellan *)getMutableImplNfa(nfa.get()); allocateFSN8(info, accel_escape_info, &m->accel_limit_8, &m->accept_limit_8); populateBasicInfo(sizeof(u8), info, total_size, aux_offset, accel_offset, accel_escape_info.size(), arb, single, nfa.get()); vector reportOffsets; ri->fillReportLists(nfa.get(), aux_offset + aux_size, reportOffsets); /* copy in the state information */ u8 *succ_table = (u8 *)(nfa_base + sizeof(NFA) + sizeof(mcclellan)); mstate_aux *aux = (mstate_aux *)(nfa_base + aux_offset); for (size_t i = 0; i < info.size(); i++) { if (contains(accel_escape_info, i)) { u32 j = info.implId(i); aux[j].accel_offset = accel_offset; accel_offset += info.strat.accelSize(); info.strat.buildAccel(i, accel_escape_info.at(i), (void *)((char *)m + aux[j].accel_offset)); } fillInBasicState8(info, aux, succ_table, reportOffsets, reports, reports_eod, i); } assert(accel_offset + sizeof(NFA) <= total_size); DEBUG_PRINTF("rl size %zu\n", ri->size()); if (accel_states && nfa) { fillAccelOut(accel_escape_info, accel_states); } return nfa; } #define MAX_SHERMAN_LIST_LEN 8 static void addIfEarlier(set &dest, dstate_id_t candidate, dstate_id_t max) { if (candidate < max) { dest.insert(candidate); } } static void addSuccessors(set &dest, const dstate &source, u16 alphasize, dstate_id_t curr_id) { for (symbol_t s = 0; s < alphasize; s++) { addIfEarlier(dest, source.next[s], curr_id); } } #define MAX_SHERMAN_SELF_LOOP 20 static void find_better_daddy(dfa_info &info, dstate_id_t curr_id, bool using8bit, bool any_cyclic_near_anchored_state, const Grey &grey) { if (!grey.allowShermanStates) { return; } const u16 width = using8bit ? sizeof(u8) : sizeof(u16); const u16 alphasize = info.impl_alpha_size; if (info.raw.start_anchored != DEAD_STATE && any_cyclic_near_anchored_state && curr_id < alphasize * 3) { /* crude attempt to prevent frequent states from being sherman'ed * depends on the fact that states are numbers are currently in bfs * order */ DEBUG_PRINTF("%hu is banned\n", curr_id); return; } if (info.raw.start_floating != DEAD_STATE && curr_id >= info.raw.start_floating && curr_id < info.raw.start_floating + alphasize * 3) { /* crude attempt to prevent frequent states from being sherman'ed * depends on the fact that states are numbers are currently in bfs * order */ DEBUG_PRINTF("%hu is banned (%hu)\n", curr_id, info.raw.start_floating); return; } const u16 full_state_size = width * alphasize; const u16 max_list_len = MIN(MAX_SHERMAN_LIST_LEN, (full_state_size - 2)/(width + 1)); u16 best_score = 0; dstate_id_t best_daddy = 0; dstate &currState = info.states[curr_id]; set hinted; /* set of states to search for a better daddy */ addIfEarlier(hinted, 0, curr_id); addIfEarlier(hinted, info.raw.start_anchored, curr_id); addIfEarlier(hinted, info.raw.start_floating, curr_id); dstate_id_t mydaddy = currState.daddy; if (mydaddy) { addIfEarlier(hinted, mydaddy, curr_id); addSuccessors(hinted, info.states[mydaddy], alphasize, curr_id); dstate_id_t mygranddaddy = info.states[mydaddy].daddy; if (mygranddaddy) { addIfEarlier(hinted, mygranddaddy, curr_id); addSuccessors(hinted, info.states[mygranddaddy], alphasize, curr_id); } } for (const dstate_id_t &donor : hinted) { assert(donor < curr_id); u32 score = 0; if (info.is_sherman(donor)) { continue; } const dstate &donorState = info.states[donor]; for (symbol_t s = 0; s < alphasize; s++) { if (currState.next[s] == donorState.next[s]) { score++; } } /* prefer lower ids to provide some stability amongst potential * siblings */ if (score > best_score || (score == best_score && donor < best_daddy)) { best_daddy = donor; best_score = score; if (score == alphasize) { break; } } } currState.daddy = best_daddy; info.extra[curr_id].daddytaken = best_score; DEBUG_PRINTF("%hu -> daddy %hu: %u/%u BF\n", curr_id, best_daddy, best_score, alphasize); if (best_score + max_list_len < alphasize) { return; /* ??? */ } if (info.is_sherman(currState.daddy)) { return; } u32 self_loop_width = 0; const dstate curr_raw = info.states[curr_id]; for (unsigned i = 0; i < N_CHARS; i++) { if (curr_raw.next[info.alpha_remap[i]] == curr_id) { self_loop_width++; } } if (self_loop_width > MAX_SHERMAN_SELF_LOOP) { DEBUG_PRINTF("%hu is banned wide self loop (%u)\n", curr_id, self_loop_width); return; } DEBUG_PRINTF("%hu is sherman\n", curr_id); info.extra[curr_id].shermanState = true; } /* * Calls accessible outside this module. */ u16 raw_dfa::getImplAlphaSize() const { return alpha_size - N_SPECIAL_SYMBOL; } void raw_dfa::stripExtraEodReports(void) { /* if a state generates a given report as a normal accept - then it does * not also need to generate an eod report for it */ for (dstate &ds : states) { for (const ReportID &report : ds.reports) { ds.reports_eod.erase(report); } } } bool raw_dfa::hasEodReports(void) const { for (const dstate &ds : states) { if (!ds.reports_eod.empty()) { return true; } } return false; } static bool is_cyclic_near(const raw_dfa &raw, dstate_id_t root) { symbol_t alphasize = raw.getImplAlphaSize(); for (symbol_t s = 0; s < alphasize; s++) { dstate_id_t succ_id = raw.states[root].next[s]; if (succ_id == DEAD_STATE) { continue; } const dstate &succ = raw.states[succ_id]; for (symbol_t t = 0; t < alphasize; t++) { if (succ.next[t] == root || succ.next[t] == succ_id) { return true; } } } return false; } aligned_unique_ptr mcclellanCompile_i(raw_dfa &raw, accel_dfa_build_strat &strat, const CompileContext &cc, set *accel_states) { u16 total_daddy = 0; dfa_info info(strat); bool using8bit = cc.grey.allowMcClellan8 && info.size() <= 256; if (!cc.streaming) { /* TODO: work out if we can do the strip in streaming * mode with our semantics */ raw.stripExtraEodReports(); } bool has_eod_reports = raw.hasEodReports(); bool any_cyclic_near_anchored_state = is_cyclic_near(raw, raw.start_anchored); for (u32 i = 0; i < info.size(); i++) { find_better_daddy(info, i, using8bit, any_cyclic_near_anchored_state, cc.grey); total_daddy += info.extra[i].daddytaken; } DEBUG_PRINTF("daddy %hu/%zu states=%zu alpha=%hu\n", total_daddy, info.size() * info.impl_alpha_size, info.size(), info.impl_alpha_size); aligned_unique_ptr nfa; if (!using8bit) { nfa = mcclellanCompile16(info, cc, accel_states); } else { nfa = mcclellanCompile8(info, cc, accel_states); } if (has_eod_reports) { nfa->flags |= NFA_ACCEPTS_EOD; } DEBUG_PRINTF("compile done\n"); return nfa; } aligned_unique_ptr mcclellanCompile(raw_dfa &raw, const CompileContext &cc, const ReportManager &rm, set *accel_states) { mcclellan_build_strat mbs(raw, rm); return mcclellanCompile_i(raw, mbs, cc, accel_states); } size_t mcclellan_build_strat::accelSize(void) const { return sizeof(AccelAux); /* McClellan accel structures are just bare * accelaux */ } u32 mcclellanStartReachSize(const raw_dfa *raw) { if (raw->states.size() < 2) { return 0; } const dstate &ds = raw->states[raw->start_anchored]; CharReach out; for (unsigned i = 0; i < N_CHARS; i++) { if (ds.next[raw->alpha_remap[i]] != DEAD_STATE) { out.set(i); } } return out.count(); } bool has_accel_mcclellan(const NFA *nfa) { const mcclellan *m = (const mcclellan *)getImplNfa(nfa); return m->has_accel; } } // namespace ue2 hyperscan-4.4.1/src/nfa/shengcompile.cpp0000644000175000017500000004136213055426554021021 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "shengcompile.h" #include "accel.h" #include "accelcompile.h" #include "shufticompile.h" #include "trufflecompile.h" #include "util/alloc.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/compare.h" #include "util/container.h" #include "util/order_check.h" #include "util/report_manager.h" #include "util/unaligned.h" #include "grey.h" #include "nfa_internal.h" #include "sheng_internal.h" #include "ue2common.h" #include "util/compile_context.h" #include "util/make_unique.h" #include "util/verify_types.h" #include "util/simd_types.h" #include #include #include #include using namespace std; using boost::adaptors::map_keys; namespace ue2 { #define ACCEL_DFA_MAX_OFFSET_DEPTH 4 /** Maximum tolerated number of escape character from an accel state. * This is larger than nfa, as we don't have a budget and the nfa cheats on stop * characters for sets of states */ #define ACCEL_DFA_MAX_STOP_CHAR 160 /** Maximum tolerated number of escape character from a sds accel state. Larger * than normal states as accelerating sds is important. Matches NFA value */ #define ACCEL_DFA_MAX_FLOATING_STOP_CHAR 192 struct dfa_info { accel_dfa_build_strat &strat; raw_dfa &raw; vector &states; dstate &floating; dstate &anchored; bool can_die; explicit dfa_info(accel_dfa_build_strat &s) : strat(s), raw(strat.get_raw()), states(raw.states), floating(states[raw.start_floating]), anchored(states[raw.start_anchored]), can_die(dfaCanDie(raw)) {} // returns adjusted size size_t size() const { return can_die ? states.size() : states.size() - 1; } // expects adjusted index dstate &operator[](dstate_id_t idx) { return states[raw_id(idx)]; } dstate &top(dstate_id_t idx) { if (isDead(idx)) { return floating; } return next(idx, TOP); } dstate &next(dstate_id_t idx, u16 chr) { auto &src = (*this)[idx]; auto next_id = src.next[raw.alpha_remap[chr]]; return states[next_id]; } // get original idx from adjusted idx dstate_id_t raw_id(dstate_id_t idx) { assert(idx < size()); // if DFA can't die, shift all indices left by 1 return can_die ? idx : idx + 1; } bool isDead(dstate &state) { return raw_id(state.impl_id) == DEAD_STATE; } bool isDead(dstate_id_t idx) { return raw_id(idx) == DEAD_STATE; } private: static bool dfaCanDie(raw_dfa &rdfa) { for (unsigned chr = 0; chr < 256; chr++) { for (dstate_id_t state = 0; state < rdfa.states.size(); state++) { auto succ = rdfa.states[state].next[rdfa.alpha_remap[chr]]; if (succ == DEAD_STATE) { return true; } } } return false; } }; namespace { struct raw_report_list { flat_set reports; raw_report_list(const flat_set &reports_in, const ReportManager &rm, bool do_remap) { if (do_remap) { for (auto &id : reports_in) { reports.insert(rm.getProgramOffset(id)); } } else { reports = reports_in; } } bool operator<(const raw_report_list &b) const { return reports < b.reports; } }; struct raw_report_info_impl : public raw_report_info { vector rl; u32 getReportListSize() const override; size_t size() const override; void fillReportLists(NFA *n, size_t base_offset, std::vector &ro /* out */) const override; }; } u32 raw_report_info_impl::getReportListSize() const { u32 rv = 0; for (const auto &reps : rl) { rv += sizeof(report_list); rv += sizeof(ReportID) * reps.reports.size(); } return rv; } size_t raw_report_info_impl::size() const { return rl.size(); } void raw_report_info_impl::fillReportLists(NFA *n, size_t base_offset, vector &ro) const { for (const auto &reps : rl) { ro.push_back(base_offset); report_list *p = (report_list *)((char *)n + base_offset); u32 i = 0; for (const ReportID report : reps.reports) { p->report[i++] = report; } p->count = verify_u32(reps.reports.size()); base_offset += sizeof(report_list); base_offset += sizeof(ReportID) * reps.reports.size(); } } unique_ptr sheng_build_strat::gatherReports( vector &reports, vector &reports_eod, u8 *isSingleReport, ReportID *arbReport) const { DEBUG_PRINTF("gathering reports\n"); const bool remap_reports = has_managed_reports(rdfa.kind); auto ri = ue2::make_unique(); map rev; for (const dstate &s : rdfa.states) { if (s.reports.empty()) { reports.push_back(MO_INVALID_IDX); continue; } raw_report_list rrl(s.reports, rm, remap_reports); DEBUG_PRINTF("non empty r\n"); if (rev.find(rrl) != rev.end()) { reports.push_back(rev[rrl]); } else { DEBUG_PRINTF("adding to rl %zu\n", ri->size()); rev[rrl] = ri->size(); reports.push_back(ri->size()); ri->rl.push_back(rrl); } } for (const dstate &s : rdfa.states) { if (s.reports_eod.empty()) { reports_eod.push_back(MO_INVALID_IDX); continue; } DEBUG_PRINTF("non empty r eod\n"); raw_report_list rrl(s.reports_eod, rm, remap_reports); if (rev.find(rrl) != rev.end()) { reports_eod.push_back(rev[rrl]); continue; } DEBUG_PRINTF("adding to rl eod %zu\n", s.reports_eod.size()); rev[rrl] = ri->size(); reports_eod.push_back(ri->size()); ri->rl.push_back(rrl); } assert(!ri->rl.empty()); /* all components should be able to generate reports */ if (!ri->rl.empty()) { *arbReport = *ri->rl.begin()->reports.begin(); } else { *arbReport = 0; } /* if we have only a single report id generated from all accepts (not eod) * we can take some short cuts */ set reps; for (u32 rl_index : reports) { if (rl_index == MO_INVALID_IDX) { continue; } assert(rl_index < ri->size()); insert(&reps, ri->rl[rl_index].reports); } if (reps.size() == 1) { *isSingleReport = 1; *arbReport = *reps.begin(); DEBUG_PRINTF("single -- %u\n", *arbReport); } else { *isSingleReport = 0; } return move(ri); } u32 sheng_build_strat::max_allowed_offset_accel() const { return ACCEL_DFA_MAX_OFFSET_DEPTH; } u32 sheng_build_strat::max_stop_char() const { return ACCEL_DFA_MAX_STOP_CHAR; } u32 sheng_build_strat::max_floating_stop_char() const { return ACCEL_DFA_MAX_FLOATING_STOP_CHAR; } size_t sheng_build_strat::accelSize() const { return sizeof(AccelAux); } #ifdef DEBUG static really_inline void dumpShuffleMask(const u8 chr, const u8 *buf, unsigned sz) { stringstream o; for (unsigned i = 0; i < sz; i++) { o.width(2); o << (buf[i] & SHENG_STATE_MASK) << " "; } DEBUG_PRINTF("chr %3u: %s\n", chr, o.str().c_str()); } #endif static void fillAccelOut(const map &accel_escape_info, set *accel_states) { for (dstate_id_t i : accel_escape_info | map_keys) { accel_states->insert(i); } } static u8 getShengState(dstate &state, dfa_info &info, map &accelInfo) { u8 s = state.impl_id; if (!state.reports.empty()) { s |= SHENG_STATE_ACCEPT; } if (info.isDead(state)) { s |= SHENG_STATE_DEAD; } if (accelInfo.find(info.raw_id(state.impl_id)) != accelInfo.end()) { s |= SHENG_STATE_ACCEL; } return s; } static void fillAccelAux(struct NFA *n, dfa_info &info, map &accelInfo) { DEBUG_PRINTF("Filling accel aux structures\n"); sheng *s = (sheng *)getMutableImplNfa(n); u32 offset = s->accel_offset; for (dstate_id_t i = 0; i < info.size(); i++) { dstate_id_t state_id = info.raw_id(i); if (accelInfo.find(state_id) != accelInfo.end()) { s->flags |= SHENG_FLAG_HAS_ACCEL; AccelAux *aux = (AccelAux *)((char *)n + offset); info.strat.buildAccel(state_id, accelInfo[state_id], aux); sstate_aux *saux = (sstate_aux *)((char *)n + s->aux_offset) + state_id; saux->accel = offset; DEBUG_PRINTF("Accel offset: %u\n", offset); offset += ROUNDUP_N(sizeof(AccelAux), alignof(AccelAux)); } } } static void populateBasicInfo(struct NFA *n, dfa_info &info, map &accelInfo, u32 aux_offset, u32 report_offset, u32 accel_offset, u32 total_size, u32 dfa_size) { n->length = total_size; n->scratchStateSize = 1; n->streamStateSize = 1; n->nPositions = info.size(); n->type = SHENG_NFA; n->flags |= info.raw.hasEodReports() ? NFA_ACCEPTS_EOD : 0; sheng *s = (sheng *)getMutableImplNfa(n); s->aux_offset = aux_offset; s->report_offset = report_offset; s->accel_offset = accel_offset; s->n_states = info.size(); s->length = dfa_size; s->flags |= info.can_die ? SHENG_FLAG_CAN_DIE : 0; s->anchored = getShengState(info.anchored, info, accelInfo); s->floating = getShengState(info.floating, info, accelInfo); } static void fillTops(NFA *n, dfa_info &info, dstate_id_t id, map &accelInfo) { sheng *s = (sheng *)getMutableImplNfa(n); u32 aux_base = s->aux_offset; DEBUG_PRINTF("Filling tops for state %u\n", id); sstate_aux *aux = (sstate_aux *)((char *)n + aux_base) + id; DEBUG_PRINTF("Aux structure for state %u, offset %zd\n", id, (char *)aux - (char *)n); /* we could conceivably end up in an accept/dead state on a top event, * so mark top as accept/dead state if it indeed is. */ auto &top_state = info.top(id); DEBUG_PRINTF("Top transition for state %u: %u\n", id, top_state.impl_id); aux->top = getShengState(top_state, info, accelInfo); } static void fillAux(NFA *n, dfa_info &info, dstate_id_t id, vector &reports, vector &reports_eod, vector &report_offsets) { sheng *s = (sheng *)getMutableImplNfa(n); u32 aux_base = s->aux_offset; auto raw_id = info.raw_id(id); auto &state = info[id]; sstate_aux *aux = (sstate_aux *)((char *)n + aux_base) + id; DEBUG_PRINTF("Filling aux and report structures for state %u\n", id); DEBUG_PRINTF("Aux structure for state %u, offset %zd\n", id, (char *)aux - (char *)n); aux->accept = state.reports.empty() ? 0 : report_offsets[reports[raw_id]]; aux->accept_eod = state.reports_eod.empty() ? 0 : report_offsets[reports_eod[raw_id]]; DEBUG_PRINTF("Report list offset: %u\n", aux->accept); DEBUG_PRINTF("EOD report list offset: %u\n", aux->accept_eod); } static void fillSingleReport(NFA *n, ReportID r_id) { sheng *s = (sheng *)getMutableImplNfa(n); DEBUG_PRINTF("Single report ID: %u\n", r_id); s->report = r_id; s->flags |= SHENG_FLAG_SINGLE_REPORT; } static void createShuffleMasks(sheng *s, dfa_info &info, map &accelInfo) { for (u16 chr = 0; chr < 256; chr++) { u8 buf[16] = {0}; for (dstate_id_t idx = 0; idx < info.size(); idx++) { auto &succ_state = info.next(idx, chr); buf[idx] = getShengState(succ_state, info, accelInfo); } #ifdef DEBUG dumpShuffleMask(chr, buf, sizeof(buf)); #endif memcpy(&s->shuffle_masks[chr], buf, sizeof(m128)); } } bool has_accel_sheng(const NFA *) { return true; /* consider the sheng region as accelerated */ } aligned_unique_ptr shengCompile(raw_dfa &raw, const CompileContext &cc, const ReportManager &rm, set *accel_states) { if (!cc.grey.allowSheng) { DEBUG_PRINTF("Sheng is not allowed!\n"); return nullptr; } sheng_build_strat strat(raw, rm); dfa_info info(strat); DEBUG_PRINTF("Trying to compile a %zu state Sheng\n", raw.states.size()); DEBUG_PRINTF("Anchored start state id: %u, floating start state id: %u\n", raw.start_anchored, raw.start_floating); DEBUG_PRINTF("This DFA %s die so effective number of states is %zu\n", info.can_die ? "can" : "cannot", info.size()); if (info.size() > 16) { DEBUG_PRINTF("Too many states\n"); return nullptr; } if (!cc.streaming) { /* TODO: work out if we can do the strip in streaming * mode with our semantics */ raw.stripExtraEodReports(); } auto accelInfo = strat.getAccelInfo(cc.grey); // set impl_id of each dfa state for (dstate_id_t i = 0; i < info.size(); i++) { info[i].impl_id = i; } DEBUG_PRINTF("Anchored start state: %u, floating start state: %u\n", info.anchored.impl_id, info.floating.impl_id); u32 nfa_size = ROUNDUP_16(sizeof(NFA) + sizeof(sheng)); vector reports, eod_reports, report_offsets; u8 isSingle = 0; ReportID single_report = 0; auto ri = strat.gatherReports(reports, eod_reports, &isSingle, &single_report); u32 total_aux = sizeof(sstate_aux) * info.size(); u32 total_accel = strat.accelSize() * accelInfo.size(); u32 total_reports = ri->getReportListSize(); u32 reports_offset = nfa_size + total_aux; u32 accel_offset = ROUNDUP_N(reports_offset + total_reports, alignof(AccelAux)); u32 total_size = ROUNDUP_N(accel_offset + total_accel, 64); DEBUG_PRINTF("NFA: %u, aux: %u, reports: %u, accel: %u, total: %u\n", nfa_size, total_aux, total_reports, total_accel, total_size); aligned_unique_ptr nfa = aligned_zmalloc_unique(total_size); populateBasicInfo(nfa.get(), info, accelInfo, nfa_size, reports_offset, accel_offset, total_size, total_size - sizeof(NFA)); DEBUG_PRINTF("Setting up aux and report structures\n"); ri->fillReportLists(nfa.get(), reports_offset, report_offsets); for (dstate_id_t idx = 0; idx < info.size(); idx++) { fillTops(nfa.get(), info, idx, accelInfo); fillAux(nfa.get(), info, idx, reports, eod_reports, report_offsets); } if (isSingle) { fillSingleReport(nfa.get(), single_report); } fillAccelAux(nfa.get(), info, accelInfo); if (accel_states) { fillAccelOut(accelInfo, accel_states); } createShuffleMasks((sheng *)getMutableImplNfa(nfa.get()), info, accelInfo); return nfa; } } // namespace ue2 hyperscan-4.4.1/src/nfa/multivermicelli.c0000644000175000017500000000617413055426554021214 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "ue2common.h" #include "multivermicelli.h" #include "multiaccel_common.h" #if !defined(__AVX2__) #define MATCH_ALGO long_ #include "multiaccel_long.h" #include "multivermicelli_sse.h" #undef MATCH_ALGO #define MATCH_ALGO longgrab_ #include "multiaccel_longgrab.h" #include "multivermicelli_sse.h" #undef MATCH_ALGO #define MATCH_ALGO shift_ #include "multiaccel_shift.h" #include "multivermicelli_sse.h" #undef MATCH_ALGO #define MATCH_ALGO shiftgrab_ #include "multiaccel_shiftgrab.h" #include "multivermicelli_sse.h" #undef MATCH_ALGO #define MULTIACCEL_DOUBLE #define MATCH_ALGO doubleshift_ #include "multiaccel_doubleshift.h" #include "multivermicelli_sse.h" #undef MATCH_ALGO #define MATCH_ALGO doubleshiftgrab_ #include "multiaccel_doubleshiftgrab.h" #include "multivermicelli_sse.h" #undef MATCH_ALGO #undef MULTIACCEL_DOUBLE #else #define MATCH_ALGO long_ #include "multiaccel_long.h" #include "multivermicelli_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO longgrab_ #include "multiaccel_longgrab.h" #include "multivermicelli_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO shift_ #include "multiaccel_shift.h" #include "multivermicelli_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO shiftgrab_ #include "multiaccel_shiftgrab.h" #include "multivermicelli_avx2.h" #undef MATCH_ALGO #define MULTIACCEL_DOUBLE #define MATCH_ALGO doubleshift_ #include "multiaccel_doubleshift.h" #include "multivermicelli_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO doubleshiftgrab_ #include "multiaccel_doubleshiftgrab.h" #include "multivermicelli_avx2.h" #undef MATCH_ALGO #undef MULTIACCEL_DOUBLE #endif hyperscan-4.4.1/src/nfa/goughdump.cpp0000644000175000017500000002667113055426554020351 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "goughdump.h" #include "gough_internal.h" #include "mcclellandump.h" #include "nfa_dump_internal.h" #include "nfa_internal.h" #include "ue2common.h" #include "util/charreach.h" #include "util/dump_charclass.h" #include "util/dump_util.h" #include "util/unaligned.h" #include #include #include #include #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { static void goughGetTransitions(const NFA *n, u16 s, u16 *t) { assert(isGoughType(n->type)); const mcclellan *m = (const mcclellan *)getImplNfa(n); const mstate_aux *aux = getAux(n, s); const u32 as = m->alphaShift; const char *sher_base = (const char *)m - sizeof(struct NFA) + m->sherman_offset; if (n->type == GOUGH_NFA_8) { const u8 *succ_table = (const u8 *)((const char *)m + sizeof(mcclellan)); for (u16 c = 0; c < N_CHARS; c++) { t[c] = succ_table[((u32)s << as) + m->remap[c]]; } } else { u16 base_s = s; if (s >= m->sherman_limit) { const char *state_base = findShermanState(m, sher_base, m->sherman_limit, s); base_s = *(const u16 *)(state_base + SHERMAN_DADDY_OFFSET); } const u16 *succ_table = (const u16 *)((const char *)m + sizeof(mcclellan)); for (u16 c = 0; c < N_CHARS; c++) { const u8 *addr = (const u8*)(succ_table + (((u32)base_s << as) + m->remap[c])); t[c] = unaligned_load_u16(addr); t[c] &= STATE_MASK; } if (s >= m->sherman_limit) { const char *state_base = findShermanState(m, sher_base, m->sherman_limit, s); u8 len = *(const u8 *)(SHERMAN_LEN_OFFSET + state_base); const u8 *chars = (const u8 *)state_base + SHERMAN_CHARS_OFFSET; const u16 *states = (const u16 *)(state_base + SHERMAN_STATES_OFFSET(len)); for (u8 i = 0; i < len; i++) { for (u16 c = 0; c < N_CHARS; c++) { if (m->remap[c] != chars[i]) { t[c] = unaligned_load_u16((const u8*)&states[i]) & STATE_MASK; } } } } } t[TOP] = aux->top & STATE_MASK; } static void describeNode(const NFA *n, const mcclellan *m, u16 i, FILE *f) { const mstate_aux *aux = getAux(n, i); bool isSherman = m->sherman_limit && i >= m->sherman_limit; const char *sher_base = (const char *)m - sizeof(NFA) + m->sherman_offset; fprintf(f, "%u [ width = 1, fixedsize = true, fontsize = 12, " "label = \"%u%s\" ]; \n", i, i, isSherman ? "w":""); if (aux->accel_offset) { dumpAccelDot(f, i, &((const gough_accel *)((const char *)m + aux->accel_offset))->accel); } if (aux->accept_eod) { fprintf(f, "%u [ color = darkorchid ];\n", i); } if (aux->accept) { fprintf(f, "%u [ shape = doublecircle ];\n", i); } if (aux->top && aux->top != i) { fprintf(f, "%u -> %u [color = darkgoldenrod weight=0.1 ]\n", i, aux->top); } if (i == m->start_anchored) { fprintf(f, "STARTA -> %u [color = blue ]\n", i); } if (i == m->start_floating) { fprintf(f, "STARTF -> %u [color = red ]\n", i); } if (isSherman) { const char *sherman_state = findShermanState(m, sher_base, m->sherman_limit, i); fprintf(f, "%u [ fillcolor = lightblue style=filled ];\n", i); u16 daddy = *(const u16 *)(sherman_state + SHERMAN_DADDY_OFFSET); if (daddy) { fprintf(f, "%u -> %u [ color=royalblue style=dashed weight=0.1]\n", i, daddy); } } } static void dump_program(FILE *f, const pair &e, const gough_ins *prog) { fprintf(f, "edge_%u_%u:\n", e.first, e.second); for (const gough_ins *it = prog;; ++it) { fprintf(f, "\t"); u32 s = it->src; u32 d = it->dest; switch (it->op) { case GOUGH_INS_END: fprintf(f, "END"); fprintf(f, "\n"); return; case GOUGH_INS_MOV: fprintf(f, "MOV %u %u", d, s); break; case GOUGH_INS_NEW: fprintf(f, "NEW-%u %u", s, d); break; case GOUGH_INS_MIN: fprintf(f, "MIN %u %u", d, s); break; default: fprintf(f, ""); fprintf(f, "\n"); return; } fprintf(f, "\n"); } } static void dump_programs(FILE *f, const NFA *nfa, const set, u32 > > &prog_dump) { fprintf(f, "Edge Programs\n"); fprintf(f, "-------------\n"); for (set, u32 > >::const_iterator it = prog_dump.begin(); it != prog_dump.end(); ++it) { assert(it->second); const gough_ins *p = (const gough_ins *)((const u8 *)nfa + it->second); dump_program(f, it->first, p); } } static void dumpTransitions(const NFA *nfa, FILE *f, set, u32 > > *prog_dump) { const mcclellan *m = (const mcclellan *)getImplNfa(nfa); const gough_info *g = get_gough(m); u32 alphaSize = 1U << m->alphaShift; const u32 *prog_offset_table = (const u32 *)(g + 1); for (u16 i = 0; i < m->state_count; i++) { fprintf(f, "%05hu", i); const mstate_aux *aux = getAux(nfa, i); if (aux->accel_offset) { dumpAccelText(f, (const union AccelAux *)((const char *)m + aux->accel_offset)); } u16 trans[ALPHABET_SIZE]; goughGetTransitions(nfa, i, trans); int rstart = 0; u16 prev = 0xffff; for (int j = 0; j < N_CHARS; j++) { u16 curr = trans[j]; if (curr == prev) { continue; } if (prev != 0xffff) { if (j == rstart + 1) { fprintf(f, " %02x->%hu", rstart, prev); } else { fprintf(f, " [%02x - %02x]->%hu", rstart, j - 1, prev); } } prev = curr; rstart = j; u32 edge_index = i * alphaSize + m->remap[j]; u32 prog_offset = prog_offset_table[edge_index]; if (prog_offset) { prog_dump->insert(make_pair(make_pair((u32)i, (u32)trans[j]), prog_offset)); } } if (N_CHARS == rstart + 1) { fprintf(f, " %02x->%hu", rstart, prev); } else { fprintf(f, " [%02x - %02x]->%hu", rstart, N_CHARS - 1, prev); } fprintf(f, " TOP->%hu\n", trans[TOP]); fprintf(f, "\n"); } fprintf(f, "\n"); } static void nfaExecGough8_dumpDot(const struct NFA *nfa, FILE *f) { assert(nfa->type == GOUGH_NFA_8); const mcclellan *m = (const mcclellan *)getImplNfa(nfa); dumpDotPreambleDfa(f); for (u16 i = 1; i < m->state_count; i++) { describeNode(nfa, m, i, f); u16 t[ALPHABET_SIZE]; goughGetTransitions(nfa, i, t); describeEdge(f, t, i); } fprintf(f, "}\n"); } static void nfaExecGough8_dumpText(const struct NFA *nfa, FILE *f) { assert(nfa->type == GOUGH_NFA_8); const mcclellan *m = (const mcclellan *)getImplNfa(nfa); fprintf(f, "gough 8\n"); fprintf(f, "report: %u, states %u, length %u\n", m->arb_report, m->state_count, m->length); fprintf(f, "astart: %hu, fstart %hu\n", m->start_anchored, m->start_floating); fprintf(f, "accel_limit: %hu, accept_limit %hu\n", m->accel_limit_8, m->accept_limit_8); fprintf(f, "\n"); describeAlphabet(f, m); set, u32 > > prog_dump; dumpTransitions(nfa, f, &prog_dump); dump_programs(f, nfa, prog_dump); dumpTextReverse(nfa, f); } static void nfaExecGough16_dumpDot(const struct NFA *nfa, FILE *f) { assert(nfa->type == GOUGH_NFA_16); const mcclellan *m = (const mcclellan *)getImplNfa(nfa); dumpDotPreambleDfa(f); for (u16 i = 1; i < m->state_count; i++) { describeNode(nfa, m, i, f); u16 t[ALPHABET_SIZE]; goughGetTransitions(nfa, i, t); describeEdge(f, t, i); } fprintf(f, "}\n"); } static void nfaExecGough16_dumpText(const struct NFA *nfa, FILE *f) { assert(nfa->type == GOUGH_NFA_16); const mcclellan *m = (const mcclellan *)getImplNfa(nfa); // const gough_info *h = get_gough(m); fprintf(f, "gough 16\n"); fprintf(f, "report: %u, states: %u, length: %u\n", m->arb_report, m->state_count, m->length); fprintf(f, "astart: %hu, fstart: %hu\n", m->start_anchored, m->start_floating); fprintf(f, "single accept: %d\n", !!(int)m->flags & MCCLELLAN_FLAG_SINGLE); fprintf(f, "sherman_limit: %u, sherman_end: %u\n", m->sherman_limit, m->sherman_end); describeAlphabet(f, m); set, u32 > > prog_dump; dumpTransitions(nfa, f, &prog_dump); dump_programs(f, nfa, prog_dump); fprintf(f, "\n"); dumpTextReverse(nfa, f); } void nfaExecGough16_dump(const NFA *nfa, const string &base) { assert(nfa->type == GOUGH_NFA_16); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); nfaExecGough16_dumpText(nfa, f); fclose(f); f = fopen_or_throw((base + ".dot").c_str(), "w"); nfaExecGough16_dumpDot(nfa, f); fclose(f); } void nfaExecGough8_dump(const NFA *nfa, const string &base) { assert(nfa->type == GOUGH_NFA_8); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); nfaExecGough8_dumpText(nfa, f); fclose(f); f = fopen_or_throw((base + ".dot").c_str(), "w"); nfaExecGough8_dumpDot(nfa, f); fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfa/limex_ring.h0000644000175000017500000000763313055426554020151 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Bounded Repeat implementation for the LimEx NFA. */ #ifndef LIMEX_RING_H #define LIMEX_RING_H #include "ue2common.h" #include "repeat.h" #ifdef __cplusplus extern "C" { #endif /** \brief Return values from \ref processTugTrigger, used to provide feedback * about a bounded repeat to the caller. * * TRIGGER_FAIL does not get cached as we prefer to use TRIGGER_STALE which * allows the exception to squash the cyclic state as well. */ enum TriggerResult { TRIGGER_FAIL, /**< no valid matches, but history still valid */ TRIGGER_SUCCESS, /**< valid match found */ TRIGGER_STALE, /**< no valid matches and history is invalid (stale) */ TRIGGER_SUCCESS_CACHE /**< valid match found; can cache as the repeat has no upper bound. */ }; /** \brief Handle a TUG trigger: given an \p offset, returns whether a repeat * matches or not. */ static really_inline enum TriggerResult processTugTrigger(const struct RepeatInfo *info, const union RepeatControl *ctrl, const char *state, u64a offset) { DEBUG_PRINTF("tug trigger, %s history, repeat={%u,%u}, offset=%llu, " "ctrl=%p, state=%p\n", repeatTypeName(info->type), info->repeatMin, info->repeatMax, offset, ctrl, state); assert(ISALIGNED(ctrl)); enum RepeatMatch rv = repeatHasMatch(info, ctrl, state, offset); switch (rv) { case REPEAT_NOMATCH: return TRIGGER_FAIL; case REPEAT_STALE: return TRIGGER_STALE; case REPEAT_MATCH: if (info->repeatMax == REPEAT_INF) { // {N,} repeats can be cached. return TRIGGER_SUCCESS_CACHE; } else { return TRIGGER_SUCCESS; } } assert(0); // unreachable return TRIGGER_FAIL; } /** \brief Handle a POS trigger: stores a top in the repeat. */ static really_inline void processPosTrigger(const struct RepeatInfo *info, union RepeatControl *ctrl, char *state, u64a offset, char is_alive) { DEBUG_PRINTF("pos trigger, %s history, repeat={%u,%u}, offset=%llu, " "is_alive=%d\n", repeatTypeName(info->type), info->repeatMin, info->repeatMax, offset, is_alive); assert(ISALIGNED(ctrl)); repeatStore(info, ctrl, state, offset, is_alive); } #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/vermicelli_sse.h0000644000175000017500000003030413055426554021010 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Vermicelli: Intel SSE implementation. * * (users should include vermicelli.h) */ #define VERM_BOUNDARY 16 #define VERM_TYPE m128 #define VERM_SET_FN set16x8 static really_inline const u8 *vermSearchAligned(m128 chars, const u8 *buf, const u8 *buf_end, char negate) { assert((size_t)buf % 16 == 0); for (; buf + 31 < buf_end; buf += 32) { m128 data = load128(buf); u32 z1 = movemask128(eq128(chars, data)); m128 data2 = load128(buf + 16); u32 z2 = movemask128(eq128(chars, data2)); u32 z = z1 | (z2 << 16); if (negate) { z = ~z; } if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } } for (; buf + 15 < buf_end; buf += 16) { m128 data = load128(buf); u32 z = movemask128(eq128(chars, data)); if (negate) { z = ~z & 0xffff; } if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } } return NULL; } static really_inline const u8 *vermSearchAlignedNocase(m128 chars, const u8 *buf, const u8 *buf_end, char negate) { assert((size_t)buf % 16 == 0); m128 casemask = set16x8(CASE_CLEAR); for (; buf + 31 < buf_end; buf += 32) { m128 data = load128(buf); u32 z1 = movemask128(eq128(chars, and128(casemask, data))); m128 data2 = load128(buf + 16); u32 z2 = movemask128(eq128(chars, and128(casemask, data2))); u32 z = z1 | (z2 << 16); if (negate) { z = ~z; } if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } } for (; buf + 15 < buf_end; buf += 16) { m128 data = load128(buf); u32 z = movemask128(eq128(chars, and128(casemask, data))); if (negate) { z = ~z & 0xffff; } if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } } return NULL; } // returns NULL if not found static really_inline const u8 *vermUnalign(m128 chars, const u8 *buf, char negate) { m128 data = loadu128(buf); // unaligned u32 z = movemask128(eq128(chars, data)); if (negate) { z = ~z & 0xffff; } if (unlikely(z)) { return buf + ctz32(z); } return NULL; } // returns NULL if not found static really_inline const u8 *vermUnalignNocase(m128 chars, const u8 *buf, char negate) { m128 casemask = set16x8(CASE_CLEAR); m128 data = loadu128(buf); // unaligned u32 z = movemask128(eq128(chars, and128(casemask, data))); if (negate) { z = ~z & 0xffff; } if (unlikely(z)) { return buf + ctz32(z); } return NULL; } static really_inline const u8 *dvermSearchAligned(m128 chars1, m128 chars2, u8 c1, u8 c2, const u8 *buf, const u8 *buf_end) { for (; buf + 16 < buf_end; buf += 16) { m128 data = load128(buf); u32 z = movemask128(and128(eq128(chars1, data), rshiftbyte_m128(eq128(chars2, data), 1))); if (buf[15] == c1 && buf[16] == c2) { z |= (1 << 15); } if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } } return NULL; } static really_inline const u8 *dvermSearchAlignedNocase(m128 chars1, m128 chars2, u8 c1, u8 c2, const u8 *buf, const u8 *buf_end) { assert((size_t)buf % 16 == 0); m128 casemask = set16x8(CASE_CLEAR); for (; buf + 16 < buf_end; buf += 16) { m128 data = load128(buf); m128 v = and128(casemask, data); u32 z = movemask128(and128(eq128(chars1, v), rshiftbyte_m128(eq128(chars2, v), 1))); if ((buf[15] & CASE_CLEAR) == c1 && (buf[16] & CASE_CLEAR) == c2) { z |= (1 << 15); } if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } } return NULL; } static really_inline const u8 *dvermSearchAlignedMasked(m128 chars1, m128 chars2, m128 mask1, m128 mask2, u8 c1, u8 c2, u8 m1, u8 m2, const u8 *buf, const u8 *buf_end) { assert((size_t)buf % 16 == 0); for (; buf + 16 < buf_end; buf += 16) { m128 data = load128(buf); m128 v1 = eq128(chars1, and128(data, mask1)); m128 v2 = eq128(chars2, and128(data, mask2)); u32 z = movemask128(and128(v1, rshiftbyte_m128(v2, 1))); if ((buf[15] & m1) == c1 && (buf[16] & m2) == c2) { z |= (1 << 15); } if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } } return NULL; } // returns NULL if not found static really_inline const u8 *dvermPrecondition(m128 chars1, m128 chars2, const u8 *buf) { m128 data = loadu128(buf); // unaligned u32 z = movemask128(and128(eq128(chars1, data), rshiftbyte_m128(eq128(chars2, data), 1))); /* no fixup of the boundary required - the aligned run will pick it up */ if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } return NULL; } // returns NULL if not found static really_inline const u8 *dvermPreconditionNocase(m128 chars1, m128 chars2, const u8 *buf) { /* due to laziness, nonalphas and nocase having interesting behaviour */ m128 casemask = set16x8(CASE_CLEAR); m128 data = loadu128(buf); // unaligned m128 v = and128(casemask, data); u32 z = movemask128(and128(eq128(chars1, v), rshiftbyte_m128(eq128(chars2, v), 1))); /* no fixup of the boundary required - the aligned run will pick it up */ if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } return NULL; } // returns NULL if not found static really_inline const u8 *dvermPreconditionMasked(m128 chars1, m128 chars2, m128 mask1, m128 mask2, const u8 *buf) { m128 data = loadu128(buf); // unaligned m128 v1 = eq128(chars1, and128(data, mask1)); m128 v2 = eq128(chars2, and128(data, mask2)); u32 z = movemask128(and128(v1, rshiftbyte_m128(v2, 1))); /* no fixup of the boundary required - the aligned run will pick it up */ if (unlikely(z)) { u32 pos = ctz32(z); return buf + pos; } return NULL; } static really_inline const u8 *lastMatchOffset(const u8 *buf_end, u32 z) { assert(z); return buf_end - 16 + 31 - clz32(z); } static really_inline const u8 *rvermSearchAligned(m128 chars, const u8 *buf, const u8 *buf_end, char negate) { assert((size_t)buf_end % 16 == 0); for (; buf + 15 < buf_end; buf_end -= 16) { m128 data = load128(buf_end - 16); u32 z = movemask128(eq128(chars, data)); if (negate) { z = ~z & 0xffff; } if (unlikely(z)) { return lastMatchOffset(buf_end, z); } } return NULL; } static really_inline const u8 *rvermSearchAlignedNocase(m128 chars, const u8 *buf, const u8 *buf_end, char negate) { assert((size_t)buf_end % 16 == 0); m128 casemask = set16x8(CASE_CLEAR); for (; buf + 15 < buf_end; buf_end -= 16) { m128 data = load128(buf_end - 16); u32 z = movemask128(eq128(chars, and128(casemask, data))); if (negate) { z = ~z & 0xffff; } if (unlikely(z)) { return lastMatchOffset(buf_end, z); } } return NULL; } // returns NULL if not found static really_inline const u8 *rvermUnalign(m128 chars, const u8 *buf, char negate) { m128 data = loadu128(buf); // unaligned u32 z = movemask128(eq128(chars, data)); if (negate) { z = ~z & 0xffff; } if (unlikely(z)) { return lastMatchOffset(buf + 16, z); } return NULL; } // returns NULL if not found static really_inline const u8 *rvermUnalignNocase(m128 chars, const u8 *buf, char negate) { m128 casemask = set16x8(CASE_CLEAR); m128 data = loadu128(buf); // unaligned u32 z = movemask128(eq128(chars, and128(casemask, data))); if (negate) { z = ~z & 0xffff; } if (unlikely(z)) { return lastMatchOffset(buf + 16, z); } return NULL; } static really_inline const u8 *rdvermSearchAligned(m128 chars1, m128 chars2, u8 c1, u8 c2, const u8 *buf, const u8 *buf_end) { assert((size_t)buf_end % 16 == 0); for (; buf + 16 < buf_end; buf_end -= 16) { m128 data = load128(buf_end - 16); u32 z = movemask128(and128(eq128(chars2, data), lshiftbyte_m128(eq128(chars1, data), 1))); if (buf_end[-17] == c1 && buf_end[-16] == c2) { z |= 1; } if (unlikely(z)) { return lastMatchOffset(buf_end, z); } } return buf_end; } static really_inline const u8 *rdvermSearchAlignedNocase(m128 chars1, m128 chars2, u8 c1, u8 c2, const u8 *buf, const u8 *buf_end) { assert((size_t)buf_end % 16 == 0); m128 casemask = set16x8(CASE_CLEAR); for (; buf + 16 < buf_end; buf_end -= 16) { m128 data = load128(buf_end - 16); m128 v = and128(casemask, data); u32 z = movemask128(and128(eq128(chars2, v), lshiftbyte_m128(eq128(chars1, v), 1))); if ((buf_end[-17] & CASE_CLEAR) == c1 && (buf_end[-16] & CASE_CLEAR) == c2) { z |= 1; } if (unlikely(z)) { return lastMatchOffset(buf_end, z); } } return buf_end; } // returns NULL if not found static really_inline const u8 *rdvermPrecondition(m128 chars1, m128 chars2, const u8 *buf) { m128 data = loadu128(buf); u32 z = movemask128(and128(eq128(chars2, data), lshiftbyte_m128(eq128(chars1, data), 1))); /* no fixup of the boundary required - the aligned run will pick it up */ if (unlikely(z)) { return lastMatchOffset(buf + 16, z); } return NULL; } // returns NULL if not found static really_inline const u8 *rdvermPreconditionNocase(m128 chars1, m128 chars2, const u8 *buf) { /* due to laziness, nonalphas and nocase having interesting behaviour */ m128 casemask = set16x8(CASE_CLEAR); m128 data = loadu128(buf); m128 v = and128(casemask, data); u32 z = movemask128(and128(eq128(chars2, v), lshiftbyte_m128(eq128(chars1, v), 1))); /* no fixup of the boundary required - the aligned run will pick it up */ if (unlikely(z)) { return lastMatchOffset(buf + 16, z); } return NULL; } hyperscan-4.4.1/src/nfa/mpvcompile.h0000644000175000017500000000545413055426554020166 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MPV_COMPILE_H #define MPV_COMPILE_H #include "ue2common.h" #include "util/alloc.h" #include "util/charreach.h" #include #include struct NFA; namespace ue2 { class ReportManager; struct raw_puff { raw_puff(u32 repeats_in, bool unbounded_in, ReportID report_in, const CharReach &reach_in, bool auto_restart_in = false, bool simple_exhaust_in = false) : repeats(repeats_in), unbounded(unbounded_in), auto_restart(auto_restart_in), simple_exhaust(simple_exhaust_in), report(report_in), reach(reach_in) {} u32 repeats; /**< report match after this many matching bytes */ bool unbounded; /**< keep producing matches after repeats are reached */ bool auto_restart; /**< for /[^X]{n}/ type patterns */ bool simple_exhaust; /* first report will exhaust us */ ReportID report; CharReach reach; /**< = ~escapes */ }; /* * puffs in the triggered_puffs vector are enabled when an TOP_N event is * delivered corresponding to their index in the vector */ aligned_unique_ptr mpvCompile(const std::vector &puffs, const std::vector &triggered_puffs, const ReportManager &rm); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/limex_exceptional.h0000644000175000017500000002661013055426554021521 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief LimEx NFA: runtime exception processing code. * * X-macro generic impl, included into the various LimEx model implementations. */ #if !defined(SIZE) || !defined(STATE_T) || !defined(LOAD_FROM_ENG) # error Must define SIZE, STATE_T, LOAD_FROM_ENG in includer. #endif #include "config.h" #include "limex_ring.h" #include "util/join.h" #include "util/uniform_ops.h" #define PE_FN JOIN(processExceptional, SIZE) #define RUN_EXCEPTION_FN JOIN(runException, SIZE) #define ZERO_STATE JOIN(zero_, STATE_T) #define AND_STATE JOIN(and_, STATE_T) #define EQ_STATE(a, b) (!JOIN(noteq_, STATE_T)((a), (b))) #define OR_STATE JOIN(or_, STATE_T) #define TESTBIT_STATE JOIN(testbit_, STATE_T) #define EXCEPTION_T JOIN(struct NFAException, SIZE) #define CONTEXT_T JOIN(NFAContext, SIZE) #define IMPL_NFA_T JOIN(LimExNFA, SIZE) #define GET_NFA_REPEAT_INFO_FN JOIN(getNfaRepeatInfo, SIZE) #ifdef ESTATE_ON_STACK #define ESTATE_ARG STATE_T estate #else #define ESTATE_ARG const STATE_T *estatep #define estate (*estatep) #endif #ifdef STATE_ON_STACK #define STATE_ARG_NAME s #define STATE_ARG STATE_T STATE_ARG_NAME #define STATE_ARG_P &s #else #define STATE_ARG_NAME sp #define STATE_ARG const STATE_T *STATE_ARG_NAME #define STATE_ARG_P sp #endif #ifndef STATE_ON_STACK #define BIG_MODEL #endif #ifdef ARCH_64_BIT #define CHUNK_T u64a #define FIND_AND_CLEAR_FN findAndClearLSB_64 #define POPCOUNT_FN popcount64 #define RANK_IN_MASK_FN rank_in_mask64 #else #define CHUNK_T u32 #define FIND_AND_CLEAR_FN findAndClearLSB_32 #define POPCOUNT_FN popcount32 #define RANK_IN_MASK_FN rank_in_mask32 #endif /** \brief Process a single exception. Returns 1 if exception handling should * continue, 0 if an accept callback has instructed us to halt. */ static really_inline int RUN_EXCEPTION_FN(const EXCEPTION_T *e, STATE_ARG, STATE_T *succ, #ifndef BIG_MODEL STATE_T *local_succ, #endif const struct IMPL_NFA_T *limex, u64a offset, struct CONTEXT_T *ctx, struct proto_cache *new_cache, enum CacheResult *cacheable, char in_rev, const char flags) { assert(e); #ifdef DEBUG_EXCEPTIONS printf("EXCEPTION e=%p reports=%u trigger=", e, e->reports); if (e->trigger == LIMEX_TRIGGER_NONE) { printf("none"); } else if (e->trigger == LIMEX_TRIGGER_POS) { printf("pos"); } else if (e->trigger == LIMEX_TRIGGER_TUG) { printf("tug"); } else { printf("unknown!"); } printf("\n"); #endif // Trigger exceptions, used in bounded repeats. assert(!in_rev || e->trigger == LIMEX_TRIGGER_NONE); if (!in_rev && e->trigger != LIMEX_TRIGGER_NONE) { assert(e->repeatOffset != MO_INVALID_IDX); const struct NFARepeatInfo *info = (const struct NFARepeatInfo *)((const char *)limex + e->repeatOffset); const struct RepeatInfo *repeat = getRepeatInfo(info); assert(ctx->repeat_ctrl && ctx->repeat_state); union RepeatControl *repeat_ctrl = ctx->repeat_ctrl + info->ctrlIndex; char *repeat_state = ctx->repeat_state + info->stateOffset; if (e->trigger == LIMEX_TRIGGER_POS) { char cyclic_on = TESTBIT_STATE(*STATE_ARG_P, info->cyclicState); processPosTrigger(repeat, repeat_ctrl, repeat_state, offset, cyclic_on); *cacheable = DO_NOT_CACHE_RESULT_AND_FLUSH_BR_ENTRIES; } else { assert(e->trigger == LIMEX_TRIGGER_TUG); enum TriggerResult rv = processTugTrigger(repeat, repeat_ctrl, repeat_state, offset); if (rv == TRIGGER_FAIL) { *cacheable = DO_NOT_CACHE_RESULT_AND_FLUSH_BR_ENTRIES; DEBUG_PRINTF("tug found no valid matches in repeat state\n"); return 1; // continue } else if (rv == TRIGGER_STALE) { *cacheable = DO_NOT_CACHE_RESULT_AND_FLUSH_BR_ENTRIES; DEBUG_PRINTF("stale history, squashing cyclic state\n"); assert(e->hasSquash == LIMEX_SQUASH_TUG); *succ = AND_STATE(*succ, LOAD_FROM_ENG(&e->squash)); return 1; // continue } else if (rv == TRIGGER_SUCCESS_CACHE) { new_cache->br = 1; } else { assert(rv == TRIGGER_SUCCESS); *cacheable = DO_NOT_CACHE_RESULT_AND_FLUSH_BR_ENTRIES; } } } // Some exceptions fire accepts. if (e->reports != MO_INVALID_IDX) { if (flags & CALLBACK_OUTPUT) { const ReportID *reports = (const ReportID *)((const char *)limex + e->reports); if (unlikely(limexRunReports(reports, ctx->callback, ctx->context, offset) == MO_HALT_MATCHING)) { DEBUG_PRINTF("callback instructed us to stop\n"); return 0; // halt } if (*cacheable == CACHE_RESULT) { if (!new_cache->reports || new_cache->reports == reports) { new_cache->reports = reports; } else { *cacheable = DO_NOT_CACHE_RESULT; } } } else { if ((flags & FIRST_BYTE) && *cacheable == CACHE_RESULT) { *cacheable = DO_NOT_CACHE_RESULT; } /* otherwise we can cache as we never care about accepts */ } } // Most exceptions have a set of successors to switch on. `local_succ' is // ORed into `succ' at the end of the caller's loop. #ifndef BIG_MODEL *local_succ = OR_STATE(*local_succ, LOAD_FROM_ENG(&e->successors)); #else ctx->local_succ = OR_STATE(ctx->local_succ, LOAD_FROM_ENG(&e->successors)); #endif // Some exceptions squash states behind them. Note that we squash states in // 'succ', not local_succ. if (e->hasSquash == LIMEX_SQUASH_CYCLIC || e->hasSquash == LIMEX_SQUASH_REPORT) { *succ = AND_STATE(*succ, LOAD_FROM_ENG(&e->squash)); if (*cacheable == CACHE_RESULT) { *cacheable = DO_NOT_CACHE_RESULT; } } return 1; // continue } #ifndef RUN_EXCEPTION_FN_ONLY /** \brief Process all of the exceptions associated with the states in the \a * estate. */ static really_inline int PE_FN(STATE_ARG, ESTATE_ARG, u32 diffmask, STATE_T *succ, const struct IMPL_NFA_T *limex, const EXCEPTION_T *exceptions, u64a offset, struct CONTEXT_T *ctx, char in_rev, char flags) { assert(diffmask > 0); // guaranteed by caller macro if (EQ_STATE(estate, ctx->cached_estate)) { DEBUG_PRINTF("using cached succ from previous state\n"); *succ = OR_STATE(*succ, ctx->cached_esucc); if (ctx->cached_reports && (flags & CALLBACK_OUTPUT)) { DEBUG_PRINTF("firing cached reports from previous state\n"); if (unlikely(limexRunReports(ctx->cached_reports, ctx->callback, ctx->context, offset) == MO_HALT_MATCHING)) { return PE_RV_HALT; // halt; } } return 0; } #ifndef BIG_MODEL STATE_T local_succ = ZERO_STATE; #else ctx->local_succ = ZERO_STATE; #endif // A copy of the estate as an array of GPR-sized chunks. CHUNK_T chunks[sizeof(STATE_T) / sizeof(CHUNK_T)]; CHUNK_T emask_chunks[sizeof(STATE_T) / sizeof(CHUNK_T)]; #ifdef ESTATE_ON_STACK memcpy(chunks, &estate, sizeof(STATE_T)); #else memcpy(chunks, estatep, sizeof(STATE_T)); #endif memcpy(emask_chunks, &limex->exceptionMask, sizeof(STATE_T)); struct proto_cache new_cache = {0, NULL}; enum CacheResult cacheable = CACHE_RESULT; u32 base_index[sizeof(STATE_T) / sizeof(CHUNK_T)]; base_index[0] = 0; for (s32 i = 0; i < (s32)ARRAY_LENGTH(base_index) - 1; i++) { base_index[i + 1] = base_index[i] + POPCOUNT_FN(emask_chunks[i]); } do { u32 t = findAndClearLSB_32(&diffmask); #ifdef ARCH_64_BIT t >>= 1; // Due to diffmask64, which leaves holes in the bitmask. #endif assert(t < ARRAY_LENGTH(chunks)); CHUNK_T word = chunks[t]; assert(word != 0); do { u32 bit = FIND_AND_CLEAR_FN(&word); u32 local_index = RANK_IN_MASK_FN(emask_chunks[t], bit); u32 idx = local_index + base_index[t]; const EXCEPTION_T *e = &exceptions[idx]; if (!RUN_EXCEPTION_FN(e, STATE_ARG_NAME, succ, #ifndef BIG_MODEL &local_succ, #endif limex, offset, ctx, &new_cache, &cacheable, in_rev, flags)) { return PE_RV_HALT; } } while (word); } while (diffmask); #ifndef BIG_MODEL *succ = OR_STATE(*succ, local_succ); #else *succ = OR_STATE(*succ, ctx->local_succ); #endif if (cacheable == CACHE_RESULT) { ctx->cached_estate = estate; #ifndef BIG_MODEL ctx->cached_esucc = local_succ; #else ctx->cached_esucc = ctx->local_succ; #endif ctx->cached_reports = new_cache.reports; ctx->cached_br = new_cache.br; } else if (cacheable == DO_NOT_CACHE_RESULT_AND_FLUSH_BR_ENTRIES) { if (ctx->cached_br) { ctx->cached_estate = ZERO_STATE; } } return 0; } #endif #undef ZERO_STATE #undef AND_STATE #undef EQ_STATE #undef OR_STATE #undef TESTBIT_STATE #undef PE_FN #undef RUN_EXCEPTION_FN #undef CONTEXT_T #undef EXCEPTION_T #ifdef estate #undef estate #endif #ifdef BIG_MODEL #undef BIG_MODEL #endif #undef STATE_ARG #undef STATE_ARG_NAME #undef STATE_ARG_P #undef IMPL_NFA_T #undef CHUNK_T #undef FIND_AND_CLEAR_FN #undef POPCOUNT_FN #undef RANK_IN_MASK_FN hyperscan-4.4.1/src/nfa/mcsheng_data.c0000644000175000017500000000375413055426554020424 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "mcsheng_internal.h" /* This table is in a separate translation unit from mcsheng.c as we want to * prevent the compiler from seeing these constants. We have the load resources * free at runtime to load the masks with no problems. */ const u64a mcsheng_pext_mask[8] = { 0, /* dummy */ 0x000000000000ff0f, 0x0000000000ff000f, 0x00000000ff00000f, 0x000000ff0000000f, 0x0000ff000000000f, 0x00ff00000000000f, 0xff0000000000000f, }; hyperscan-4.4.1/src/nfa/nfa_api.h0000644000175000017500000002554713055426554017415 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Declarations for the main NFA Engine API. * * This file provides the internal API for all runtime engines ("NFAs", even if * they're not strictly NFA implementations). */ #ifndef NFA_API_H #define NFA_API_H #ifdef __cplusplus extern "C" { #endif #include "callback.h" #include "ue2common.h" struct mq; struct NFA; /** * Indicates if an nfa is a zombie. Note: that there were plans for a more * nuanced view of zombiehood but this never eventuated. */ enum nfa_zombie_status { NFA_ZOMBIE_NO, /**< nfa is not a zombie and will respond to top events */ NFA_ZOMBIE_ALWAYS_YES /**< nfa is a zombie and will always be a zombie */ }; /** * Compresses an engine's state. * The expanded state (@ref mq::state, @ref mq::streamState) is reduced purely * to a corresponding compressed stream state (@ref mq::streamState). * * @param nfa engine the state belongs to * @param q queue for the engine. The final compressed stream stream is placed * in the location indicated by @ref mq::streamState * @param loc the location corresponding to the engine's current state */ char nfaQueueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); /** * Expands an engine's compressed stream state, into its scratch space * representation. This is required before an engine starts operating over its * queue. * * @param nfa engine the state belongs to * @param dest location in scratch for decompressed state * @param src compressed stream state * @param offset the current stream offset. * @param key byte corresponding to the location where the compressed state was * created. */ char nfaExpandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); /** * Gives us a properly initialised dead state suitable for later @ref * nfaQueueExec calls. */ char nfaQueueInitState(const struct NFA *nfa, struct mq *q); /** * Initialise the state, applying a TOP appropriate for the offset. If the * NFA becomes inactive, return zero. Otherwise, write out its compressed * representation to `state' and return non-zero. * * @param nfa engine the state belongs to * @param offset offset in the stream (relative to start of stream) * @param state pointer indicating where the state is to be written * @param key byte corresponding to the location where the compressed state is * to be created. */ char nfaInitCompressedState(const struct NFA *nfa, u64a offset, void *state, u8 key); /** * Process the queued commands on the given NFA. * * @param nfa the NFA to execute * @param q the queued commands. It must start with some variant of start and * end with some variant of end. The location field of the events must * be monotonically increasing. * @param end stop processing command queue when we reach this point * * @return non-zero if the nfa is still active, if the nfa is not active the * state data is undefined * * Note: this function can not process events from the past: the location field * of each event must be >= current offset. */ char nfaQueueExec(const struct NFA *nfa, struct mq *q, s64a end); /** * Main execution function that doesn't perform the checks and optimisations of * nfaQueueExec() and just dispatches directly to the nfa implementations. It is * intended to be used by the Tamarama engine. */ char nfaQueueExec_raw(const struct NFA *nfa, struct mq *q, s64a end); /** Return value indicating that the engine is dead. */ #define MO_DEAD 0 /** Return value indicating that the engine is alive. */ #define MO_ALIVE 1 /** Return value from @ref nfaQueueExecToMatch indicating that engine progress * stopped as a match state was reached. */ #define MO_MATCHES_PENDING 2 /** * Process the queued commands on the given nfa up to end or the first match. * This function will only fire the callback in response to an report_current * being set and accepts at the starting offset, in all other situations accepts * will result in the queue pausing with a return value of * @ref MO_MATCHES_PENDING. * * @param nfa the NFA to execute * @param q the queued commands. It must start with some variant of start and * end with some variant of end. The location field of the events must * be monotonically increasing. If not all the data was processed during * the call, the queue is updated to reflect the remaining work. * @param end stop processing command queue when we reach this point * * @return @ref MO_ALIVE if the nfa is still active with no matches pending, * and @ref MO_MATCHES_PENDING if there are matches pending, 0 if not * alive * * Note: if it can be determined that the stream can never match, the nfa * may be reported as dead even if not all the data was scanned * * Note: if the nfa is not alive the state data is undefined * * Note: this function can not process events from the past: the location field * of each event must be >= current offset. */ char nfaQueueExecToMatch(const struct NFA *nfa, struct mq *q, s64a end); /** * Main execution function that doesn't perform the checks and optimisations of * nfaQueueExecToMatch() and just dispatches directly to the nfa * implementations. It is intended to be used by the Tamarama engine. */ char nfaQueueExec2_raw(const struct NFA *nfa, struct mq *q, s64a end); /** * Report matches at the current queue location. * * @param nfa the NFA to execute * @param q the queued commands. It must start with some variant of start and * end with some variant of end. The location field of the events must * be monotonically increasing. * * Note: the queue MUST be located at position where @ref nfaQueueExecToMatch * returned @ref MO_MATCHES_PENDING. * * Note: the return value of this call is undefined, and should be ignored. */ char nfaReportCurrentMatches(const struct NFA *nfa, struct mq *q); /** * Returns non-zero if the NFA is in an accept state with the given report ID. */ char nfaInAcceptState(const struct NFA *nfa, ReportID report, struct mq *q); /** * Returns non-zero if the NFA is in any accept state regardless of report * ID. */ char nfaInAnyAcceptState(const struct NFA *nfa, struct mq *q); /** * Process the queued commands on the given NFA up to end or the first match. * * Note: This version is meant for rose prefix/infix NFAs: * - never uses a callback * - loading of state at a point in history is not special cased * * @param nfa the NFA to execute * @param q the queued commands. It must start with some variant of start and * end with some variant of end. The location field of the events must * be monotonically increasing. If not all the data was processed during * the call, the queue is updated to reflect the remaining work. * @param report we are interested in. If the given report will be raised at * the end location, the function returns @ref MO_MATCHES_PENDING. If no * match information is desired, MO_INVALID_IDX should be passed in. * @return @ref MO_ALIVE if the nfa is still active with no matches pending, * and @ref MO_MATCHES_PENDING if there are matches pending, 0 if not * alive * * Note: if it can be determined that the stream can never match, the nfa * may be reported as dead even if not all the data was scanned * * Note: if the NFA is not active the state data is undefined. */ char nfaQueueExecRose(const struct NFA *nfa, struct mq *q, ReportID report); /** * Runs an NFA in reverse from (buf + buflen) to buf and then from (hbuf + hlen) * to hbuf (main buffer and history buffer). * * Note: provides the match location as the "end" offset when the callback is * called. * * @param nfa engine to run * @param offset base offset of buf * @param buf main buffer * @param buflen length of buf * @param hbuf history buf * @param hlen length of hbuf * @param callback the callback to call for each match raised * @param context context pointer passed to each callback */ char nfaBlockExecReverse(const struct NFA *nfa, u64a offset, const u8 *buf, size_t buflen, const u8 *hbuf, size_t hlen, NfaCallback callback, void *context); /** * Check whether the given NFA's state indicates that it is in one or more * final (accept at end of data) state. If so, call the callback for each * match. * * @param nfa the NFA to execute * @param state current state associated with this NFA * @param streamState stream version of the state associated with this NFA * (including br region) * @param offset the offset to return (via the callback) with each match * @param callback the callback to call for each match raised * @param context context pointer passed to each callback * * @return @ref MO_HALT_MATCHING if the user instructed us to halt, otherwise * @ref MO_CONTINUE_MATCHING. */ char nfaCheckFinalState(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); /** * Indicates if an engine is a zombie. * * @param nfa engine to consider * @param q queue corresponding to the engine * @param loc current location in the buffer for an engine */ enum nfa_zombie_status nfaGetZombieStatus(const struct NFA *nfa, struct mq *q, s64a loc); #ifdef __cplusplus } /* extern "C" */ #endif #endif hyperscan-4.4.1/src/nfa/multivermicelli.h0000644000175000017500000000520713055426554021215 0ustar sleuthkidsleuthkid/* * 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 MULTIVERMICELLI_H_ #define MULTIVERMICELLI_H_ #ifdef __cplusplus extern "C" { #endif const u8 *long_vermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *longgrab_vermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *shift_vermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *shiftgrab_vermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *doubleshift_vermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end, const u8 run_len, const u8 run2_len); const u8 *doubleshiftgrab_vermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end, const u8 run_len, const u8 run2_len); #ifdef __cplusplus } #endif #endif /* MULTIVERMICELLI_H_ */ hyperscan-4.4.1/src/nfa/rdfa_graph.h0000644000175000017500000000357513055426554020112 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 RDFA_GRAPH_H #define RDFA_GRAPH_H #include "ue2common.h" #include "util/ue2_graph.h" namespace ue2 { struct raw_dfa; struct RdfaVertexProps { size_t index = 0; }; struct RdfaEdgeProps { size_t index = 0; }; struct RdfaGraph : public ue2_graph { RdfaGraph(const raw_dfa &rdfa); }; } #endif hyperscan-4.4.1/src/nfa/mcsheng.h0000644000175000017500000001032013055426554017423 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 MCSHENG_H #define MCSHENG_H #include "callback.h" #include "ue2common.h" struct mq; struct NFA; /* 8-bit Sheng-McClellan hybrid */ char nfaExecMcSheng8_testEOD(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); char nfaExecMcSheng8_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecMcSheng8_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecMcSheng8_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecMcSheng8_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecMcSheng8_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecMcSheng8_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecMcSheng8_queueInitState(const struct NFA *n, struct mq *q); char nfaExecMcSheng8_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecMcSheng8_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecMcSheng8_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecMcSheng8_B_Reverse NFA_API_NO_IMPL #define nfaExecMcSheng8_zombie_status NFA_API_ZOMBIE_NO_IMPL /* 16-bit Sheng-McClellan hybrid */ char nfaExecMcSheng16_testEOD(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); char nfaExecMcSheng16_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecMcSheng16_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecMcSheng16_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecMcSheng16_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecMcSheng16_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecMcSheng16_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecMcSheng16_queueInitState(const struct NFA *n, struct mq *q); char nfaExecMcSheng16_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecMcSheng16_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecMcSheng16_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecMcSheng16_B_Reverse NFA_API_NO_IMPL #define nfaExecMcSheng16_zombie_status NFA_API_ZOMBIE_NO_IMPL #endif hyperscan-4.4.1/src/nfa/tamarama_internal.h0000644000175000017500000000706613055426554021473 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file *\brief Tamarama: container engine for exclusive engines, * data structures. */ /* Tamarama bytecode layout: * * |-----| * * | | struct NFA * * |-----| * * | | struct Tamarama * * | | * * |-----| * * | | top remapping table: * * | | stores top base for each subengine. * * | | old_top = remapped_top - top_base; * * | | The size of table is equal to the number of subengines. * * ... * * | | * * |-----| * * | | offsets from the start of struct Tamarama to subengines --\ * * ... | * * | | -----------\ | * * |-----| | | * * ||--| | subengine 1 (struct NFA + rest of subengine) <--/ | * * || | | | * * ||--| | | * * || | | | * * || | | | * * ||--| | | * * | | | * * ||--| | subengine 2 (struct NFA + rest of subengine) <-------/ * * || | | * * ||--| | * * || | | * * || | | * * ||--| | * * | | * * ... * * | | * * |-----| total size of tamarama * * * * Tamarama stream state: * * * * |---| * * | | active subengine id * * |---| * * | | common pool of stream state for each engine * * | | * * | | * * ... * * | | * * | | * * |---| * * * * Tamarama scratch space: * * * * |---| * * | | common pool of scratch for each engine * * | | * * | | * * ... * * | | * * | | * * |---| * */ #ifndef NFA_TAMARAMA_INTERNAL_H #define NFA_TAMARAMA_INTERNAL_H #include "ue2common.h" struct ALIGN_AVX_DIRECTIVE Tamarama { u32 numSubEngines; u8 activeIdxSize; }; #endif // NFA_TAMARAMA_INTERNAL_H hyperscan-4.4.1/src/nfa/limex_simd384.c0000644000175000017500000000417713055426554020400 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief LimEx NFA: 384-bit SIMD runtime implementations. */ //#define DEBUG_INPUT //#define DEBUG_EXCEPTIONS #include "limex.h" #include "accel.h" #include "limex_internal.h" #include "nfa_internal.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" // Common code #include "limex_runtime.h" #define SIZE 384 #define STATE_T m384 #define ENG_STATE_T m384 #define LOAD_FROM_ENG load_m384 #include "limex_exceptional.h" #include "limex_state_impl.h" #define INLINE_ATTR really_inline #include "limex_common_impl.h" #include "limex_runtime_impl.h" hyperscan-4.4.1/src/nfa/repeatcompile.h0000644000175000017500000000615013055426554020636 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Bounded repeat compile-time code. */ #ifndef REPEATCOMPILE_H #define REPEATCOMPILE_H #include "repeat_internal.h" #include #include #include namespace ue2 { class CharReach; class depth; /** * \brief Structure representing the various state requirements for a given * bounded repeat. */ struct RepeatStateInfo { RepeatStateInfo(enum RepeatType type, const depth &repeatMin, const depth &repeatMax, u32 minPeriod); u32 stateSize; u32 packedCtrlSize; u32 horizon; u32 patchCount; u32 patchSize; u32 encodingSize; u32 patchesOffset; std::vector packedFieldSizes; std::vector table; // not u64a, for boost/gcc-4.9 }; /** * \brief Given the parameters of a repeat, choose a repeat implementation * type. */ enum RepeatType chooseRepeatType(const depth &repeatMin, const depth &repeatMax, u32 minPeriod, bool is_reset, bool has_external_guard = false); u32 calcPackedBytes(u64a val); bool matches(std::vector::const_iterator a_it, std::vector::const_iterator a_ite, std::vector::const_iterator b_it, std::vector::const_iterator b_ite); std::vector minResetDistToEnd(const std::vector> &triggers, const CharReach &cr); u32 minPeriod(const std::vector> &triggers, const CharReach &cr, bool *can_reset); } // namespace ue2 #endif // REPEATCOMPILE_H hyperscan-4.4.1/src/nfa/nfa_dump_api.h0000644000175000017500000000405213055426554020426 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Declarations for the NFA Engine dump API. */ #ifndef NFA_DUMP_API_H #define NFA_DUMP_API_H #if defined(DUMP_SUPPORT) #include struct NFA; namespace ue2 { /** * \brief Dump files representing the engine. All files dumped should begin with * path/prefix specified by base. Generally a text file and a grpahviz (dot) * files should be produced. */ void nfaGenerateDumpFiles(const struct NFA *nfa, const std::string &base); } // namespace ue2 #endif // DUMP_SUPPORT #endif // NFA_DUMP_API_H hyperscan-4.4.1/src/nfa/tamarama.c0000644000175000017500000003465313055426554017574 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file \brief Tamarama: container engine for exclusive engines, runtime code. */ #include "config.h" #include "tamarama.h" #include "tamarama_internal.h" #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_api_util.h" #include "nfa_internal.h" #include "scratch.h" #include "util/partial_store.h" static really_inline u32 getSubOffset(const struct Tamarama *t, u32 num) { DEBUG_PRINTF("subengine:%u\n", num); assert(num < t->numSubEngines); const u32 *sub = (const u32 *)((const char *)t + sizeof(struct Tamarama) + t->numSubEngines * sizeof(u32)); assert(ISALIGNED(sub)); return sub[num]; } static const struct NFA *getSubEngine(const struct Tamarama *t, const u32 activeIdx) { const u32 offset = getSubOffset(t, activeIdx); DEBUG_PRINTF("activeIdx:%u offsets:%u\n", activeIdx, offset); const char *base = (const char *)t; return (const struct NFA *)(base + offset); } static void storeActiveIdx(const struct Tamarama *t, char *state, const u32 idx) { assert(idx <= t->numSubEngines); partial_store_u32(state, idx, t->activeIdxSize); } static u32 loadActiveIdx(const char *state, const u32 activeIdxSize) { return partial_load_u32(state, activeIdxSize); } static really_inline void copyQueueProperties(const struct mq *q1, struct mq *q2, const u32 activeIdxSize) { q2->state = q1->state; q2->streamState = q1->streamState + activeIdxSize; q2->offset = q1->offset; q2->buffer = q1->buffer; q2->length = q1->length; q2->history = q1->history; q2->hlength = q1->hlength; q2->cb = q1->cb; q2->context = q1->context; q2->scratch = q1->scratch; q2->report_current = q1->report_current; } static void copyQueueItems(const struct Tamarama *t, const struct NFA *sub, struct mq *q1, struct mq *q2, const u32 activeIdx) { const u32 *baseTop = (const u32 *)((const char *)t + sizeof(struct Tamarama)); u32 lower = baseTop[activeIdx]; u32 upper = activeIdx == t->numSubEngines - 1 ? ~0U : baseTop[activeIdx + 1]; u32 event_base = isMultiTopType(sub->type) ? MQE_TOP_FIRST : MQE_TOP; while (q1->cur < q1->end) { u32 type = q1->items[q1->cur].type; s64a loc = q1->items[q1->cur].location; DEBUG_PRINTF("type:%u lower:%u upper:%u\n", type, lower, upper); if (type >= lower && type < upper) { u32 event = event_base; if (event == MQE_TOP_FIRST) { event += type - lower; } pushQueue(q2, event, loc); } else { pushQueueNoMerge(q2, MQE_END, loc); break; } q1->cur++; } } static void copyQueue(const struct Tamarama *t, const struct NFA *sub, struct mq *q1, struct mq *q2, const u32 activeIdx) { copyQueueProperties(q1, q2, t->activeIdxSize); // copy MQE_START item u32 cur = q1->cur++; q2->cur = cur; q2->items[cur] = q1->items[cur]; q2->end = cur + 1; copyQueueItems(t, sub, q1, q2, activeIdx); // restore cur index of the main queue q1->cur = cur; } static u32 findEngineForTop(const u32 *baseTop, const u32 cur, const u32 numSubEngines) { u32 i; for (i = 0; i < numSubEngines; ++i) { DEBUG_PRINTF("cur:%u base:%u\n", cur, baseTop[i]); if (cur >= baseTop[i] && (i == numSubEngines - 1 || cur < baseTop[i + 1])) { break; } } return i; } static void initSubQueue(const struct Tamarama *t, struct mq *q1, struct mq *q2, const u32 lastActiveIdx, const u32 activeIdx) { // Push events to the new queue const struct NFA *sub = getSubEngine(t, activeIdx); assert(!isContainerType(sub->type)); q2->nfa = sub; // Reinitialize state if the last active subengine is different // from current one if (lastActiveIdx == t->numSubEngines || lastActiveIdx != activeIdx) { nfaQueueInitState(q2->nfa, q2); } copyQueueItems(t, sub, q1, q2, activeIdx); if (q1->items[q1->cur].type == MQE_END) { q1->cur++; } DEBUG_PRINTF("update lastIdx:%u\n", activeIdx); storeActiveIdx(t, q1->streamState, activeIdx); } static void updateQueues(const struct Tamarama *t, struct mq *q1, struct mq *q2) { q2->cur = q2->end = 0; copyQueueProperties(q1, q2, t->activeIdxSize); const u32 numSubEngines = t->numSubEngines; u32 lastActiveIdx = loadActiveIdx(q1->streamState, t->activeIdxSize); #ifdef DEBUG DEBUG_PRINTF("external queue\n"); debugQueue(q1); #endif // Push MQE_START event to the subqueue s64a loc = q1->items[q1->cur].location; pushQueueAt(q2, 0, MQE_START, loc); char hasStart = 0; if (q1->items[q1->cur].type == MQE_START) { hasStart = 1; q1->cur++; } u32 activeIdx = lastActiveIdx; // If we have top events in the main queue, update current active id if (q1->cur < q1->end - 1) { const u32 *baseTop = (const u32 *)((const char *)t + sizeof(struct Tamarama)); u32 curTop = q1->items[q1->cur].type; activeIdx = findEngineForTop(baseTop, curTop, numSubEngines); } assert(activeIdx < numSubEngines); DEBUG_PRINTF("last id:%u, current id:%u, num of subengines:%u\n", lastActiveIdx, activeIdx, numSubEngines); // Handle unfinished last alive subengine if (lastActiveIdx != activeIdx && lastActiveIdx != numSubEngines && hasStart) { loc = q1->items[q1->cur].location; pushQueueNoMerge(q2, MQE_END, loc); q2->nfa = getSubEngine(t, lastActiveIdx); return; } initSubQueue(t, q1, q2, lastActiveIdx, activeIdx); DEBUG_PRINTF("finish queues\n"); } // After processing subqueue items for subengines, we need to copy back // remaining items in subqueue if there are any to Tamarama main queue static void copyBack(const struct Tamarama *t, struct mq *q, struct mq *q1) { DEBUG_PRINTF("copy back %u, %u\n", q1->cur, q1->end); q->report_current = q1->report_current; if (q->cur >= q->end && q1->cur >= q1->end) { return; } const u32 *baseTop = (const u32 *)((const char *)t + sizeof(struct Tamarama)); const u32 lastIdx = loadActiveIdx(q->streamState, t->activeIdxSize); u32 base = 0, event_base = 0; if (lastIdx != t->numSubEngines) { base = baseTop[lastIdx]; const struct NFA *sub = getSubEngine(t, lastIdx); event_base = isMultiTopType(sub->type) ? MQE_TOP_FIRST : MQE_TOP; } u32 numItems = q1->end > q1->cur + 1 ? q1->end - q1->cur - 1 : 1; // Also need to copy MQE_END if the main queue is empty if (q->cur == q->end) { assert(q->cur > 1 && q1->items[q1->end - 1].type == MQE_END); q->items[--q->cur] = q1->items[q1->end - 1]; } u32 cur = q->cur - numItems; q->items[cur] = q1->items[q1->cur++]; q->items[cur].type = MQE_START; q->cur = cur++; for (u32 i = 0; i < numItems - 1; ++i) { assert(q1->cur < q1->end); u32 type = q1->items[q1->cur].type; if (type > MQE_END) { q1->items[q1->cur].type = type - event_base + base; } q->items[cur++] = q1->items[q1->cur++]; } #ifdef DEBUG DEBUG_PRINTF("external queue\n"); debugQueue(q); #endif } char nfaExecTamarama_testEOD(const struct NFA *n, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context) { const struct Tamarama *t = getImplNfa(n); u32 activeIdx = loadActiveIdx(streamState, t->activeIdxSize); if (activeIdx == t->numSubEngines) { return MO_CONTINUE_MATCHING; } const struct NFA *sub = getSubEngine(t, activeIdx); if (nfaAcceptsEod(sub)) { assert(!isContainerType(sub->type)); const char *subStreamState = streamState + t->activeIdxSize; return nfaCheckFinalState(sub, state, subStreamState, offset, callback, context); } return MO_CONTINUE_MATCHING; } char nfaExecTamarama_QR(const struct NFA *n, struct mq *q, ReportID report) { DEBUG_PRINTF("exec rose\n"); struct mq q1; q1.cur = q1.end = 0; char rv = 0; const struct Tamarama *t = getImplNfa(n); while (q->cur < q->end) { updateQueues(t, q, &q1); } if (q1.cur < q1.end) { rv = nfaQueueExecRose(q1.nfa, &q1, report); } DEBUG_PRINTF("exec rose rv:%u\n", rv); return rv; } char nfaExecTamarama_reportCurrent(const struct NFA *n, struct mq *q) { const struct Tamarama *t = getImplNfa(n); u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize); if (activeIdx == t->numSubEngines) { return 1; } const struct NFA *sub = getSubEngine(t, activeIdx); struct mq q1; copyQueue(t, sub, q, &q1, activeIdx); return nfaReportCurrentMatches(sub, &q1); } char nfaExecTamarama_inAccept(const struct NFA *n, ReportID report, struct mq *q) { const struct Tamarama *t = getImplNfa(n); u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize); if (activeIdx == t->numSubEngines) { return 0; } const struct NFA *sub = getSubEngine(t, activeIdx); struct mq q1; copyQueue(t, sub, q, &q1, activeIdx); return nfaInAcceptState(sub, report, &q1); } char nfaExecTamarama_inAnyAccept(const struct NFA *n, struct mq *q) { const struct Tamarama *t = getImplNfa(n); u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize); if (activeIdx == t->numSubEngines) { return 0; } const struct NFA *sub = getSubEngine(t, activeIdx); struct mq q1; copyQueue(t, sub, q, &q1, activeIdx); return nfaInAnyAcceptState(sub, &q1); } char nfaExecTamarama_queueInitState(const struct NFA *n, struct mq *q) { DEBUG_PRINTF("init state\n"); const struct Tamarama *t = getImplNfa(n); char *ptr = q->streamState; // Use activeIdxSize as a sentinel value and initialize the state to // an invalid engine as nothing has been triggered yet storeActiveIdx(t, ptr, t->numSubEngines); return 0; } char nfaExecTamarama_queueCompressState(const struct NFA *n, const struct mq *q, s64a loc) { const struct Tamarama *t = getImplNfa(n); u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize); if (activeIdx == t->numSubEngines) { return 0; } const struct NFA *sub = getSubEngine(t, activeIdx); struct mq q1; copyQueueProperties(q, &q1, t->activeIdxSize); return nfaQueueCompressState(sub, &q1, loc); } char nfaExecTamarama_expandState(const struct NFA *n, void *dest, const void *src, u64a offset, u8 key) { const struct Tamarama *t = getImplNfa(n); u32 activeIdx = loadActiveIdx(src, t->activeIdxSize); if (activeIdx == t->numSubEngines) { return 0; } const struct NFA *sub = getSubEngine(t, activeIdx); const char *subStreamState = (const char *)src + t->activeIdxSize; return nfaExpandState(sub, dest, subStreamState, offset, key); } enum nfa_zombie_status nfaExecTamarama_zombie_status(const struct NFA *n, struct mq *q, s64a loc) { const struct Tamarama *t = getImplNfa(n); u32 activeIdx = loadActiveIdx(q->streamState, t->activeIdxSize); if (activeIdx == t->numSubEngines) { return NFA_ZOMBIE_NO; } const struct NFA *sub = getSubEngine(t, activeIdx); struct mq q1; copyQueue(t, sub, q, &q1, activeIdx); return nfaGetZombieStatus(sub, &q1, loc); } char nfaExecTamarama_Q(const struct NFA *n, struct mq *q, s64a end) { DEBUG_PRINTF("exec\n"); struct mq q1; char rv = MO_ALIVE; char copy = 0; const struct Tamarama *t = getImplNfa(n); while (q->cur < q->end && q_cur_loc(q) <= end) { updateQueues(t, q, &q1); rv = nfaQueueExec_raw(q1.nfa, &q1, end); q->report_current = q1.report_current; copy = 1; if (can_stop_matching(q->scratch)) { break; } } if (copy) { copyBack(t, q, &q1); } return rv; } char nfaExecTamarama_Q2(const struct NFA *n, struct mq *q, s64a end) { DEBUG_PRINTF("exec to match\n"); struct mq q1; char rv = 0; char copy = 0; const struct Tamarama *t = getImplNfa(n); while (q->cur < q->end && q_cur_loc(q) <= end && rv != MO_MATCHES_PENDING) { updateQueues(t, q, &q1); rv = nfaQueueExec2_raw(q1.nfa, &q1, end); q->report_current = q1.report_current; copy = 1; if (can_stop_matching(q->scratch)) { break; } } if (copy) { copyBack(t, q, &q1); } return rv; } hyperscan-4.4.1/src/nfa/mcsheng_dump.h0000644000175000017500000000361313055426554020457 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 MCSHENG_DUMP_H #define MCSHENG_DUMP_H #ifdef DUMP_SUPPORT #include "rdfa.h" #include #include struct NFA; namespace ue2 { void nfaExecMcSheng8_dump(const struct NFA *nfa, const std::string &base); void nfaExecMcSheng16_dump(const struct NFA *nfa, const std::string &base); } // namespace ue2 #endif // DUMP_SUPPORT #endif // MCSHENG_DUMP_H hyperscan-4.4.1/src/nfa/repeat.c0000644000175000017500000014662113055426554017270 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ /** \file * \brief API for handling bounded repeats. * * This file provides an internal API for handling bounded repeats of character * classes. It is used by the Large Bounded Repeat (LBR) engine and by the * bounded repeat handling in the LimEx NFA engine as well. */ #include "repeat.h" #include "util/bitutils.h" #include "util/multibit.h" #include "util/pack_bits.h" #include "util/partial_store.h" #include "util/unaligned.h" #include #include /** \brief Returns the total capacity of the ring. * Note that it's currently one greater than repeatMax so that we can handle * cases where the tug and pos triggers overlap. */ static u32 ringCapacity(const struct RepeatInfo *info) { return info->repeatMax + 1; } /** \brief Returns the number of elements currently in the ring. Note that if * the first and last indices are equal, the ring is full. */ static u32 ringOccupancy(const struct RepeatRingControl *xs, const u32 ringSize) { if (xs->last > xs->first) { return xs->last - xs->first; } else { // wrapped return ringSize - (xs->first - xs->last); } } /** \brief Returns the offset of the _last_ top stored in the ring. */ static u64a ringLastTop(const struct RepeatRingControl *xs, const u32 ringSize) { return xs->offset + ringOccupancy(xs, ringSize) - 1; } #if !defined(NDEBUG) || defined(DUMP_SUPPORT) /** \brief For debugging: returns the total capacity of the range list. */ static UNUSED u32 rangeListCapacity(const struct RepeatInfo *info) { u32 d = info->repeatMax - info->repeatMin; assert(d > 0); // should be in a RING model! return 2 * ((info->repeatMax / d) + 1); } #endif #ifdef DEBUG static void dumpRing(const struct RepeatInfo *info, const struct RepeatRingControl *xs, const u8 *ring) { const u32 ringSize = ringCapacity(info); DEBUG_PRINTF("ring (occ %u/%u, %u->%u): ", ringOccupancy(xs, ringSize), ringSize, xs->first, xs->last); u16 i = xs->first, n = 0; do { if (mmbit_isset(ring, ringSize, i)) { u64a ringOffset = xs->offset + n; printf("%llu ", ringOffset); } ++i, ++n; if (i == ringSize) { i = 0; } } while (i != xs->last); printf("\n"); } static void dumpRange(const struct RepeatInfo *info, const struct RepeatRangeControl *xs, const u16 *ring) { const u32 ringSize = rangeListCapacity(info); DEBUG_PRINTF("ring (occ %u/%u): ", xs->num, ringSize); if (xs->num) { for (u32 i = 0; i < xs->num; i++) { printf("%llu ", xs->offset + unaligned_load_u16(ring + i)); } } else { printf("empty"); } printf("\n"); } static void dumpBitmap(const struct RepeatBitmapControl *xs) { DEBUG_PRINTF("bitmap (base=%llu): ", xs->offset); u64a bitmap = xs->bitmap; while (bitmap) { printf("%llu ", xs->offset + findAndClearLSB_64(&bitmap)); } printf("\n"); } static void dumpTrailer(const struct RepeatInfo *info, const struct RepeatTrailerControl *xs) { const u64a m_width = info->repeatMax - info->repeatMin; DEBUG_PRINTF("trailer: current extent is [%llu,%llu]", xs->offset, xs->offset + m_width); u64a bitmap = xs->bitmap; if (bitmap) { printf(", also matches at: "); while (bitmap) { u32 idx = findAndClearMSB_64(&bitmap); printf("%llu ", xs->offset - idx - 1); } } else { printf(", no earlier matches"); } printf("\n"); } #endif // DEBUG #ifndef NDEBUG /** \brief For debugging: returns true if the range is ordered with no dupes. */ static UNUSED int rangeListIsOrdered(const struct RepeatRangeControl *xs, const u16 *ring) { for (u32 i = 1; i < xs->num; i++) { u16 a = unaligned_load_u16(ring + i - 1); u16 b = unaligned_load_u16(ring + i); if (a >= b) { return 0; } } return 1; } #endif u64a repeatLastTopRing(const struct RepeatInfo *info, const union RepeatControl *ctrl) { const u32 ringSize = ringCapacity(info); return ringLastTop(&ctrl->ring, ringSize); } u64a repeatLastTopRange(const union RepeatControl *ctrl, const void *state) { const u16 *ring = (const u16 *)state; const struct RepeatRangeControl *xs = &ctrl->range; assert(xs->num); return xs->offset + unaligned_load_u16(ring + xs->num - 1); } u64a repeatLastTopBitmap(const union RepeatControl *ctrl) { const struct RepeatBitmapControl *xs = &ctrl->bitmap; if (!xs->bitmap) { /* last top was too long ago */ return 0; } return xs->offset + 63 - clz64(xs->bitmap); } u64a repeatLastTopTrailer(const struct RepeatInfo *info, const union RepeatControl *ctrl) { const struct RepeatTrailerControl *xs = &ctrl->trailer; assert(xs->offset >= info->repeatMin); return xs->offset - info->repeatMin; } u64a repeatNextMatchRing(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset) { const struct RepeatRingControl *xs = &ctrl->ring; const u8 *ring = (const u8 *)state; const u32 ringSize = ringCapacity(info); // We should have at least one top stored. assert(mmbit_any(ring, ringSize)); assert(info->repeatMax < REPEAT_INF); // Increment offset, as we want the NEXT match. offset++; const u64a base_offset = xs->offset; DEBUG_PRINTF("offset=%llu, base_offset=%llu\n", offset, base_offset); u64a delta = offset - base_offset; if (offset < base_offset || delta < info->repeatMin) { DEBUG_PRINTF("before min repeat\n"); return base_offset + info->repeatMin; } if (offset > ringLastTop(xs, ringSize) + info->repeatMax) { DEBUG_PRINTF("ring is stale\n"); return 0; // no more matches } DEBUG_PRINTF("delta=%llu\n", delta); u64a lower = delta > info->repeatMax ? delta - info->repeatMax : 0; DEBUG_PRINTF("lower=%llu\n", lower); assert(lower < ringSize); // First scan, either to xs->last if there's no wrap-around or ringSize // (end of the underlying multibit) if we are wrapping. u32 begin = xs->first + lower; if (begin >= ringSize) { // This branch and sub tested a lot faster than using % (integer div). begin -= ringSize; } const u32 end = begin >= xs->last ? ringSize : xs->last; u32 i = mmbit_iterate_bounded(ring, ringSize, begin, end); if (i != MMB_INVALID) { u32 j = i - begin + lower; return MAX(offset, base_offset + j + info->repeatMin); } // A second scan is necessary if we need to cope with wrap-around in the // ring buffer. if (begin >= xs->last) { i = mmbit_iterate_bounded(ring, ringSize, 0, xs->last); if (i != MMB_INVALID) { u32 j = i + (ringSize - begin) + lower; return MAX(offset, base_offset + j + info->repeatMin); } } return 0; } u64a repeatNextMatchRange(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset) { const struct RepeatRangeControl *xs = &ctrl->range; const u16 *ring = (const u16 *)state; assert(xs->num > 0); assert(xs->num <= rangeListCapacity(info)); assert(rangeListIsOrdered(xs, ring)); assert(info->repeatMax < REPEAT_INF); for (u32 i = 0; i < xs->num; i++) { u64a base = xs->offset + unaligned_load_u16(ring + i); u64a first = base + info->repeatMin; if (offset < first) { return first; } if (offset < base + info->repeatMax) { return offset + 1; } } return 0; } u64a repeatNextMatchBitmap(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatBitmapControl *xs = &ctrl->bitmap; const u64a base = xs->offset; u64a bitmap = xs->bitmap; // FIXME: quick exit if there is no match, based on last top in bitmap? while (bitmap) { u64a top = base + findAndClearLSB_64(&bitmap); if (offset < top + info->repeatMin) { return top + info->repeatMin; } if (offset < top + info->repeatMax) { return offset + 1; } } return 0; // No more matches. } u64a repeatNextMatchTrailer(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatTrailerControl *xs = &ctrl->trailer; const u32 m_width = info->repeatMax - info->repeatMin; DEBUG_PRINTF("offset=%llu, xs->offset=%llu\n", offset, xs->offset); DEBUG_PRINTF("{%u,%u} repeat, m_width=%u\n", info->repeatMin, info->repeatMax, m_width); assert(xs->offset >= info->repeatMin); if (offset >= xs->offset + m_width) { DEBUG_PRINTF("no more matches\n"); return 0; } if (offset >= xs->offset) { DEBUG_PRINTF("inside most recent match window, next match %llu\n", offset + 1); return offset + 1; } // Offset is before the match window, we need to consult the bitmap of // earlier match offsets. u64a bitmap = xs->bitmap; u64a diff = xs->offset - offset; DEBUG_PRINTF("diff=%llu\n", diff); if (diff <= 64) { assert(diff); bitmap &= (1ULL << (diff - 1)) - 1; } DEBUG_PRINTF("bitmap = 0x%llx\n", bitmap); if (bitmap) { u32 idx = 63 - clz64(bitmap); DEBUG_PRINTF("clz=%u, idx = %u -> offset %llu\n", clz64(bitmap), idx, xs->offset - idx); DEBUG_PRINTF("next match at %llu\n", xs->offset - idx - 1); u64a next_match = xs->offset - idx - 1; assert(next_match > offset); return next_match; } DEBUG_PRINTF("next match is start of match window, %llu\n", xs->offset); return xs->offset; } /** \brief Store the first top in the ring buffer. */ static void storeInitialRingTop(struct RepeatRingControl *xs, u8 *ring, u64a offset, const u32 ringSize) { DEBUG_PRINTF("ring=%p, ringSize=%u\n", ring, ringSize); xs->offset = offset; mmbit_clear(ring, ringSize); mmbit_set(ring, ringSize, 0); xs->first = 0; xs->last = 1; } static really_inline char ringIsStale(const struct RepeatRingControl *xs, const u32 ringSize, const u64a offset) { u64a finalMatch = ringLastTop(xs, ringSize); if (offset - finalMatch >= ringSize) { DEBUG_PRINTF("all matches in ring are stale\n"); return 1; } return 0; } void repeatStoreRing(const struct RepeatInfo *info, union RepeatControl *ctrl, void *state, u64a offset, char is_alive) { struct RepeatRingControl *xs = &ctrl->ring; u8 *ring = (u8 *)state; const u32 ringSize = ringCapacity(info); assert(ringSize > 0); DEBUG_PRINTF("storing top for offset %llu in ring\n", offset); if (!is_alive || ringIsStale(xs, ringSize, offset)) { storeInitialRingTop(xs, ring, offset, ringSize); } else { assert(offset > ringLastTop(xs, ringSize)); // Dupe or out of order. u32 occ = ringOccupancy(xs, ringSize); u64a diff = offset - xs->offset; DEBUG_PRINTF("diff=%llu, occ=%u\n", diff, occ); if (diff >= ringSize) { u32 push = diff - ringSize + 1; DEBUG_PRINTF("push ring %u\n", push); xs->first += push; if (xs->first >= ringSize) { xs->first -= ringSize; } xs->offset += push; diff -= push; occ -= push; } // There's now room in the ring for this top, so we write a run of // zeroes, then a one. DEBUG_PRINTF("diff=%llu, occ=%u\n", diff, occ); assert(diff < ringSize); assert(diff >= occ); u32 n = diff - occ; u32 i = xs->last + n; mmbit_unset_range(ring, ringSize, xs->last, MIN(i, ringSize)); if (i >= ringSize) { i -= ringSize; mmbit_unset_range(ring, ringSize, 0, i); } assert(i != xs->first); DEBUG_PRINTF("set bit %u\n", i); mmbit_set(ring, ringSize, i); xs->last = i + 1; if (xs->last == ringSize) { xs->last = 0; } } // Our ring indices shouldn't have spiraled off into uncharted space. assert(xs->first < ringSize); assert(xs->last < ringSize); #ifdef DEBUG DEBUG_PRINTF("post-store ring state\n"); dumpRing(info, xs, ring); #endif // The final top stored in our ring should be the one we just wrote in. assert(ringLastTop(xs, ringSize) == offset); } static really_inline void storeInitialRangeTop(struct RepeatRangeControl *xs, u16 *ring, u64a offset) { xs->offset = offset; xs->num = 1; unaligned_store_u16(ring, 0); } void repeatStoreRange(const struct RepeatInfo *info, union RepeatControl *ctrl, void *state, u64a offset, char is_alive) { struct RepeatRangeControl *xs = &ctrl->range; u16 *ring = (u16 *)state; if (!is_alive) { DEBUG_PRINTF("storing initial top at %llu\n", offset); storeInitialRangeTop(xs, ring, offset); return; } DEBUG_PRINTF("storing top at %llu, list currently has %u/%u elements\n", offset, xs->num, rangeListCapacity(info)); #ifdef DEBUG dumpRange(info, xs, ring); #endif // Walk ring from front. Identify the number of stale elements, and shift // the whole ring to delete them. u32 i = 0; for (; i < xs->num; i++) { u64a this_offset = xs->offset + unaligned_load_u16(ring + i); DEBUG_PRINTF("this_offset=%llu, diff=%llu\n", this_offset, offset - this_offset); if (offset - this_offset <= info->repeatMax) { break; } } if (i == xs->num) { DEBUG_PRINTF("whole ring is stale\n"); storeInitialRangeTop(xs, ring, offset); return; } else if (i > 0) { DEBUG_PRINTF("expiring %u stale tops\n", i); u16 first_offset = unaligned_load_u16(ring + i); // first live top for (u32 j = 0; j < xs->num - i; j++) { u16 val = unaligned_load_u16(ring + i + j); assert(val >= first_offset); unaligned_store_u16(ring + j, val - first_offset); } xs->offset += first_offset; xs->num -= i; } #ifdef DEBUG DEBUG_PRINTF("post-expire:\n"); dumpRange(info, xs, ring); #endif if (xs->num == 1) { goto append; } // Let d = repeatMax - repeatMin // Examine penultimate entry x[-2]. // If (offset - x[-2] <= d), then last entry x[-1] can be replaced with // entry for offset. assert(xs->num >= 2); u32 d = info->repeatMax - info->repeatMin; u64a penultimate_offset = xs->offset + unaligned_load_u16(ring + xs->num - 2); if (offset - penultimate_offset <= d) { assert(offset - xs->offset <= (u16)-1); unaligned_store_u16(ring + xs->num - 1, offset - xs->offset); goto done; } // Otherwise, write a new entry for offset and return. append: assert(offset - xs->offset <= (u16)-1); assert(xs->num < rangeListCapacity(info)); unaligned_store_u16(ring + xs->num, offset - xs->offset); xs->num++; done: assert(rangeListIsOrdered(xs, ring)); } void repeatStoreBitmap(const struct RepeatInfo *info, union RepeatControl *ctrl, u64a offset, char is_alive) { DEBUG_PRINTF("{%u,%u} repeat, storing top at %llu\n", info->repeatMin, info->repeatMax, offset); struct RepeatBitmapControl *xs = &ctrl->bitmap; if (!is_alive || !xs->bitmap) { DEBUG_PRINTF("storing initial top at %llu\n", offset); xs->offset = offset; xs->bitmap = 1U; return; } #ifdef DEBUG DEBUG_PRINTF("pre-store:\n"); dumpBitmap(xs); #endif assert(offset >= xs->offset); u64a last_top = xs->offset + 63 - clz64(xs->bitmap); if (offset > last_top + info->repeatMax) { DEBUG_PRINTF("bitmap stale, storing initial top\n"); xs->offset = offset; xs->bitmap = 1U; return; } u64a diff = offset - xs->offset; if (diff >= info->repeatMax + 1) { DEBUG_PRINTF("need expire, diff=%llu\n", diff); u64a push = diff - info->repeatMax; xs->offset += push; xs->bitmap = push >= 64 ? 0 : xs->bitmap >> push; DEBUG_PRINTF("pushed xs->offset to %llu\n", xs->offset); } // Write a new entry. diff = offset - xs->offset; assert(diff < 64); xs->bitmap |= (1ULL << diff); #ifdef DEBUG DEBUG_PRINTF("post-store:\n"); dumpBitmap(xs); #endif } /** \brief Returns 1 if the ring has a match between (logical) index \a lower * and \a upper, excluding \a upper. */ static int ringHasMatch(const struct RepeatRingControl *xs, const u8 *ring, const u32 ringSize, u32 lower, u32 upper) { assert(lower < upper); assert(lower < ringSize); assert(upper <= ringSize); u32 i = xs->first + lower; if (i >= ringSize) { i -= ringSize; } // Performance tweak: if we're looking at a fixed repeat, we can just use // mmbit_isset. if (lower + 1 == upper) { return mmbit_isset(ring, ringSize, i); } u32 end = xs->first + upper; if (end >= ringSize) { end -= ringSize; } // First scan, either to end if there's no wrap-around or ringSize (end of // the underlying multibit) if we are wrapping. u32 scan_end = i < end ? end : ringSize; u32 m = mmbit_iterate_bounded(ring, ringSize, i, scan_end); if (m != MMB_INVALID) { return 1; } // A second scan is necessary if we need to cope with wrap-around in the // ring buffer. if (i >= end) { m = mmbit_iterate_bounded(ring, ringSize, 0, end); return m != MMB_INVALID; } return 0; } /** Return a mask of ones in bit positions [0..v]. */ static really_inline u64a mask_ones_to(u32 v) { if (v < 63) { return (1ULL << (v + 1)) - 1; } else { return ~(0ULL); } } void repeatStoreTrailer(const struct RepeatInfo *info, union RepeatControl *ctrl, u64a offset, char is_alive) { DEBUG_PRINTF("{%u,%u} repeat, top at %llu\n", info->repeatMin, info->repeatMax, offset); struct RepeatTrailerControl *xs = &ctrl->trailer; /* The TRAILER repeat model stores the following data in its control block: * * 1. offset, which is the min extent of the most recent match window * (i.e. corresponding to the most recent top) * 2. bitmap, which is a bitmap of up to repeatMin matches before * the min extent offset. */ const u64a next_extent = offset + info->repeatMin; if (!is_alive) { xs->offset = next_extent; xs->bitmap = 0; DEBUG_PRINTF("initial top, set extent to %llu\n", next_extent); return; } #ifdef DEBUG DEBUG_PRINTF("pre-store:\n"); dumpTrailer(info, xs); #endif const u32 m_width = info->repeatMax - info->repeatMin; DEBUG_PRINTF("most recent match window is [%llu,%llu]\n", xs->offset, xs->offset + m_width); assert(next_extent > xs->offset); u64a diff = next_extent - xs->offset; DEBUG_PRINTF("diff=%llu, m_width=%u\n", diff, m_width); assert(diff); xs->bitmap = diff < 64 ? xs->bitmap << diff : 0; // Switch on bits in the bitmask corresponding to matches in the previous // match window. if (diff <= m_width) { u64a m = mask_ones_to(diff - 1); xs->bitmap |= m; } else { u64a shift = diff - m_width - 1; if (shift < 64) { u64a m = mask_ones_to(m_width); m <<= shift; xs->bitmap |= m; } } DEBUG_PRINTF("bitmap=0x%llx\n", xs->bitmap); // Update max extent. xs->offset = next_extent; // Trim stale history: we only need repeatMin bytes of history. if (info->repeatMin < 63) { u64a mask = (1ULL << (info->repeatMin + 1)) - 1; xs->bitmap &= mask; } #ifdef DEBUG DEBUG_PRINTF("post-store:\n"); dumpTrailer(info, xs); #endif } enum RepeatMatch repeatHasMatchRing(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset) { const struct RepeatRingControl *xs = &ctrl->ring; const u8 *ring = (const u8 *)state; const u32 ringSize = ringCapacity(info); assert(mmbit_any(ring, ringSize)); assert(offset >= xs->offset); DEBUG_PRINTF("check: offset=%llu, repeat=[%u,%u]\n", offset, info->repeatMin, info->repeatMax); #ifdef DEBUG DEBUG_PRINTF("ring state\n"); dumpRing(info, xs, ring); #endif if (offset - xs->offset < info->repeatMin) { DEBUG_PRINTF("haven't even seen repeatMin bytes yet!\n"); return REPEAT_NOMATCH; } if (offset - ringLastTop(xs, ringSize) >= ringSize) { DEBUG_PRINTF("ring is stale\n"); return REPEAT_STALE; } // If we're not stale, delta fits in the range [repeatMin, lastTop + // repeatMax], which fits in a u32. assert(offset - xs->offset < UINT32_MAX); u32 delta = (u32)(offset - xs->offset); DEBUG_PRINTF("delta=%u\n", delta); // Find the bounds on possible matches in the ring buffer. u32 lower = delta > info->repeatMax ? delta - info->repeatMax : 0; u32 upper = MIN(delta - info->repeatMin + 1, ringOccupancy(xs, ringSize)); if (lower >= upper) { DEBUG_PRINTF("no matches to check\n"); return REPEAT_NOMATCH; } DEBUG_PRINTF("possible match indices=[%u,%u]\n", lower, upper); if (ringHasMatch(xs, ring, ringSize, lower, upper)) { return REPEAT_MATCH; } return REPEAT_NOMATCH; } enum RepeatMatch repeatHasMatchRange(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset) { const struct RepeatRangeControl *xs = &ctrl->range; const u16 *ring = (const u16 *)state; assert(xs->num > 0); assert(xs->num <= rangeListCapacity(info)); assert(rangeListIsOrdered(xs, ring)); // Walk the ring. For each entry x: // if (offset - x) falls inside repeat bounds, return success. // It may be worth doing tests on first and last elements first to bail // early if the whole ring is too young or stale. DEBUG_PRINTF("check %u (of %u) elements, offset %llu, bounds={%u,%u}\n", xs->num, rangeListCapacity(info), offset, info->repeatMin, info->repeatMax); #ifdef DEBUG dumpRange(info, xs, ring); #endif // Quick pre-check for minimum. assert(offset >= xs->offset); if (offset - xs->offset < info->repeatMin) { DEBUG_PRINTF("haven't even seen repeatMin bytes yet!\n"); return REPEAT_NOMATCH; } // We check the most recent offset first, as we can establish staleness. u64a match = xs->offset + unaligned_load_u16(ring + xs->num - 1); assert(offset >= match); u64a diff = offset - match; if (diff > info->repeatMax) { DEBUG_PRINTF("range list is stale\n"); return REPEAT_STALE; } else if (diff >= info->repeatMin && diff <= info->repeatMax) { return REPEAT_MATCH; } // Check the other offsets in the list. u32 count = xs->num - 1; for (u32 i = 0; i < count; i++) { match = xs->offset + unaligned_load_u16(ring + i); assert(offset >= match); diff = offset - match; if (diff >= info->repeatMin && diff <= info->repeatMax) { return REPEAT_MATCH; } } return REPEAT_NOMATCH; } enum RepeatMatch repeatHasMatchBitmap(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatBitmapControl *xs = &ctrl->bitmap; DEBUG_PRINTF("checking if offset=%llu is a match\n", offset); #ifdef DEBUG dumpBitmap(xs); #endif u64a bitmap = xs->bitmap; if (!bitmap) { DEBUG_PRINTF("no tops; stale\n"); return REPEAT_STALE; } // Quick pre-check for minimum. const u64a base = xs->offset; assert(offset >= base); if (offset - base < info->repeatMin) { DEBUG_PRINTF("haven't even seen repeatMin bytes yet!\n"); return REPEAT_NOMATCH; } // We check the most recent offset first, as we can establish staleness. u64a match = base + findAndClearMSB_64(&bitmap); DEBUG_PRINTF("offset=%llu, last_match %llu\n", offset, match); assert(offset >= match); u64a diff = offset - match; if (diff > info->repeatMax) { DEBUG_PRINTF("stale\n"); return REPEAT_STALE; } else if (diff >= info->repeatMin && diff <= info->repeatMax) { return REPEAT_MATCH; } while (bitmap) { match = base + findAndClearLSB_64(&bitmap); DEBUG_PRINTF("offset=%llu, last_match %llu\n", offset, match); assert(offset >= match); diff = offset - match; if (diff >= info->repeatMin && diff <= info->repeatMax) { return REPEAT_MATCH; } } return REPEAT_NOMATCH; } enum RepeatMatch repeatHasMatchTrailer(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatTrailerControl *xs = &ctrl->trailer; const u32 m_width = info->repeatMax - info->repeatMin; DEBUG_PRINTF("offset=%llu, xs->offset=%llu, xs->bitmap=0x%llx\n", offset, xs->offset, xs->bitmap); if (offset > xs->offset + m_width) { DEBUG_PRINTF("stale\n"); return REPEAT_STALE; } if (offset >= xs->offset) { DEBUG_PRINTF("in match window\n"); return REPEAT_MATCH; } if (offset >= xs->offset - info->repeatMin) { u32 idx = xs->offset - offset - 1; DEBUG_PRINTF("check bitmap idx %u\n", idx); assert(idx < 64); if (xs->bitmap & (1ULL << idx)) { DEBUG_PRINTF("match in bitmap\n"); return REPEAT_MATCH; } } DEBUG_PRINTF("no match\n"); return REPEAT_NOMATCH; } /** \brief True if the given value can be packed into len bytes. */ static really_inline int fits_in_len_bytes(u64a val, u32 len) { if (len >= 8) { return 1; } return val <= (1ULL << (len * 8)); } static really_inline void storePackedRelative(char *dest, u64a val, u64a offset, u64a max, u32 len) { assert(val <= offset); assert(fits_in_len_bytes(max, len)); u64a delta = offset - val; if (delta >= max) { delta = max; } DEBUG_PRINTF("delta %llu\n", delta); assert(fits_in_len_bytes(delta, len)); partial_store_u64a(dest, delta, len); } static void repeatPackRing(char *dest, const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatRingControl *xs = &ctrl->ring; const u32 ring_indices_len = info->repeatMax < 254 ? 2 : 4; const u32 offset_len = info->packedCtrlSize - ring_indices_len; // Write out packed relative base offset. assert(info->packedCtrlSize > ring_indices_len); storePackedRelative(dest, xs->offset, offset, info->horizon, offset_len); // Write out ring indices. if (ring_indices_len == 4) { unaligned_store_u16(dest + offset_len, xs->first); unaligned_store_u16(dest + offset_len + 2, xs->last); } else { assert(xs->first < 256 && xs->last < 256); u8 *indices = (u8 *)dest + offset_len; indices[0] = xs->first; indices[1] = xs->last; } } static void repeatPackOffset(char *dest, const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatOffsetControl *xs = &ctrl->offset; DEBUG_PRINTF("packing offset %llu [h %u]\n", xs->offset, info->horizon); if (!info->packedCtrlSize) { assert(info->type == REPEAT_ALWAYS); DEBUG_PRINTF("externally guarded .*\n"); return; } storePackedRelative(dest, xs->offset, offset, info->horizon, info->packedCtrlSize); } static void repeatPackRange(char *dest, const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatRangeControl *xs = &ctrl->range; // Write out packed relative base offset. assert(info->packedCtrlSize > 1); storePackedRelative(dest, xs->offset, offset, info->horizon, info->packedCtrlSize - 1); // Write out range number of elements. dest[info->packedCtrlSize - 1] = xs->num; } static void repeatPackBitmap(char *dest, const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatBitmapControl *xs = &ctrl->bitmap; const u32 bound = info->repeatMax; assert(offset >= xs->offset); u64a new_base = offset > bound ? offset - bound : 0; // Shift bitmap to begin at new_base rather than xs->offset. u64a bitmap = xs->bitmap; if (new_base >= xs->offset) { u64a shift = new_base - xs->offset; bitmap = shift < 64 ? bitmap >> shift : 0; } else { u64a shift = xs->offset - new_base; bitmap = shift < 64 ? bitmap << shift : 0; } DEBUG_PRINTF("packing %llu into %u bytes\n", bitmap, info->packedCtrlSize); // Write out packed bitmap. assert(fits_in_len_bytes(bitmap, info->packedCtrlSize)); partial_store_u64a(dest, bitmap, info->packedCtrlSize); } static void repeatPackSparseOptimalP(char *dest, const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatRingControl *xs = &ctrl->ring; // set ring index pointer according to patch count const u32 ring_indices_len = info->patchCount < 254 ? 2 : 4; const u32 offset_len = info->packedCtrlSize - ring_indices_len; // Write out packed relative base offset. assert(info->packedCtrlSize > ring_indices_len); storePackedRelative(dest, xs->offset, offset, info->horizon, offset_len); // Write out ring indices. if (ring_indices_len == 4) { unaligned_store_u16(dest + offset_len, xs->first); unaligned_store_u16(dest + offset_len + 2, xs->last); } else { assert(xs->first < 256 && xs->last < 256); u8 *indices = (u8 *)dest + offset_len; indices[0] = xs->first; indices[1] = xs->last; } } static void repeatPackTrailer(char *dest, const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { const struct RepeatTrailerControl *xs = &ctrl->trailer; DEBUG_PRINTF("saving: offset=%llu, xs->offset=%llu, xs->bitmap=0x%llx\n", offset, xs->offset, xs->bitmap); // XXX: xs->offset may be zero in the NFA path (effectively uninitialized). u64a top; if (xs->offset) { assert(xs->offset >= info->repeatMin); top = xs->offset - info->repeatMin; } else { top = 0; } top = offset - top; // Pack top relative to offset. u64a v[2]; v[0] = MIN(top, info->horizon); v[1] = xs->bitmap; pack_bits_64(dest, v, info->packedFieldSizes, 2); } void repeatPack(char *dest, const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { assert(dest && info && ctrl); switch ((enum RepeatType)info->type) { case REPEAT_RING: repeatPackRing(dest, info, ctrl, offset); break; case REPEAT_FIRST: case REPEAT_LAST: repeatPackOffset(dest, info, ctrl, offset); break; case REPEAT_RANGE: repeatPackRange(dest, info, ctrl, offset); break; case REPEAT_BITMAP: repeatPackBitmap(dest, info, ctrl, offset); break; case REPEAT_SPARSE_OPTIMAL_P: repeatPackSparseOptimalP(dest, info, ctrl, offset); break; case REPEAT_TRAILER: repeatPackTrailer(dest, info, ctrl, offset); break; case REPEAT_ALWAYS: /* nothing to do - no state */ break; } } static really_inline u64a loadPackedRelative(const char *src, u64a offset, u32 len) { u64a delta = partial_load_u64a(src, len); DEBUG_PRINTF("delta %llu\n", delta); assert(offset >= delta); return offset - delta; } static void repeatUnpackRing(const char *src, const struct RepeatInfo *info, u64a offset, union RepeatControl *ctrl) { struct RepeatRingControl *xs = &ctrl->ring; const u32 ring_indices_len = info->repeatMax < 254 ? 2 : 4; const u32 offset_len = info->packedCtrlSize - ring_indices_len; xs->offset = loadPackedRelative(src, offset, offset_len); if (ring_indices_len == 4) { xs->first = unaligned_load_u16(src + offset_len); xs->last = unaligned_load_u16(src + offset_len + 2); } else { const u8 *indices = (const u8 *)src + offset_len; xs->first = indices[0]; xs->last = indices[1]; } } static void repeatUnpackOffset(const char *src, const struct RepeatInfo *info, u64a offset, union RepeatControl *ctrl) { struct RepeatOffsetControl *xs = &ctrl->offset; if (!info->packedCtrlSize) { assert(info->type == REPEAT_ALWAYS); DEBUG_PRINTF("externally guarded .*\n"); xs->offset = 0; } else { xs->offset = loadPackedRelative(src, offset, info->packedCtrlSize); } DEBUG_PRINTF("unpacking offset %llu [h%u]\n", xs->offset, info->horizon); } static void repeatUnpackRange(const char *src, const struct RepeatInfo *info, u64a offset, union RepeatControl *ctrl) { struct RepeatRangeControl *xs = &ctrl->range; xs->offset = loadPackedRelative(src, offset, info->packedCtrlSize - 1); xs->num = src[info->packedCtrlSize - 1]; } static void repeatUnpackBitmap(const char *src, const struct RepeatInfo *info, u64a offset, union RepeatControl *ctrl) { struct RepeatBitmapControl *xs = &ctrl->bitmap; xs->offset = offset > info->repeatMax ? offset - info->repeatMax : 0; xs->bitmap = partial_load_u64a(src, info->packedCtrlSize); } static void repeatUnpackSparseOptimalP(const char *src, const struct RepeatInfo *info, u64a offset, union RepeatControl *ctrl) { struct RepeatRingControl *xs = &ctrl->ring; const u32 ring_indices_len = info->patchCount < 254 ? 2 : 4; const u32 offset_len = info->packedCtrlSize - ring_indices_len; xs->offset = loadPackedRelative(src, offset, offset_len); if (ring_indices_len == 4) { xs->first = unaligned_load_u16(src + offset_len); xs->last = unaligned_load_u16(src + offset_len + 2); } else { const u8 *indices = (const u8 *)src + offset_len; xs->first = indices[0]; xs->last = indices[1]; } } static void repeatUnpackTrailer(const char *src, const struct RepeatInfo *info, u64a offset, union RepeatControl *ctrl) { struct RepeatTrailerControl *xs = &ctrl->trailer; u64a v[2]; unpack_bits_64(v, (const u8 *)src, info->packedFieldSizes, 2); xs->offset = offset - v[0] + info->repeatMin; xs->bitmap = v[1]; DEBUG_PRINTF("loaded: xs->offset=%llu, xs->bitmap=0x%llx\n", xs->offset, xs->bitmap); } void repeatUnpack(const char *src, const struct RepeatInfo *info, u64a offset, union RepeatControl *ctrl) { assert(src && info && ctrl); switch ((enum RepeatType)info->type) { case REPEAT_RING: repeatUnpackRing(src, info, offset, ctrl); break; case REPEAT_FIRST: case REPEAT_LAST: repeatUnpackOffset(src, info, offset, ctrl); break; case REPEAT_RANGE: repeatUnpackRange(src, info, offset, ctrl); break; case REPEAT_BITMAP: repeatUnpackBitmap(src, info, offset, ctrl); break; case REPEAT_SPARSE_OPTIMAL_P: repeatUnpackSparseOptimalP(src, info, offset, ctrl); break; case REPEAT_TRAILER: repeatUnpackTrailer(src, info, offset, ctrl); break; case REPEAT_ALWAYS: /* nothing to do - no state */ break; } } static really_inline const u64a *getImplTable(const struct RepeatInfo *info) { const u64a *table = ((const u64a *)(ROUNDUP_PTR( ((const char *)(info) + sizeof(*info)), alignof(u64a)))); return table; } static void storeInitialRingTopPatch(const struct RepeatInfo *info, struct RepeatRingControl *xs, u8 *state, u64a offset) { DEBUG_PRINTF("set the first patch, offset=%llu\n", offset); xs->offset = offset; u8 *active = state; u32 patch_count = info->patchCount; mmbit_clear(active, patch_count); mmbit_set(active, patch_count, 0); u8 *ring = active + info->patchesOffset; u32 encoding_size = info->encodingSize; partial_store_u64a(ring, 1ull, encoding_size); xs->first = 0; xs->last = 1; } static u32 getSparseOptimalTargetValue(const struct RepeatInfo *info, const u32 tval, u64a *val) { u32 patch_size = info->patchSize; const u64a *repeatTable = getImplTable(info); u32 loc = 0; DEBUG_PRINTF("val:%llu \n", *val); for (u32 i = 1; i <= patch_size - tval; i++) { u64a tmp = repeatTable[patch_size - i]; if (*val >= tmp) { *val -= tmp; loc = i; i += (info->minPeriod - 1); } } return loc; } static u64a sparseLastTop(const struct RepeatInfo *info, const struct RepeatRingControl *xs, const u8 *state) { DEBUG_PRINTF("looking for last top\n"); u32 patch_size = info->patchSize; u32 patch_count = info->patchCount; u32 encoding_size = info->encodingSize; u32 occ = ringOccupancy(xs, patch_count); u32 patch = xs->first + occ - 1; if (patch >= patch_count) { patch -= patch_count; } DEBUG_PRINTF("patch%u encoding_size%u occ%u\n", patch, encoding_size, occ); const u8 *ring = state + info->patchesOffset; u64a val = partial_load_u64a(ring + encoding_size * patch, encoding_size); DEBUG_PRINTF("val:%llu\n", val); const u64a *repeatTable = getImplTable(info); for (s32 i = patch_size - 1; i >= 0; i--) { if (val >= repeatTable[i]) { DEBUG_PRINTF("xs->offset%llu v%u p%llu\n", xs->offset, i, repeatTable[i]); return xs->offset + i + (occ - 1) * patch_size; } } assert(0); return 0; } u64a repeatLastTopSparseOptimalP(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state) { return sparseLastTop(info, &ctrl->ring, state); } u64a repeatNextMatchSparseOptimalP(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset) { const struct RepeatRingControl *xs = &ctrl->ring; DEBUG_PRINTF("repeat [%u, %u] looking for match after %llu\n", info->repeatMin, info->repeatMax, offset); assert(offset >= xs->offset); u64a nextOffset = offset + 1; u32 patch_size = info->patchSize; u32 patch; u32 tval; if (nextOffset <= xs->offset + info->repeatMin) { patch = xs->first; tval = 0; } else if (nextOffset > sparseLastTop(info, xs, state) + info->repeatMax) { DEBUG_PRINTF("ring is stale\n"); return 0; } else { assert(nextOffset - xs->offset < UINT32_MAX); // ring is not stale u32 delta = (u32)(nextOffset - xs->offset); u32 lower = delta > info->repeatMax ? delta - info->repeatMax : 0; patch = lower / patch_size; tval = lower - patch * patch_size; } DEBUG_PRINTF("patch %u\n", patch); u32 patch_count = info->patchCount; if (patch >= patch_count) { return 0; } DEBUG_PRINTF("initial test for %u\n", tval); u32 begin = xs->first + patch; if (begin >= patch_count) { begin -= patch_count; } const u8 *active = (const u8 *)state; const u8 *ring = active + info->patchesOffset; u32 encoding_size = info->encodingSize; const u32 end = begin >= xs->last ? patch_count : xs->last; u32 low = tval; u64a diff = 0, loc = 0; DEBUG_PRINTF("begin %u end %u\n", begin, end); for (u32 p = mmbit_iterate_bounded(active, patch_count, begin, end); p != MMB_INVALID; p = mmbit_iterate_bounded(active, patch_count, p + 1, end)) { if (p != begin) { low = 0; } u64a val = partial_load_u64a(ring + encoding_size * p, encoding_size); u32 p1 = 0; if (p >= xs->first) { p1 = p - xs->first; } else { p1 = p + patch_count - xs->first; } if (val) { loc = getSparseOptimalTargetValue(info, low, &val); diff = (p1 + 1) * patch_size - loc; } if (loc) { u64a rv = MAX(nextOffset, xs->offset + info->repeatMin + diff); DEBUG_PRINTF("offset%llu next match at %llu\n", xs->offset, rv); return rv; } low = 0; } low = 0; if (begin >= xs->last) { for (u32 p = mmbit_iterate_bounded(active, patch_count, 0, xs->last); p != MMB_INVALID; p = mmbit_iterate_bounded(active, patch_count, p + 1, xs->last)) { u64a val = partial_load_u64a(ring + encoding_size * p, encoding_size); if (val) { loc = getSparseOptimalTargetValue(info, low, &val); diff = (p + 1) * patch_size - loc; } if (loc) { u64a rv = MAX(nextOffset, xs->offset + info->repeatMin + diff + (end - xs->first) * patch_size); DEBUG_PRINTF("next match at %llu\n", rv); return rv; } } } DEBUG_PRINTF("next match\n"); return 0; } void repeatStoreSparseOptimalP(const struct RepeatInfo *info, union RepeatControl *ctrl, void *state, u64a offset, char is_alive) { struct RepeatRingControl *xs = &ctrl->ring; u8 *active = (u8 *)state; DEBUG_PRINTF("offset: %llu encoding_size: %u\n", offset, info->encodingSize); // If (a) this is the first top, or (b) the ring is stale, initialize the // ring and write this offset in as the first top. if (!is_alive || offset > sparseLastTop(info, xs, state) + info->repeatMax) { storeInitialRingTopPatch(info, xs, active, offset); return; } // Tops should arrive in order, with no duplicates. assert(offset > sparseLastTop(info, xs, state)); // As the ring is not stale, our delta should fit within a u32. assert(offset - xs->offset <= UINT32_MAX); u32 delta = (u32)(offset - xs->offset); u32 patch_size = info->patchSize; u32 patch_count = info->patchCount; u32 encoding_size = info->encodingSize; u32 patch = delta / patch_size; DEBUG_PRINTF("delta=%u, patch_size=%u, patch=%u\n", delta, patch_size, patch); u8 *ring = active + info->patchesOffset; u32 occ = ringOccupancy(xs, patch_count); u64a val = 0; u32 idx; DEBUG_PRINTF("patch: %u patch_count: %u occ: %u\n", patch, patch_count, occ); if (patch >= patch_count) { u32 patch_shift_count = patch - patch_count + 1; assert(patch >= patch_shift_count); DEBUG_PRINTF("shifting by %u\n", patch_shift_count); xs->offset += patch_size * patch_shift_count; xs->first += patch_shift_count; if (xs->first >= patch_count) { xs->first -= patch_count; } idx = xs->last + patch - occ; mmbit_unset_range(active, patch_count, xs->last, MIN(idx, patch_count)); if (idx >= patch_count) { idx -= patch_count; mmbit_unset_range(active, patch_count, 0, idx + 1); } xs->last = idx + 1; if (xs->last == patch_count) { xs->last = 0; } } else if (patch < occ) { assert(patch == occ - 1); idx = xs->last == 0 ? patch_count - 1 : (u32)xs->last - 1; val = partial_load_u64a(ring + encoding_size * idx, encoding_size); } else { idx = xs->last + patch - occ; mmbit_unset_range(active, patch_count, xs->last, MIN(idx, patch_count)); if (idx >= patch_count) { idx -= patch_count; mmbit_unset_range(active, patch_count, 0, idx + 1); } xs->last = idx + 1; if (xs->last == patch_count) { xs->last = 0; } } assert((u64a)patch * patch_size <= delta); u32 diff = delta - patch * patch_size; const u64a *repeatTable = getImplTable(info); val += repeatTable[diff]; DEBUG_PRINTF("patch=%u, occ=%u\n", patch, occ); DEBUG_PRINTF("xs->first:%u xs->last:%u patch:%u\n", xs->first, xs->last, patch); DEBUG_PRINTF("value:%llu\n", val); assert(fits_in_len_bytes(val, encoding_size)); partial_store_u64a(ring + encoding_size * idx, val, encoding_size); mmbit_set(active, patch_count, idx); } static char sparseHasMatch(const struct RepeatInfo *info, const u8 *state, u32 lower, u32 upper) { u32 patch_size = info->patchSize; u32 patch_count = info->patchCount; u32 encoding_size = info->encodingSize; u32 patch_lower = lower / patch_size; u32 patch_upper = upper / patch_size; u32 diff = lower - patch_lower * patch_size; DEBUG_PRINTF("lower=%u, upper=%u\n", lower, upper); const u64a *repeatTable = getImplTable(info); const u8 *ring = state + info->patchesOffset; const u8 *active = state; u64a val; // test the first patch if (mmbit_isset(active, patch_count, patch_lower)) { val = partial_load_u64a(ring + encoding_size * patch_lower, encoding_size); DEBUG_PRINTF("patch_size=%u, diff=%u, table=%llu\n", patch_size, diff, repeatTable[diff]); DEBUG_PRINTF("patch_lower=%u, patch_upper=%u\n", patch_lower, patch_upper); if (patch_upper == patch_lower) { u32 limit = upper - patch_lower * patch_size; getSparseOptimalTargetValue(info, limit + 1, &val); } if (val >= repeatTable[diff]) { return 1; } } if (patch_lower == patch_upper) { return 0; } // test the patches between first and last u32 m = mmbit_iterate_bounded(active, patch_count, patch_lower + 1, patch_upper); if (m != MMB_INVALID) { return 1; } if (patch_upper == patch_count) { return 0; } // test the last patch if (!mmbit_isset(active, patch_count, patch_upper)) { return 0; } diff = (patch_upper + 1) * patch_size - upper; DEBUG_PRINTF("diff=%u\n", diff); val = partial_load_u64a(ring + encoding_size * patch_upper, encoding_size); getSparseOptimalTargetValue(info, patch_size - diff + 1, &val); if (val) { DEBUG_PRINTF("last patch: val=%llu\n", val); return 1; } return 0; } enum RepeatMatch repeatHasMatchSparseOptimalP(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset) { DEBUG_PRINTF("check for match at %llu corresponding to trigger " "at [%llu, %llu]\n", offset, offset - info->repeatMax, offset - info->repeatMin); const struct RepeatRingControl *xs = &ctrl->ring; const u8 *ring = (const u8 *)state; assert(offset >= xs->offset); if (offset < xs->offset + info->repeatMin) { DEBUG_PRINTF("too soon\n"); return REPEAT_NOMATCH; } else if (offset > sparseLastTop(info, xs, state) + info->repeatMax) { DEBUG_PRINTF("stale\n"); return REPEAT_STALE; } // Our delta between the base offset of the ring and the current offset // must fit within the range [repeatMin, lastPossibleTop + repeatMax]. This // range fits comfortably within a u32. assert(offset - xs->offset <= UINT32_MAX); u32 delta = (u32)(offset - xs->offset); u32 patch_size = info->patchSize; u32 patch_count = info->patchCount; u32 occ = ringOccupancy(xs, patch_count); u32 lower = delta > info->repeatMax ? delta - info->repeatMax : 0; u32 upper = MIN(delta - info->repeatMin, occ * patch_size - 1); DEBUG_PRINTF("lower=%u, upper=%u\n", lower, upper); u32 patch_lower = lower / patch_size; u32 patch_upper = upper / patch_size; if (patch_lower >= occ) { DEBUG_PRINTF("too late\n"); return REPEAT_NOMATCH; } u32 remaining_lower = lower - patch_lower * patch_size; u32 remaining_upper = upper - patch_upper * patch_size; patch_lower += xs->first; patch_upper += xs->first; if (patch_lower >= patch_count) { patch_lower -= patch_count; patch_upper -= patch_count; } else if (patch_upper >= patch_count) { patch_upper -= patch_count; } DEBUG_PRINTF("xs->first:%u xs->last:%u patch_lower:%u, patch_upper:%u\n", xs->first, xs->last, patch_lower, patch_upper); u32 scan_end; const char is_not_wrapped = (patch_lower <= patch_upper); if (is_not_wrapped) { scan_end = patch_upper * patch_size + remaining_upper; } else { scan_end = patch_count * patch_size; } lower = patch_lower * patch_size + remaining_lower; if (sparseHasMatch(info, ring, lower, scan_end)) { return REPEAT_MATCH; } if (!is_not_wrapped) { upper -= (patch_count - xs->first) * patch_size; if (sparseHasMatch(info, ring, 0, upper)) { return REPEAT_MATCH; } } return REPEAT_NOMATCH; } hyperscan-4.4.1/src/nfa/tamaramacompile.cpp0000644000175000017500000001451713055426554021502 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Tamarama: container engine for exclusive engines, * compiler code. */ #include "config.h" #include "tamaramacompile.h" #include "tamarama_internal.h" #include "nfa_internal.h" #include "nfa_api_queue.h" #include "repeatcompile.h" #include "util/container.h" #include "util/verify_types.h" using namespace std; namespace ue2 { static void remapTops(const TamaInfo &tamaInfo, vector &top_base, map, u32> &out_top_remap) { u32 i = 0; u32 cur = 0; for (const auto &sub : tamaInfo.subengines) { u32 base = cur; top_base.push_back(base + MQE_TOP_FIRST); DEBUG_PRINTF("subengine:%u\n", i); for (const auto &t : tamaInfo.tops[i++]) { cur = base + t; DEBUG_PRINTF("top remapping %u:%u\n", t ,cur); out_top_remap.emplace(make_pair(sub, t), cur++); } } } /** * update stream state and scratch state sizes and copy in * subengines in Tamarama. */ static void copyInSubnfas(const char *base_offset, NFA &nfa, const TamaInfo &tamaInfo, u32 *offsets, char *sub_nfa_offset, const u32 activeIdxSize) { u32 maxStreamStateSize = 0; u32 maxScratchStateSize = 0; sub_nfa_offset = ROUNDUP_PTR(sub_nfa_offset, 64); bool infinite_max_width = false; for (auto &sub : tamaInfo.subengines) { u32 streamStateSize = verify_u32(sub->streamStateSize); u32 scratchStateSize = verify_u32(sub->scratchStateSize); maxStreamStateSize = max(maxStreamStateSize, streamStateSize); maxScratchStateSize = max(maxScratchStateSize, scratchStateSize); sub->queueIndex = nfa.queueIndex; memcpy(sub_nfa_offset, sub, sub->length); *offsets = verify_u32(sub_nfa_offset - base_offset); DEBUG_PRINTF("type:%u offsets:%u\n", sub->type, *offsets); ++offsets; sub_nfa_offset += ROUNDUP_CL(sub->length); // update nfa properties nfa.flags |= sub->flags; if (!sub->maxWidth) { infinite_max_width = true; } else if (!infinite_max_width) { nfa.maxWidth = max(nfa.maxWidth, sub->maxWidth); } } if (infinite_max_width) { nfa.maxWidth = 0; } nfa.maxBiAnchoredWidth = 0; nfa.streamStateSize = activeIdxSize + maxStreamStateSize; nfa.scratchStateSize = maxScratchStateSize; } /** * Take in a collection of exclusive sub engines and produces a tamarama, also * returns via out_top_remap, a mapping indicating how tops in the subengines in * relate to the tamarama's tops. */ aligned_unique_ptr buildTamarama(const TamaInfo &tamaInfo, const u32 queue, map, u32> &out_top_remap) { vector top_base; remapTops(tamaInfo, top_base, out_top_remap); size_t subSize = tamaInfo.subengines.size(); DEBUG_PRINTF("subSize:%zu\n", subSize); size_t total_size = sizeof(NFA) + // initial NFA structure sizeof(Tamarama) + // Tamarama structure sizeof(u32) * subSize + // base top event value for subengines, // used for top remapping at runtime sizeof(u32) * subSize + 64; // offsets to subengines in bytecode and // padding for subengines for (const auto &sub : tamaInfo.subengines) { total_size += ROUNDUP_CL(sub->length); } // use subSize as a sentinel value for no active subengines, // so add one to subSize here u32 activeIdxSize = calcPackedBytes(subSize + 1); aligned_unique_ptr nfa = aligned_zmalloc_unique(total_size); nfa->type = verify_u8(TAMARAMA_NFA); nfa->length = verify_u32(total_size); nfa->queueIndex = queue; char *ptr = (char *)nfa.get() + sizeof(NFA); char *base_offset = ptr; Tamarama *t = (Tamarama *)ptr; t->numSubEngines = verify_u32(subSize); t->activeIdxSize = verify_u8(activeIdxSize); ptr += sizeof(Tamarama); copy_bytes(ptr, top_base); ptr += byte_length(top_base); u32 *offsets = (u32*)ptr; char *sub_nfa_offset = ptr + sizeof(u32) * subSize; copyInSubnfas(base_offset, *nfa, tamaInfo, offsets, sub_nfa_offset, activeIdxSize); assert((size_t)(sub_nfa_offset - (char *)nfa.get()) <= total_size); return nfa; } set all_reports(const TamaProto &proto) { return proto.reports; } void TamaInfo::add(NFA *sub, const set &top) { assert(subengines.size() < max_occupancy); subengines.push_back(sub); tops.push_back(top); } void TamaProto::add(const NFA *n, const u32 id, const u32 top, const map, u32> &out_top_remap) { top_remap.emplace(make_pair(id, top), out_top_remap.at(make_pair(n, top))); } } // namespace ue2 hyperscan-4.4.1/src/nfa/limex.h0000644000175000017500000001046213055426554017124 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 LIMEX_H #define LIMEX_H #ifdef __cplusplus #include extern "C" { #endif #include "nfa_api.h" #if defined(DUMP_SUPPORT) && defined(__cplusplus) #define GENERATE_NFA_DUMP_DECL(gf_name) \ } /* extern "C" */ \ namespace ue2 { \ void gf_name##_dump(const struct NFA *nfa, const std::string &base); \ } /* namespace ue2 */ \ extern "C" { #else #define GENERATE_NFA_DUMP_DECL(gf_name) #endif #define GENERATE_NFA_DECL(gf_name) \ char gf_name##_testEOD(const struct NFA *nfa, const char *state, \ const char *streamState, u64a offset, \ NfaCallback callback, void *context); \ char gf_name##_Q(const struct NFA *n, struct mq *q, s64a end); \ char gf_name##_Q2(const struct NFA *n, struct mq *q, s64a end); \ char gf_name##_QR(const struct NFA *n, struct mq *q, ReportID report); \ char gf_name##_reportCurrent(const struct NFA *n, struct mq *q); \ char gf_name##_inAccept(const struct NFA *n, ReportID report, \ struct mq *q); \ char gf_name##_inAnyAccept(const struct NFA *n, struct mq *q); \ char gf_name##_queueInitState(const struct NFA *n, struct mq *q); \ char gf_name##_initCompressedState(const struct NFA *n, u64a offset, \ void *state, u8 key); \ char gf_name##_B_Reverse(const struct NFA *n, u64a offset, const u8 *buf, \ size_t buflen, const u8 *hbuf, size_t hlen, \ NfaCallback cb, void *context); \ char gf_name##_queueCompressState(const struct NFA *nfa, \ const struct mq *q, s64a loc); \ char gf_name##_expandState(const struct NFA *nfa, void *dest, \ const void *src, u64a offset, u8 key); \ enum nfa_zombie_status gf_name##_zombie_status(const struct NFA *nfa, \ struct mq *q, s64a loc); \ GENERATE_NFA_DUMP_DECL(gf_name) GENERATE_NFA_DECL(nfaExecLimEx32) GENERATE_NFA_DECL(nfaExecLimEx64) GENERATE_NFA_DECL(nfaExecLimEx128) GENERATE_NFA_DECL(nfaExecLimEx256) GENERATE_NFA_DECL(nfaExecLimEx384) GENERATE_NFA_DECL(nfaExecLimEx512) #undef GENERATE_NFA_DECL #undef GENERATE_NFA_DUMP_DECL #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/multiaccel_longgrab.h0000644000175000017500000001102113055426554021773 0ustar sleuthkidsleuthkid/* * 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_ */ hyperscan-4.4.1/src/nfa/repeat.h0000644000175000017500000003243713055426554017274 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief API for handling bounded repeats. * * This file provides an internal API for handling bounded repeats of character * classes. It is used by the Large Bounded Repeat (LBR) engine and by the * bounded repeat handling in the LimEx NFA engine as well. * * The state required by these functions is split into two regions: * * 1. Control block. This is a small structure (size varies with repeat mode) * that may be copied around or compressed into stream state. * 2. Repeat state. This is a larger structure that can be quite big for large * repeats, often containing a multibit ring or large vector of indices. * This generally lives in stream state and is not copied. */ #ifndef REPEAT_H #define REPEAT_H #include "ue2common.h" #include "repeat_internal.h" #include "util/bitutils.h" #ifdef __cplusplus extern "C" { #endif /** Returns the offset of the most recent 'top' offset set in the repeat. */ static really_inline u64a repeatLastTop(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state); /** Returns the offset of the next match after 'offset', or zero if no further * matches are possible. */ static really_inline u64a repeatNextMatch(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset); /** Stores a new top in the repeat. If is_alive is false, the repeat will be * initialised first and this top will become the first (and only) one. */ static really_inline void repeatStore(const struct RepeatInfo *info, union RepeatControl *ctrl, void *state, u64a offset, char is_alive); /** Return type for repeatHasMatch. */ enum RepeatMatch { REPEAT_NOMATCH, /**< This offset is not a valid match. */ REPEAT_MATCH, /**< This offset is a valid match. */ REPEAT_STALE /**< This offset is not a valid match and no greater offset will be (unless another top is stored). */ }; /** Query whether the repeat has a match at the given offset. Returns * ::REPEAT_STALE if it does not have a match at that offset _and_ * no further matches are possible. */ static really_inline enum RepeatMatch repeatHasMatch(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset); /** \brief Serialize a packed version of the repeat control block into stream * state. */ void repeatPack(char *dest, const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset); /** \brief Deserialize a packed version of the repeat control block. */ void repeatUnpack(const char *src, const struct RepeatInfo *info, u64a offset, union RepeatControl *ctrl); //// //// IMPLEMENTATION. //// u64a repeatLastTopRing(const struct RepeatInfo *info, const union RepeatControl *ctrl); u64a repeatLastTopRange(const union RepeatControl *ctrl, const void *state); u64a repeatLastTopBitmap(const union RepeatControl *ctrl); u64a repeatLastTopTrailer(const struct RepeatInfo *info, const union RepeatControl *ctrl); u64a repeatLastTopSparseOptimalP(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state); static really_inline u64a repeatLastTop(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state) { assert(info && ctrl && state); switch ((enum RepeatType)info->type) { case REPEAT_RING: return repeatLastTopRing(info, ctrl); case REPEAT_FIRST: case REPEAT_LAST: return ctrl->offset.offset; case REPEAT_RANGE: return repeatLastTopRange(ctrl, state); case REPEAT_BITMAP: return repeatLastTopBitmap(ctrl); case REPEAT_SPARSE_OPTIMAL_P: return repeatLastTopSparseOptimalP(info, ctrl, state); case REPEAT_TRAILER: return repeatLastTopTrailer(info, ctrl); case REPEAT_ALWAYS: return 0; } DEBUG_PRINTF("bad repeat type %u\n", info->type); assert(0); return 0; } // Used for both FIRST and LAST models. static really_inline u64a repeatNextMatchOffset(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { u64a first = ctrl->offset.offset + info->repeatMin; if (offset < first) { return first; } if (info->repeatMax == REPEAT_INF || offset < ctrl->offset.offset + info->repeatMax) { return offset + 1; } return 0; // No more matches. } u64a repeatNextMatchRing(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset); u64a repeatNextMatchRange(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset); u64a repeatNextMatchBitmap(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset); u64a repeatNextMatchSparseOptimalP(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset); u64a repeatNextMatchTrailer(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset); static really_inline u64a repeatNextMatch(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset) { assert(info && ctrl && state); assert(ISALIGNED(info)); assert(ISALIGNED(ctrl)); switch ((enum RepeatType)info->type) { case REPEAT_RING: return repeatNextMatchRing(info, ctrl, state, offset); case REPEAT_FIRST: // fall through case REPEAT_LAST: return repeatNextMatchOffset(info, ctrl, offset); case REPEAT_RANGE: return repeatNextMatchRange(info, ctrl, state, offset); case REPEAT_BITMAP: return repeatNextMatchBitmap(info, ctrl, offset); case REPEAT_SPARSE_OPTIMAL_P: return repeatNextMatchSparseOptimalP(info, ctrl, state, offset); case REPEAT_TRAILER: return repeatNextMatchTrailer(info, ctrl, offset); case REPEAT_ALWAYS: return offset + 1; } DEBUG_PRINTF("bad repeat type %u\n", info->type); assert(0); return 0; } static really_inline void repeatStoreFirst(union RepeatControl *ctrl, u64a offset, char is_alive) { if (is_alive) { return; } ctrl->offset.offset = offset; } static really_inline void repeatStoreLast(union RepeatControl *ctrl, u64a offset, UNUSED char is_alive) { assert(!is_alive || offset >= ctrl->offset.offset); ctrl->offset.offset = offset; } void repeatStoreRing(const struct RepeatInfo *info, union RepeatControl *ctrl, void *state, u64a offset, char is_alive); void repeatStoreRange(const struct RepeatInfo *info, union RepeatControl *ctrl, void *state, u64a offset, char is_alive); void repeatStoreBitmap(const struct RepeatInfo *info, union RepeatControl *ctrl, u64a offset, char is_alive); void repeatStoreSparseOptimalP(const struct RepeatInfo *info, union RepeatControl *ctrl, void *state, u64a offset, char is_alive); void repeatStoreTrailer(const struct RepeatInfo *info, union RepeatControl *ctrl, u64a offset, char is_alive); static really_inline void repeatStore(const struct RepeatInfo *info, union RepeatControl *ctrl, void *state, u64a offset, char is_alive) { assert(info && ctrl && state); assert(ISALIGNED(info)); assert(ISALIGNED(ctrl)); assert(info->repeatMin <= info->repeatMax); assert(info->repeatMax <= REPEAT_INF); switch ((enum RepeatType)info->type) { case REPEAT_RING: repeatStoreRing(info, ctrl, state, offset, is_alive); break; case REPEAT_FIRST: repeatStoreFirst(ctrl, offset, is_alive); break; case REPEAT_LAST: repeatStoreLast(ctrl, offset, is_alive); break; case REPEAT_RANGE: repeatStoreRange(info, ctrl, state, offset, is_alive); break; case REPEAT_BITMAP: repeatStoreBitmap(info, ctrl, offset, is_alive); break; case REPEAT_SPARSE_OPTIMAL_P: repeatStoreSparseOptimalP(info, ctrl, state, offset, is_alive); break; case REPEAT_TRAILER: repeatStoreTrailer(info, ctrl, offset, is_alive); break; case REPEAT_ALWAYS: /* nothing to do - no state */ break; } } static really_inline enum RepeatMatch repeatHasMatchFirst(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { if (offset < ctrl->offset.offset + info->repeatMin) { return REPEAT_NOMATCH; } // FIRST models are {N,} repeats, i.e. they always have inf max depth. assert(info->repeatMax == REPEAT_INF); return REPEAT_MATCH; } static really_inline enum RepeatMatch repeatHasMatchLast(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset) { if (offset < ctrl->offset.offset + info->repeatMin) { return REPEAT_NOMATCH; } assert(info->repeatMax < REPEAT_INF); if (offset <= ctrl->offset.offset + info->repeatMax) { return REPEAT_MATCH; } return REPEAT_STALE; } enum RepeatMatch repeatHasMatchRing(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset); enum RepeatMatch repeatHasMatchRange(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset); enum RepeatMatch repeatHasMatchSparseOptimalP(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset); enum RepeatMatch repeatHasMatchBitmap(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset); enum RepeatMatch repeatHasMatchTrailer(const struct RepeatInfo *info, const union RepeatControl *ctrl, u64a offset); static really_inline enum RepeatMatch repeatHasMatch(const struct RepeatInfo *info, const union RepeatControl *ctrl, const void *state, u64a offset) { assert(info && ctrl && state); assert(ISALIGNED(info)); assert(ISALIGNED(ctrl)); switch ((enum RepeatType)info->type) { case REPEAT_RING: return repeatHasMatchRing(info, ctrl, state, offset); case REPEAT_FIRST: return repeatHasMatchFirst(info, ctrl, offset); case REPEAT_LAST: return repeatHasMatchLast(info, ctrl, offset); case REPEAT_RANGE: return repeatHasMatchRange(info, ctrl, state, offset); case REPEAT_BITMAP: return repeatHasMatchBitmap(info, ctrl, offset); case REPEAT_SPARSE_OPTIMAL_P: return repeatHasMatchSparseOptimalP(info, ctrl, state, offset); case REPEAT_TRAILER: return repeatHasMatchTrailer(info, ctrl, offset); case REPEAT_ALWAYS: return REPEAT_MATCH; } assert(0); return REPEAT_NOMATCH; } #ifdef __cplusplus } #endif #endif // REPEAT_H hyperscan-4.4.1/src/nfa/castle.c0000644000175000017500000011573713055426554017267 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Castle: multi-tenant repeat engine, runtime code. */ #include "castle.h" #include "castle_internal.h" #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "repeat.h" #include "shufti.h" #include "truffle.h" #include "vermicelli.h" #include "util/bitutils.h" #include "util/multibit.h" #include "util/partial_store.h" #include "ue2common.h" static really_inline const struct SubCastle *getSubCastle(const struct Castle *c, u32 num) { assert(num < c->numRepeats); const struct SubCastle *sub = (const struct SubCastle *)((const char *)c + sizeof(struct Castle)); assert(ISALIGNED(sub)); return &sub[num]; } static really_inline const struct RepeatInfo *getRepeatInfo(const struct SubCastle *sub) { const struct RepeatInfo *repeatInfo = (const struct RepeatInfo *)((const char *)sub + sub->repeatInfoOffset); return repeatInfo; } static really_inline union RepeatControl *getControl(char *full_state, const struct SubCastle *sub) { union RepeatControl *rctrl = (union RepeatControl *)(full_state + sub->fullStateOffset); assert(ISALIGNED(rctrl)); return rctrl; } static really_inline const union RepeatControl *getControlConst(const char *full_state, const struct SubCastle *sub) { const union RepeatControl *rctrl = (const union RepeatControl *)(full_state + sub->fullStateOffset); assert(ISALIGNED(rctrl)); return rctrl; } enum MatchMode { CALLBACK_OUTPUT, STOP_AT_MATCH, }; static really_inline char subCastleReportCurrent(const struct Castle *c, struct mq *q, const u64a offset, const u32 subIdx) { const struct SubCastle *sub = getSubCastle(c, subIdx); const struct RepeatInfo *info = getRepeatInfo(sub); union RepeatControl *rctrl = getControl(q->state, sub); char *rstate = (char *)q->streamState + sub->streamStateOffset + info->packedCtrlSize; enum RepeatMatch match = repeatHasMatch(info, rctrl, rstate, offset); DEBUG_PRINTF("repeatHasMatch returned %d\n", match); if (match == REPEAT_MATCH) { DEBUG_PRINTF("firing match at %llu for sub %u, report %u\n", offset, subIdx, sub->report); if (q->cb(0, offset, sub->report, q->context) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } return MO_CONTINUE_MATCHING; } static really_inline int castleReportCurrent(const struct Castle *c, struct mq *q) { const u64a offset = q_cur_offset(q); DEBUG_PRINTF("offset=%llu\n", offset); if (c->exclusive) { u8 *active = (u8 *)q->streamState; u8 *groups = active + c->groupIterOffset; for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) { u8 *cur = active + i * c->activeIdxSize; const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize); DEBUG_PRINTF("subcastle %u\n", activeIdx); if (subCastleReportCurrent(c, q, offset, activeIdx) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } } if (c->exclusive != PURE_EXCLUSIVE) { const u8 *active = (const u8 *)q->streamState + c->activeOffset; for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) { DEBUG_PRINTF("subcastle %u\n", i); if (subCastleReportCurrent(c, q, offset, i) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } } return MO_CONTINUE_MATCHING; } static really_inline char subCastleInAccept(const struct Castle *c, struct mq *q, const ReportID report, const u64a offset, const u32 subIdx) { const struct SubCastle *sub = getSubCastle(c, subIdx); if (sub->report != report) { return 0; } const struct RepeatInfo *info = getRepeatInfo(sub); union RepeatControl *rctrl = getControl(q->state, sub); char *rstate = (char *)q->streamState + sub->streamStateOffset + info->packedCtrlSize; enum RepeatMatch match = repeatHasMatch(info, rctrl, rstate, offset); if (match == REPEAT_MATCH) { DEBUG_PRINTF("in an accept\n"); return 1; } return 0; } static really_inline char castleInAccept(const struct Castle *c, struct mq *q, const ReportID report, const u64a offset) { DEBUG_PRINTF("offset=%llu\n", offset); /* ignore when just catching up due to full queue */ if (report == MO_INVALID_IDX) { return 0; } if (c->exclusive) { u8 *active = (u8 *)q->streamState; u8 *groups = active + c->groupIterOffset; for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) { u8 *cur = active + i * c->activeIdxSize; const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize); DEBUG_PRINTF("subcastle %u\n", activeIdx); if (subCastleInAccept(c, q, report, offset, activeIdx)) { return 1; } } } if (c->exclusive != PURE_EXCLUSIVE) { const u8 *active = (const u8 *)q->streamState + c->activeOffset; for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) { DEBUG_PRINTF("subcastle %u\n", i); if (subCastleInAccept(c, q, report, offset, i)) { return 1; } } } return 0; } static really_inline void subCastleDeactivateStaleSubs(const struct Castle *c, const u64a offset, void *full_state, void *stream_state, const u32 subIdx) { const struct SubCastle *sub = getSubCastle(c, subIdx); const struct RepeatInfo *info = getRepeatInfo(sub); union RepeatControl *rctrl = getControl(full_state, sub); char *rstate = (char *)stream_state + sub->streamStateOffset + info->packedCtrlSize; if (repeatHasMatch(info, rctrl, rstate, offset) == REPEAT_STALE) { DEBUG_PRINTF("sub %u is stale at offset %llu\n", subIdx, offset); if (sub->exclusiveId < c->numRepeats) { u8 *active = (u8 *)stream_state; u8 *groups = active + c->groupIterOffset; mmbit_unset(groups, c->numGroups, sub->exclusiveId); } else { u8 *active = (u8 *)stream_state + c->activeOffset; mmbit_unset(active, c->numRepeats, subIdx); } } } static really_inline void castleDeactivateStaleSubs(const struct Castle *c, const u64a offset, void *full_state, void *stream_state) { DEBUG_PRINTF("offset=%llu\n", offset); if (!c->staleIterOffset) { DEBUG_PRINTF("{no repeats can go stale}\n"); return; /* no subcastle can ever go stale */ } if (c->exclusive) { u8 *active = (u8 *)stream_state; u8 *groups = active + c->groupIterOffset; for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) { u8 *cur = active + i * c->activeIdxSize; const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize); DEBUG_PRINTF("subcastle %u\n", activeIdx); subCastleDeactivateStaleSubs(c, offset, full_state, stream_state, activeIdx); } } if (c->exclusive != PURE_EXCLUSIVE) { const u8 *active = (const u8 *)stream_state + c->activeOffset; const struct mmbit_sparse_iter *it = (const void *)((const char *)c + c->staleIterOffset); struct mmbit_sparse_state si_state[MAX_SPARSE_ITER_STATES]; u32 numRepeats = c->numRepeats; u32 idx = 0; u32 i = mmbit_sparse_iter_begin(active, numRepeats, &idx, it, si_state); while(i != MMB_INVALID) { DEBUG_PRINTF("subcastle %u\n", i); subCastleDeactivateStaleSubs(c, offset, full_state, stream_state, i); i = mmbit_sparse_iter_next(active, numRepeats, i, &idx, it, si_state); } } } static really_inline void castleProcessTop(const struct Castle *c, const u32 top, const u64a offset, void *full_state, void *stream_state, UNUSED char stale_checked) { assert(top < c->numRepeats); const struct SubCastle *sub = getSubCastle(c, top); const struct RepeatInfo *info = getRepeatInfo(sub); union RepeatControl *rctrl = getControl(full_state, sub); char *rstate = (char *)stream_state + sub->streamStateOffset + info->packedCtrlSize; char is_alive = 0; u8 *active = (u8 *)stream_state; if (sub->exclusiveId < c->numRepeats) { u8 *groups = active + c->groupIterOffset; active += sub->exclusiveId * c->activeIdxSize; if (mmbit_set(groups, c->numGroups, sub->exclusiveId)) { const u32 activeIdx = partial_load_u32(active, c->activeIdxSize); is_alive = (activeIdx == top); } if (!is_alive) { partial_store_u32(active, top, c->activeIdxSize); } } else { active += c->activeOffset; is_alive = mmbit_set(active, c->numRepeats, top); } if (!is_alive) { DEBUG_PRINTF("first top for inactive repeat %u\n", top); } else { DEBUG_PRINTF("repeat %u is already alive\n", top); // Caller should ensure we're not stale. assert(!stale_checked || repeatHasMatch(info, rctrl, rstate, offset) != REPEAT_STALE); // Ignore duplicate top events. u64a last = repeatLastTop(info, rctrl, rstate); assert(last <= offset); if (last == offset) { DEBUG_PRINTF("dupe top at %llu\n", offset); return; } } repeatStore(info, rctrl, rstate, offset, is_alive); } static really_inline void subCastleFindMatch(const struct Castle *c, const u64a begin, const u64a end, void *full_state, void *stream_state, size_t *mloc, char *found, const u32 subIdx) { const struct SubCastle *sub = getSubCastle(c, subIdx); const struct RepeatInfo *info = getRepeatInfo(sub); union RepeatControl *rctrl = getControl(full_state, sub); char *rstate = (char *)stream_state + sub->streamStateOffset + info->packedCtrlSize; u64a match = repeatNextMatch(info, rctrl, rstate, begin); if (match == 0) { DEBUG_PRINTF("no more matches for sub %u\n", subIdx); if (sub->exclusiveId < c->numRepeats) { u8 *groups = (u8 *)stream_state + c->groupIterOffset; mmbit_unset(groups, c->numGroups, sub->exclusiveId); } else { u8 *active = (u8 *)stream_state + c->activeOffset; mmbit_unset(active, c->numRepeats, subIdx); } return; } else if (match > end) { DEBUG_PRINTF("next match for sub %u at %llu is > horizon\n", subIdx, match); return; } DEBUG_PRINTF("sub %u earliest match at %llu\n", subIdx, match); size_t diff = match - begin; if (!(*found) || diff < *mloc) { *mloc = diff; DEBUG_PRINTF("mloc=%zu\n", *mloc); } *found = 1; } static really_inline char castleFindMatch(const struct Castle *c, const u64a begin, const u64a end, void *full_state, void *stream_state, size_t *mloc) { DEBUG_PRINTF("begin=%llu, end=%llu\n", begin, end); assert(begin <= end); if (begin == end) { DEBUG_PRINTF("no work to do\n"); return 0; } char found = 0; *mloc = 0; if (c->exclusive) { u8 *active = (u8 *)stream_state; u8 *groups = active + c->groupIterOffset; for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) { u8 *cur = active + i * c->activeIdxSize; const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize); DEBUG_PRINTF("subcastle %u\n", activeIdx); subCastleFindMatch(c, begin, end, full_state, stream_state, mloc, &found, activeIdx); } } if (c->exclusive != PURE_EXCLUSIVE) { u8 *active = (u8 *)stream_state + c->activeOffset; for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) { DEBUG_PRINTF("subcastle %u\n", i); subCastleFindMatch(c, begin, end, full_state, stream_state, mloc, &found, i); } } return found; } static really_inline u64a subCastleNextMatch(const struct Castle *c, void *full_state, void *stream_state, const u64a loc, const u32 subIdx) { DEBUG_PRINTF("subcastle %u\n", subIdx); const struct SubCastle *sub = getSubCastle(c, subIdx); const struct RepeatInfo *info = getRepeatInfo(sub); const union RepeatControl *rctrl = getControlConst(full_state, sub); const char *rstate = (const char *)stream_state + sub->streamStateOffset + info->packedCtrlSize; return repeatNextMatch(info, rctrl, rstate, loc); } static really_inline void set_matching(const struct Castle *c, const u64a match, u8 *active, u8 *matching, const u32 active_size, const u32 active_id, const u32 matching_id, u64a *offset, const u64a end) { if (match == 0) { DEBUG_PRINTF("no more matches\n"); mmbit_unset(active, active_size, active_id); } else if (match > end) { // If we had a local copy of the active mmbit, we could skip // looking at this repeat again. But we don't, so we just move // on. } else if (match == *offset) { mmbit_set(matching, c->numRepeats, matching_id); } else if (match < *offset) { // New minimum offset. *offset = match; mmbit_clear(matching, c->numRepeats); mmbit_set(matching, c->numRepeats, matching_id); } } static really_inline void subCastleMatchLoop(const struct Castle *c, void *full_state, void *stream_state, const u64a end, const u64a loc, u64a *offset) { u8 *active = (u8 *)stream_state + c->activeOffset; u8 *matching = full_state; for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) { u64a match = subCastleNextMatch(c, full_state, stream_state, loc, i); set_matching(c, match, active, matching, c->numRepeats, i, i, offset, end); } } static really_inline char subCastleFireMatch(const struct Castle *c, const void *full_state, UNUSED const void *stream_state, NfaCallback cb, void *ctx, const u64a offset) { const u8 *matching = full_state; // Fire all matching sub-castles at this offset. for (u32 i = mmbit_iterate(matching, c->numRepeats, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(matching, c->numRepeats, i)) { const struct SubCastle *sub = getSubCastle(c, i); DEBUG_PRINTF("firing match at %llu for sub %u\n", offset, i); if (cb(0, offset, sub->report, ctx) == MO_HALT_MATCHING) { DEBUG_PRINTF("caller told us to halt\n"); return MO_HALT_MATCHING; } } return MO_CONTINUE_MATCHING; } static really_inline char castleMatchLoop(const struct Castle *c, const u64a begin, const u64a end, void *full_state, void *stream_state, NfaCallback cb, void *ctx) { DEBUG_PRINTF("begin=%llu, end=%llu\n", begin, end); assert(begin <= end); u8 *matching = full_state; // temp multibit u64a loc = begin; while (loc < end) { // Find minimum next offset for the next match(es) from amongst our // active sub-castles, and store the indices of the sub-castles that // match at that offset in the 'matching' mmbit, which is in the // full_state (scratch). u64a offset = end; // min offset of next match u32 activeIdx = 0; mmbit_clear(matching, c->numRepeats); if (c->exclusive) { u8 *active = (u8 *)stream_state; u8 *groups = active + c->groupIterOffset; for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) { u8 *cur = active + i * c->activeIdxSize; activeIdx = partial_load_u32(cur, c->activeIdxSize); u64a match = subCastleNextMatch(c, full_state, stream_state, loc, activeIdx); set_matching(c, match, groups, matching, c->numGroups, i, activeIdx, &offset, end); } } if (c->exclusive != PURE_EXCLUSIVE) { subCastleMatchLoop(c, full_state, stream_state, end, loc, &offset); } DEBUG_PRINTF("offset=%llu\n", offset); if (!mmbit_any(matching, c->numRepeats)) { DEBUG_PRINTF("no more matches\n"); break; } if (subCastleFireMatch(c, full_state, stream_state, cb, ctx, offset) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } loc = offset; } return MO_CONTINUE_MATCHING; } static really_inline char castleScanVerm(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { const u8 *ptr = vermicelliExec(c->u.verm.c, 0, buf + begin, buf + end); if (ptr == buf + end) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); assert(ptr >= buf && ptr < buf + end); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char castleScanNVerm(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { const u8 *ptr = nvermicelliExec(c->u.verm.c, 0, buf + begin, buf + end); if (ptr == buf + end) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); assert(ptr >= buf && ptr < buf + end); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char castleScanShufti(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { const m128 mask_lo = c->u.shuf.mask_lo; const m128 mask_hi = c->u.shuf.mask_hi; const u8 *ptr = shuftiExec(mask_lo, mask_hi, buf + begin, buf + end); if (ptr == buf + end) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); assert(ptr >= buf && ptr < buf + end); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char castleScanTruffle(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { const u8 *ptr = truffleExec(c->u.truffle.mask1, c->u.truffle.mask2, buf + begin, buf + end); if (ptr == buf + end) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); assert(ptr >= buf && ptr < buf + end); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char castleScan(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { assert(begin <= end); if (begin == end) { return 0; } switch (c->type) { case CASTLE_DOT: // Nothing can stop a dot scan! return 0; case CASTLE_VERM: return castleScanVerm(c, buf, begin, end, loc); case CASTLE_NVERM: return castleScanNVerm(c, buf, begin, end, loc); case CASTLE_SHUFTI: return castleScanShufti(c, buf, begin, end, loc); case CASTLE_TRUFFLE: return castleScanTruffle(c, buf, begin, end, loc); default: DEBUG_PRINTF("unknown scan type!\n"); assert(0); return 0; } } static really_inline char castleRevScanVerm(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { const u8 *ptr = rvermicelliExec(c->u.verm.c, 0, buf + begin, buf + end); if (ptr == buf + begin - 1) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); assert(ptr >= buf && ptr < buf + end); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char castleRevScanNVerm(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { const u8 *ptr = rnvermicelliExec(c->u.verm.c, 0, buf + begin, buf + end); if (ptr == buf + begin - 1) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); assert(ptr >= buf && ptr < buf + end); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char castleRevScanShufti(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { const m128 mask_lo = c->u.shuf.mask_lo; const m128 mask_hi = c->u.shuf.mask_hi; const u8 *ptr = rshuftiExec(mask_lo, mask_hi, buf + begin, buf + end); if (ptr == buf + begin - 1) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); assert(ptr >= buf && ptr < buf + end); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char castleRevScanTruffle(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { const u8 *ptr = rtruffleExec(c->u.truffle.mask1, c->u.truffle.mask2, buf + begin, buf + end); if (ptr == buf + begin - 1) { DEBUG_PRINTF("no escape found\n"); return 0; } assert(loc); assert(ptr >= buf && ptr < buf + end); *loc = (size_t)(ptr - buf); DEBUG_PRINTF("escape found at offset %zu\n", *loc); return 1; } static really_inline char castleRevScan(const struct Castle *c, const u8 *buf, const size_t begin, const size_t end, size_t *loc) { assert(begin <= end); DEBUG_PRINTF("scanning backwards over (%zu,%zu]\n", begin, end); if (begin == end) { return 0; } switch (c->type) { case CASTLE_DOT: // Nothing can stop a dot scan! return 0; case CASTLE_VERM: return castleRevScanVerm(c, buf, begin, end, loc); case CASTLE_NVERM: return castleRevScanNVerm(c, buf, begin, end, loc); case CASTLE_SHUFTI: return castleRevScanShufti(c, buf, begin, end, loc); case CASTLE_TRUFFLE: return castleRevScanTruffle(c, buf, begin, end, loc); default: DEBUG_PRINTF("unknown scan type!\n"); assert(0); return 0; } } static really_inline void castleHandleEvent(const struct Castle *c, struct mq *q, const u64a sp, char stale_checked) { const u32 event = q->items[q->cur].type; switch (event) { case MQE_TOP: assert(0); // should be a numbered top break; case MQE_START: case MQE_END: break; default: assert(event >= MQE_TOP_FIRST); assert(event < MQE_INVALID); u32 top = event - MQE_TOP_FIRST; DEBUG_PRINTF("top %u at offset %llu\n", top, sp); castleProcessTop(c, top, sp, q->state, q->streamState, stale_checked); break; } } static really_inline void clear_repeats(const struct Castle *c, const struct mq *q, u8 *active) { DEBUG_PRINTF("clearing active repeats due to escape\n"); if (c->exclusive) { u8 *groups = (u8 *)q->streamState + c->groupIterOffset; mmbit_clear(groups, c->numGroups); } if (c->exclusive != PURE_EXCLUSIVE) { mmbit_clear(active, c->numRepeats); } } static really_inline char nfaExecCastle_Q_i(const struct NFA *n, struct mq *q, s64a end, enum MatchMode mode) { assert(n && q); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("state=%p, streamState=%p\n", q->state, q->streamState); const struct Castle *c = getImplNfa(n); if (q->report_current) { int rv = castleReportCurrent(c, q); q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } if (q->cur == q->end) { return 1; } u8 *active = (u8 *)q->streamState + c->activeOffset;// active multibit assert(q->cur + 1 < q->end); // require at least two items assert(q_cur_type(q) == MQE_START); u64a sp = q_cur_offset(q); q->cur++; DEBUG_PRINTF("sp=%llu, abs_end=%llu\n", sp, end + q->offset); while (q->cur < q->end) { DEBUG_PRINTF("q item type=%d offset=%llu\n", q_cur_type(q), q_cur_offset(q)); char found = 0; if (c->exclusive) { u8 *groups = (u8 *)q->streamState + c->groupIterOffset; found = mmbit_any(groups, c->numGroups); } if (!found && !mmbit_any(active, c->numRepeats)) { DEBUG_PRINTF("no repeats active, skipping scan\n"); goto scan_done; } u64a ep = q_cur_offset(q); ep = MIN(ep, q->offset + end); if (sp < ep) { size_t eloc = 0; char escape_found = 0; DEBUG_PRINTF("scanning from sp=%llu to ep=%llu\n", sp, ep); assert(sp >= q->offset && ep >= q->offset); if (castleScan(c, q->buffer, sp - q->offset, ep - q->offset, &eloc)) { escape_found = 1; ep = q->offset + eloc; DEBUG_PRINTF("escape found at %llu\n", ep); assert(ep >= sp); } assert(sp <= ep); if (mode == STOP_AT_MATCH) { size_t mloc; if (castleFindMatch(c, sp, ep, q->state, q->streamState, &mloc)) { DEBUG_PRINTF("storing match at %llu\n", sp + mloc); q->cur--; assert(q->cur < MAX_MQE_LEN); q->items[q->cur].type = MQE_START; q->items[q->cur].location = (s64a)(sp - q->offset) + mloc; return MO_MATCHES_PENDING; } } else { assert(mode == CALLBACK_OUTPUT); char rv = castleMatchLoop(c, sp, ep, q->state, q->streamState, q->cb, q->context); if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } assert(rv == MO_CONTINUE_MATCHING); } if (escape_found) { clear_repeats(c, q, active); } } scan_done: if (q_cur_loc(q) > end) { q->cur--; assert(q->cur < MAX_MQE_LEN); q->items[q->cur].type = MQE_START; q->items[q->cur].location = end; return MO_ALIVE; } sp = q_cur_offset(q); castleHandleEvent(c, q, sp, 1); q->cur++; } if (c->exclusive) { u8 *groups = (u8 *)q->streamState + c->groupIterOffset; if (mmbit_any_precise(groups, c->numGroups)) { return 1; } } return mmbit_any_precise(active, c->numRepeats); } char nfaExecCastle_Q(const struct NFA *n, struct mq *q, s64a end) { DEBUG_PRINTF("entry\n"); return nfaExecCastle_Q_i(n, q, end, CALLBACK_OUTPUT); } char nfaExecCastle_Q2(const struct NFA *n, struct mq *q, s64a end) { DEBUG_PRINTF("entry\n"); return nfaExecCastle_Q_i(n, q, end, STOP_AT_MATCH); } static s64a castleLastKillLoc(const struct Castle *c, struct mq *q) { assert(q_cur_type(q) == MQE_START); assert(q_last_type(q) == MQE_END); s64a sp = q_cur_loc(q); s64a ep = q_last_loc(q); DEBUG_PRINTF("finding final squash in (%lld, %lld]\n", sp, ep); size_t loc; if (ep > 0) { if (castleRevScan(c, q->buffer, sp > 0 ? sp : 0, ep, &loc)) { return (s64a)loc; } ep = 0; } if (sp < 0) { s64a hlen = q->hlength; if (castleRevScan(c, q->history, sp + hlen, ep + hlen, &loc)) { return (s64a)loc - hlen; } ep = 0; } return sp - 1; /* the repeats are never killed */ } char nfaExecCastle_QR(const struct NFA *n, struct mq *q, ReportID report) { assert(n && q); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("entry\n"); if (q->cur == q->end) { return 1; } assert(q->cur + 1 < q->end); /* require at least two items */ assert(q_cur_type(q) == MQE_START); const struct Castle *c = getImplNfa(n); u8 *active = (u8 *)q->streamState + c->activeOffset; u64a end_offset = q_last_loc(q) + q->offset; s64a last_kill_loc = castleLastKillLoc(c, q); DEBUG_PRINTF("all repeats killed at %lld (exec range %lld, %lld)\n", last_kill_loc, q_cur_loc(q), q_last_loc(q)); assert(last_kill_loc < q_last_loc(q)); if (last_kill_loc != q_cur_loc(q) - 1) { clear_repeats(c, q, active); } q->cur++; /* skip start event */ /* skip events prior to the repeats being squashed */ while (q_cur_loc(q) <= last_kill_loc) { DEBUG_PRINTF("skipping moot event at %lld\n", q_cur_loc(q)); q->cur++; assert(q->cur < q->end); } while (q->cur < q->end) { DEBUG_PRINTF("q item type=%d offset=%llu\n", q_cur_type(q), q_cur_offset(q)); u64a sp = q_cur_offset(q); castleHandleEvent(c, q, sp, 0); q->cur++; } castleDeactivateStaleSubs(c, end_offset, q->state, q->streamState); char found = 0; if (c->exclusive) { u8 *groups = (u8 *)q->streamState + c->groupIterOffset; found = mmbit_any_precise(groups, c->numGroups); } if (!found && !mmbit_any_precise(active, c->numRepeats)) { DEBUG_PRINTF("castle is dead\n"); return 0; } if (castleInAccept(c, q, report, end_offset)) { return MO_MATCHES_PENDING; } return 1; } char nfaExecCastle_reportCurrent(const struct NFA *n, struct mq *q) { assert(n && q); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("entry\n"); const struct Castle *c = getImplNfa(n); castleReportCurrent(c, q); return 0; } char nfaExecCastle_inAccept(const struct NFA *n, ReportID report, struct mq *q) { assert(n && q); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("entry\n"); const struct Castle *c = getImplNfa(n); return castleInAccept(c, q, report, q_cur_offset(q)); } char nfaExecCastle_inAnyAccept(const struct NFA *n, struct mq *q) { assert(n && q); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("entry\n"); const struct Castle *c = getImplNfa(n); const u64a offset = q_cur_offset(q); DEBUG_PRINTF("offset=%llu\n", offset); if (c->exclusive) { u8 *active = (u8 *)q->streamState; u8 *groups = active + c->groupIterOffset; for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) { u8 *cur = active + i * c->activeIdxSize; const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize); DEBUG_PRINTF("subcastle %u\n", activeIdx); const struct SubCastle *sub = getSubCastle(c, activeIdx); if (subCastleInAccept(c, q, sub->report, offset, activeIdx)) { return 1; } } } if (c->exclusive != PURE_EXCLUSIVE) { const u8 *active = (const u8 *)q->streamState + c->activeOffset; for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) { DEBUG_PRINTF("subcastle %u\n", i); const struct SubCastle *sub = getSubCastle(c, i); if (subCastleInAccept(c, q, sub->report, offset, i)) { return 1; } } } return 0; } char nfaExecCastle_queueInitState(UNUSED const struct NFA *n, struct mq *q) { assert(n && q); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("entry\n"); const struct Castle *c = getImplNfa(n); assert(q->streamState); if (c->exclusive) { u8 *groups = (u8 *)q->streamState + c->groupIterOffset; mmbit_clear(groups, c->numGroups); } if (c->exclusive != PURE_EXCLUSIVE) { u8 *active = (u8 *)q->streamState + c->activeOffset; mmbit_clear(active, c->numRepeats); } return 0; } char nfaExecCastle_initCompressedState(const struct NFA *n, UNUSED u64a offset, void *state, UNUSED u8 key) { assert(n && state); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("entry\n"); const struct Castle *c = getImplNfa(n); if (c->exclusive) { u8 *groups = (u8 *)state + c->groupIterOffset; mmbit_clear(groups, c->numGroups); } if (c->exclusive != PURE_EXCLUSIVE) { u8 *active = (u8 *)state + c->activeOffset; mmbit_clear(active, c->numRepeats); } return 0; } static really_inline void subCastleQueueCompressState(const struct Castle *c, const u32 subIdx, const struct mq *q, const u64a offset) { const struct SubCastle *sub = getSubCastle(c, subIdx); const struct RepeatInfo *info = getRepeatInfo(sub); union RepeatControl *rctrl = getControl(q->state, sub); char *packed = (char *)q->streamState + sub->streamStateOffset; DEBUG_PRINTF("sub %u next match %llu\n", subIdx, repeatNextMatch(info, rctrl, packed + info->packedCtrlSize, offset)); repeatPack(packed, info, rctrl, offset); } char nfaExecCastle_queueCompressState(const struct NFA *n, const struct mq *q, s64a loc) { assert(n && q); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("entry, loc=%lld\n", loc); const struct Castle *c = getImplNfa(n); // Pack state for all active repeats. const u64a offset = q->offset + loc; DEBUG_PRINTF("offset=%llu\n", offset); if (c->exclusive) { u8 *active = (u8 *)q->streamState; u8 *groups = active + c->groupIterOffset; for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) { u8 *cur = active + i * c->activeIdxSize; const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize); DEBUG_PRINTF("packing state for sub %u\n", activeIdx); subCastleQueueCompressState(c, activeIdx, q, offset); } } if (c->exclusive != PURE_EXCLUSIVE) { const u8 *active = (const u8 *)q->streamState + c->activeOffset; for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) { DEBUG_PRINTF("packing state for sub %u\n", i); subCastleQueueCompressState(c, i, q, offset); } } return 0; } static really_inline void subCastleExpandState(const struct Castle *c, const u32 subIdx, void *dest, const void *src, const u64a offset) { const struct SubCastle *sub = getSubCastle(c, subIdx); const struct RepeatInfo *info = getRepeatInfo(sub); DEBUG_PRINTF("unpacking state for sub %u\n", subIdx); union RepeatControl *rctrl = getControl(dest, sub); const char *packed = (const char *)src + sub->streamStateOffset; repeatUnpack(packed, info, offset, rctrl); DEBUG_PRINTF("sub %u next match %llu\n", subIdx, repeatNextMatch(info, rctrl, packed + info->packedCtrlSize, offset)); } char nfaExecCastle_expandState(const struct NFA *n, void *dest, const void *src, u64a offset, UNUSED u8 key) { assert(n && dest && src); assert(n->type == CASTLE_NFA); DEBUG_PRINTF("entry, src=%p, dest=%p, offset=%llu\n", src, dest, offset); const struct Castle *c = getImplNfa(n); if (c->exclusive) { const u8 *active = (const u8 *)src; const u8 *groups = active + c->groupIterOffset; for (u32 i = mmbit_iterate(groups, c->numGroups, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(groups, c->numGroups, i)) { const u8 *cur = active + i * c->activeIdxSize; const u32 activeIdx = partial_load_u32(cur, c->activeIdxSize); subCastleExpandState(c, activeIdx, dest, src, offset); } } if (c->exclusive != PURE_EXCLUSIVE) { // Unpack state for all active repeats. const u8 *active = (const u8 *)src + c->activeOffset; for (u32 i = mmbit_iterate(active, c->numRepeats, MMB_INVALID); i != MMB_INVALID; i = mmbit_iterate(active, c->numRepeats, i)) { subCastleExpandState(c, i, dest, src, offset); } } return 0; } hyperscan-4.4.1/src/nfa/truffle.c0000644000175000017500000002276513055426554017461 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /* * Matches a byte in a charclass using three shuffles */ #include "ue2common.h" #include "truffle.h" #include "util/bitutils.h" #include "util/simd_utils.h" #include "truffle_common.h" #if !defined(__AVX2__) static really_inline const u8 *lastMatch(const u8 *buf, u32 z) { if (unlikely(z != 0xffff)) { u32 pos = clz32(~z & 0xffff); assert(pos >= 16 && pos < 32); return buf + (31 - pos); } return NULL; // no match } static really_inline const u8 *fwdBlock(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, m128 v, const u8 *buf) { u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v); return firstMatch(buf, z); } static really_inline const u8 *revBlock(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, m128 v, const u8 *buf) { u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v); return lastMatch(buf, z); } const u8 *truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("len %zu\n", buf_end - buf); assert(buf && buf_end); assert(buf < buf_end); const u8 *rv; if (buf_end - buf < 16) { return truffleMini(shuf_mask_lo_highclear, shuf_mask_lo_highset, buf, buf_end); } size_t min = (size_t)buf % 16; assert(buf_end - buf >= 16); // Preconditioning: most of the time our buffer won't be aligned. m128 chars = loadu128(buf); rv = fwdBlock(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars, buf); if (rv) { return rv; } buf += (16 - min); const u8 *last_block = buf_end - 16; while (buf < last_block) { m128 lchars = load128(buf); rv = fwdBlock(shuf_mask_lo_highclear, shuf_mask_lo_highset, lchars, buf); if (rv) { return rv; } buf += 16; } // Use an unaligned load to mop up the last 16 bytes and get an accurate // picture to buf_end. assert(buf <= buf_end && buf >= buf_end - 16); chars = loadu128(buf_end - 16); rv = fwdBlock(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars, buf_end - 16); if (rv) { return rv; } return buf_end; } static const u8 *truffleRevMini(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end) { uintptr_t len = buf_end - buf; assert(len < 16); m128 chars = zeroes128(); memcpy(&chars, buf, len); u32 mask = (0xFFFF >> (16 - len)) ^ 0xFFFF; u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars); const u8 *rv = lastMatch(buf, z | mask); if (rv) { return rv; } return buf - 1; } const u8 *rtruffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end) { assert(buf && buf_end); assert(buf < buf_end); const u8 *rv; DEBUG_PRINTF("len %zu\n", buf_end - buf); if (buf_end - buf < 16) { return truffleRevMini(shuf_mask_lo_highclear, shuf_mask_lo_highset, buf, buf_end); } assert(buf_end - buf >= 16); // Preconditioning: most of the time our buffer won't be aligned. m128 chars = loadu128(buf_end - 16); rv = revBlock(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars, buf_end - 16); if (rv) { return rv; } buf_end = (const u8 *)((size_t)buf_end & ~((size_t)0xf)); const u8 *last_block = buf + 16; while (buf_end > last_block) { buf_end -= 16; m128 lchars = load128(buf_end); rv = revBlock(shuf_mask_lo_highclear, shuf_mask_lo_highset, lchars, buf_end); if (rv) { return rv; } } // Use an unaligned load to mop up the last 16 bytes and get an accurate // picture to buf_end. chars = loadu128(buf); rv = revBlock(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars, buf); if (rv) { return rv; } return buf - 1; } #else static really_inline const u8 *lastMatch(const u8 *buf, u32 z) { if (unlikely(z != 0xffffffff)) { u32 pos = clz32(~z); assert(pos < 32); return buf + (31 - pos); } return NULL; // no match } static really_inline const u8 *fwdBlock(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset, m256 v, const u8 *buf) { u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v); return firstMatch(buf, z); } static really_inline const u8 *revBlock(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset, m256 v, const u8 *buf) { u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, v); return lastMatch(buf, z); } const u8 *truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("len %zu\n", buf_end - buf); const m256 wide_clear = set2x128(shuf_mask_lo_highclear); const m256 wide_set = set2x128(shuf_mask_lo_highset); assert(buf && buf_end); assert(buf < buf_end); const u8 *rv; if (buf_end - buf < 32) { return truffleMini(wide_clear, wide_set, buf, buf_end); } size_t min = (size_t)buf % 32; assert(buf_end - buf >= 32); // Preconditioning: most of the time our buffer won't be aligned. m256 chars = loadu256(buf); rv = fwdBlock(wide_clear, wide_set, chars, buf); if (rv) { return rv; } buf += (32 - min); const u8 *last_block = buf_end - 32; while (buf < last_block) { m256 lchars = load256(buf); rv = fwdBlock(wide_clear, wide_set, lchars, buf); if (rv) { return rv; } buf += 32; } // Use an unaligned load to mop up the last 32 bytes and get an accurate // picture to buf_end. assert(buf <= buf_end && buf >= buf_end - 32); chars = loadu256(buf_end - 32); rv = fwdBlock(wide_clear, wide_set, chars, buf_end - 32); if (rv) { return rv; } return buf_end; } static const u8 *truffleRevMini(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end) { uintptr_t len = buf_end - buf; assert(len < 32); m256 chars = zeroes256(); memcpy(&chars, buf, len); u32 mask = (0xFFFFFFFF >> (32 - len)) ^ 0xFFFFFFFF; u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars); const u8 *rv = lastMatch(buf, z | mask); if (rv) { return rv; } return buf - 1; } const u8 *rtruffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end) { const m256 wide_clear = set2x128(shuf_mask_lo_highclear); const m256 wide_set = set2x128(shuf_mask_lo_highset); assert(buf && buf_end); assert(buf < buf_end); const u8 *rv; DEBUG_PRINTF("len %zu\n", buf_end - buf); if (buf_end - buf < 32) { return truffleRevMini(wide_clear, wide_set, buf, buf_end); } assert(buf_end - buf >= 32); // Preconditioning: most of the time our buffer won't be aligned. m256 chars = loadu256(buf_end - 32); rv = revBlock(wide_clear, wide_set, chars, buf_end - 32); if (rv) { return rv; } buf_end = (const u8 *)((size_t)buf_end & ~((size_t)0x1f)); const u8 *last_block = buf + 32; while (buf_end > last_block) { buf_end -= 32; m256 lchars = load256(buf_end); rv = revBlock(wide_clear, wide_set, lchars, buf_end); if (rv) { return rv; } } // Use an unaligned load to mop up the last 32 bytes and get an accurate // picture to buf_end. chars = loadu256(buf); rv = revBlock(wide_clear, wide_set, chars, buf); if (rv) { return rv; } return buf - 1; } #endif hyperscan-4.4.1/src/nfa/limex_dump.cpp0000644000175000017500000004266213055426554020513 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "limex.h" #include "accel.h" #include "accel_dump.h" #include "limex_internal.h" #include "nfa_dump_internal.h" #include "ue2common.h" #include "util/charreach.h" #include "util/dump_charclass.h" #include "util/dump_mask.h" #include "util/dump_util.h" #include #include #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { template struct limex_traits {}; template<> struct limex_traits { static const u32 size = 512; typedef NFAException512 exception_type; }; template<> struct limex_traits { static const u32 size = 384; typedef NFAException384 exception_type; }; template<> struct limex_traits { static const u32 size = 256; typedef NFAException256 exception_type; }; template<> struct limex_traits { static const u32 size = 128; typedef NFAException128 exception_type; }; template<> struct limex_traits { static const u32 size = 64; typedef NFAException64 exception_type; }; template<> struct limex_traits { static const u32 size = 32; typedef NFAException32 exception_type; }; static void dumpMask(FILE *f, const char *name, const u8 *mask, u32 mask_bits) { fprintf(f, "MSK %-20s %s\n", name, dumpMask(mask, mask_bits).c_str()); } template static u32 rank_in_mask(const mask_t &mask, u32 bit) { assert(bit < 8 * sizeof(mask)); u32 chunks[sizeof(mask)/sizeof(u32)]; memcpy(chunks, &mask, sizeof(mask)); u32 base_rank = 0; for (u32 i = 0; i < bit / 32; i++) { base_rank += popcount32(chunks[i]); } u32 chunk = chunks[bit / 32]; u32 local_bit = bit % 32; assert(chunk & (1U << local_bit)); return base_rank + popcount32(chunk & ((1U << local_bit) - 1)); } template static void dumpRepeats(const limex_type *limex, u32 model_size, FILE *f) { fprintf(f, "\n"); fprintf(f, "%u bounded repeats.\n", limex->repeatCount); const char *base = (const char *)limex; const u32 *repeatOffset = (const u32 *)(base + limex->repeatOffset); for (u32 i = 0; i < limex->repeatCount; i++) { const NFARepeatInfo *info = (const NFARepeatInfo *)(base + repeatOffset[i]); const RepeatInfo *repeat = (const RepeatInfo *)((const char *)info + sizeof(*info)); fprintf(f, " repeat %u: %s {%u,%u} packedCtrlSize=%u, " "stateSize=%u\n", i, repeatTypeName(repeat->type), repeat->repeatMin, repeat->repeatMax, repeat->packedCtrlSize, repeat->stateSize); fprintf(f, " nfa state: stream offset %u\n", info->stateOffset); fprintf(f, " "); const u8 *tug_mask = (const u8 *)info + info->tugMaskOffset; dumpMask(f, "tugs", tug_mask, model_size); } fprintf(f, "\n"); } static void dumpLimexReachMasks(u32 model_size, const u8 *reach, u32 reachCount, FILE *f) { for (u32 i = 0; i < reachCount; i++) { char tmp_common[100]; const u8 *row = reach + (i * (model_size/8)); sprintf(tmp_common, "reach mask %u ", i); dumpMask(f, tmp_common, row, model_size); } } static void dumpLimexReachMap(const u8 *reachMap, FILE *f) { for (u32 i = 0; i < N_CHARS; i++) { fprintf(f, "reach 0x%02x ", i); if (!isprint(i)) { fprintf(f, " "); } else { fprintf(f, "'%c'", (char)i); } fprintf(f, " -> mask %hhu\n", reachMap[i]); } } template static const NFA *limex_to_nfa(const limex_type *limex) { return (const NFA *)((const char *)limex - sizeof(NFA)); } template static void dumpAccel(const limex_type *limex, FILE *f) { fprintf(f, "\n"); fprintf(f, "%u acceleration schemes.\n", limex->accelCount); if (!limex->accelCount) { return; } u32 tableOffset = limex->accelTableOffset; u32 auxOffset = limex->accelAuxOffset; const u8 *accelTable = (const u8 *)((const char *)limex + tableOffset); const AccelAux *aux = (const AccelAux *)((const char *)limex + auxOffset); for (u32 i = 0; i < limex->accelCount; i++) { fprintf(f, " accel %u (aux entry %u): ", i, accelTable[i]); dumpAccelInfo(f, aux[accelTable[i]]); } } static void dumpAcceptList(const char *limex_base, const struct NFAAccept *accepts, u32 acceptCount, FILE *f) { for (u32 i = 0; i < acceptCount; i++) { const NFAAccept &a = accepts[i]; if (a.single_report) { fprintf(f, " idx %u fires single report %u\n", i, a.reports); continue; } fprintf(f, " idx %u fires report list %u:", i, a.reports); const ReportID *report = (const ReportID *)(limex_base + a.reports); for (; *report != MO_INVALID_IDX; report++) { fprintf(f, " %u", *report); } fprintf(f, "\n"); } } template static void dumpAccepts(const limex_type *limex, FILE *f) { const char *limex_base = (const char *)limex; const u32 acceptCount = limex->acceptCount; const u32 acceptEodCount = limex->acceptEodCount; fprintf(f, "\n%u accepts.\n", acceptCount); const auto *accepts = (const struct NFAAccept *)(limex_base + limex->acceptOffset); dumpAcceptList(limex_base, accepts, acceptCount, f); fprintf(f, "\n%u accepts at EOD.\n", acceptEodCount); const auto *accepts_eod = (const struct NFAAccept *)(limex_base + limex->acceptEodOffset); dumpAcceptList(limex_base, accepts_eod, acceptEodCount, f); fprintf(f, "\n"); } template static void dumpSquash(const limex_type *limex, FILE *f) { u32 size = limex_traits::size; // Dump squash masks, if there are any. const u8 *squashMask = (const u8 *)limex + limex->squashOffset; for (u32 i = 0; i < limex->squashCount; i++) { std::ostringstream name; name << "squash_" << i; dumpMask(f, name.str().c_str(), squashMask, size); squashMask += size / 8; } } template static const typename limex_traits::exception_type * getExceptionTable(const limex_type *limex) { return (const typename limex_traits::exception_type *) ((const char *)limex + limex->exceptionOffset); } template static void dumpLimexExceptions(const limex_type *limex, FILE *f) { const typename limex_traits::exception_type *e = getExceptionTable(limex); const u32 size = limex_traits::size; const char *limex_base = (const char *)limex; fprintf(f, "\n"); for (u32 i = 0; i < limex->exceptionCount; i++) { fprintf(f, "exception %u: hasSquash=%u, reports offset=%u\n", i, e[i].hasSquash, e[i].reports); switch (e[i].trigger) { case LIMEX_TRIGGER_TUG: fprintf(f, " trigger: TUG\n"); break; case LIMEX_TRIGGER_POS: fprintf(f, " trigger: POS\n"); break; default: break; } dumpMask(f, "succ", (const u8 *)&e[i].successors, size); dumpMask(f, "squash", (const u8 *)&e[i].squash, size); fprintf(f, "reports: "); if (e[i].reports == MO_INVALID_IDX) { fprintf(f, " \n"); } else { const ReportID *r = (const ReportID *)(limex_base + e[i].reports); while (*r != MO_INVALID_IDX) { fprintf(f, " %u", *r++); } fprintf(f, "\n"); } } } template static void dumpLimexShifts(const limex_type *limex, FILE *f) { u32 size = limex_traits::size; fprintf(f, "Shift Masks:\n"); for(u32 i = 0; i < limex->shiftCount; i++) { fprintf(f, "\t Shift %u(%hhu)\t\tMask: %s\n", i, limex->shiftAmount[i], dumpMask((const u8 *)&limex->shift[i], size).c_str()); } } template static void dumpLimexText(const limex_type *limex, FILE *f) { u32 size = limex_traits::size; dumpMask(f, "init", (const u8 *)&limex->init, size); dumpMask(f, "init_dot_star", (const u8 *)&limex->initDS, size); dumpMask(f, "accept", (const u8 *)&limex->accept, size); dumpMask(f, "accept_at_eod", (const u8 *)&limex->acceptAtEOD, size); dumpMask(f, "accel", (const u8 *)&limex->accel, size); dumpMask(f, "accel_and_friends", (const u8 *)&limex->accel_and_friends, size); dumpMask(f, "compress_mask", (const u8 *)&limex->compressMask, size); dumpMask(f, "emask", (const u8 *)&limex->exceptionMask, size); dumpMask(f, "zombie", (const u8 *)&limex->zombieMask, size); // Dump top masks, if there are any. u32 topCount = limex->topCount; const u8 *topMask = (const u8 *)limex + limex->topOffset; for (u32 i = 0; i < topCount; i++) { std::ostringstream name; name << "top_" << i; dumpMask(f, name.str().c_str(), topMask, size); topMask += size / 8; } // Dump shift masks dumpLimexShifts(limex, f); dumpSquash(limex, f); dumpLimexReachMap(limex->reachMap, f); dumpLimexReachMasks(size, (const u8 *)limex + sizeof(*limex) /* reach*/, limex->reachSize, f); dumpAccepts(limex, f); dumpLimexExceptions(limex, f); dumpAccel(limex, f); dumpRepeats(limex, size, f); dumpTextReverse(limex_to_nfa(limex), f); } static bool testbit(const u8 *mask, UNUSED u32 mask_bits, u32 bit) { u32 byte = bit / 8; return mask[byte] & (1 << (bit % 8)); } static void setupReach(const u8 *reachMap, const u8 *reachBase, u32 size, u32 state_count, vector *perStateReach) { for (u32 i = 0; i < state_count; i++) { perStateReach->push_back(CharReach()); for (u32 j = 0; j < N_CHARS; j++) { u8 k = reachMap[j]; const u8 *r = reachBase + k * (size/8); if (testbit(r, size, i)) { perStateReach->back().set(j); } } } } namespace { struct nfa_labeller { virtual ~nfa_labeller() {} virtual void label_state(FILE *f, u32 state) const = 0; }; template struct limex_labeller : public nfa_labeller { explicit limex_labeller(const limex_type *limex_in) : limex(limex_in) {} void label_state(FILE *f, u32 state) const override { const typename limex_traits::exception_type *exceptions = getExceptionTable(limex); if (!testbit((const u8 *)&limex->exceptionMask, limex_traits::size, state)) { return; } u32 ex_index = rank_in_mask(limex->exceptionMask, state); const typename limex_traits::exception_type *e = &exceptions[ex_index]; switch (e->trigger) { case LIMEX_TRIGGER_TUG: fprintf(f, "\\nTUG"); break; case LIMEX_TRIGGER_POS: fprintf(f, "\\nPOS"); break; default: break; } } const limex_type *limex; }; } template static void dumpVertexDotInfo(const limex_type *limex, u32 state_count, FILE *f, const nfa_labeller &labeller) { u32 size = sizeof(limex->init) * 8; const u8 *reach = (const u8 *)limex + sizeof(*limex); vector perStateReach; setupReach(limex->reachMap, reach, size, state_count, &perStateReach); const u8 *topMask = (const u8 *)limex + limex->topOffset; for (u32 state = 0; state < state_count; state++) { fprintf(f, "%u [ width = 1, fixedsize = true, fontsize = 12, " "label = \"%u\\n", state, state); assert(perStateReach[state].any()); describeClass(f, perStateReach[state], 5, CC_OUT_DOT); labeller.label_state(f, state); // bung in another couple lines to push char class (the widest thing) up a bit fprintf(f, "\\n\\n\" ];\n"); if (testbit((const u8 *)&limex->acceptAtEOD, size, state)) { fprintf(f, "%u [ shape = box ];\n", state); } else if (testbit((const u8 *)&limex->accept, size, state)) { fprintf(f, "%u [ shape = doublecircle ];\n", state); } if (testbit((const u8 *)&limex->accel, size, state)) { fprintf(f, "%u [ color = red style = diagonals];\n", state); } if (testbit((const u8 *)&limex->init, size, state)) { fprintf(f, "START -> %u [ color = grey ];\n", state); } // vertex could be in a top mask. for (u32 i = 0; i < limex->topCount; i++) { const u8 *msk = topMask + i * (size / 8); if (testbit(msk, size, state)) { fprintf(f, "START -> %u [ color = grey, " "label = \"TOP %u\" ];\n", state, i); } } } } template static void dumpExDotInfo(const limex_type *limex, u32 state, FILE *f) { u32 size = limex_traits::size; if (!testbit((const u8 *)&limex->exceptionMask, size, state)) { return; /* not exceptional */ } const typename limex_traits::exception_type *exceptions = getExceptionTable(limex); u32 ex_index = rank_in_mask(limex->exceptionMask, state); const typename limex_traits::exception_type *e = &exceptions[ex_index]; u32 state_count = limex_to_nfa(limex)->nPositions; for (u32 j = 0; j < state_count; j++) { if (testbit((const u8 *)&e->successors, size, j)) { fprintf(f, "%u -> %u [color = blue];\n", state, j); } if (!testbit((const u8 *)&e->squash, size, j)) { fprintf(f, "%u -> %u [color = grey style = dashed];\n", state, j); } } if (e->trigger != LIMEX_TRIGGER_NONE) { fprintf(f, "%u [color = forestgreen];\n", state); } else { fprintf(f, "%u [color = blue];\n", state); } } template static void dumpLimDotInfo(const limex_type *limex, u32 state, FILE *f) { for (u32 j = 0; j < limex->shiftCount; j++) { const u32 shift_amount = limex->shiftAmount[j]; if (testbit((const u8 *)&limex->shift[j], limex_traits::size, state)) { fprintf(f, "%u -> %u;\n", state, state + shift_amount); } } } #define LIMEX_DUMP_FN(size) \ void nfaExecLimEx##size##_dump(const NFA *nfa, const string &base) { \ auto limex = (const LimExNFA##size *)getImplNfa(nfa); \ \ FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); \ dumpLimexText(limex, f); \ fclose(f); \ \ f = fopen_or_throw((base + ".dot").c_str(), "w"); \ dumpDotPreamble(f); \ u32 state_count = nfa->nPositions; \ dumpVertexDotInfo(limex, state_count, f, \ limex_labeller(limex)); \ for (u32 i = 0; i < state_count; i++) { \ dumpLimDotInfo(limex, i, f); \ dumpExDotInfo(limex, i, f); \ } \ dumpDotTrailer(f); \ fclose(f); \ } LIMEX_DUMP_FN(32) LIMEX_DUMP_FN(64) LIMEX_DUMP_FN(128) LIMEX_DUMP_FN(256) LIMEX_DUMP_FN(384) LIMEX_DUMP_FN(512) } // namespace ue2 hyperscan-4.4.1/src/nfa/gough.h0000644000175000017500000001004413055426554017113 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 GOUGH_H #define GOUGH_H #include "callback.h" #include "ue2common.h" struct NFA; struct mq; // 8-bit Gough char nfaExecGough8_testEOD(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); char nfaExecGough8_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecGough8_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecGough8_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecGough8_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecGough8_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecGough8_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecGough8_queueInitState(const struct NFA *n, struct mq *q); char nfaExecGough8_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecGough8_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecGough8_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecGough8_B_Reverse NFA_API_NO_IMPL #define nfaExecGough8_zombie_status NFA_API_ZOMBIE_NO_IMPL // 16-bit Gough char nfaExecGough16_testEOD(const struct NFA *nfa, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); char nfaExecGough16_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecGough16_Q2(const struct NFA *n, struct mq *q, s64a end); char nfaExecGough16_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecGough16_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecGough16_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecGough16_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecGough16_queueInitState(const struct NFA *n, struct mq *q); char nfaExecGough16_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecGough16_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecGough16_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecGough16_B_Reverse NFA_API_NO_IMPL #define nfaExecGough16_zombie_status NFA_API_ZOMBIE_NO_IMPL #endif hyperscan-4.4.1/src/nfa/truffle_common.h0000644000175000017500000001077313055426554021032 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 TRUFFLE_COMMON_H_ #define TRUFFLE_COMMON_H_ #include "util/bitutils.h" #include "util/simd_utils.h" /* * Common stuff for all versions of truffle (single, multi and multidouble) */ #if !defined(__AVX2__) static really_inline const u8 *firstMatch(const u8 *buf, u32 z) { if (unlikely(z != 0xffff)) { u32 pos = ctz32(~z & 0xffff); assert(pos < 16); return buf + pos; } return NULL; // no match } static really_inline u32 block(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, m128 v) { m128 highconst = _mm_set1_epi8(0x80); m128 shuf_mask_hi = _mm_set1_epi64x(0x8040201008040201); // and now do the real work m128 shuf1 = pshufb(shuf_mask_lo_highclear, v); m128 t1 = xor128(v, highconst); m128 shuf2 = pshufb(shuf_mask_lo_highset, t1); m128 t2 = andnot128(highconst, rshift64_m128(v, 4)); m128 shuf3 = pshufb(shuf_mask_hi, t2); m128 tmp = and128(or128(shuf1, shuf2), shuf3); m128 tmp2 = eq128(tmp, zeroes128()); u32 z = movemask128(tmp2); return z; } static const u8 *truffleMini(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end) { uintptr_t len = buf_end - buf; assert(len < 16); m128 chars = zeroes128(); memcpy(&chars, buf, len); u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars); // can't be these bytes in z u32 mask = (0xFFFF >> (16 - len)) ^ 0xFFFF; const u8 *rv = firstMatch(buf, z| mask); if (rv) { return rv; } else { return buf_end; } } #else static really_inline const u8 *firstMatch(const u8 *buf, u32 z) { if (unlikely(z != 0xffffffff)) { u32 pos = ctz32(~z); assert(pos < 32); return buf + pos; } return NULL; // no match } static really_inline u32 block(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset, m256 v) { m256 highconst = _mm256_set1_epi8(0x80); m256 shuf_mask_hi = _mm256_set1_epi64x(0x8040201008040201); // and now do the real work m256 shuf1 = vpshufb(shuf_mask_lo_highclear, v); m256 t1 = xor256(v, highconst); m256 shuf2 = vpshufb(shuf_mask_lo_highset, t1); m256 t2 = andnot256(highconst, rshift64_m256(v, 4)); m256 shuf3 = vpshufb(shuf_mask_hi, t2); m256 tmp = and256(or256(shuf1, shuf2), shuf3); m256 tmp2 = eq256(tmp, zeroes256()); u32 z = movemask256(tmp2); return z; } static const u8 *truffleMini(m256 shuf_mask_lo_highclear, m256 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end) { uintptr_t len = buf_end - buf; assert(len < 32); m256 chars = zeroes256(); memcpy(&chars, buf, len); u32 z = block(shuf_mask_lo_highclear, shuf_mask_lo_highset, chars); // can't be these bytes in z u32 mask = (0xFFFFFFFF >> (32 - len)) ^ 0xFFFFFFFF; const u8 *rv = firstMatch(buf, z | mask); if (rv) { return rv; } else { return buf_end; } } #endif #endif /* TRUFFLE_COMMON_H_ */ hyperscan-4.4.1/src/nfa/limex_accel.c0000644000175000017500000001515513055426554020252 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Limex NFA: acceleration runtime. */ #include "limex_accel.h" #include "accel.h" #include "limex_internal.h" #include "limex_limits.h" #include "limex_shuffle.h" #include "nfa_internal.h" #include "shufti.h" #include "truffle.h" #include "multishufti.h" #include "multitruffle.h" #include "multivermicelli.h" #include "ue2common.h" #include "vermicelli.h" #include "util/bitutils.h" #include "util/simd_utils.h" static really_inline size_t accelScanWrapper(const u8 *accelTable, const union AccelAux *aux, const u8 *input, u32 idx, size_t i, size_t end) { assert(accelTable); assert(aux); DEBUG_PRINTF("shuffle returned %u -> aux %u\n", idx, accelTable[idx]); assert(idx < (1 << NFA_MAX_ACCEL_STATES)); if (!idx) { return end; } u8 aux_idx = accelTable[idx]; if (!aux_idx) { assert(aux[0].accel_type == ACCEL_NONE); DEBUG_PRINTF("no accel, bailing\n"); return i; } aux = aux + aux_idx; const u8 *ptr = run_accel(aux, &input[i], &input[end]); assert(ptr >= &input[i]); size_t j = (size_t)(ptr - input); DEBUG_PRINTF("accel skipped %zu of %zu chars\n", (j - i), (end - i)); DEBUG_PRINTF("returning j=%zu (i=%zu, end=%zu)\n", j, i, end); return j; } size_t doAccel32(u32 s, u32 accel, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end) { u32 idx = pext32(s, accel); return accelScanWrapper(accelTable, aux, input, idx, i, end); } #ifdef ARCH_64_BIT size_t doAccel64(u64a s, u64a accel, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end) { u32 idx = pext64(s, accel); return accelScanWrapper(accelTable, aux, input, idx, i, end); } #else size_t doAccel64(m128 s, m128 accel, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end) { u32 idx = pext64(movq(s), movq(accel)); return accelScanWrapper(accelTable, aux, input, idx, i, end); } #endif size_t doAccel128(const m128 *state, const struct LimExNFA128 *limex, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end) { u32 idx; m128 s = *state; DEBUG_PRINTF("using PSHUFB for 128-bit shuffle\n"); m128 accelPerm = limex->accelPermute; m128 accelComp = limex->accelCompare; idx = packedExtract128(s, accelPerm, accelComp); return accelScanWrapper(accelTable, aux, input, idx, i, end); } size_t doAccel256(const m256 *state, const struct LimExNFA256 *limex, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end) { u32 idx; m256 s = *state; DEBUG_PRINTF("using PSHUFB for 256-bit shuffle\n"); m256 accelPerm = limex->accelPermute; m256 accelComp = limex->accelCompare; #if !defined(__AVX2__) u32 idx1 = packedExtract128(s.lo, accelPerm.lo, accelComp.lo); u32 idx2 = packedExtract128(s.hi, accelPerm.hi, accelComp.hi); assert((idx1 & idx2) == 0); // should be no shared bits idx = idx1 | idx2; #else idx = packedExtract256(s, accelPerm, accelComp); #endif return accelScanWrapper(accelTable, aux, input, idx, i, end); } size_t doAccel384(const m384 *state, const struct LimExNFA384 *limex, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end) { u32 idx; m384 s = *state; DEBUG_PRINTF("using PSHUFB for 384-bit shuffle\n"); m384 accelPerm = limex->accelPermute; m384 accelComp = limex->accelCompare; u32 idx1 = packedExtract128(s.lo, accelPerm.lo, accelComp.lo); u32 idx2 = packedExtract128(s.mid, accelPerm.mid, accelComp.mid); u32 idx3 = packedExtract128(s.hi, accelPerm.hi, accelComp.hi); assert((idx1 & idx2 & idx3) == 0); // should be no shared bits idx = idx1 | idx2 | idx3; return accelScanWrapper(accelTable, aux, input, idx, i, end); } size_t doAccel512(const m512 *state, const struct LimExNFA512 *limex, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end) { u32 idx; m512 s = *state; DEBUG_PRINTF("using PSHUFB for 512-bit shuffle\n"); m512 accelPerm = limex->accelPermute; m512 accelComp = limex->accelCompare; #if !defined(__AVX2__) u32 idx1 = packedExtract128(s.lo.lo, accelPerm.lo.lo, accelComp.lo.lo); u32 idx2 = packedExtract128(s.lo.hi, accelPerm.lo.hi, accelComp.lo.hi); u32 idx3 = packedExtract128(s.hi.lo, accelPerm.hi.lo, accelComp.hi.lo); u32 idx4 = packedExtract128(s.hi.hi, accelPerm.hi.hi, accelComp.hi.hi); assert((idx1 & idx2 & idx3 & idx4) == 0); // should be no shared bits idx = idx1 | idx2 | idx3 | idx4; #else u32 idx1 = packedExtract256(s.lo, accelPerm.lo, accelComp.lo); u32 idx2 = packedExtract256(s.hi, accelPerm.hi, accelComp.hi); assert((idx1 & idx2) == 0); // should be no shared bits idx = idx1 | idx2; #endif return accelScanWrapper(accelTable, aux, input, idx, i, end); } hyperscan-4.4.1/src/nfa/goughcompile.h0000644000175000017500000000656413055426554020500 0ustar sleuthkidsleuthkid/* * 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 GOUGHCOMPILE_H #define GOUGHCOMPILE_H #include "mcclellancompile.h" #include "nfa_kind.h" #include "ue2common.h" #include "util/alloc.h" #include "util/ue2_containers.h" #include "util/order_check.h" #include #include #include #include namespace ue2 { #define CREATE_NEW_SOM (~0U) /* dest nfa state -> som info for dest state is min of provided loc idx som * info */ typedef flat_map> som_tran_info; struct som_report { som_report(ReportID r, u32 s) : report(r), slot(s) {} ReportID report; u32 slot; bool operator<(const som_report &b) const { const som_report &a = *this; ORDER_CHECK(report); ORDER_CHECK(slot); return false; } }; struct dstate_som { std::set reports; std::set reports_eod; som_tran_info preds; /* live nfa states mapped back to pred states */ }; struct raw_som_dfa : public raw_dfa { raw_som_dfa(nfa_kind k, bool unordered_som_triggers_in, u32 trigger, u32 stream_som_loc_width_in) : raw_dfa(k), stream_som_loc_width(stream_som_loc_width_in), unordered_som_triggers(unordered_som_triggers_in), trigger_nfa_state(trigger) { assert(!unordered_som_triggers || is_triggered(kind)); } std::vector state_som; u32 stream_som_loc_width; bool unordered_som_triggers; void stripExtraEodReports(void) override; std::map new_som_nfa_states; /* map nfa vertex id -> offset */ u32 trigger_nfa_state; /* for triggered cases, slot_id that contains a new * som */ }; aligned_unique_ptr goughCompile(raw_som_dfa &raw, u8 somPrecision, const CompileContext &cc, const ReportManager &rm); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/accel.h0000644000175000017500000001125513055426554017056 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Acceleration: data structures and common definitions. */ #ifndef ACCEL_H #define ACCEL_H #include "ue2common.h" /* run time defs */ #define BAD_ACCEL_DIST 4 #define SMALL_ACCEL_PENALTY 8 #define BIG_ACCEL_PENALTY 32 /// Minimum length of the scan buffer for us to attempt acceleration. #define ACCEL_MIN_LEN 16 enum AccelType { ACCEL_NONE, ACCEL_VERM, ACCEL_VERM_NOCASE, ACCEL_DVERM, ACCEL_DVERM_NOCASE, ACCEL_RVERM, ACCEL_RVERM_NOCASE, ACCEL_RDVERM, ACCEL_RDVERM_NOCASE, ACCEL_REOD, ACCEL_REOD_NOCASE, ACCEL_RDEOD, ACCEL_RDEOD_NOCASE, ACCEL_SHUFTI, ACCEL_DSHUFTI, ACCEL_TRUFFLE, ACCEL_RED_TAPE, /* multibyte vermicellis */ ACCEL_MLVERM, ACCEL_MLVERM_NOCASE, ACCEL_MLGVERM, ACCEL_MLGVERM_NOCASE, ACCEL_MSVERM, ACCEL_MSVERM_NOCASE, ACCEL_MSGVERM, ACCEL_MSGVERM_NOCASE, ACCEL_MDSVERM, ACCEL_MDSVERM_NOCASE, ACCEL_MDSGVERM, ACCEL_MDSGVERM_NOCASE, /* multibyte shuftis */ ACCEL_MLSHUFTI, ACCEL_MLGSHUFTI, ACCEL_MSSHUFTI, ACCEL_MSGSHUFTI, ACCEL_MDSSHUFTI, ACCEL_MDSGSHUFTI, /* multibyte truffles */ ACCEL_MLTRUFFLE, ACCEL_MLGTRUFFLE, ACCEL_MSTRUFFLE, ACCEL_MSGTRUFFLE, ACCEL_MDSTRUFFLE, ACCEL_MDSGTRUFFLE, /* masked dverm */ ACCEL_DVERM_MASKED, }; /** \brief Structure for accel framework. */ union AccelAux { u8 accel_type; struct { u8 accel_type; u8 offset; } generic; struct { u8 accel_type; u8 offset; u8 c; // uppercase if nocase } verm; struct { u8 accel_type; u8 offset; u8 c1; // uppercase if nocase u8 c2; // uppercase if nocase u8 m1; // masked variant u8 m2; // masked variant } dverm; struct { u8 accel_type; u8 offset; u8 c; // uppercase if nocase u8 len; } mverm; struct { u8 accel_type; u8 offset; u8 c; // uppercase if nocase u8 len1; u8 len2; } mdverm; struct { u8 accel_type; u8 offset; m128 lo; m128 hi; } shufti; struct { u8 accel_type; u8 offset; m128 lo1; m128 hi1; m128 lo2; m128 hi2; } dshufti; struct { u8 accel_type; u8 offset; m128 lo; m128 hi; u8 len; } mshufti; struct { u8 accel_type; u8 offset; m128 lo; m128 hi; u8 len1; u8 len2; } mdshufti; struct { u8 accel_type; u8 offset; m128 mask1; m128 mask2; } truffle; struct { u8 accel_type; u8 offset; m128 mask1; m128 mask2; u8 len; } mtruffle; struct { u8 accel_type; u8 offset; m128 mask1; m128 mask2; u8 len1; u8 len2; } mdtruffle; }; /** * Runs the specified acceleration scheme between c and c_end, returns a point * such that the acceleration scheme does not match before. */ const u8 *run_accel(const union AccelAux *accel, const u8 *c, const u8 *c_end); #endif hyperscan-4.4.1/src/nfa/tamaramacompile.h0000644000175000017500000000644513055426554021150 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Tamarama: container engine for exclusive engines, compiler code. */ #ifndef NFA_TAMARAMACOMPILE_H #define NFA_TAMARAMACOMPILE_H #include "ue2common.h" #include "util/alloc.h" #include #include #include struct NFA; namespace ue2 { /** * \brief A TamaProto that contains top remapping and reports info */ struct TamaProto { void add(const NFA *n, const u32 id, const u32 top, const std::map, u32> &out_top_remap); /** Top remapping between and ** remapped top value. */ std::map, u32> top_remap; /** All the reports in subengines */ std::set reports; }; /** * \brief Contruction info for a Tamarama engine: * contains at least two subengines. * * A TamaInfo is converted into a single NFA, with each top triggering a * subengine. A TamaInfo can contain at most TamaInfo::max_occupancy * subengines. */ struct TamaInfo { static constexpr size_t max_occupancy = 65536; // arbitrary limit /** \brief Add a new subengine. */ void add(NFA* sub, const std::set &top); /** \brief All the subengines */ std::vector subengines; /** \brief Tops of subengines */ std::vector> tops; }; std::set all_reports(const TamaProto &proto); /** * Take in a collection of exclusive subengines and produces a tamarama, also * returns via out_top_remap, a mapping indicating how tops in the subengines in * relate to the tamarama's tops. */ ue2::aligned_unique_ptr buildTamarama(const TamaInfo &tamaInfo, const u32 queue, std::map, u32> &out_top_remap); } // namespace ue2 #endif // NFA_TAMARAMACOMPILE_H hyperscan-4.4.1/src/nfa/nfa_api_util.h0000644000175000017500000000630613055426554020442 0ustar sleuthkidsleuthkid/* * 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 NFA_API_UTIL_H #define NFA_API_UTIL_H #include "nfa_api_queue.h" #include "ue2common.h" /* returns the byte prior to the given location, NUL if not available */ static really_inline u8 queue_prev_byte(const struct mq *q, s64a loc) { if (loc <= 0) { if (1LL - loc > (s64a)q->hlength) { return 0; /* assume NUL for start of stream write */ } // In the history buffer. assert(q->history); assert(q->hlength >= (u64a)(loc * -1)); return q->history[q->hlength - 1 + loc]; } else { // In the stream write buffer. assert(q->buffer); assert(q->length >= (u64a)loc); return q->buffer[loc - 1]; } } /* this is a modified version of pushQueue where we statically know the state of * the queue. Does not attempt to merge and inserts at the given queue * position. */ static really_inline void pushQueueAt(struct mq * restrict q, u32 pos, u32 e, s64a loc) { assert(pos == q->end); DEBUG_PRINTF("pushing %u@%lld -> %u\n", e, loc, q->end); assert(q->end < MAX_MQE_LEN); assert(e < MQE_INVALID); /* stop gcc getting too smart for its own good */ /* assert(!q->end || q->items[q->end - 1].location <= loc); */ assert(q->end || e == MQE_START); #ifndef NDEBUG // We assert that the event is different from its predecessor. If it's a // dupe, you should have used the ordinary pushQueue call. if (q->end) { UNUSED struct mq_item *prev = &q->items[q->end - 1]; assert(prev->type != e || prev->location != loc); } #endif struct mq_item *item = &q->items[pos]; item->type = e; item->location = loc; item->som = 0; q->end = pos + 1; } #endif hyperscan-4.4.1/src/nfa/multitruffle.c0000644000175000017500000000622213055426554020522 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "ue2common.h" #include "multitruffle.h" #include "util/bitutils.h" #include "util/simd_utils.h" #include "multiaccel_common.h" #if !defined(__AVX2__) #define MATCH_ALGO long_ #include "multiaccel_long.h" #include "multitruffle_sse.h" #undef MATCH_ALGO #define MATCH_ALGO longgrab_ #include "multiaccel_longgrab.h" #include "multitruffle_sse.h" #undef MATCH_ALGO #define MATCH_ALGO shift_ #include "multiaccel_shift.h" #include "multitruffle_sse.h" #undef MATCH_ALGO #define MATCH_ALGO shiftgrab_ #include "multiaccel_shiftgrab.h" #include "multitruffle_sse.h" #undef MATCH_ALGO #define MULTIACCEL_DOUBLE #define MATCH_ALGO doubleshift_ #include "multiaccel_doubleshift.h" #include "multitruffle_sse.h" #undef MATCH_ALGO #define MATCH_ALGO doubleshiftgrab_ #include "multiaccel_doubleshiftgrab.h" #include "multitruffle_sse.h" #undef MATCH_ALGO #undef MULTIACCEL_DOUBLE #else #define MATCH_ALGO long_ #include "multiaccel_long.h" #include "multitruffle_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO longgrab_ #include "multiaccel_longgrab.h" #include "multitruffle_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO shift_ #include "multiaccel_shift.h" #include "multitruffle_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO shiftgrab_ #include "multiaccel_shiftgrab.h" #include "multitruffle_avx2.h" #undef MATCH_ALGO #define MULTIACCEL_DOUBLE #define MATCH_ALGO doubleshift_ #include "multiaccel_doubleshift.h" #include "multitruffle_avx2.h" #undef MATCH_ALGO #define MATCH_ALGO doubleshiftgrab_ #include "multiaccel_doubleshiftgrab.h" #include "multitruffle_avx2.h" #undef MATCH_ALGO #undef MULTIACCEL_DOUBLE #endif hyperscan-4.4.1/src/nfa/nfa_build_util.cpp0000644000175000017500000004725213055426554021330 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "nfa_build_util.h" #include "limex_internal.h" #include "mcclellancompile.h" #include "mcsheng_compile.h" #include "shengcompile.h" #include "nfa_internal.h" #include "repeat_internal.h" #include "ue2common.h" #include #include #include #include #include #include #include using namespace std; namespace ue2 { namespace { template struct NFATraits { }; template class sfunc, typename rv_t, typename arg_t, NFAEngineType lb> struct DISPATCH_BY_NFA_TYPE_INT { static rv_t doOp(NFAEngineType i, const arg_t &arg) { if (i == lb) { return sfunc::call(arg); } else { return DISPATCH_BY_NFA_TYPE_INT ::doOp(i, arg); } } }; template class sfunc, typename rv_t, typename arg_t> struct DISPATCH_BY_NFA_TYPE_INT { // dummy static rv_t doOp(NFAEngineType, const arg_t &) { assert(0); throw std::logic_error("Unreachable"); } }; #define DISPATCH_BY_NFA_TYPE(i, op, arg) \ DISPATCH_BY_NFA_TYPE_INT::call(arg)), \ decltype(arg), (NFAEngineType)0>::doOp(i, arg) } typedef bool (*nfa_dispatch_fn)(const NFA *nfa); template static bool has_accel_limex(const NFA *nfa) { const T *limex = (const T *)getImplNfa(nfa); return limex->accelCount; } template static bool has_repeats_limex(const NFA *nfa) { const T *limex = (const T *)getImplNfa(nfa); return limex->repeatCount; } template static bool has_repeats_other_than_firsts_limex(const NFA *nfa) { const T *limex = (const T *)getImplNfa(nfa); const char *ptr = (const char *)limex; const u32 *repeatOffset = (const u32 *)(ptr + limex->repeatOffset); for (u32 i = 0; i < limex->repeatCount; i++) { u32 offset = repeatOffset[i]; const NFARepeatInfo *info = (const NFARepeatInfo *)(ptr + offset); const RepeatInfo *repeat = (const RepeatInfo *)((const char *)info + sizeof(*info)); if (repeat->type != REPEAT_FIRST) { return true; } } return false; } static bool dispatch_false(const NFA *) { return false; } #ifdef DUMP_SUPPORT namespace { template struct getName { static const char *call(void *) { return NFATraits::name; } }; // descr helper for LimEx NFAs template static string getDescriptionLimEx(const NFA *nfa) { const typename NFATraits::implNFA_t *limex = (const typename NFATraits::implNFA_t *)getImplNfa(nfa); ostringstream oss; oss << NFATraits::name << "/" << limex->exceptionCount; if (limex->repeatCount) { oss << " +" << limex->repeatCount << "r"; } return oss.str(); } } // generic description: just return the name namespace { template struct getDescription { static string call(const void *) { return string(NFATraits::name); } }; } #endif /* build-utility Traits */ namespace { enum NFACategory {NFA_LIMEX, NFA_OTHER}; // Some of our traits we want around in DUMP_SUPPORT mode only. #if defined(DUMP_SUPPORT) #define DO_IF_DUMP_SUPPORT(a) a #else #define DO_IF_DUMP_SUPPORT(a) #endif #define MAKE_LIMEX_TRAITS(mlt_size, mlt_align) \ template<> struct NFATraits { \ static UNUSED const char *name; \ static const NFACategory category = NFA_LIMEX; \ typedef LimExNFA##mlt_size implNFA_t; \ static const nfa_dispatch_fn has_accel; \ static const nfa_dispatch_fn has_repeats; \ static const nfa_dispatch_fn has_repeats_other_than_firsts; \ static const u32 stateAlign = \ MAX(mlt_align, alignof(RepeatControl)); \ static const bool fast = mlt_size <= 64; \ }; \ const nfa_dispatch_fn NFATraits::has_accel \ = has_accel_limex; \ const nfa_dispatch_fn NFATraits::has_repeats \ = has_repeats_limex; \ const nfa_dispatch_fn \ NFATraits::has_repeats_other_than_firsts \ = has_repeats_other_than_firsts_limex; \ DO_IF_DUMP_SUPPORT( \ const char *NFATraits::name \ = "LimEx "#mlt_size; \ template<> struct getDescription { \ static string call(const void *p) { \ return getDescriptionLimEx((const NFA *)p); \ } \ };) MAKE_LIMEX_TRAITS(32, alignof(u32)) MAKE_LIMEX_TRAITS(64, alignof(m128)) /* special, 32bit arch uses m128 */ MAKE_LIMEX_TRAITS(128, alignof(m128)) MAKE_LIMEX_TRAITS(256, alignof(m256)) MAKE_LIMEX_TRAITS(384, alignof(m384)) MAKE_LIMEX_TRAITS(512, alignof(m512)) template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 1; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = has_accel_mcclellan; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "McClellan 8"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 2; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = has_accel_mcclellan; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "McClellan 16"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = has_accel_mcclellan; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Goughfish 8"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = has_accel_mcclellan; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Goughfish 16"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Mega-Puff-Vac"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Castle"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Lim Bounded Repeat (D)"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Lim Bounded Repeat (V)"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Lim Bounded Repeat (NV)"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Lim Bounded Repeat (S)"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 8; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Lim Bounded Repeat (M)"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 1; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = has_accel_sheng; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Sheng"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 32; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Tamarama"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 1; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = has_accel_mcsheng; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Shengy McShengFace 8"; #endif template<> struct NFATraits { UNUSED static const char *name; static const NFACategory category = NFA_OTHER; static const u32 stateAlign = 2; static const bool fast = true; static const nfa_dispatch_fn has_accel; static const nfa_dispatch_fn has_repeats; static const nfa_dispatch_fn has_repeats_other_than_firsts; }; const nfa_dispatch_fn NFATraits::has_accel = has_accel_mcsheng; const nfa_dispatch_fn NFATraits::has_repeats = dispatch_false; const nfa_dispatch_fn NFATraits::has_repeats_other_than_firsts = dispatch_false; #if defined(DUMP_SUPPORT) const char *NFATraits::name = "Shengy McShengFace 16"; #endif } // namespace #if defined(DUMP_SUPPORT) const char *nfa_type_name(NFAEngineType type) { return DISPATCH_BY_NFA_TYPE(type, getName, nullptr); } string describe(const NFA &nfa) { return DISPATCH_BY_NFA_TYPE((NFAEngineType)nfa.type, getDescription, &nfa); } #endif /* DUMP_SUPPORT */ namespace { template struct getStateAlign { static u32 call(void *) { return NFATraits::stateAlign; } }; } u32 state_alignment(const NFA &nfa) { return DISPATCH_BY_NFA_TYPE((NFAEngineType)nfa.type, getStateAlign, nullptr); } namespace { template struct getFastness { static u32 call(void *) { return NFATraits::fast; } }; } bool is_fast(const NFA &nfa) { NFAEngineType t = (NFAEngineType)nfa.type; return DISPATCH_BY_NFA_TYPE(t, getFastness, nullptr); } namespace { template struct is_limex { static bool call(const void *) { return NFATraits::category == NFA_LIMEX; } }; } namespace { template struct has_repeats_other_than_firsts_dispatch { static nfa_dispatch_fn call(const void *) { return NFATraits::has_repeats_other_than_firsts; } }; } bool has_bounded_repeats_other_than_firsts(const NFA &nfa) { return DISPATCH_BY_NFA_TYPE((NFAEngineType)nfa.type, has_repeats_other_than_firsts_dispatch, &nfa)(&nfa); } namespace { template struct has_repeats_dispatch { static nfa_dispatch_fn call(const void *) { return NFATraits::has_repeats; } }; } bool has_bounded_repeats(const NFA &nfa) { return DISPATCH_BY_NFA_TYPE((NFAEngineType)nfa.type, has_repeats_dispatch, &nfa)(&nfa); } namespace { template struct has_accel_dispatch { static nfa_dispatch_fn call(const void *) { return NFATraits::has_accel; } }; } bool has_accel(const NFA &nfa) { return DISPATCH_BY_NFA_TYPE((NFAEngineType)nfa.type, has_accel_dispatch, &nfa)(&nfa); } bool requires_decompress_key(const NFA &nfa) { return DISPATCH_BY_NFA_TYPE((NFAEngineType)nfa.type, is_limex, &nfa); } } // namespace ue2 hyperscan-4.4.1/src/nfa/accel_dump.cpp0000644000175000017500000002700713055426554020440 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Acceleration: dump code. */ #include "config.h" #include "accel.h" #include "accel_dump.h" #include "shufticompile.h" #include "trufflecompile.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/dump_charclass.h" #include "util/dump_mask.h" #include "util/simd_types.h" #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { static const char *accelName(u8 accel_type) { switch (accel_type) { case ACCEL_NONE: return "none"; case ACCEL_VERM: return "vermicelli"; case ACCEL_VERM_NOCASE: return "vermicelli nocase"; case ACCEL_DVERM: return "double-vermicelli"; case ACCEL_DVERM_NOCASE: return "double-vermicelli nocase"; case ACCEL_DVERM_MASKED: return "double-vermicelli masked"; case ACCEL_RVERM: return "reverse vermicelli"; case ACCEL_RVERM_NOCASE: return "reverse vermicelli nocase"; case ACCEL_RDVERM: return "reverse double-vermicelli"; case ACCEL_RDVERM_NOCASE: return "reverse double-vermicelli nocase"; case ACCEL_REOD: return "reverse eod"; case ACCEL_REOD_NOCASE: return "reverse eod nocase"; case ACCEL_RDEOD: return "reverse double-eod"; case ACCEL_RDEOD_NOCASE: return "reverse double-eod nocase"; case ACCEL_SHUFTI: return "shufti"; case ACCEL_DSHUFTI: return "double-shufti"; case ACCEL_TRUFFLE: return "truffle"; case ACCEL_RED_TAPE: return "red tape"; case ACCEL_MLVERM: return "multibyte long vermicelli"; case ACCEL_MLVERM_NOCASE: return "multibyte long vermicelli nocase"; case ACCEL_MLGVERM: return "multibyte long-grab vermicelli"; case ACCEL_MLGVERM_NOCASE: return "multibyte long-grab vermicelli nocase"; case ACCEL_MSVERM: return "multibyte shift vermicelli"; case ACCEL_MSVERM_NOCASE: return "multibyte shift vermicelli nocase"; case ACCEL_MSGVERM: return "multibyte shift-grab vermicelli"; case ACCEL_MSGVERM_NOCASE: return "multibyte shift-grab vermicelli nocase"; case ACCEL_MDSVERM: return "multibyte doubleshift vermicelli"; case ACCEL_MDSVERM_NOCASE: return "multibyte doubleshift vermicelli nocase"; case ACCEL_MDSGVERM: return "multibyte doubleshift-grab vermicelli"; case ACCEL_MDSGVERM_NOCASE: return "multibyte doubleshift-grab vermicelli nocase"; case ACCEL_MLSHUFTI: return "multibyte long shufti"; case ACCEL_MLGSHUFTI: return "multibyte long-grab shufti"; case ACCEL_MSSHUFTI: return "multibyte shift shufti"; case ACCEL_MSGSHUFTI: return "multibyte shift-grab shufti"; case ACCEL_MDSSHUFTI: return "multibyte doubleshift shufti"; case ACCEL_MDSGSHUFTI: return "multibyte doubleshift-grab shufti"; case ACCEL_MLTRUFFLE: return "multibyte long truffle"; case ACCEL_MLGTRUFFLE: return "multibyte long-grab truffle"; case ACCEL_MSTRUFFLE: return "multibyte shift truffle"; case ACCEL_MSGTRUFFLE: return "multibyte shift-grab truffle"; case ACCEL_MDSTRUFFLE: return "multibyte doubleshift truffle"; case ACCEL_MDSGTRUFFLE: return "multibyte doubleshift-grab truffle"; default: return "unknown!"; } } static void dumpShuftiCharReach(FILE *f, const u8 *lo, const u8 *hi) { CharReach cr = shufti2cr(lo, hi); fprintf(f, "count %zu class %s\n", cr.count(), describeClass(cr).c_str()); } static vector dshufti2cr_array(const u8 *lo_in, const u8 *hi_in) { u8 lo[16]; u8 hi[16]; for (u32 i = 0; i < 16; i++) { lo[i] = ~lo_in[i]; hi[i] = ~hi_in[i]; } vector crs(8); for (u32 i = 0; i < 256; i++) { u32 combined = lo[(u8)i & 0xf] & hi[(u8)i >> 4]; while (combined) { u32 j = findAndClearLSB_32(&combined); crs.at(j).set(i); } } return crs; } static void dumpDShuftiCharReach(FILE *f, const u8 *lo1, const u8 *hi1, const u8 *lo2, const u8 *hi2) { vector cr1 = dshufti2cr_array(lo1, hi1); vector cr2 = dshufti2cr_array(lo2, hi2); map > cr1_group; assert(cr1.size() == 8 && cr2.size() == 8); for (u32 i = 0; i < 8; i++) { if (!cr1[i].any()) { continue; } cr1_group[cr1[i]].insert(i); } map rev; for (const auto &e : cr1_group) { CharReach rhs; for (u32 r : e.second) { rhs |= cr2.at(r); } rev[rhs] |= e.first; } fprintf(f, "escapes: {"); for (auto it = rev.begin(); it != rev.end(); ++it) { const auto &e = *it; if (it != rev.begin()) { fprintf(f, ", "); } if (e.first.all()) { fprintf(f, "%s", describeClass(e.second).c_str()); } else { fprintf(f, "%s%s", describeClass(e.second).c_str(), describeClass(e.first).c_str()); } } fprintf(f, "}\n"); } static void dumpShuftiMasks(FILE *f, const u8 *lo, const u8 *hi) { fprintf(f, "lo %s\n", dumpMask(lo, 128).c_str()); fprintf(f, "hi %s\n", dumpMask(hi, 128).c_str()); } static void dumpTruffleCharReach(FILE *f, const u8 *hiset, const u8 *hiclear) { CharReach cr = truffle2cr(hiset, hiclear); fprintf(f, "count %zu class %s\n", cr.count(), describeClass(cr).c_str()); } static void dumpTruffleMasks(FILE *f, const u8 *hiset, const u8 *hiclear) { fprintf(f, "lo %s\n", dumpMask(hiset, 128).c_str()); fprintf(f, "hi %s\n", dumpMask(hiclear, 128).c_str()); } void dumpAccelInfo(FILE *f, const AccelAux &accel) { fprintf(f, " %s", accelName(accel.accel_type)); if (accel.generic.offset) { fprintf(f, "+%hhu", accel.generic.offset); } switch (accel.accel_type) { case ACCEL_VERM: case ACCEL_VERM_NOCASE: case ACCEL_RVERM: case ACCEL_RVERM_NOCASE: fprintf(f, " [\\x%02hhx]\n", accel.verm.c); break; case ACCEL_DVERM: case ACCEL_DVERM_NOCASE: case ACCEL_RDVERM: case ACCEL_RDVERM_NOCASE: fprintf(f, " [\\x%02hhx\\x%02hhx]\n", accel.dverm.c1, accel.dverm.c2); break; case ACCEL_DVERM_MASKED: fprintf(f, " [\\x%02hhx\\x%02hhx] & [\\x%02hhx\\x%02hhx]\n", accel.dverm.c1, accel.dverm.c2, accel.dverm.m1, accel.dverm.m2); break; case ACCEL_SHUFTI: { fprintf(f, "\n"); dumpShuftiMasks(f, (const u8 *)&accel.shufti.lo, (const u8 *)&accel.shufti.hi); dumpShuftiCharReach(f, (const u8 *)&accel.shufti.lo, (const u8 *)&accel.shufti.hi); break; } case ACCEL_DSHUFTI: fprintf(f, "\n"); fprintf(f, "mask 1\n"); dumpShuftiMasks(f, (const u8 *)&accel.dshufti.lo1, (const u8 *)&accel.dshufti.hi1); fprintf(f, "mask 2\n"); dumpShuftiMasks(f, (const u8 *)&accel.dshufti.lo2, (const u8 *)&accel.dshufti.hi2); dumpDShuftiCharReach(f, (const u8 *)&accel.dshufti.lo1, (const u8 *)&accel.dshufti.hi1, (const u8 *)&accel.dshufti.lo2, (const u8 *)&accel.dshufti.hi2); break; case ACCEL_TRUFFLE: { fprintf(f, "\n"); dumpTruffleMasks(f, (const u8 *)&accel.truffle.mask1, (const u8 *)&accel.truffle.mask2); dumpTruffleCharReach(f, (const u8 *)&accel.truffle.mask1, (const u8 *)&accel.truffle.mask2); break; } case ACCEL_MLVERM: case ACCEL_MLVERM_NOCASE: case ACCEL_MLGVERM: case ACCEL_MLGVERM_NOCASE: case ACCEL_MSVERM: case ACCEL_MSVERM_NOCASE: case ACCEL_MSGVERM: case ACCEL_MSGVERM_NOCASE: fprintf(f, " [\\x%02hhx] len:%u\n", accel.mverm.c, accel.mverm.len); break; case ACCEL_MDSVERM: case ACCEL_MDSVERM_NOCASE: case ACCEL_MDSGVERM: case ACCEL_MDSGVERM_NOCASE: fprintf(f, " [\\x%02hhx] len1:%u len2:%u\n", accel.mdverm.c, accel.mdverm.len1, accel.mdverm.len2); break; case ACCEL_MLSHUFTI: case ACCEL_MLGSHUFTI: case ACCEL_MSSHUFTI: case ACCEL_MSGSHUFTI: fprintf(f, " len:%u\n", accel.mshufti.len); dumpShuftiMasks(f, (const u8 *)&accel.mshufti.lo, (const u8 *)&accel.mshufti.hi); dumpShuftiCharReach(f, (const u8 *)&accel.mshufti.lo, (const u8 *)&accel.mshufti.hi); break; case ACCEL_MDSSHUFTI: case ACCEL_MDSGSHUFTI: fprintf(f, " len1:%u len2:%u\n", accel.mdshufti.len1, accel.mdshufti.len2); dumpShuftiMasks(f, (const u8 *)&accel.mdshufti.lo, (const u8 *)&accel.mdshufti.hi); dumpShuftiCharReach(f, (const u8 *)&accel.mdshufti.lo, (const u8 *)&accel.mdshufti.hi); break; case ACCEL_MLTRUFFLE: case ACCEL_MLGTRUFFLE: case ACCEL_MSTRUFFLE: case ACCEL_MSGTRUFFLE: fprintf(f, " len:%u\n", accel.mtruffle.len); dumpTruffleMasks(f, (const u8 *)&accel.mtruffle.mask1, (const u8 *)&accel.mtruffle.mask2); dumpTruffleCharReach(f, (const u8 *)&accel.mtruffle.mask1, (const u8 *)&accel.mtruffle.mask2); break; case ACCEL_MDSTRUFFLE: case ACCEL_MDSGTRUFFLE: fprintf(f, " len1:%u len2:%u\n", accel.mdtruffle.len1, accel.mdtruffle.len2); dumpTruffleMasks(f, (const u8 *)&accel.mdtruffle.mask1, (const u8 *)&accel.mdtruffle.mask2); dumpTruffleCharReach(f, (const u8 *)&accel.mdtruffle.mask1, (const u8 *)&accel.mdtruffle.mask2); break; default: fprintf(f, "\n"); break; } } } // namespace ue2 hyperscan-4.4.1/src/nfa/goughcompile_reg.cpp0000644000175000017500000004062213055426554021661 0ustar sleuthkidsleuthkid/* * 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. */ #include "goughcompile.h" #include "goughcompile_dump.h" #include "goughcompile_internal.h" #include "gough_internal.h" #include "grey.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/order_check.h" #include "util/ue2_containers.h" #include "ue2common.h" #include #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { template void push_back_all_raw(vector *out, const vector &in) { for (const auto &var : in) { out->push_back(var.get()); } } static void all_vars(const GoughGraph &g, vector *out) { for (auto v : vertices_range(g)) { push_back_all_raw(out, g[v].vars); } for (const auto &e : edges_range(g)) { push_back_all_raw(out, g[e].vars); } } namespace { struct GoughGraphAux { map containing_v; map containing_e; map > reporters; }; } static never_inline void fill_aux(const GoughGraph &g, GoughGraphAux *aux) { for (auto v : vertices_range(g)) { for (const auto &var : g[v].vars) { aux->containing_v[var.get()] = v; DEBUG_PRINTF("%u is on vertex %u\n", var->slot, g[v].state_id); } for (GoughSSAVar *var : g[v].reports | map_values) { aux->reporters[var].insert(v); } for (GoughSSAVar *var : g[v].reports_eod | map_values) { aux->reporters[var].insert(v); } } for (const auto &e : edges_range(g)) { for (const auto &var : g[e].vars) { aux->containing_e[var.get()] = e; DEBUG_PRINTF("%u is on edge %u->%u\n", var->slot, g[source(e, g)].state_id, g[target(e, g)].state_id); } } } static bool is_block_local(const GoughGraph &cfg, GoughSSAVar *var, const GoughGraphAux &aux) { /* if var used as a report, it cannot be considered block local */ if (contains(aux.reporters, var)) { return false; } /* (useful) vertex/join vars never local - they are terminal in blocks * and so should be read by another block. */ if (!contains(aux.containing_e, var)) { return false; } /* for other cases, require that all uses of var are later in the same edge * or on the target AND if on target it is sole on flow coming from the * edge in question. */ const GoughEdge &e = aux.containing_e.at(var); GoughVertex t = target(e, cfg); size_t seen_outputs = 0; const flat_set &out = var->get_outputs(); bool seen_var = false; for (const auto &e_var : cfg[e].vars) { if (seen_var) { GoughSSAVarWithInputs *w = dynamic_cast(e_var.get()); if (contains(out, w)) { seen_outputs++; } } else { seen_var = var == e_var.get(); } } assert(seen_var); for (const auto &t_var : cfg[t].vars) { if (contains(out, t_var.get())) { seen_outputs++; const flat_set &flow = t_var->get_edges_for_input(var); if (flow.size() != 1 || *flow.begin() != e) { /* this var is used by the target join var BUT on a different * flow, so this is not a block local variable */ return false; } } } assert(seen_outputs <= out.size()); return seen_outputs == out.size(); } static void handle_pending_edge(const GoughGraph &g, const GoughEdge &e, GoughSSAVar *start, set &pending_vertex, set &rv) { const vector > &vars = g[e].vars; bool marking = !start; DEBUG_PRINTF(" ---checking edge %u->%u %s %zu\n", g[source(e, g)].state_id, g[target(e, g)].state_id, marking ? "full" : "partial", vars.size()); for (auto it = vars.rbegin(); it != vars.rend(); ++it) { GoughSSAVar *var = it->get(); if (contains(rv, var)) { DEBUG_PRINTF("somebody has already processed this vertex [%u]\n", var->slot); return; } if (var == start) { assert(!marking); marking = true; continue; } if (marking) { rv.insert(var); } } assert(marking); GoughVertex s = source(e, g); for (const auto &var : g[s].vars) { DEBUG_PRINTF("interferes %u\n", var->slot); rv.insert(var.get()); } pending_vertex.insert(s); } static void handle_pending_vars(GoughSSAVar *def, const GoughGraph &g, const GoughGraphAux &aux, const flat_set &pending_var, set &pending_vertex, set &rv) { for (GoughSSAVarWithInputs *var : pending_var) { if (contains(aux.containing_v, var)) { /* def is used by join vertex, value only needs to be live on some * incoming edges */ GoughSSAVarJoin *vj = (GoughSSAVarJoin *)var; const flat_set &live_edges = vj->get_edges_for_input(def); for (const auto &e : live_edges) { handle_pending_edge(g, e, nullptr, pending_vertex, rv); } continue; } const GoughEdge &e = aux.containing_e.at(var); handle_pending_edge(g, e, var, pending_vertex, rv); } } static void handle_pending_vertex(GoughVertex def_v, const GoughGraph &g, GoughVertex current, set &pending_vertex, set &rv) { DEBUG_PRINTF("---checking vertex %u\n", g[current].state_id); if (def_v == current) { DEBUG_PRINTF("contains target vertex\n"); return; /* we have reached def */ } for (const auto &e : in_edges_range(current, g)) { handle_pending_edge(g, e, nullptr, pending_vertex, rv); } } static void handle_pending_vertices(GoughSSAVar *def, const GoughGraph &g, const GoughGraphAux &aux, set &pending_vertex, set &rv) { if (pending_vertex.empty()) { return; } GoughVertex def_v = GoughGraph::null_vertex(); if (contains(aux.containing_v, def)) { def_v = aux.containing_v.at(def); } ue2::unordered_set done; while (!pending_vertex.empty()) { GoughVertex current = *pending_vertex.begin(); pending_vertex.erase(current); if (contains(done, current)) { continue; } done.insert(current); handle_pending_vertex(def_v, g, current, pending_vertex, rv); } } /* returns set of labels that the given def is live at */ static never_inline set live_during(GoughSSAVar *def, const GoughGraph &g, const GoughGraphAux &aux) { DEBUG_PRINTF("checking who is defined during %u lifetime\n", def->slot); set pending_vertex; set rv; rv.insert(def); if (contains(aux.reporters, def)) { DEBUG_PRINTF("--> gets reported\n"); const set &reporters = aux.reporters.at(def); for (auto v : reporters) { pending_vertex.insert(v); for (const auto &var : g[v].vars) { DEBUG_PRINTF("interferes %u\n", var->slot); rv.insert(var.get()); } } } handle_pending_vars(def, g, aux, def->get_outputs(), pending_vertex, rv); handle_pending_vertices(def, g, aux, pending_vertex, rv); rv.erase(def); return rv; } template void set_initial_slots(const vector &vars, u32 *next_slot) { for (auto &var : vars) { assert(var->slot == INVALID_SLOT); var->slot = (*next_slot)++; } } /* crude, deterministic assignment of symbolic register slots. * returns number of slots given out */ static u32 initial_slots(const GoughGraph &g) { u32 next_slot = 0; for (auto v : vertices_range(g)) { set_initial_slots(g[v].vars, &next_slot); } for (const auto &e : edges_range(g)) { set_initial_slots(g[e].vars, &next_slot); } return next_slot; } #define NO_COLOUR (~0U) static u32 available_colour(const flat_set &bad_colours) { u32 rv = 0; for (const u32 &colour : bad_colours) { if (colour != rv) { assert(colour > rv); break; } rv = colour + 1; } assert(rv != NO_COLOUR); return rv; } static void poison_colours(const set &live, u32 c, const vector &colour_map, vector > *bad_colour) { for (const GoughSSAVar *var : live) { u32 var_index = var->slot; if (colour_map[var_index] != NO_COLOUR) { assert(c != colour_map[var_index]); } else { (*bad_colour)[var_index].insert(c); } } } static void find_bad_due_to_live(const set &live, const vector &colour_map, flat_set *out) { for (const GoughSSAVar *var : live) { u32 var_index = var->slot; if (colour_map[var_index] != NO_COLOUR) { out->insert(colour_map[var_index]); } } } static void sequential_vertex_colouring(const GoughGraph &g, const GoughGraphAux &aux, const vector &order, vector &colour_map) { assert(order.size() < NO_COLOUR); colour_map.clear(); colour_map.resize(order.size(), NO_COLOUR); vector temp(order.size(), ~0U); vector > bad_colour(order.size()); for (GoughSSAVar *var : order) { u32 var_index = var->slot; if (is_block_local(g, var, aux)) { DEBUG_PRINTF("%u is block local\n", var_index); /* ignore variable whose lifetime is limited to their local block * there is no need to assign stream state to these variables */ continue; } assert(colour_map[var_index] == NO_COLOUR); set live = live_during(var, g, aux); flat_set &local_bad = bad_colour[var_index]; find_bad_due_to_live(live, colour_map, &local_bad); DEBUG_PRINTF("colouring %u\n", var_index); u32 c = available_colour(local_bad); colour_map[var_index] = c; assert(!contains(bad_colour[var_index], c)); poison_colours(live, c, colour_map, &bad_colour); flat_set temp_set; local_bad.swap(temp_set); DEBUG_PRINTF(" %u coloured %u\n", var_index, c); } } template void add_to_dom_ordering(const vector &vars, vector *out) { for (const auto &var : vars) { out->push_back(var.get()); } } namespace { class FinishVisitor : public boost::default_dfs_visitor { public: explicit FinishVisitor(vector *o) : out(o) {} void finish_vertex(const GoughVertex v, const GoughGraph &) { out->push_back(v); } vector *out; }; } static void find_dom_ordering(const GoughGraph &cfg, vector *out) { vector g_order; /* due to construction quirks, default vertex order provides entry points */ depth_first_search(cfg, visitor(FinishVisitor(&g_order)) .root_vertex(cfg[boost::graph_bundle].initial_vertex)); for (auto it = g_order.rbegin(); it != g_order.rend(); ++it) { add_to_dom_ordering(cfg[*it].vars, out); for (const auto &e : out_edges_range(*it, cfg)) { add_to_dom_ordering(cfg[e].vars, out); } } } static void create_slot_mapping(const GoughGraph &cfg, UNUSED u32 old_slot_count, vector *old_new) { /* Interference graphs from SSA form are chordal -> optimally colourable in * poly time. * * Chordal graphs can be coloured by walking in perfect elimination order. * If the SSA CFG is iterated over in a way that respects dominance * relationship, the interference graph will be iterated in a perfect * elimination order. * * We can avoid creating the full interference graph and use liveness * information as we iterate over the definitions to perform the colouring. * * See S Hack various 2006- */ vector dom_order; GoughGraphAux aux; fill_aux(cfg, &aux); find_dom_ordering(cfg, &dom_order); assert(dom_order.size() == old_slot_count); sequential_vertex_colouring(cfg, aux, dom_order, *old_new); } static void update_local_slots(GoughGraph &g, set &locals, u32 local_base) { DEBUG_PRINTF("%zu local variables\n", locals.size()); /* local variables only occur on edges (joins are never local) */ u32 allocated_count = 0; for (const auto &e : edges_range(g)) { u32 next_slot = local_base; for (auto &var : g[e].vars) { if (contains(locals, var.get())) { DEBUG_PRINTF("updating slot %u using local %u\n", var->slot, next_slot); var->slot = next_slot++; allocated_count++; } } } assert(allocated_count == locals.size()); } static never_inline u32 update_slots(GoughGraph &g, const vector &old_new, UNUSED u32 old_slot_count) { vector vars; set locals; all_vars(g, &vars); u32 slot_count = 0; for (GoughSSAVar *v : vars) { assert(v->slot < old_new.size()); DEBUG_PRINTF("updating slot %u to %u\n", v->slot, old_new[v->slot]); if (old_new[v->slot] != NO_COLOUR) { /* not local, assign final slot */ v->slot = old_new[v->slot]; ENSURE_AT_LEAST(&slot_count, v->slot + 1); } else { locals.insert(v); } } assert(slot_count <= old_slot_count); DEBUG_PRINTF("reduce stream slots from %u to %u\n", old_slot_count, slot_count); update_local_slots(g, locals, slot_count); return slot_count; } u32 assign_slots(GoughGraph &cfg, const Grey &grey) { u32 slot_count = initial_slots(cfg); if (!grey.goughRegisterAllocate) { return slot_count; } dump(cfg, "slots_pre", grey); vector old_new; create_slot_mapping(cfg, slot_count, &old_new); slot_count = update_slots(cfg, old_new, slot_count); return slot_count; } } // namespace ue2 hyperscan-4.4.1/src/nfa/mcclellancompile_util.h0000644000175000017500000000457113055426554022352 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MCCLELLAN_COMPILE_UTIL_H #define MCCLELLAN_COMPILE_UTIL_H #include "rdfa.h" #include "ue2common.h" #include namespace ue2 { u32 remove_leading_dots(raw_dfa &raw); /** * Prunes any states which cannot be reached within max_offset from start of * stream. Returns false if no changes are made to the rdfa */ bool prune_overlong(raw_dfa &raw, u32 max_offset); std::set all_reports(const raw_dfa &rdfa); bool has_eod_accepts(const raw_dfa &rdfa); bool has_non_eod_accepts(const raw_dfa &rdfa); /** \brief Compute a simple hash of this raw_dfa. Does not include report * information. */ size_t hash_dfa_no_reports(const raw_dfa &rdfa); /** \brief Compute a simple hash of this raw_dfa, including its reports. */ size_t hash_dfa(const raw_dfa &rdfa); bool can_die_early(const raw_dfa &raw, u32 age_limit); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/sheng.c0000644000175000017500000006105313055426554017107 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "sheng.h" #include "accel.h" #include "sheng_internal.h" #include "nfa_api.h" #include "nfa_api_queue.h" #include "nfa_internal.h" #include "util/bitutils.h" #include "util/compare.h" #include "util/join.h" #include "util/simd_utils.h" enum MatchMode { CALLBACK_OUTPUT, STOP_AT_MATCH, NO_MATCHES }; static really_inline const struct sheng *get_sheng(const struct NFA *n) { return (const struct sheng *)getImplNfa(n); } static really_inline const struct sstate_aux *get_aux(const struct sheng *sh, u8 id) { u32 offset = sh->aux_offset - sizeof(struct NFA) + (id & SHENG_STATE_MASK) * sizeof(struct sstate_aux); DEBUG_PRINTF("Getting aux for state %u at offset %llu\n", id & SHENG_STATE_MASK, (u64a)offset + sizeof(struct NFA)); return (const struct sstate_aux *)((const char *) sh + offset); } static really_inline const union AccelAux *get_accel(const struct sheng *sh, u8 id) { const struct sstate_aux *saux = get_aux(sh, id); DEBUG_PRINTF("Getting accel aux at offset %u\n", saux->accel); const union AccelAux *aux = (const union AccelAux *) ((const char *)sh + saux->accel - sizeof(struct NFA)); return aux; } static really_inline const struct report_list *get_rl(const struct sheng *sh, const struct sstate_aux *aux) { DEBUG_PRINTF("Getting report list at offset %u\n", aux->accept); return (const struct report_list *) ((const char *)sh + aux->accept - sizeof(struct NFA)); } static really_inline const struct report_list *get_eod_rl(const struct sheng *sh, const struct sstate_aux *aux) { DEBUG_PRINTF("Getting EOD report list at offset %u\n", aux->accept); return (const struct report_list *) ((const char *)sh + aux->accept_eod - sizeof(struct NFA)); } static really_inline char shengHasAccept(const struct sheng *sh, const struct sstate_aux *aux, ReportID report) { assert(sh && aux); const struct report_list *rl = get_rl(sh, aux); assert(ISALIGNED_N(rl, 4)); DEBUG_PRINTF("report list has %u entries\n", rl->count); for (u32 i = 0; i < rl->count; i++) { if (rl->report[i] == report) { DEBUG_PRINTF("reporting %u\n", rl->report[i]); return 1; } } return 0; } static really_inline char fireSingleReport(NfaCallback cb, void *ctxt, ReportID r, u64a loc) { DEBUG_PRINTF("reporting %u\n", r); if (cb(0, loc, r, ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } static really_inline char fireReports(const struct sheng *sh, NfaCallback cb, void *ctxt, const u8 state, u64a loc, u8 *const cached_accept_state, ReportID *const cached_accept_id, char eod) { DEBUG_PRINTF("reporting matches @ %llu\n", loc); if (!eod && state == *cached_accept_state) { DEBUG_PRINTF("reporting %u\n", *cached_accept_id); if (cb(0, loc, *cached_accept_id, ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } const struct sstate_aux *aux = get_aux(sh, state); const struct report_list *rl = eod ? get_eod_rl(sh, aux) : get_rl(sh, aux); assert(ISALIGNED(rl)); DEBUG_PRINTF("report list has %u entries\n", rl->count); u32 count = rl->count; if (!eod && count == 1) { *cached_accept_state = state; *cached_accept_id = rl->report[0]; DEBUG_PRINTF("reporting %u\n", rl->report[0]); if (cb(0, loc, rl->report[0], ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } return MO_CONTINUE_MATCHING; /* continue execution */ } for (u32 i = 0; i < count; i++) { DEBUG_PRINTF("reporting %u\n", rl->report[i]); if (cb(0, loc, rl->report[i], ctxt) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; /* termination requested */ } } return MO_CONTINUE_MATCHING; /* continue execution */ } /* include Sheng function definitions */ #include "sheng_defs.h" static really_inline char runShengCb(const struct sheng *sh, NfaCallback cb, void *ctxt, u64a offset, u8 *const cached_accept_state, ReportID *const cached_accept_id, const u8 *cur_buf, const u8 *start, const u8 *end, u8 can_die, u8 has_accel, u8 single, const u8 **scanned, u8 *state) { DEBUG_PRINTF("Scanning %llu bytes (offset %llu) in callback mode\n", (u64a)(end - start), offset); DEBUG_PRINTF("start: %lli end: %lli\n", (s64a)(start - cur_buf), (s64a)(end - cur_buf)); DEBUG_PRINTF("can die: %u has accel: %u single: %u\n", !!can_die, !!has_accel, !!single); int rv; /* scan and report all matches */ if (can_die) { if (has_accel) { rv = sheng4_coda(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } else { rv = sheng4_cod(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } if (rv == MO_HALT_MATCHING) { return MO_DEAD; } rv = sheng_cod(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, *scanned, end, scanned); } else { if (has_accel) { rv = sheng4_coa(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } else { rv = sheng4_co(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } if (rv == MO_HALT_MATCHING) { return MO_DEAD; } rv = sheng_co(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, *scanned, end, scanned); } if (rv == MO_HALT_MATCHING) { return MO_DEAD; } return MO_ALIVE; } static really_inline void runShengNm(const struct sheng *sh, NfaCallback cb, void *ctxt, u64a offset, u8 *const cached_accept_state, ReportID *const cached_accept_id, const u8 *cur_buf, const u8 *start, const u8 *end, u8 can_die, u8 has_accel, u8 single, const u8 **scanned, u8 *state) { DEBUG_PRINTF("Scanning %llu bytes (offset %llu) in nomatch mode\n", (u64a)(end - start), offset); DEBUG_PRINTF("start: %lli end: %lli\n", (s64a)(start - cur_buf), (s64a)(end - cur_buf)); DEBUG_PRINTF("can die: %u has accel: %u single: %u\n", !!can_die, !!has_accel, !!single); /* just scan the buffer */ if (can_die) { if (has_accel) { sheng4_nmda(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } else { sheng4_nmd(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } sheng_nmd(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, *scanned, end, scanned); } else { sheng4_nm(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); sheng_nm(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, *scanned, end, scanned); } } static really_inline char runShengSam(const struct sheng *sh, NfaCallback cb, void *ctxt, u64a offset, u8 *const cached_accept_state, ReportID *const cached_accept_id, const u8 *cur_buf, const u8 *start, const u8 *end, u8 can_die, u8 has_accel, u8 single, const u8 **scanned, u8 *state) { DEBUG_PRINTF("Scanning %llu bytes (offset %llu) in stop at match mode\n", (u64a)(end - start), offset); DEBUG_PRINTF("start: %lli end: %lli\n", (s64a)(start - cur_buf), (s64a)(end - cur_buf)); DEBUG_PRINTF("can die: %u has accel: %u single: %u\n", !!can_die, !!has_accel, !!single); int rv; /* scan until first match */ if (can_die) { if (has_accel) { rv = sheng4_samda(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } else { rv = sheng4_samd(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } if (rv == MO_HALT_MATCHING) { return MO_DEAD; } /* if we stopped before we expected, we found a match */ if (rv == MO_MATCHES_PENDING) { return MO_MATCHES_PENDING; } rv = sheng_samd(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, *scanned, end, scanned); } else { if (has_accel) { rv = sheng4_sama(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } else { rv = sheng4_sam(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, start, end, scanned); } if (rv == MO_HALT_MATCHING) { return MO_DEAD; } /* if we stopped before we expected, we found a match */ if (rv == MO_MATCHES_PENDING) { return MO_MATCHES_PENDING; } rv = sheng_sam(state, cb, ctxt, sh, cached_accept_state, cached_accept_id, single, offset, cur_buf, *scanned, end, scanned); } if (rv == MO_HALT_MATCHING) { return MO_DEAD; } /* if we stopped before we expected, we found a match */ if (rv == MO_MATCHES_PENDING) { return MO_MATCHES_PENDING; } return MO_ALIVE; } static never_inline char runSheng(const struct sheng *sh, struct mq *q, s64a b_end, enum MatchMode mode) { u8 state = *(u8 *)q->state; u8 can_die = sh->flags & SHENG_FLAG_CAN_DIE; u8 has_accel = sh->flags & SHENG_FLAG_HAS_ACCEL; u8 single = sh->flags & SHENG_FLAG_SINGLE_REPORT; u8 cached_accept_state = 0; ReportID cached_accept_id = 0; DEBUG_PRINTF("starting Sheng execution in state %u\n", state & SHENG_STATE_MASK); if (q->report_current) { DEBUG_PRINTF("reporting current pending matches\n"); assert(sh); q->report_current = 0; int rv; if (single) { rv = fireSingleReport(q->cb, q->context, sh->report, q_cur_offset(q)); } else { rv = fireReports(sh, q->cb, q->context, state, q_cur_offset(q), &cached_accept_state, &cached_accept_id, 0); } if (rv == MO_HALT_MATCHING) { DEBUG_PRINTF("exiting in state %u\n", state & SHENG_STATE_MASK); return MO_DEAD; } DEBUG_PRINTF("proceeding with matching\n"); } assert(q_cur_type(q) == MQE_START); s64a start = q_cur_loc(q); DEBUG_PRINTF("offset: %lli, location: %lli, mode: %s\n", q->offset, start, mode == CALLBACK_OUTPUT ? "CALLBACK OUTPUT" : mode == NO_MATCHES ? "NO MATCHES" : mode == STOP_AT_MATCH ? "STOP AT MATCH" : "???"); DEBUG_PRINTF("processing event @ %lli: %s\n", q->offset + q_cur_loc(q), q_cur_type(q) == MQE_START ? "START" : q_cur_type(q) == MQE_TOP ? "TOP" : q_cur_type(q) == MQE_END ? "END" : "???"); const u8* cur_buf; if (start < 0) { DEBUG_PRINTF("negative location, scanning history\n"); DEBUG_PRINTF("min location: %zd\n", -q->hlength); cur_buf = q->history + q->hlength; } else { DEBUG_PRINTF("positive location, scanning buffer\n"); DEBUG_PRINTF("max location: %lli\n", b_end); cur_buf = q->buffer; } /* if we our queue event is past our end */ if (mode != NO_MATCHES && q_cur_loc(q) > b_end) { DEBUG_PRINTF("current location past buffer end\n"); DEBUG_PRINTF("setting q location to %llu\n", b_end); DEBUG_PRINTF("exiting in state %u\n", state & SHENG_STATE_MASK); q->items[q->cur].location = b_end; return MO_ALIVE; } q->cur++; s64a cur_start = start; while (1) { DEBUG_PRINTF("processing event @ %lli: %s\n", q->offset + q_cur_loc(q), q_cur_type(q) == MQE_START ? "START" : q_cur_type(q) == MQE_TOP ? "TOP" : q_cur_type(q) == MQE_END ? "END" : "???"); s64a end = q_cur_loc(q); if (mode != NO_MATCHES) { end = MIN(end, b_end); } assert(end <= (s64a) q->length); s64a cur_end = end; /* we may cross the border between history and current buffer */ if (cur_start < 0) { cur_end = MIN(0, cur_end); } DEBUG_PRINTF("start: %lli end: %lli\n", start, end); /* don't scan zero length buffer */ if (cur_start != cur_end) { const u8 * scanned = cur_buf; char rv; if (mode == NO_MATCHES) { runShengNm(sh, q->cb, q->context, q->offset, &cached_accept_state, &cached_accept_id, cur_buf, cur_buf + cur_start, cur_buf + cur_end, can_die, has_accel, single, &scanned, &state); } else if (mode == CALLBACK_OUTPUT) { rv = runShengCb(sh, q->cb, q->context, q->offset, &cached_accept_state, &cached_accept_id, cur_buf, cur_buf + cur_start, cur_buf + cur_end, can_die, has_accel, single, &scanned, &state); if (rv == MO_DEAD) { DEBUG_PRINTF("exiting in state %u\n", state & SHENG_STATE_MASK); return MO_DEAD; } } else if (mode == STOP_AT_MATCH) { rv = runShengSam(sh, q->cb, q->context, q->offset, &cached_accept_state, &cached_accept_id, cur_buf, cur_buf + cur_start, cur_buf + cur_end, can_die, has_accel, single, &scanned, &state); if (rv == MO_DEAD) { DEBUG_PRINTF("exiting in state %u\n", state & SHENG_STATE_MASK); return rv; } else if (rv == MO_MATCHES_PENDING) { assert(q->cur); DEBUG_PRINTF("found a match, setting q location to %zd\n", scanned - cur_buf + 1); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = scanned - cur_buf + 1; /* due to exiting early */ *(u8 *)q->state = state; DEBUG_PRINTF("exiting in state %u\n", state & SHENG_STATE_MASK); return rv; } } else { assert(!"invalid scanning mode!"); } assert(scanned == cur_buf + cur_end); cur_start = cur_end; } /* if we our queue event is past our end */ if (mode != NO_MATCHES && q_cur_loc(q) > b_end) { DEBUG_PRINTF("current location past buffer end\n"); DEBUG_PRINTF("setting q location to %llu\n", b_end); DEBUG_PRINTF("exiting in state %u\n", state & SHENG_STATE_MASK); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = b_end; *(u8 *)q->state = state; return MO_ALIVE; } /* crossing over into actual buffer */ if (cur_start == 0) { DEBUG_PRINTF("positive location, scanning buffer\n"); DEBUG_PRINTF("max offset: %lli\n", b_end); cur_buf = q->buffer; } /* continue scanning the same buffer */ if (end != cur_end) { continue; } switch (q_cur_type(q)) { case MQE_END: *(u8 *)q->state = state; q->cur++; DEBUG_PRINTF("exiting in state %u\n", state & SHENG_STATE_MASK); if (can_die) { return (state & SHENG_STATE_DEAD) ? MO_DEAD : MO_ALIVE; } return MO_ALIVE; case MQE_TOP: if (q->offset + cur_start == 0) { DEBUG_PRINTF("Anchored start, going to state %u\n", sh->anchored); state = sh->anchored; } else { u8 new_state = get_aux(sh, state)->top; DEBUG_PRINTF("Top event %u->%u\n", state & SHENG_STATE_MASK, new_state & SHENG_STATE_MASK); state = new_state; } break; default: assert(!"invalid queue event"); break; } q->cur++; } } char nfaExecSheng_B(const struct NFA *n, u64a offset, const u8 *buffer, size_t length, NfaCallback cb, void *context) { DEBUG_PRINTF("smallwrite Sheng\n"); assert(n->type == SHENG_NFA); const struct sheng *sh = getImplNfa(n); u8 state = sh->anchored; u8 can_die = sh->flags & SHENG_FLAG_CAN_DIE; u8 has_accel = sh->flags & SHENG_FLAG_HAS_ACCEL; u8 single = sh->flags & SHENG_FLAG_SINGLE_REPORT; u8 cached_accept_state = 0; ReportID cached_accept_id = 0; /* scan and report all matches */ int rv; s64a end = length; const u8 *scanned; rv = runShengCb(sh, cb, context, offset, &cached_accept_state, &cached_accept_id, buffer, buffer, buffer + end, can_die, has_accel, single, &scanned, &state); if (rv == MO_DEAD) { DEBUG_PRINTF("exiting in state %u\n", state & SHENG_STATE_MASK); return MO_DEAD; } DEBUG_PRINTF("%u\n", state & SHENG_STATE_MASK); const struct sstate_aux *aux = get_aux(sh, state); if (aux->accept_eod) { DEBUG_PRINTF("Reporting EOD matches\n"); fireReports(sh, cb, context, state, end + offset, &cached_accept_state, &cached_accept_id, 1); } return state & SHENG_STATE_DEAD ? MO_DEAD : MO_ALIVE; } char nfaExecSheng_Q(const struct NFA *n, struct mq *q, s64a end) { const struct sheng *sh = get_sheng(n); char rv = runSheng(sh, q, end, CALLBACK_OUTPUT); return rv; } char nfaExecSheng_Q2(const struct NFA *n, struct mq *q, s64a end) { const struct sheng *sh = get_sheng(n); char rv = runSheng(sh, q, end, STOP_AT_MATCH); return rv; } char nfaExecSheng_QR(const struct NFA *n, struct mq *q, ReportID report) { assert(q_cur_type(q) == MQE_START); const struct sheng *sh = get_sheng(n); char rv = runSheng(sh, q, 0 /* end */, NO_MATCHES); if (rv && nfaExecSheng_inAccept(n, report, q)) { return MO_MATCHES_PENDING; } return rv; } char nfaExecSheng_inAccept(const struct NFA *n, ReportID report, struct mq *q) { assert(n && q); const struct sheng *sh = get_sheng(n); u8 s = *(const u8 *)q->state; DEBUG_PRINTF("checking accepts for %u\n", (u8)(s & SHENG_STATE_MASK)); const struct sstate_aux *aux = get_aux(sh, s); if (!aux->accept) { return 0; } return shengHasAccept(sh, aux, report); } char nfaExecSheng_inAnyAccept(const struct NFA *n, struct mq *q) { assert(n && q); const struct sheng *sh = get_sheng(n); u8 s = *(const u8 *)q->state; DEBUG_PRINTF("checking accepts for %u\n", (u8)(s & SHENG_STATE_MASK)); const struct sstate_aux *aux = get_aux(sh, s); return !!aux->accept; } char nfaExecSheng_testEOD(const struct NFA *nfa, const char *state, UNUSED const char *streamState, u64a offset, NfaCallback cb, void *ctxt) { assert(nfa); const struct sheng *sh = get_sheng(nfa); u8 s = *(const u8 *)state; DEBUG_PRINTF("checking EOD accepts for %u\n", (u8)(s & SHENG_STATE_MASK)); const struct sstate_aux *aux = get_aux(sh, s); if (!aux->accept_eod) { return MO_CONTINUE_MATCHING; } return fireReports(sh, cb, ctxt, s, offset, NULL, NULL, 1); } char nfaExecSheng_reportCurrent(const struct NFA *n, struct mq *q) { const struct sheng *sh = (const struct sheng *)getImplNfa(n); NfaCallback cb = q->cb; void *ctxt = q->context; u8 s = *(u8 *)q->state; const struct sstate_aux *aux = get_aux(sh, s); u64a offset = q_cur_offset(q); u8 cached_state_id = 0; ReportID cached_report_id = 0; assert(q_cur_type(q) == MQE_START); if (aux->accept) { if (sh->flags & SHENG_FLAG_SINGLE_REPORT) { fireSingleReport(cb, ctxt, sh->report, offset); } else { fireReports(sh, cb, ctxt, s, offset, &cached_state_id, &cached_report_id, 1); } } return 0; } char nfaExecSheng_initCompressedState(const struct NFA *nfa, u64a offset, void *state, UNUSED u8 key) { const struct sheng *sh = get_sheng(nfa); u8 *s = (u8 *)state; *s = offset ? sh->floating: sh->anchored; return !(*s & SHENG_STATE_DEAD); } char nfaExecSheng_queueInitState(const struct NFA *nfa, struct mq *q) { assert(nfa->scratchStateSize == 1); /* starting in floating state */ const struct sheng *sh = get_sheng(nfa); *(u8 *)q->state = sh->floating; DEBUG_PRINTF("starting in floating state\n"); return 0; } char nfaExecSheng_queueCompressState(UNUSED const struct NFA *nfa, const struct mq *q, UNUSED s64a loc) { void *dest = q->streamState; const void *src = q->state; assert(nfa->scratchStateSize == 1); assert(nfa->streamStateSize == 1); *(u8 *)dest = *(const u8 *)src; return 0; } char nfaExecSheng_expandState(UNUSED const struct NFA *nfa, void *dest, const void *src, UNUSED u64a offset, UNUSED u8 key) { assert(nfa->scratchStateSize == 1); assert(nfa->streamStateSize == 1); *(u8 *)dest = *(const u8 *)src; return 0; } hyperscan-4.4.1/src/nfa/mpv_dump.cpp0000644000175000017500000001216713055426554020174 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "mpv_dump.h" #include "mpv_internal.h" #include "nfa_dump_internal.h" #include "nfa_internal.h" #include "ue2common.h" #include "util/compare.h" #include "util/dump_mask.h" #include "util/dump_util.h" #include #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif /* Note: No dot files for MPV */ using namespace std; namespace ue2 { static really_inline u32 largest_puff_repeat(const mpv *m, const mpv_kilopuff *kp) { return get_puff_array(m, kp)[kp->count - 1].repeats; } static void dumpKilo(FILE *f, const mpv *m, const mpv_kilopuff *k) { if (k->auto_restart) { fprintf(f, " AUTO RESTART\n"); } fprintf(f, " "); switch (k->type) { case MPV_DOT: fprintf(f, "dot\n"); break; case MPV_VERM: if (!ourisprint(k->u.verm.c)) { fprintf(f, "verm 0x%02x\n", k->u.verm.c); } else { fprintf(f, "verm 0x%02x '%c'\n", k->u.verm.c, k->u.verm.c); } break; case MPV_SHUFTI: fprintf(f, "shufti\n"); fprintf(f, "lo %s\n", dumpMask((const u8 *)&k->u.shuf.mask_lo, 128).c_str()); fprintf(f, "hi %s\n", dumpMask((const u8 *)&k->u.shuf.mask_hi, 128).c_str()); break; case MPV_TRUFFLE: fprintf(f, "truffle\n"); break; case MPV_NVERM: if (!ourisprint(k->u.verm.c)) { fprintf(f, "nverm 0x%02x\n", k->u.verm.c); } else { fprintf(f, "nverm 0x%02x '%c'\n", k->u.verm.c, k->u.verm.c); } break; default: fprintf(f, "unknown type: %hhu\n", k->type); } fprintf(f, " %u puffettes\n", k->count); fprintf(f, " largest repeat %u\n", largest_puff_repeat(m, k)); fprintf(f, " dead point %llu\n", k->dead_point); fprintf(f, " counter offset %u\n", k->counter_offset); fprintf(f, " puffette offset %u\n", k->puffette_offset); const mpv_puffette *p = get_puff_array(m, k); for (u32 i = 0; i < k->count; i++) { fprintf(f, "\n"); fprintf(f, " Puffette %u\n", i); fprintf(f, " repeats: %u%s\n", p[i].repeats, p[i].unbounded ? "," : ""); if (p[i].simple_exhaust) { fprintf(f, " simple exhaustible\n"); } fprintf(f, " report id: %u\n", p[i].report); } fprintf(f, "\n"); } static void dumpCounter(FILE *f, const mpv_counter_info *c) { fprintf(f, " max value %llu\n", c->max_counter); fprintf(f, " state offset %u\n", c->counter_offset); fprintf(f, " used by kilopuffs %u - %u\n", c->kilo_begin, c->kilo_end - 1); fprintf(f, " bytes %u\n", c->counter_size); fprintf(f, "\n"); } void nfaExecMpv_dump(const NFA *nfa, const string &base) { const mpv *m = (const mpv *)getImplNfa(nfa); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); fprintf(f, "Puff the Magic Engines\n"); fprintf(f, "\n"); fprintf(f, "%u puffettes in %u kilopuffs\n", m->puffette_count, m->kilo_count); fprintf(f, "initial kilopuffs %u - %u\n", m->top_kilo_begin, m->top_kilo_end - 1); const mpv_kilopuff *k = (const mpv_kilopuff *)(m + 1); for (u32 i = 0; i < m->kilo_count; i++) { fprintf(f, "\nKILOPUFF %u\n", i); dumpKilo(f, m, k++); } const mpv_counter_info *c = get_counter_info(m); for (u32 i = 0; i < m->counter_count; i++) { fprintf(f, "\nCOUNTER %u\n", i); dumpCounter(f, c++); } dumpTextReverse(nfa, f); fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfa/nfa_dump_internal.h0000644000175000017500000000377713055426554021506 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Common dump code for nfa engines. */ #ifndef NFA_DUMP_INTERNAL_H #define NFA_DUMP_INTERNAL_H #if defined(DUMP_SUPPORT) #include struct NFA; namespace ue2 { /** \brief Writes a Graphviz DOT graph preamble. */ void dumpDotPreamble(FILE *f); /** \brief Finishes a Graphviz DOT graph. */ void dumpDotTrailer(FILE *f); /** \brief Dumps text information about \a nfa. */ void dumpTextReverse(const struct NFA *nfa, FILE *f); } #endif // DUMP_SUPPORT #endif hyperscan-4.4.1/src/nfa/tamarama.h0000644000175000017500000000604613055426554017574 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 TAMARAMA_H #define TAMARAMA_H #ifdef __cplusplus extern "C" { #endif #include "callback.h" #include "ue2common.h" struct mq; struct NFA; struct hs_scratch; char nfaExecTamarama_testEOD(const struct NFA *n, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context); char nfaExecTamarama_QR(const struct NFA *n, struct mq *q, ReportID report); char nfaExecTamarama_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecTamarama_inAccept(const struct NFA *n, ReportID report, struct mq *q); char nfaExecTamarama_inAnyAccept(const struct NFA *n, struct mq *q); char nfaExecTamarama_queueInitState(const struct NFA *n, struct mq *q); char nfaExecTamarama_queueCompressState(const struct NFA *n, const struct mq *q, s64a loc); char nfaExecTamarama_expandState(const struct NFA *n, void *dest, const void *src, u64a offset, u8 key); enum nfa_zombie_status nfaExecTamarama_zombie_status(const struct NFA *n, struct mq *q, s64a loc); char nfaExecTamarama_Q(const struct NFA *nfa, struct mq *q, s64a end); char nfaExecTamarama_Q2(const struct NFA *nfa, struct mq *q, s64a end); // only used by outfix and miracles, no implementation for tamarama #define nfaExecTamarama_initCompressedState NFA_API_NO_IMPL #define nfaExecTamarama_B_Reverse NFA_API_NO_IMPL #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/shufticompile.cpp0000644000175000017500000001564613055426554021225 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Shufti acceleration: compile code. */ #include "shufticompile.h" #include "ue2common.h" #include "util/charreach.h" #include "util/container.h" #include "util/ue2_containers.h" #include #include #include #include using namespace std; namespace ue2 { /** \brief Single-byte variant. * * Returns -1 if unable to construct masks, otherwise returns number of bits * used in the mask. * * Note: always able to construct masks for 8 or fewer characters. */ int shuftiBuildMasks(const CharReach &c, u8 *lo, u8 *hi) { /* Things could be packed much more optimally, but this should be able to * handle any set of characters entirely in the lower half. */ assert(c.count() < 256); assert(!c.none()); map by_hi; /* hi nibble -> set of matching lo nibbles */ /* group matching characters by high nibble */ for (size_t i = c.find_first(); i != CharReach::npos; i = c.find_next(i)) { u8 it_hi = i >> 4; u8 it_lo = i & 0xf; by_hi[it_hi].set(it_lo); } map by_lo_set; /* group all hi nibbles with a common set of lo nibbles together */ for (map::const_iterator it = by_hi.begin(); it != by_hi.end(); ++it) { by_lo_set[it->second].set(it->first); } if (by_lo_set.size() > 8) { /* too many char classes on the dance floor */ assert(c.size() > 8); return -1; } u8 bit_index = 0; array lo_a; lo_a.fill(0); array hi_a; hi_a.fill(0); for (map::const_iterator it = by_lo_set.begin(); it != by_lo_set.end(); ++it) { const CharReach &lo_nibbles = it->first; const CharReach &hi_nibbles = it->second; /* set bits in low mask */ for (size_t j = lo_nibbles.find_first(); j != CharReach::npos; j = lo_nibbles.find_next(j)) { lo_a[j] |= (1 << bit_index); } /* set bits in high mask */ for (size_t j = hi_nibbles.find_first(); j != CharReach::npos; j = hi_nibbles.find_next(j)) { hi_a[j] |= (1 << bit_index); } bit_index++; } memcpy(lo, lo_a.data(), sizeof(m128)); memcpy(hi, hi_a.data(), sizeof(m128)); return bit_index; } static array or_array(array a, const array &b) { a[0] |= b[0]; a[1] |= b[1]; a[2] |= b[2]; a[3] |= b[3]; return a; } #define MAX_BUCKETS 8 static void set_buckets_from_mask(u16 nibble_mask, u32 bucket, array &byte_mask) { assert(bucket < MAX_BUCKETS); u32 mask = nibble_mask; while (mask) { u32 n = findAndClearLSB_32(&mask); byte_mask[n] &= ~(1 << bucket); } } bool shuftiBuildDoubleMasks(const CharReach &onechar, const flat_set> &twochar, u8 *lo1, u8 *hi1, u8 *lo2, u8 *hi2) { DEBUG_PRINTF("unibytes %zu dibytes %zu\n", onechar.size(), twochar.size()); array lo1_a; array lo2_a; array hi1_a; array hi2_a; lo1_a.fill(0xff); lo2_a.fill(0xff); hi1_a.fill(0xff); hi2_a.fill(0xff); // two-byte literals vector> nibble_masks; for (const auto &p : twochar) { DEBUG_PRINTF("%02hhx %02hhx\n", p.first, p.second); u16 a_lo = 1U << (p.first & 0xf); u16 a_hi = 1U << (p.first >> 4); u16 b_lo = 1U << (p.second & 0xf); u16 b_hi = 1U << (p.second >> 4); nibble_masks.push_back({{a_lo, a_hi, b_lo, b_hi}}); } // one-byte literals (second byte is a wildcard) for (size_t it = onechar.find_first(); it != CharReach::npos; it = onechar.find_next(it)) { DEBUG_PRINTF("%02hhx\n", (u8)it); u16 a_lo = 1U << (it & 0xf); u16 a_hi = 1U << (it >> 4); u16 wildcard = 0xffff; nibble_masks.push_back({{a_lo, a_hi, wildcard, wildcard}}); } // try to merge strings into shared buckets for (u32 i = 0; i < 4; i++) { map, array> new_masks; for (const auto &a : nibble_masks) { auto key = a; key[i] = 0; if (!contains(new_masks, key)) { new_masks[key] = a; } else { new_masks[key] = or_array(new_masks[key], a); } } nibble_masks.clear(); for (const auto &e : new_masks) { nibble_masks.push_back(e.second); } } if (nibble_masks.size() > MAX_BUCKETS) { DEBUG_PRINTF("too many buckets needed (%zu)\n", nibble_masks.size()); return false; } u32 i = 0; for (const auto &a : nibble_masks) { set_buckets_from_mask(a[0], i, lo1_a); set_buckets_from_mask(a[1], i, hi1_a); set_buckets_from_mask(a[2], i, lo2_a); set_buckets_from_mask(a[3], i, hi2_a); i++; } memcpy(lo1, lo1_a.data(), sizeof(m128)); memcpy(lo2, lo2_a.data(), sizeof(m128)); memcpy(hi1, hi1_a.data(), sizeof(m128)); memcpy(hi2, hi2_a.data(), sizeof(m128)); return true; } #ifdef DUMP_SUPPORT CharReach shufti2cr(const u8 *lo, const u8 *hi) { CharReach cr; for (u32 i = 0; i < 256; i++) { if (lo[(u8)i & 0xf] & hi[(u8)i >> 4]) { cr.set(i); } } return cr; } #endif // DUMP_SUPPORT } // namespace ue2 hyperscan-4.4.1/src/nfa/limex_simd256.c0000644000175000017500000000417713055426554020376 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief LimEx NFA: 256-bit SIMD runtime implementations. */ //#define DEBUG_INPUT //#define DEBUG_EXCEPTIONS #include "limex.h" #include "accel.h" #include "limex_internal.h" #include "nfa_internal.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" // Common code #include "limex_runtime.h" #define SIZE 256 #define STATE_T m256 #define ENG_STATE_T m256 #define LOAD_FROM_ENG load_m256 #include "limex_exceptional.h" #include "limex_state_impl.h" #define INLINE_ATTR really_inline #include "limex_common_impl.h" #include "limex_runtime_impl.h" hyperscan-4.4.1/src/nfa/accelcompile.h0000644000175000017500000000662013055426554020427 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 ACCEL_COMPILE_H #define ACCEL_COMPILE_H #include "ue2common.h" #include "util/charreach.h" #include "util/ue2_containers.h" union AccelAux; namespace ue2 { struct MultibyteAccelInfo { /* multibyte accel schemes, ordered by strength */ enum multiaccel_type { MAT_SHIFT, MAT_SHIFTGRAB, MAT_DSHIFT, MAT_DSHIFTGRAB, MAT_LONG, MAT_LONGGRAB, MAT_MAX, MAT_NONE = MAT_MAX }; CharReach cr; u32 offset = 0; u32 len1 = 0; u32 len2 = 0; multiaccel_type type = MAT_NONE; }; struct AccelInfo { AccelInfo() : single_offset(0U), double_offset(0U), single_stops(CharReach::dot()), multiaccel_offset(0), ma_len1(0), ma_len2(0), ma_type(MultibyteAccelInfo::MAT_NONE) {} u32 single_offset; /**< offset correction to apply to single schemes */ u32 double_offset; /**< offset correction to apply to double schemes */ CharReach double_stop1; /**< single-byte accel stop literals for double * schemes */ flat_set> double_stop2; /**< double-byte accel stop * literals */ CharReach single_stops; /**< escapes for single byte acceleration */ u32 multiaccel_offset; /**< offset correction to apply to multibyte schemes */ CharReach multiaccel_stops; /**< escapes for multibyte acceleration */ u32 ma_len1; /**< multiaccel len1 */ u32 ma_len2; /**< multiaccel len2 */ MultibyteAccelInfo::multiaccel_type ma_type; /**< multiaccel type */ }; bool buildAccelAux(const AccelInfo &info, AccelAux *aux); /* returns true is the escape set can be handled with a masked double_verm */ bool buildDvermMask(const flat_set> &escape_set, u8 *m1_out = nullptr, u8 *m2_out = nullptr); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/multiaccel_compilehelper.h0000644000175000017500000000515713055426554023045 0ustar sleuthkidsleuthkid/* * 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 MULTIACCELCOMPILE_H_ #define MULTIACCELCOMPILE_H_ #include "ue2common.h" #include "nfagraph/ng_limex_accel.h" #include namespace ue2 { /* accel scheme state machine */ enum accel_scheme_state { STATE_FIRST_RUN, STATE_SECOND_RUN, STATE_WAITING_FOR_GRAB, STATE_FIRST_TAIL, STATE_SECOND_TAIL, STATE_STOPPED, STATE_INVALID }; struct accel_data { MultibyteAccelInfo::multiaccel_type type = MultibyteAccelInfo::MAT_NONE; accel_scheme_state state = STATE_INVALID; unsigned len1 = 0; /* length of first run */ unsigned len2 = 0; /* length of second run, if present */ unsigned tlen1 = 0; /* first tail length */ unsigned tlen2 = 0; /* second tail length */ }; class MultiaccelCompileHelper { private: const CharReach &cr; u32 offset; std::vector accels; unsigned max_len; public: MultiaccelCompileHelper(const CharReach &cr, u32 off, unsigned max_len); bool canAdvance(); MultibyteAccelInfo getBestScheme(); void advance(const ue2::CharReach &cr); }; }; // namespace #endif /* MULTIACCELCOMPILE_H_ */ hyperscan-4.4.1/src/nfa/dfa_min.cpp0000644000175000017500000002614213055426554017740 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Build code for DFA minimization */ /** * /Summary of the Hopcrofts algorithm/ * partition := {F, Q \ F}; * work_queue := {F}; * while (work_queue is not empty) do * choose and remove a set A from work_queue * for each c in . do * let X be the set of states for which a transition on c * leads to a state in A * for each set Y in partition for which X . Y is nonempty and * Y \ X is nonempty do * replace Y in partition by the two sets X . Y and Y \ X * if Y is in work_queue * replace Y in work_queue by the same two sets * else * if |X . Y| <= |Y \ X| * add X . Y to work_queue * else * add Y \ X to work_queue * end; * end; * end; */ #include "dfa_min.h" #include "grey.h" #include "nfa/rdfa.h" #include "nfagraph/ng_mcclellan.h" #include "ue2common.h" #include "util/partitioned_set.h" #include "util/container.h" #include "util/ue2_containers.h" #include #include #include #include #include #include #include #include using namespace std; namespace ue2 { namespace { struct hopcroft_state_info { vector > prev; }; struct DFA_components : boost::noncopyable { dstate_id_t nstates; size_t inp_size; set work_queue; /*Partition contains reduced states*/ partitioned_set partition; vector states; explicit DFA_components(const raw_dfa &rdfa); }; } //namespace /** * create_map: * Creates an initial partitioning and work_queue. * Initial partition contains {accepting states..., Non-accepting states} * Initial work_queue contains accepting state subsets * * The initial partitioning needs to distinguish between the different * reporting behaviours (unlike standard hopcroft) --> more than one subset * possible for the accepting states. * * Look for accepting states in both reports and reports_eod. * Creates a map with a key(reports, reports_eod) and an id. * Reports of each state are searched against the map and * added to the corresponding id -> partition[id] and work_queue[id]. * Non Accept states are added to partition[id+1]. */ static vector create_map(const raw_dfa &rdfa, set &work_queue) { using ReportKey = pair, flat_set>; map subset_map; vector state_to_subset(rdfa.states.size(), INVALID_SUBSET); for (size_t i = 0; i < rdfa.states.size(); i++) { if (!rdfa.states[i].reports.empty() || !rdfa.states[i].reports_eod.empty()) { ReportKey key(rdfa.states[i].reports, rdfa.states[i].reports_eod); if (contains(subset_map, key)) { state_to_subset[i] = subset_map[key]; } else { size_t sub = subset_map.size(); subset_map[key] = sub; state_to_subset[i] = sub; work_queue.insert(sub); } } } /* handle non accepts */ size_t non_accept_sub = subset_map.size(); for (size_t i = 0; i < state_to_subset.size(); i++) { if (state_to_subset[i] == INVALID_SUBSET) { state_to_subset[i] = non_accept_sub; } } return state_to_subset; } DFA_components::DFA_components(const raw_dfa &rdfa) : nstates(rdfa.states.size()), inp_size(rdfa.states[nstates - 1].next.size()), partition(create_map(rdfa, work_queue)) { /* initializing states */ for (size_t i = 0; i < nstates; i++) { states.push_back(hopcroft_state_info()); states.back().prev.resize(inp_size); } for (size_t i = 0; i < nstates; i++) { // i is the previous state for (size_t j = 0; j < inp_size; j++) { /* Creating X_table */ dstate_id_t present_state = rdfa.states[i].next[j]; states[present_state].prev[j].push_back(i); DEBUG_PRINTF("rdfa.states[%zu].next[%zu] %hu \n", i, j, rdfa.states[i].next[j]); } } } /** * choose and remove a set A from work_queue. */ static void get_work_item(DFA_components &mdfa, ue2::flat_set &A) { A.clear(); assert(!mdfa.work_queue.empty()); set::iterator pt = mdfa.work_queue.begin(); insert(&A, mdfa.partition[*pt]); mdfa.work_queue.erase(pt); } /** * X is the set of states for which a transition on the input leads to a state * in A. */ static void create_X(const DFA_components &mdfa, const ue2::flat_set &A, size_t inp, ue2::flat_set &X) { X.clear(); for (dstate_id_t id : A) { insert(&X, mdfa.states[id].prev[inp]); } } /** * For a split set X, each subset S (given by part_index) in the partition, two * sets are created: v_inter (X intersection S) and v_sub (S - X). * * For each subset S in the partition that could be split (v_inter is nonempty * and v_sub is nonempty): * - replace S in partition by the two sets v_inter and v_sub. * - if S is in work_queue: * - replace S in work_queue by the two subsets. * - else: * - replace S in work_queue by the smaller of the two sets. */ static void split_and_replace_set(const size_t part_index, DFA_components &mdfa, const ue2::flat_set &splitter) { /* singleton sets cannot be split */ if (mdfa.partition[part_index].size() == 1) { return; } size_t small_index = mdfa.partition.split(part_index, splitter); if (small_index == INVALID_SUBSET) { /* the set could not be split */ return; } /* larger subset remains at the input subset index, if the input subset was * already in the work queue then the larger subset will remain there. */ mdfa.work_queue.insert(small_index); } /** * The complete Hopcrofts algorithm is implemented in this function. * Choose and remove a set tray from work_queue * For each input- X is created. * For each subset in the partition, split_and_replace_sets are called with the * split set. */ static void dfa_min(DFA_components &mdfa) { ue2::flat_set A, X; vector cand_subsets; while (!mdfa.work_queue.empty()) { get_work_item(mdfa, A); for (size_t inp = 0; inp < mdfa.inp_size; inp++) { create_X(mdfa, A, inp, X); if (X.empty()) { continue; } /* we only need to consider subsets with at least one member in X for * splitting */ cand_subsets.clear(); mdfa.partition.find_overlapping(X, &cand_subsets); for (size_t sub : cand_subsets) { split_and_replace_set(sub, mdfa, X); } } } } /** * Creating new dfa table * Map ordering contains key being an equivalence classes first state * and the value being the equivalence class index. * Eq_state[i] tells us new state id the equivalence class located at * partition[i]. */ static void mapping_new_states(const DFA_components &mdfa, vector &old_to_new, raw_dfa &rdfa) { const size_t num_partitions = mdfa.partition.size(); // Mapping from equiv class's first state to equiv class index. map ordering; // New state id for each equiv class. vector eq_state(num_partitions); for (size_t i = 0; i < num_partitions; i++) { ordering[*mdfa.partition[i].begin()] = i; } dstate_id_t new_id = 0; for (const auto &m : ordering) { eq_state[m.second] = new_id++; } for (size_t t = 0; t < mdfa.partition.size(); t++) { for (dstate_id_t id : mdfa.partition[t]) { old_to_new[id] = eq_state[t]; } } vector new_states; new_states.reserve(num_partitions); for (size_t i = 0; i < mdfa.nstates; i++) { if (contains(ordering, i)) { new_states.push_back(rdfa.states[i]); } } rdfa.states.swap(new_states); } static void renumber_new_states(const DFA_components &mdfa, const vector &old_to_new, raw_dfa &rdfa) { for (size_t i = 0; i < mdfa.partition.size(); i++) { for (size_t j = 0; j < mdfa.inp_size; j++) { dstate_id_t output = rdfa.states[i].next[j]; rdfa.states[i].next[j] = old_to_new[output]; } dstate_id_t dad = rdfa.states[i].daddy; rdfa.states[i].daddy = old_to_new[dad]; } rdfa.start_floating = old_to_new[rdfa.start_floating]; rdfa.start_anchored = old_to_new[rdfa.start_anchored]; } static void new_dfa(raw_dfa &rdfa, const DFA_components &mdfa) { if (mdfa.partition.size() != mdfa.nstates) { vector old_to_new(mdfa.nstates); mapping_new_states(mdfa, old_to_new, rdfa); renumber_new_states(mdfa, old_to_new, rdfa); } } /** * MAIN FUNCTION */ void minimize_hopcroft(raw_dfa &rdfa, const Grey &grey) { if (!grey.minimizeDFA) { return; } UNUSED const size_t states_before = rdfa.states.size(); DFA_components mdfa(rdfa); dfa_min(mdfa); new_dfa(rdfa, mdfa); DEBUG_PRINTF("reduced from %zu to %zu states\n", states_before, rdfa.states.size()); } } // namespace ue2 hyperscan-4.4.1/src/nfa/nfa_dump_dispatch.cpp0000644000175000017500000001063613055426554022014 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "nfa_dump_api.h" #include "nfa_internal.h" #include "ue2common.h" // Engine implementations. #include "goughdump.h" #include "castle_dump.h" #include "lbr_dump.h" #include "limex.h" #include "mcclellandump.h" #include "mcsheng_dump.h" #include "mpv_dump.h" #include "shengdump.h" #include "tamarama_dump.h" #ifndef DUMP_SUPPORT #error "no dump support" #endif namespace ue2 { #define DISPATCH_CASE(dc_ltype, dc_ftype, dc_func_call) \ case dc_ltype: \ nfaExec##dc_ftype##dc_func_call; \ break // general framework calls #define DISPATCH_BY_NFA_TYPE(dbnt_func) \ DEBUG_PRINTF("dispatch for NFA type %u\n", nfa->type); \ switch (nfa->type) { \ DISPATCH_CASE(LIMEX_NFA_32, LimEx32, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_64, LimEx64, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_128, LimEx128, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_256, LimEx256, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_384, LimEx384, dbnt_func); \ DISPATCH_CASE(LIMEX_NFA_512, LimEx512, dbnt_func); \ DISPATCH_CASE(MCCLELLAN_NFA_8, McClellan8, dbnt_func); \ DISPATCH_CASE(MCCLELLAN_NFA_16, McClellan16, dbnt_func); \ DISPATCH_CASE(GOUGH_NFA_8, Gough8, dbnt_func); \ DISPATCH_CASE(GOUGH_NFA_16, Gough16, dbnt_func); \ DISPATCH_CASE(MPV_NFA, Mpv, dbnt_func); \ DISPATCH_CASE(LBR_NFA_DOT, LbrDot, dbnt_func); \ DISPATCH_CASE(LBR_NFA_VERM, LbrVerm, dbnt_func); \ DISPATCH_CASE(LBR_NFA_NVERM, LbrNVerm, dbnt_func); \ DISPATCH_CASE(LBR_NFA_SHUF, LbrShuf, dbnt_func); \ DISPATCH_CASE(LBR_NFA_TRUF, LbrTruf, dbnt_func); \ DISPATCH_CASE(CASTLE_NFA, Castle, dbnt_func); \ DISPATCH_CASE(SHENG_NFA, Sheng, dbnt_func); \ DISPATCH_CASE(TAMARAMA_NFA, Tamarama, dbnt_func); \ DISPATCH_CASE(MCSHENG_NFA_8, McSheng8, dbnt_func); \ DISPATCH_CASE(MCSHENG_NFA_16, McSheng16, dbnt_func); \ default: \ assert(0); \ } void nfaGenerateDumpFiles(const struct NFA *nfa, const std::string &base) { DISPATCH_BY_NFA_TYPE(_dump(nfa, base)); } } // namespace ue2 hyperscan-4.4.1/src/nfa/multishufti_sse.h0000644000175000017500000002036313055426554021236 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "shufti_common.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" /* Normal SSSE3 shufti */ static really_inline const u8 *JOIN(MATCH_ALGO, fwdBlock)(m128 mask_lo, m128 mask_hi, m128 chars, const u8 *buf, const m128 low4bits, const m128 zeroes, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { // negate first 16 bits u32 z = block(mask_lo, mask_hi, chars, low4bits, zeroes) ^ 0xFFFF; return (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len])(buf, z #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); } /* * 16-byte pipeline, for smaller scans */ static const u8 *JOIN(MATCH_ALGO, shuftiPipeline16)(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const m128 low4bits, const m128 zeroes, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8* ptr, *last_buf; u32 last_res; // pipeline prologue: scan first 16 bytes m128 data = load128(buf); u32 z = block(mask_lo, mask_hi, data, low4bits, zeroes) ^ 0xFFFF; last_buf = buf; last_res = z; buf += 16; // now, start the pipeline! assert((size_t)buf % 16 == 0); for (; buf + 15 < buf_end; buf += 16) { // scan more data data = load128(buf); z = block(mask_lo, mask_hi, data, low4bits, zeroes) ^ 0xFFFF; // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_buf = buf; last_res = z; } assert(buf <= buf_end && buf >= buf_end - 16); // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 32)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } return NULL; } /* * 32-byte pipeline, for bigger scans */ static const u8 *JOIN(MATCH_ALGO, shuftiPipeline32)(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const m128 low4bits, const m128 zeroes, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { const u8* ptr, *last_buf; u32 res; // pipeline prologue: scan first 32 bytes m128 data1 = load128(buf); u32 z1 = block(mask_lo, mask_hi, data1, low4bits, zeroes) ^ 0xFFFF; m128 data2 = load128(buf + 16); u32 z2 = block(mask_lo, mask_hi, data2, low4bits, zeroes) ^ 0xFFFF; // store the results u32 last_res = z1 | (z2 << 16); last_buf = buf; buf += 32; // now, start the pipeline! assert((size_t)buf % 16 == 0); for (; buf + 31 < buf_end; buf += 32) { // scan more data data1 = load128(buf); z1 = block(mask_lo, mask_hi, data1, low4bits, zeroes) ^ 0xFFFF; data2 = load128(buf + 16); z2 = block(mask_lo, mask_hi, data2, low4bits, zeroes) ^ 0xFFFF; res = z1 | (z2 << 16); // do a comparison on previous result ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } last_res = res; last_buf = buf; } // epilogue: compare final results ptr = (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len]) (last_buf, last_res #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } // if we still have some data left, scan it too for (; buf + 15 < buf_end; buf += 16) { m128 chars = load128(buf); ptr = JOIN(MATCH_ALGO, fwdBlock)(mask_lo, mask_hi, chars, buf, low4bits, zeroes, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(ptr)) { return ptr; } } assert(buf <= buf_end && buf >= buf_end - 16); return NULL; } const u8 *JOIN(MATCH_ALGO, shuftiExec)(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, u8 run_len #ifdef MULTIACCEL_DOUBLE , u8 run_len2 #endif ) { assert(buf && buf_end); assert(buf < buf_end); // Slow path for small cases. if (buf_end - buf < 16) { return shuftiFwdSlow((const u8 *)&mask_lo, (const u8 *)&mask_hi, buf, buf_end); } const m128 zeroes = zeroes128(); const m128 low4bits = _mm_set1_epi8(0xf); const u8 *rv; size_t min = (size_t)buf % 16; assert(buf_end - buf >= 16); // Preconditioning: most of the time our buffer won't be aligned. m128 chars = loadu128(buf); rv = JOIN(MATCH_ALGO, fwdBlock)(mask_lo, mask_hi, chars, buf, low4bits, zeroes, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } buf += (16 - min); // if we have enough data, run bigger pipeline; otherwise run smaller one if (buf_end - buf >= 128) { rv = JOIN(MATCH_ALGO, shuftiPipeline32)(mask_lo, mask_hi, buf, buf_end, low4bits, zeroes, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(rv)) { return rv; } } else if (buf_end - buf >= 16){ rv = JOIN(MATCH_ALGO, shuftiPipeline16)(mask_lo, mask_hi, buf, buf_end, low4bits, zeroes, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (unlikely(rv)) { return rv; } } // Use an unaligned load to mop up the last 16 bytes and get an accurate // picture to buf_end. chars = loadu128(buf_end - 16); rv = JOIN(MATCH_ALGO, fwdBlock)(mask_lo, mask_hi, chars, buf_end - 16, low4bits, zeroes, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } return buf_end; } hyperscan-4.4.1/src/nfa/limex_common_impl.h0000644000175000017500000003717013055426554021522 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "repeat.h" #include "util/join.h" /* impl of limex functions which depend only on state size */ #if !defined(SIZE) || !defined(STATE_T) || !defined(LOAD_FROM_ENG) \ || !defined(INLINE_ATTR) # error Must define SIZE, STATE_T, LOAD_FROM_ENG and INLINE_ATTR in includer. #endif #define IMPL_NFA_T JOIN(struct LimExNFA, SIZE) #define TESTEOD_FN JOIN(moNfaTestEod, SIZE) #define LIMEX_INACCEPT_FN JOIN(limexInAccept, SIZE) #define LIMEX_INANYACCEPT_FN JOIN(limexInAnyAccept, SIZE) #define EXPIRE_ESTATE_FN JOIN(limexExpireExtendedState, SIZE) #define REPORTCURRENT_FN JOIN(moNfaReportCurrent, SIZE) #define INITIAL_FN JOIN(moNfaInitial, SIZE) #define TOP_FN JOIN(moNfaTop, SIZE) #define TOPN_FN JOIN(moNfaTopN, SIZE) #define PROCESS_ACCEPTS_IMPL_FN JOIN(moProcessAcceptsImpl, SIZE) #define PROCESS_ACCEPTS_FN JOIN(moProcessAccepts, SIZE) #define PROCESS_ACCEPTS_NOSQUASH_FN JOIN(moProcessAcceptsNoSquash, SIZE) #define CONTEXT_T JOIN(NFAContext, SIZE) #define ONES_STATE JOIN(ones_, STATE_T) #define AND_STATE JOIN(and_, STATE_T) #define OR_STATE JOIN(or_, STATE_T) #define ANDNOT_STATE JOIN(andnot_, STATE_T) #define CLEARBIT_STATE JOIN(clearbit_, STATE_T) #define TESTBIT_STATE JOIN(testbit_, STATE_T) #define ISNONZERO_STATE JOIN(isNonZero_, STATE_T) #define ISZERO_STATE JOIN(isZero_, STATE_T) #define SQUASH_UNTUG_BR_FN JOIN(lazyTug, SIZE) #define GET_NFA_REPEAT_INFO_FN JOIN(getNfaRepeatInfo, SIZE) #if defined(ARCH_64_BIT) && (SIZE >= 64) #define CHUNK_T u64a #define FIND_AND_CLEAR_FN findAndClearLSB_64 #define POPCOUNT_FN popcount64 #define RANK_IN_MASK_FN rank_in_mask64 #else #define CHUNK_T u32 #define FIND_AND_CLEAR_FN findAndClearLSB_32 #define POPCOUNT_FN popcount32 #define RANK_IN_MASK_FN rank_in_mask32 #endif #define NUM_STATE_CHUNKS (sizeof(STATE_T) / sizeof(CHUNK_T)) static really_inline void SQUASH_UNTUG_BR_FN(const IMPL_NFA_T *limex, const union RepeatControl *repeat_ctrl, const char *repeat_state, u64a offset, STATE_T *accstate) { // switch off cyclic tug-accepts which aren't tuggable right now. /* TODO: might be nice to work which br to examine based on accstate rather * than iterating overall br */ if (!limex->repeatCount) { return; } assert(repeat_ctrl); assert(repeat_state); for (u32 i = 0; i < limex->repeatCount; i++) { const struct NFARepeatInfo *info = GET_NFA_REPEAT_INFO_FN(limex, i); u32 cyclicState = info->cyclicState; if (!TESTBIT_STATE(*accstate, cyclicState)) { continue; } DEBUG_PRINTF("repeat %u (cyclic state %u) is active\n", i, cyclicState); DEBUG_PRINTF("checking if offset %llu would match\n", offset); const union RepeatControl *ctrl = repeat_ctrl + i; const char *state = repeat_state + info->stateOffset; const struct RepeatInfo *repeat = getRepeatInfo(info); if (repeatHasMatch(repeat, ctrl, state, offset) != REPEAT_MATCH) { DEBUG_PRINTF("not ready to accept yet\n"); CLEARBIT_STATE(accstate, cyclicState); } } } static really_inline char PROCESS_ACCEPTS_IMPL_FN(const IMPL_NFA_T *limex, const STATE_T *s, STATE_T *squash, const STATE_T *acceptMask, const struct NFAAccept *acceptTable, u64a offset, NfaCallback callback, void *context) { assert(s); assert(limex); assert(callback); const STATE_T accept_mask = *acceptMask; STATE_T accepts = AND_STATE(*s, accept_mask); // Caller must ensure that we have at least one accept state on. assert(ISNONZERO_STATE(accepts)); CHUNK_T chunks[NUM_STATE_CHUNKS]; memcpy(chunks, &accepts, sizeof(accepts)); CHUNK_T mask_chunks[NUM_STATE_CHUNKS]; memcpy(mask_chunks, &accept_mask, sizeof(accept_mask)); u32 base_index = 0; // Cumulative sum of mask popcount up to current chunk. for (u32 i = 0; i < NUM_STATE_CHUNKS; i++) { CHUNK_T chunk = chunks[i]; while (chunk != 0) { u32 bit = FIND_AND_CLEAR_FN(&chunk); u32 local_idx = RANK_IN_MASK_FN(mask_chunks[i], bit); u32 idx = local_idx + base_index; const struct NFAAccept *a = &acceptTable[idx]; DEBUG_PRINTF("state %u: firing report list=%u, offset=%llu\n", bit + i * (u32)sizeof(chunk) * 8, a->reports, offset); int rv = limexRunAccept((const char *)limex, a, callback, context, offset); if (unlikely(rv == MO_HALT_MATCHING)) { return 1; } if (squash != NULL && a->squash != MO_INVALID_IDX) { DEBUG_PRINTF("applying squash mask at offset %u\n", a->squash); const ENG_STATE_T *sq = (const ENG_STATE_T *)((const char *)limex + a->squash); *squash = AND_STATE(*squash, LOAD_FROM_ENG(sq)); } } base_index += POPCOUNT_FN(mask_chunks[i]); } return 0; } static never_inline char PROCESS_ACCEPTS_FN(const IMPL_NFA_T *limex, STATE_T *s, const STATE_T *acceptMask, const struct NFAAccept *acceptTable, u64a offset, NfaCallback callback, void *context) { // We have squash masks we might have to apply after firing reports. STATE_T squash = ONES_STATE; return PROCESS_ACCEPTS_IMPL_FN(limex, s, &squash, acceptMask, acceptTable, offset, callback, context); *s = AND_STATE(*s, squash); } static never_inline char PROCESS_ACCEPTS_NOSQUASH_FN(const IMPL_NFA_T *limex, const STATE_T *s, const STATE_T *acceptMask, const struct NFAAccept *acceptTable, u64a offset, NfaCallback callback, void *context) { STATE_T *squash = NULL; return PROCESS_ACCEPTS_IMPL_FN(limex, s, squash, acceptMask, acceptTable, offset, callback, context); } // Run EOD accepts. Note that repeat_ctrl and repeat_state may be NULL if this // LimEx contains no repeat structures. static really_inline char TESTEOD_FN(const IMPL_NFA_T *limex, const STATE_T *s, const union RepeatControl *repeat_ctrl, const char *repeat_state, u64a offset, NfaCallback callback, void *context) { assert(limex && s); // There may not be any EOD accepts in this NFA. if (!limex->acceptEodCount) { return MO_CONTINUE_MATCHING; } const STATE_T acceptEodMask = LOAD_FROM_ENG(&limex->acceptAtEOD); STATE_T foundAccepts = AND_STATE(*s, acceptEodMask); SQUASH_UNTUG_BR_FN(limex, repeat_ctrl, repeat_state, offset + 1 /* EOD 'symbol' */, &foundAccepts); if (unlikely(ISNONZERO_STATE(foundAccepts))) { const struct NFAAccept *acceptEodTable = getAcceptEodTable(limex); if (PROCESS_ACCEPTS_NOSQUASH_FN(limex, &foundAccepts, &acceptEodMask, acceptEodTable, offset, callback, context)) { return MO_HALT_MATCHING; } } return MO_CONTINUE_MATCHING; } // Run accepts corresponding to current state. static really_inline char REPORTCURRENT_FN(const IMPL_NFA_T *limex, const struct mq *q) { assert(limex && q); assert(q->state); assert(q_cur_type(q) == MQE_START); STATE_T s = *(STATE_T *)q->state; STATE_T acceptMask = LOAD_FROM_ENG(&limex->accept); STATE_T foundAccepts = AND_STATE(s, acceptMask); if (unlikely(ISNONZERO_STATE(foundAccepts))) { DEBUG_PRINTF("found accepts\n"); DEBUG_PRINTF("for nfa %p\n", limex); const struct NFAAccept *acceptTable = getAcceptTable(limex); u64a offset = q_cur_offset(q); if (PROCESS_ACCEPTS_NOSQUASH_FN(limex, &foundAccepts, &acceptMask, acceptTable, offset, q->cb, q->context)) { return MO_HALT_MATCHING; } } return MO_CONTINUE_MATCHING; } static really_inline STATE_T INITIAL_FN(const IMPL_NFA_T *impl, char onlyDs) { return LOAD_FROM_ENG(onlyDs ? &impl->initDS : &impl->init); } static really_inline STATE_T TOP_FN(const IMPL_NFA_T *impl, char onlyDs, STATE_T state) { return OR_STATE(INITIAL_FN(impl, onlyDs), state); } static really_inline STATE_T TOPN_FN(const IMPL_NFA_T *limex, STATE_T state, u32 n) { assert(n < limex->topCount); const ENG_STATE_T *topsptr = (const ENG_STATE_T *)((const char *)limex + limex->topOffset); STATE_T top = LOAD_FROM_ENG(&topsptr[n]); return OR_STATE(top, state); } static really_inline void EXPIRE_ESTATE_FN(const IMPL_NFA_T *limex, struct CONTEXT_T *ctx, u64a offset) { assert(limex); assert(ctx); if (!limex->repeatCount) { return; } DEBUG_PRINTF("expire estate at offset %llu\n", offset); const STATE_T cyclics = AND_STATE(ctx->s, LOAD_FROM_ENG(&limex->repeatCyclicMask)); if (ISZERO_STATE(cyclics)) { DEBUG_PRINTF("no cyclic states are on\n"); return; } for (u32 i = 0; i < limex->repeatCount; i++) { const struct NFARepeatInfo *info = GET_NFA_REPEAT_INFO_FN(limex, i); u32 cyclicState = info->cyclicState; if (!TESTBIT_STATE(cyclics, cyclicState)) { continue; } DEBUG_PRINTF("repeat %u (cyclic state %u) is active\n", i, cyclicState); const struct RepeatInfo *repeat = getRepeatInfo(info); if (repeat->repeatMax == REPEAT_INF) { continue; // can't expire } const union RepeatControl *repeat_ctrl = ctx->repeat_ctrl + i; const char *repeat_state = ctx->repeat_state + info->stateOffset; u64a last_top = repeatLastTop(repeat, repeat_ctrl, repeat_state); assert(repeat->repeatMax < REPEAT_INF); DEBUG_PRINTF("offset %llu, last_top %llu repeatMax %u\n", offset, last_top, repeat->repeatMax); u64a adj = 0; /* if the cycle's tugs are active at repeat max, it is still alive */ if (TESTBIT_STATE(LOAD_FROM_ENG(&limex->accept), cyclicState) || TESTBIT_STATE(LOAD_FROM_ENG(&limex->acceptAtEOD), cyclicState)) { DEBUG_PRINTF("lazy tug possible - may still be inspected\n"); adj = 1; } else { const ENG_STATE_T *tug_mask = (const ENG_STATE_T *)((const char *)info + info->tugMaskOffset); if (ISNONZERO_STATE(AND_STATE(ctx->s, LOAD_FROM_ENG(tug_mask)))) { DEBUG_PRINTF("tug possible - may still be inspected\n"); adj = 1; } } if (offset >= last_top + repeat->repeatMax + adj) { DEBUG_PRINTF("repeat state is stale, squashing state %u\n", cyclicState); CLEARBIT_STATE(&ctx->s, cyclicState); } } } // Specialised inAccept call: LimEx NFAs with the "lazy tug" optimisation (see // UE-1636) need to guard cyclic tug-accepts as well. static really_inline char LIMEX_INACCEPT_FN(const IMPL_NFA_T *limex, STATE_T state, union RepeatControl *repeat_ctrl, char *repeat_state, u64a offset, ReportID report) { assert(limex); const STATE_T accept_mask = LOAD_FROM_ENG(&limex->accept); STATE_T accepts = AND_STATE(state, accept_mask); // Are we in an accept state? if (ISZERO_STATE(accepts)) { DEBUG_PRINTF("no accept states are on\n"); return 0; } SQUASH_UNTUG_BR_FN(limex, repeat_ctrl, repeat_state, offset, &accepts); DEBUG_PRINTF("looking for report %u\n", report); const struct NFAAccept *acceptTable = getAcceptTable(limex); CHUNK_T chunks[NUM_STATE_CHUNKS]; memcpy(chunks, &accepts, sizeof(accepts)); CHUNK_T mask_chunks[NUM_STATE_CHUNKS]; memcpy(mask_chunks, &accept_mask, sizeof(accept_mask)); u32 base_index = 0; // Cumulative sum of mask popcount up to current chunk. for (u32 i = 0; i < NUM_STATE_CHUNKS; i++) { CHUNK_T chunk = chunks[i]; while (chunk != 0) { u32 bit = FIND_AND_CLEAR_FN(&chunk); u32 local_idx = RANK_IN_MASK_FN(mask_chunks[i], bit); u32 idx = local_idx + base_index; assert(idx < limex->acceptCount); const struct NFAAccept *a = &acceptTable[idx]; DEBUG_PRINTF("state %u is on, report list at %u\n", bit + i * (u32)sizeof(chunk) * 8, a->reports); if (limexAcceptHasReport((const char *)limex, a, report)) { DEBUG_PRINTF("report %u is on\n", report); return 1; } } base_index += POPCOUNT_FN(mask_chunks[i]); } return 0; } static really_inline char LIMEX_INANYACCEPT_FN(const IMPL_NFA_T *limex, STATE_T state, union RepeatControl *repeat_ctrl, char *repeat_state, u64a offset) { assert(limex); const STATE_T acceptMask = LOAD_FROM_ENG(&limex->accept); STATE_T accstate = AND_STATE(state, acceptMask); // Are we in an accept state? if (ISZERO_STATE(accstate)) { DEBUG_PRINTF("no accept states are on\n"); return 0; } SQUASH_UNTUG_BR_FN(limex, repeat_ctrl, repeat_state, offset, &accstate); return ISNONZERO_STATE(accstate); } #undef TESTEOD_FN #undef REPORTCURRENT_FN #undef EXPIRE_ESTATE_FN #undef LIMEX_INACCEPT_FN #undef LIMEX_INANYACCEPT_FN #undef INITIAL_FN #undef TOP_FN #undef TOPN_FN #undef CONTEXT_T #undef IMPL_NFA_T #undef ONES_STATE #undef AND_STATE #undef OR_STATE #undef ANDNOT_STATE #undef CLEARBIT_STATE #undef TESTBIT_STATE #undef ISNONZERO_STATE #undef ISZERO_STATE #undef PROCESS_ACCEPTS_IMPL_FN #undef PROCESS_ACCEPTS_FN #undef PROCESS_ACCEPTS_NOSQUASH_FN #undef SQUASH_UNTUG_BR_FN #undef GET_NFA_REPEAT_INFO_FN #undef CHUNK_T #undef FIND_AND_CLEAR_FN #undef POPCOUNT_FN #undef RANK_IN_MASK_FN #undef NUM_STATE_CHUNKS hyperscan-4.4.1/src/nfa/tamarama_dump.cpp0000644000175000017500000000536613055426554021160 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Tamarama: container engine for exclusve engines, dump code. */ #include "config.h" #include "tamarama_dump.h" #include "tamarama_internal.h" #include "nfa_dump_api.h" #include "nfa_dump_internal.h" #include "nfa_internal.h" #include "util/dump_util.h" #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { void nfaExecTamarama_dump(const struct NFA *nfa, const string &base) { const Tamarama *t = (const Tamarama *)getImplNfa(nfa); FILE *f = fopen_or_throw((base + ".txt").c_str(), "w"); fprintf(f, "Tamarama container engine\n"); fprintf(f, "\n"); fprintf(f, "Number of subengine tenants: %u\n", t->numSubEngines); fprintf(f, "\n"); dumpTextReverse(nfa, f); fprintf(f, "\n"); fclose(f); const u32 *subOffset = (const u32 *)((const char *)t + sizeof(struct Tamarama) + t->numSubEngines * sizeof(u32)); for (u32 i = 0; i < t->numSubEngines; i++) { const NFA *sub = (const struct NFA *)((const char *)t + subOffset[i]); stringstream sssub; sssub << base << "_sub_" << i; nfaGenerateDumpFiles(sub, sssub.str()); } } } // namespace ue2 hyperscan-4.4.1/src/nfa/vermicelli.h0000644000175000017500000003450413055426554020144 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Vermicelli: single-byte and double-byte acceleration. */ #ifndef VERMICELLI_H #define VERMICELLI_H #include "util/bitutils.h" #include "util/simd_utils.h" #include "util/unaligned.h" #include "vermicelli_sse.h" static really_inline const u8 *vermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("verm scan %s\\x%02hhx over %zu bytes\n", nocase ? "nocase " : "", c, (size_t)(buf_end - buf)); assert(buf < buf_end); // Handle small scans. if (buf_end - buf < VERM_BOUNDARY) { for (; buf < buf_end; buf++) { char cur = (char)*buf; if (nocase) { cur &= CASE_CLEAR; } if (cur == c) { break; } } return buf; } VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY; if (min) { // Input isn't aligned, so we need to run one iteration with an // unaligned load, then skip buf forward to the next aligned address. // There's some small overlap here, but we don't mind scanning it twice // if we can do it quickly, do we? const u8 *ptr = nocase ? vermUnalignNocase(chars, buf, 0) : vermUnalign(chars, buf, 0); if (ptr) { return ptr; } buf += VERM_BOUNDARY - min; assert(buf < buf_end); } // Aligned loops from here on in const u8 *ptr = nocase ? vermSearchAlignedNocase(chars, buf, buf_end - 1, 0) : vermSearchAligned(chars, buf, buf_end - 1, 0); if (ptr) { return ptr; } // Tidy up the mess at the end ptr = nocase ? vermUnalignNocase(chars, buf_end - VERM_BOUNDARY, 0) : vermUnalign(chars, buf_end - VERM_BOUNDARY, 0); return ptr ? ptr : buf_end; } /* like vermicelliExec except returns the address of the first character which * is not c */ static really_inline const u8 *nvermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("nverm scan %s\\x%02hhx over %zu bytes\n", nocase ? "nocase " : "", c, (size_t)(buf_end - buf)); assert(buf < buf_end); // Handle small scans. if (buf_end - buf < VERM_BOUNDARY) { for (; buf < buf_end; buf++) { char cur = (char)*buf; if (nocase) { cur &= CASE_CLEAR; } if (cur != c) { break; } } return buf; } VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ size_t min = (size_t)buf % VERM_BOUNDARY; if (min) { // Input isn't aligned, so we need to run one iteration with an // unaligned load, then skip buf forward to the next aligned address. // There's some small overlap here, but we don't mind scanning it twice // if we can do it quickly, do we? const u8 *ptr = nocase ? vermUnalignNocase(chars, buf, 1) : vermUnalign(chars, buf, 1); if (ptr) { return ptr; } buf += VERM_BOUNDARY - min; assert(buf < buf_end); } // Aligned loops from here on in const u8 *ptr = nocase ? vermSearchAlignedNocase(chars, buf, buf_end - 1, 1) : vermSearchAligned(chars, buf, buf_end - 1, 1); if (ptr) { return ptr; } // Tidy up the mess at the end ptr = nocase ? vermUnalignNocase(chars, buf_end - VERM_BOUNDARY, 1) : vermUnalign(chars, buf_end - VERM_BOUNDARY, 1); return ptr ? ptr : buf_end; } static really_inline const u8 *vermicelliDoubleExec(char c1, char c2, char nocase, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("double verm scan %s\\x%02hhx%02hhx over %zu bytes\n", nocase ? "nocase " : "", c1, c2, (size_t)(buf_end - buf)); assert(buf < buf_end); assert((buf_end - buf) >= VERM_BOUNDARY); uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY; VERM_TYPE chars1 = VERM_SET_FN(c1); /* nocase already uppercase */ VERM_TYPE chars2 = VERM_SET_FN(c2); /* nocase already uppercase */ if (min) { // Input isn't aligned, so we need to run one iteration with an // unaligned load, then skip buf forward to the next aligned address. // There's some small overlap here, but we don't mind scanning it twice // if we can do it quickly, do we? const u8 *ptr = nocase ? dvermPreconditionNocase(chars1, chars2, buf) : dvermPrecondition(chars1, chars2, buf); if (ptr) { return ptr; } buf += VERM_BOUNDARY - min; assert(buf < buf_end); } // Aligned loops from here on in const u8 *ptr = nocase ? dvermSearchAlignedNocase(chars1, chars2, c1, c2, buf, buf_end) : dvermSearchAligned(chars1, chars2, c1, c2, buf, buf_end); if (ptr) { return ptr; } // Tidy up the mess at the end ptr = nocase ? dvermPreconditionNocase(chars1, chars2, buf_end - VERM_BOUNDARY) : dvermPrecondition(chars1, chars2, buf_end - VERM_BOUNDARY); if (ptr) { return ptr; } /* check for partial match at end */ u8 mask = nocase ? CASE_CLEAR : 0xff; if ((buf_end[-1] & mask) == (u8)c1) { DEBUG_PRINTF("partial!!!\n"); return buf_end - 1; } return buf_end; } static really_inline const u8 *vermicelliDoubleMaskedExec(char c1, char c2, char m1, char m2, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("double verm scan (\\x%02hhx&\\x%02hhx)(\\x%02hhx&\\x%02hhx) " "over %zu bytes\n", c1, m1, c2, m2, (size_t)(buf_end - buf)); assert(buf < buf_end); assert((buf_end - buf) >= VERM_BOUNDARY); uintptr_t min = (uintptr_t)buf % VERM_BOUNDARY; VERM_TYPE chars1 = VERM_SET_FN(c1); VERM_TYPE chars2 = VERM_SET_FN(c2); VERM_TYPE mask1 = VERM_SET_FN(m1); VERM_TYPE mask2 = VERM_SET_FN(m2); if (min) { // Input isn't aligned, so we need to run one iteration with an // unaligned load, then skip buf forward to the next aligned address. // There's some small overlap here, but we don't mind scanning it twice // if we can do it quickly, do we? const u8 *p = dvermPreconditionMasked(chars1, chars2, mask1, mask2, buf); if (p) { return p; } buf += VERM_BOUNDARY - min; assert(buf < buf_end); } // Aligned loops from here on in const u8 *ptr = dvermSearchAlignedMasked(chars1, chars2, mask1, mask2, c1, c2, m1, m2, buf, buf_end); if (ptr) { return ptr; } // Tidy up the mess at the end ptr = dvermPreconditionMasked(chars1, chars2, mask1, mask2, buf_end - VERM_BOUNDARY); if (ptr) { return ptr; } /* check for partial match at end */ if ((buf_end[-1] & m1) == (u8)c1) { return buf_end - 1; } return buf_end; } // Reverse vermicelli scan. Provides exact semantics and returns (buf - 1) if // character not found. static really_inline const u8 *rvermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("rev verm scan %s\\x%02hhx over %zu bytes\n", nocase ? "nocase " : "", c, (size_t)(buf_end - buf)); assert(buf < buf_end); // Handle small scans. if (buf_end - buf < VERM_BOUNDARY) { for (buf_end--; buf_end >= buf; buf_end--) { char cur = (char)*buf_end; if (nocase) { cur &= CASE_CLEAR; } if (cur == c) { break; } } return buf_end; } VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ size_t min = (size_t)buf_end % VERM_BOUNDARY; if (min) { // Input isn't aligned, so we need to run one iteration with an // unaligned load, then skip buf backward to the next aligned address. // There's some small overlap here, but we don't mind scanning it twice // if we can do it quickly, do we? if (nocase) { const u8 *ptr = rvermUnalignNocase(chars, buf_end - VERM_BOUNDARY, 0); if (ptr) { return ptr; } } else { const u8 *ptr = rvermUnalign(chars, buf_end - VERM_BOUNDARY, 0); if (ptr) { return ptr; } } buf_end -= min; if (buf >= buf_end) { return buf_end; } } // Aligned loops from here on in. const u8 *ptr = nocase ? rvermSearchAlignedNocase(chars, buf, buf_end, 0) : rvermSearchAligned(chars, buf, buf_end, 0); if (ptr) { return ptr; } // Tidy up the mess at the end, return buf - 1 if not found. ptr = nocase ? rvermUnalignNocase(chars, buf, 0) : rvermUnalign(chars, buf, 0); return ptr ? ptr : buf - 1; } /* like rvermicelliExec except returns the address of the last character which * is not c */ static really_inline const u8 *rnvermicelliExec(char c, char nocase, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("rev verm scan %s\\x%02hhx over %zu bytes\n", nocase ? "nocase " : "", c, (size_t)(buf_end - buf)); assert(buf < buf_end); // Handle small scans. if (buf_end - buf < VERM_BOUNDARY) { for (buf_end--; buf_end >= buf; buf_end--) { char cur = (char)*buf_end; if (nocase) { cur &= CASE_CLEAR; } if (cur != c) { break; } } return buf_end; } VERM_TYPE chars = VERM_SET_FN(c); /* nocase already uppercase */ size_t min = (size_t)buf_end % VERM_BOUNDARY; if (min) { // Input isn't aligned, so we need to run one iteration with an // unaligned load, then skip buf backward to the next aligned address. // There's some small overlap here, but we don't mind scanning it twice // if we can do it quickly, do we? if (nocase) { const u8 *ptr = rvermUnalignNocase(chars, buf_end - VERM_BOUNDARY, 1); if (ptr) { return ptr; } } else { const u8 *ptr = rvermUnalign(chars, buf_end - VERM_BOUNDARY, 1); if (ptr) { return ptr; } } buf_end -= min; if (buf >= buf_end) { return buf_end; } } // Aligned loops from here on in. const u8 *ptr = nocase ? rvermSearchAlignedNocase(chars, buf, buf_end, 1) : rvermSearchAligned(chars, buf, buf_end, 1); if (ptr) { return ptr; } // Tidy up the mess at the end, return buf - 1 if not found. ptr = nocase ? rvermUnalignNocase(chars, buf, 1) : rvermUnalign(chars, buf, 1); return ptr ? ptr : buf - 1; } /* returns highest offset of c2 (NOTE: not c1) */ static really_inline const u8 *rvermicelliDoubleExec(char c1, char c2, char nocase, const u8 *buf, const u8 *buf_end) { DEBUG_PRINTF("rev double verm scan %s\\x%02hhx%02hhx over %zu bytes\n", nocase ? "nocase " : "", c1, c2, (size_t)(buf_end - buf)); assert(buf < buf_end); assert((buf_end - buf) >= VERM_BOUNDARY); size_t min = (size_t)buf_end % VERM_BOUNDARY; VERM_TYPE chars1 = VERM_SET_FN(c1); /* nocase already uppercase */ VERM_TYPE chars2 = VERM_SET_FN(c2); /* nocase already uppercase */ if (min) { // input not aligned, so we need to run one iteration with an unaligned // load, then skip buf forward to the next aligned address. There's // some small overlap here, but we don't mind scanning it twice if we // can do it quickly, do we? const u8 *ptr; if (nocase) { ptr = rdvermPreconditionNocase(chars1, chars2, buf_end - VERM_BOUNDARY); } else { ptr = rdvermPrecondition(chars1, chars2, buf_end - VERM_BOUNDARY); } if (ptr) { return ptr; } buf_end -= min; if (buf >= buf_end) { return buf_end; } } // Aligned loops from here on in if (nocase) { return rdvermSearchAlignedNocase(chars1, chars2, c1, c2, buf, buf_end); } else { return rdvermSearchAligned(chars1, chars2, c1, c2, buf, buf_end); } } #endif /* VERMICELLI_H */ hyperscan-4.4.1/src/nfa/mcclellan_common_impl.h0000644000175000017500000000620713055426554022333 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ enum MatchMode { CALLBACK_OUTPUT, STOP_AT_MATCH, NO_MATCHES }; static really_inline const struct mstate_aux *get_aux(const struct mcclellan *m, u32 s) { const char *nfa = (const char *)m - sizeof(struct NFA); const struct mstate_aux *aux = s + (const struct mstate_aux *)(nfa + m->aux_offset); assert(ISALIGNED(aux)); return aux; } static really_inline u32 mcclellanEnableStarts(const struct mcclellan *m, u32 s) { const struct mstate_aux *aux = get_aux(m, s); DEBUG_PRINTF("enabling starts %u->%hu\n", s, aux->top); return aux->top; } static really_inline u32 doSherman16(const char *sherman_state, u8 cprime, const u16 *succ_table, u32 as) { assert(ISALIGNED_N(sherman_state, 16)); u8 len = *(const u8 *)(sherman_state + SHERMAN_LEN_OFFSET); if (len) { m128 ss_char = load128(sherman_state); m128 cur_char = set16x8(cprime); u32 z = movemask128(eq128(ss_char, cur_char)); /* remove header cruft: type 1, len 1, daddy 2*/ z &= ~0xf; z &= (1U << (len + 4)) - 1; if (z) { u32 i = ctz32(z & ~0xf) - 4; u32 s_out = unaligned_load_u16((const u8 *)sherman_state + SHERMAN_STATES_OFFSET(len) + sizeof(u16) * i); DEBUG_PRINTF("found sherman match at %u/%u for c'=%hhu s=%u\n", i, len, cprime, s_out); return s_out; } } u32 daddy = *(const u16 *)(sherman_state + SHERMAN_DADDY_OFFSET); return succ_table[(daddy << as) + cprime]; } hyperscan-4.4.1/src/nfa/limex_accel.h0000644000175000017500000000634313055426554020256 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Limex NFA: acceleration runtime. * * For the SIMD types (128 bits and above), we pass a pointer to the * implementation NFA structure instead of three masks: otherwise we spend all * our time building stack frames. */ #ifndef LIMEX_ACCEL_H #define LIMEX_ACCEL_H #include "util/simd_utils.h" // for m128 etc union AccelAux; struct LimExNFA64; struct LimExNFA128; struct LimExNFA256; struct LimExNFA384; struct LimExNFA512; size_t doAccel32(u32 s, u32 accel, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end); #ifdef ARCH_64_BIT size_t doAccel64(u64a s, u64a accel, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end); #else size_t doAccel64(m128 s, m128 accel, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end); #endif size_t doAccel128(const m128 *s, const struct LimExNFA128 *limex, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end); size_t doAccel256(const m256 *s, const struct LimExNFA256 *limex, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end); size_t doAccel384(const m384 *s, const struct LimExNFA384 *limex, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end); size_t doAccel512(const m512 *s, const struct LimExNFA512 *limex, const u8 *accelTable, const union AccelAux *aux, const u8 *input, size_t i, size_t end); #endif hyperscan-4.4.1/src/nfa/limex_runtime_impl.h0000644000175000017500000010672713055426554021722 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ #include "util/join.h" #include /** \file * \brief Limex Execution Engine Or: * How I Learned To Stop Worrying And Love The Preprocessor * * Version 2.0: now with X-Macros, so you get line numbers in your debugger. */ #if !defined(SIZE) || !defined(STATE_T) || !defined(LOAD_FROM_ENG) # error Must define SIZE, STATE_T, LOAD_FROM_ENG in includer. #endif #define LIMEX_API_ROOT JOIN(nfaExecLimEx, SIZE) #define IMPL_NFA_T JOIN(struct LimExNFA, SIZE) #define TESTEOD_FN JOIN(moNfaTestEod, SIZE) #define INITIAL_FN JOIN(moNfaInitial, SIZE) #define TOP_FN JOIN(moNfaTop, SIZE) #define TOPN_FN JOIN(moNfaTopN, SIZE) #define REPORTCURRENT_FN JOIN(moNfaReportCurrent, SIZE) #define COMPRESS_FN JOIN(moNfaCompressState, SIZE) #define EXPAND_FN JOIN(moNfaExpandState, SIZE) #define COMPRESS_REPEATS_FN JOIN(LIMEX_API_ROOT, _Compress_Repeats) #define EXPAND_REPEATS_FN JOIN(LIMEX_API_ROOT, _Expand_Repeats) #define PROCESS_ACCEPTS_FN JOIN(moProcessAccepts, SIZE) #define PROCESS_ACCEPTS_NOSQUASH_FN JOIN(moProcessAcceptsNoSquash, SIZE) #define GET_NFA_REPEAT_INFO_FN JOIN(getNfaRepeatInfo, SIZE) #define RUN_ACCEL_FN JOIN(LIMEX_API_ROOT, _Run_Accel) #define RUN_EXCEPTIONS_FN JOIN(LIMEX_API_ROOT, _Run_Exceptions) #define REV_STREAM_FN JOIN(LIMEX_API_ROOT, _Rev_Stream) #define STREAM_FN JOIN(LIMEX_API_ROOT, _Stream) #define STREAMCB_FN JOIN(LIMEX_API_ROOT, _Stream_CB) #define STREAMFIRST_FN JOIN(LIMEX_API_ROOT, _Stream_First) #define STREAMSILENT_FN JOIN(LIMEX_API_ROOT, _Stream_Silent) #define CONTEXT_T JOIN(NFAContext, SIZE) #define EXCEPTION_T JOIN(struct NFAException, SIZE) #define AND_STATE JOIN(and_, STATE_T) #define ANDNOT_STATE JOIN(andnot_, STATE_T) #define OR_STATE JOIN(or_, STATE_T) #define LSHIFT_STATE JOIN(lshift_, STATE_T) #define TESTBIT_STATE JOIN(testbit_, STATE_T) #define CLEARBIT_STATE JOIN(clearbit_, STATE_T) #define ZERO_STATE JOIN(zero_, STATE_T) #define ISNONZERO_STATE JOIN(isNonZero_, STATE_T) #define ISZERO_STATE JOIN(isZero_, STATE_T) #define NOTEQ_STATE JOIN(noteq_, STATE_T) // Pick an appropriate diffrich function for this platform. #ifdef ARCH_64_BIT #define DIFFRICH_STATE JOIN(diffrich64_, STATE_T) #else #define DIFFRICH_STATE JOIN(diffrich_, STATE_T) #endif #define EXPIRE_ESTATE_FN JOIN(limexExpireExtendedState, SIZE) #define SQUASH_UNTUG_BR_FN JOIN(lazyTug, SIZE) // Acceleration and exception masks: we load them on the fly for really big // models. #if SIZE < 256 #define ACCEL_MASK accelMask #define ACCEL_AND_FRIENDS_MASK accel_and_friendsMask #define EXCEPTION_MASK exceptionMask #else #define ACCEL_MASK LOAD_FROM_ENG(&limex->accel) #define ACCEL_AND_FRIENDS_MASK LOAD_FROM_ENG(&limex->accel_and_friends) #define EXCEPTION_MASK LOAD_FROM_ENG(&limex->exceptionMask) #endif // Run exception processing, if necessary. Returns 0 if scanning should // continue, 1 if an accept was fired and the user instructed us to halt. static really_inline char RUN_EXCEPTIONS_FN(const IMPL_NFA_T *limex, const EXCEPTION_T *exceptions, STATE_T s, const STATE_T emask, size_t i, u64a offset, STATE_T *succ, u64a *final_loc, struct CONTEXT_T *ctx, const char flags, const char in_rev, const char first_match) { STATE_T estate = AND_STATE(s, emask); u32 diffmask = DIFFRICH_STATE(ZERO_STATE, estate); if (likely(!diffmask)) { return 0; // No exceptions to process. } if (first_match && i) { STATE_T acceptMask = LOAD_FROM_ENG(&limex->accept); STATE_T foundAccepts = AND_STATE(s, acceptMask); if (unlikely(ISNONZERO_STATE(foundAccepts))) { DEBUG_PRINTF("first match at %zu\n", i); DEBUG_PRINTF("for nfa %p\n", limex); assert(final_loc); ctx->s = s; *final_loc = i; return 1; // Halt matching. } } u64a callback_offset = i + offset; char localflags = (!i && !in_rev) ? NO_OUTPUT | FIRST_BYTE : flags; int rv = JOIN(processExceptional, SIZE)( pass_state, pass_estate, diffmask, succ, limex, exceptions, callback_offset, ctx, in_rev, localflags); if (rv == PE_RV_HALT) { return 1; // Halt matching. } return 0; } static really_inline size_t RUN_ACCEL_FN(const STATE_T s, UNUSED const STATE_T accelMask, UNUSED const IMPL_NFA_T *limex, const u8 *accelTable, const union AccelAux *accelAux, const u8 *input, size_t i, size_t length) { size_t j; #if SIZE < 128 // For small cases, we pass the state by value. j = JOIN(doAccel, SIZE)(s, accelMask, accelTable, accelAux, input, i, length); #else j = JOIN(doAccel, SIZE)(&s, limex, accelTable, accelAux, input, i, length); #endif assert(j >= i); assert(i <= length); return j; } // Shift macros for Limited NFAs. Defined in terms of uniform ops. // LimExNFAxxx ptr in 'limex' and the current state in 's' #define NFA_EXEC_LIM_SHIFT(limex_m, curr_m, shift_idx) \ LSHIFT_STATE(AND_STATE(curr_m, LOAD_FROM_ENG(&limex_m->shift[shift_idx])), \ limex_m->shiftAmount[shift_idx]) // Calculate the (limited model) successors for a number of variable shifts. // Assumes current state in 'curr_m' and places the successors in 'succ_m'. #define NFA_EXEC_GET_LIM_SUCC(limex_m, curr_m, succ_m) \ do { \ succ_m = NFA_EXEC_LIM_SHIFT(limex_m, curr_m, 0); \ switch (limex_m->shiftCount) { \ case 8: \ succ_m = OR_STATE(succ_m, NFA_EXEC_LIM_SHIFT(limex_m, curr_m, 7)); \ case 7: \ succ_m = OR_STATE(succ_m, NFA_EXEC_LIM_SHIFT(limex_m, curr_m, 6)); \ case 6: \ succ_m = OR_STATE(succ_m, NFA_EXEC_LIM_SHIFT(limex_m, curr_m, 5)); \ case 5: \ succ_m = OR_STATE(succ_m, NFA_EXEC_LIM_SHIFT(limex_m, curr_m, 4)); \ case 4: \ succ_m = OR_STATE(succ_m, NFA_EXEC_LIM_SHIFT(limex_m, curr_m, 3)); \ case 3: \ succ_m = OR_STATE(succ_m, NFA_EXEC_LIM_SHIFT(limex_m, curr_m, 2)); \ case 2: \ succ_m = OR_STATE(succ_m, NFA_EXEC_LIM_SHIFT(limex_m, curr_m, 1)); \ case 1: \ case 0: \ ; \ } \ } while (0) static really_inline char STREAM_FN(const IMPL_NFA_T *limex, const u8 *input, size_t length, struct CONTEXT_T *ctx, u64a offset, const char flags, u64a *final_loc, const char first_match) { const ENG_STATE_T *reach = get_reach_table(limex); #if SIZE < 256 const STATE_T accelMask = LOAD_FROM_ENG(&limex->accel); const STATE_T accel_and_friendsMask = LOAD_FROM_ENG(&limex->accel_and_friends); const STATE_T exceptionMask = LOAD_FROM_ENG(&limex->exceptionMask); #endif const u8 *accelTable = (const u8 *)((const char *)limex + limex->accelTableOffset); const union AccelAux *accelAux = (const union AccelAux *)((const char *)limex + limex->accelAuxOffset); const EXCEPTION_T *exceptions = getExceptionTable(EXCEPTION_T, limex); STATE_T s = ctx->s; /* assert(ISALIGNED_16(exceptions)); */ /* assert(ISALIGNED_16(reach)); */ size_t i = 0; size_t min_accel_offset = 0; if (!limex->accelCount || length < ACCEL_MIN_LEN) { min_accel_offset = length; goto without_accel; } else { goto with_accel; } without_accel: for (; i != min_accel_offset; i++) { DUMP_INPUT(i); if (ISZERO_STATE(s)) { DEBUG_PRINTF("no states are switched on, early exit\n"); ctx->s = s; return MO_CONTINUE_MATCHING; } u8 c = input[i]; STATE_T succ; NFA_EXEC_GET_LIM_SUCC(limex, s, succ); if (RUN_EXCEPTIONS_FN(limex, exceptions, s, EXCEPTION_MASK, i, offset, &succ, final_loc, ctx, flags, 0, first_match)) { return MO_HALT_MATCHING; } s = AND_STATE(succ, LOAD_FROM_ENG(&reach[limex->reachMap[c]])); } with_accel: for (; i != length; i++) { DUMP_INPUT(i); if (i + 16 <= length && ISZERO_STATE(ANDNOT_STATE(ACCEL_AND_FRIENDS_MASK, s))) { DEBUG_PRINTF("current states are all accelerable\n"); assert(i + 16 <= length); size_t post_idx = RUN_ACCEL_FN(s, ACCEL_MASK, limex, accelTable, accelAux, input, i, length); if (post_idx != i) { /* squashing any friends as they may no longer be valid; * offset back off should ensure they weren't doing anything * important */ s = AND_STATE(ACCEL_MASK, s); } if (i && post_idx < min_accel_offset + BAD_ACCEL_DIST) { min_accel_offset = post_idx + BIG_ACCEL_PENALTY; } else { min_accel_offset = post_idx + SMALL_ACCEL_PENALTY; } if (min_accel_offset >= length - ACCEL_MIN_LEN) { min_accel_offset = length; } DEBUG_PRINTF("advanced %zd, next accel chance in %zd/%zd\n", post_idx - i, min_accel_offset - post_idx, length - post_idx); i = post_idx; if (i == length) { break; /* all chars eaten, break out of loop */ } goto without_accel; } u8 c = input[i]; STATE_T succ; NFA_EXEC_GET_LIM_SUCC(limex, s, succ); if (RUN_EXCEPTIONS_FN(limex, exceptions, s, EXCEPTION_MASK, i, offset, &succ, final_loc, ctx, flags, 0, first_match)) { return MO_HALT_MATCHING; } s = AND_STATE(succ, LOAD_FROM_ENG(&reach[limex->reachMap[c]])); } ctx->s = s; if ((first_match || (flags & CALLBACK_OUTPUT)) && limex->acceptCount) { STATE_T acceptMask = LOAD_FROM_ENG(&limex->accept); const struct NFAAccept *acceptTable = getAcceptTable(limex); STATE_T foundAccepts = AND_STATE(s, acceptMask); if (unlikely(ISNONZERO_STATE(foundAccepts))) { if (first_match) { ctx->s = s; assert(final_loc); *final_loc = length; return MO_HALT_MATCHING; } else if (PROCESS_ACCEPTS_FN(limex, &ctx->s, &acceptMask, acceptTable, offset + length, ctx->callback, ctx->context)) { return MO_HALT_MATCHING; } } } if (first_match) { assert(final_loc); *final_loc = length; } return MO_CONTINUE_MATCHING; } static never_inline char REV_STREAM_FN(const IMPL_NFA_T *limex, const u8 *input, size_t length, struct CONTEXT_T *ctx, u64a offset) { const ENG_STATE_T *reach = get_reach_table(limex); #if SIZE < 256 const STATE_T exceptionMask = LOAD_FROM_ENG(&limex->exceptionMask); #endif const EXCEPTION_T *exceptions = getExceptionTable(EXCEPTION_T, limex); STATE_T s = ctx->s; /* assert(ISALIGNED_16(exceptions)); */ /* assert(ISALIGNED_16(reach)); */ const char flags = CALLBACK_OUTPUT; u64a *final_loc = NULL; for (size_t i = length; i != 0; i--) { DUMP_INPUT(i-1); if (ISZERO_STATE(s)) { DEBUG_PRINTF("no states are switched on, early exit\n"); ctx->s = s; return MO_CONTINUE_MATCHING; } u8 c = input[i-1]; STATE_T succ; NFA_EXEC_GET_LIM_SUCC(limex, s, succ); if (RUN_EXCEPTIONS_FN(limex, exceptions, s, EXCEPTION_MASK, i, offset, &succ, final_loc, ctx, flags, 1, 0)) { return MO_HALT_MATCHING; } s = AND_STATE(succ, LOAD_FROM_ENG(&reach[limex->reachMap[c]])); } ctx->s = s; STATE_T acceptMask = LOAD_FROM_ENG(&limex->accept); const struct NFAAccept *acceptTable = getAcceptTable(limex); const u32 acceptCount = limex->acceptCount; assert(flags & CALLBACK_OUTPUT); if (acceptCount) { STATE_T foundAccepts = AND_STATE(s, acceptMask); if (unlikely(ISNONZERO_STATE(foundAccepts))) { if (PROCESS_ACCEPTS_NOSQUASH_FN(limex, &ctx->s, &acceptMask, acceptTable, offset, ctx->callback, ctx->context)) { return MO_HALT_MATCHING; } } } return MO_CONTINUE_MATCHING; } static really_inline void COMPRESS_REPEATS_FN(const IMPL_NFA_T *limex, void *dest, void *src, u64a offset) { if (!limex->repeatCount) { return; } STATE_T s = *(STATE_T *)src; if (ISZERO_STATE(AND_STATE(LOAD_FROM_ENG(&limex->repeatCyclicMask), s))) { DEBUG_PRINTF("no cyclics are on\n"); return; } const union RepeatControl *ctrl = getRepeatControlBaseConst((const char *)src, sizeof(STATE_T)); char *state_base = (char *)dest + limex->stateSize; for (u32 i = 0; i < limex->repeatCount; i++) { DEBUG_PRINTF("repeat %u\n", i); const struct NFARepeatInfo *info = GET_NFA_REPEAT_INFO_FN(limex, i); const ENG_STATE_T *tug_mask = (const ENG_STATE_T *)((const char *)info + info->tugMaskOffset); /* repeat may still be inspected if its tug state is on */ if (!TESTBIT_STATE(s, info->cyclicState) && ISZERO_STATE(AND_STATE(s, LOAD_FROM_ENG(tug_mask)))) { DEBUG_PRINTF("is dead\n"); continue; } const struct RepeatInfo *repeat = getRepeatInfo(info); DEBUG_PRINTF("packing state (packedCtrlOffset=%u)\n", info->packedCtrlOffset); repeatPack(state_base + info->packedCtrlOffset, repeat, &ctrl[i], offset); } *(STATE_T *)src = s; } char JOIN(LIMEX_API_ROOT, _queueCompressState)(const struct NFA *n, const struct mq *q, s64a loc) { void *dest = q->streamState; void *src = q->state; u8 key = queue_prev_byte(q, loc); const IMPL_NFA_T *limex = getImplNfa(n); COMPRESS_REPEATS_FN(limex, dest, src, q->offset + loc); COMPRESS_FN(limex, dest, src, key); return 0; } static really_inline void EXPAND_REPEATS_FN(const IMPL_NFA_T *limex, void *dest, const void *src, u64a offset) { if (!limex->repeatCount) { return; } // Note: state has already been expanded into 'dest'. const STATE_T cyclics = AND_STATE(*(STATE_T *)dest, LOAD_FROM_ENG(&limex->repeatCyclicMask)); if (ISZERO_STATE(cyclics)) { DEBUG_PRINTF("no cyclics are on\n"); return; } union RepeatControl *ctrl = getRepeatControlBase((char *)dest, sizeof(STATE_T)); const char *state_base = (const char *)src + limex->stateSize; for (u32 i = 0; i < limex->repeatCount; i++) { DEBUG_PRINTF("repeat %u\n", i); const struct NFARepeatInfo *info = GET_NFA_REPEAT_INFO_FN(limex, i); const ENG_STATE_T *tug_mask = (const ENG_STATE_T *)((const char *)info + info->tugMaskOffset); if (!TESTBIT_STATE(cyclics, info->cyclicState) && ISZERO_STATE(AND_STATE(cyclics, LOAD_FROM_ENG(tug_mask)))) { DEBUG_PRINTF("is dead\n"); continue; } DEBUG_PRINTF("unpacking state (packedCtrlOffset=%u)\n", info->packedCtrlOffset); const struct RepeatInfo *repeat = getRepeatInfo(info); repeatUnpack(state_base + info->packedCtrlOffset, repeat, offset, &ctrl[i]); } } char JOIN(LIMEX_API_ROOT, _expandState)(const struct NFA *n, void *dest, const void *src, u64a offset, u8 key) { const IMPL_NFA_T *limex = getImplNfa(n); EXPAND_FN(limex, dest, src, key); EXPAND_REPEATS_FN(limex, dest, src, offset); return 0; } char JOIN(LIMEX_API_ROOT, _queueInitState)(const struct NFA *n, struct mq *q) { *(STATE_T *)q->state = ZERO_STATE; // Zero every bounded repeat control block in state. const IMPL_NFA_T *limex = getImplNfa(n); union RepeatControl *ctrl = getRepeatControlBase(q->state, sizeof(STATE_T)); for (u32 i = 0; i < limex->repeatCount; i++) { memset(&ctrl[i], 0, sizeof(*ctrl)); } return 0; } char JOIN(LIMEX_API_ROOT, _initCompressedState)(const struct NFA *n, u64a offset, void *state, u8 key) { const IMPL_NFA_T *limex = getImplNfa(n); STATE_T s = INITIAL_FN(limex, !!offset); if (ISZERO_STATE(s)) { DEBUG_PRINTF("state went to zero\n"); return 0; } // NFA is still active, compress its state and ship it out. COMPRESS_FN(limex, state, &s, key); // Zero every packed bounded repeat control block in stream state. char *repeat_region = (char *)state + limex->stateSize; for (u32 i = 0; i < limex->repeatCount; i++) { const struct NFARepeatInfo *info = GET_NFA_REPEAT_INFO_FN(limex, i); const struct RepeatInfo *repeat = getRepeatInfo(info); memset(repeat_region + info->packedCtrlOffset, 0, repeat->packedCtrlSize); } return 1; } // Helper for history buffer scans, which catch up the NFA state but don't emit // matches. static never_inline void STREAMSILENT_FN(const IMPL_NFA_T *limex, const u8 *input, size_t length, struct CONTEXT_T *ctx, u64a offset) { const char first_match = 0; UNUSED char rv = STREAM_FN(limex, input, length, ctx, offset, NO_OUTPUT, NULL, first_match); assert(rv != MO_HALT_MATCHING); } static never_inline char STREAMCB_FN(const IMPL_NFA_T *limex, const u8 *input, size_t length, struct CONTEXT_T *ctx, u64a offset) { const char first_match = 0; assert(ISALIGNED_CL(ctx)); return STREAM_FN(limex, input, length, ctx, offset, CALLBACK_OUTPUT, NULL, first_match); } static never_inline char STREAMFIRST_FN(const IMPL_NFA_T *limex, const u8 *input, size_t length, struct CONTEXT_T *ctx, u64a offset, u64a *final_loc) { const char first_match = 1; // Run to first match and stop, no callbacks. return STREAM_FN(limex, input, length, ctx, offset, NO_OUTPUT, final_loc, first_match); } // Common code for handling the current event on the queue. static really_inline void JOIN(LIMEX_API_ROOT, _HandleEvent)(const IMPL_NFA_T *limex, struct mq *q, struct CONTEXT_T *ctx, u64a sp) { #define DEFINE_CASE(ee) \ case ee: \ DEBUG_PRINTF(#ee "\n"); u32 e = q->items[q->cur].type; switch (e) { DEFINE_CASE(MQE_TOP) ctx->s = TOP_FN(limex, !!sp, ctx->s); break; DEFINE_CASE(MQE_START) break; DEFINE_CASE(MQE_END) break; default: assert(e >= MQE_TOP_FIRST); assert(e < MQE_INVALID); DEBUG_PRINTF("MQE_TOP + %d\n", ((int)e - MQE_TOP_FIRST)); ctx->s = TOPN_FN(limex, ctx->s, e - MQE_TOP_FIRST); } #undef DEFINE_CASE } // "Classic" queue call, used by outfixes char JOIN(LIMEX_API_ROOT, _Q)(const struct NFA *n, struct mq *q, s64a end) { const IMPL_NFA_T *limex = getImplNfa(n); if (q->report_current) { char rv = REPORTCURRENT_FN(limex, q); q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } if (q->cur == q->end) { return 1; } assert(q->cur + 1 < q->end); /* require at least two items */ struct CONTEXT_T ctx; ctx.repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T)); ctx.repeat_state = q->streamState + limex->stateSize; ctx.callback = q->cb; ctx.context = q->context; ctx.cached_estate = ZERO_STATE; ctx.cached_br = 0; assert(q->items[q->cur].location >= 0); DEBUG_PRINTF("LOAD STATE\n"); ctx.s = *(STATE_T *)q->state; assert(q->items[q->cur].type == MQE_START); u64a offset = q->offset; u64a sp = offset + q->items[q->cur].location; u64a end_abs = offset + end; q->cur++; while (q->cur < q->end && sp <= end_abs) { u64a ep = offset + q->items[q->cur].location; ep = MIN(ep, end_abs); assert(ep >= sp); assert(sp >= offset); // We no longer do history buffer scans here. if (sp >= ep) { goto scan_done; } /* do main buffer region */ DEBUG_PRINTF("MAIN BUFFER SCAN\n"); assert(ep - offset <= q->length); if (STREAMCB_FN(limex, q->buffer + sp - offset, ep - sp, &ctx, sp) == MO_HALT_MATCHING) { *(STATE_T *)q->state = ZERO_STATE; return 0; } DEBUG_PRINTF("SCAN DONE\n"); scan_done: sp = ep; if (sp != offset + q->items[q->cur].location) { assert(q->cur); DEBUG_PRINTF("bail: sp = %llu end_abs == %llu offset == %llu\n", sp, end_abs, offset); assert(sp == end_abs); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = sp - offset; DEBUG_PRINTF("bailing q->cur %u q->end %u\n", q->cur, q->end); *(STATE_T *)q->state = ctx.s; return MO_ALIVE; } JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, &ctx, sp); q->cur++; } EXPIRE_ESTATE_FN(limex, &ctx, sp); DEBUG_PRINTF("END\n"); *(STATE_T *)q->state = ctx.s; if (q->cur != q->end) { q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = sp - offset; return MO_ALIVE; } return ISNONZERO_STATE(ctx.s); } /* used by suffix execution in Rose */ char JOIN(LIMEX_API_ROOT, _Q2)(const struct NFA *n, struct mq *q, s64a end) { const IMPL_NFA_T *limex = getImplNfa(n); if (q->report_current) { char rv = REPORTCURRENT_FN(limex, q); q->report_current = 0; if (rv == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } if (q->cur == q->end) { return 1; } assert(q->cur + 1 < q->end); /* require at least two items */ struct CONTEXT_T ctx; ctx.repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T)); ctx.repeat_state = q->streamState + limex->stateSize; ctx.callback = q->cb; ctx.context = q->context; ctx.cached_estate = ZERO_STATE; ctx.cached_br = 0; DEBUG_PRINTF("LOAD STATE\n"); ctx.s = *(STATE_T *)q->state; assert(q->items[q->cur].type == MQE_START); u64a offset = q->offset; u64a sp = offset + q->items[q->cur].location; u64a end_abs = offset + end; q->cur++; while (q->cur < q->end && sp <= end_abs) { u64a ep = offset + q->items[q->cur].location; DEBUG_PRINTF("sp = %llu, ep = %llu, end_abs = %llu\n", sp, ep, end_abs); ep = MIN(ep, end_abs); assert(ep >= sp); if (sp < offset) { DEBUG_PRINTF("HISTORY BUFFER SCAN\n"); assert(offset - sp <= q->hlength); u64a local_ep = MIN(offset, ep); u64a final_look = 0; /* we are starting inside the history buffer */ if (STREAMFIRST_FN(limex, q->history + q->hlength + sp - offset, local_ep - sp, &ctx, sp, &final_look) == MO_HALT_MATCHING) { DEBUG_PRINTF("final_look:%llu sp:%llu end_abs:%llu " "offset:%llu\n", final_look, sp, end_abs, offset); assert(q->cur); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = sp + final_look - offset; *(STATE_T *)q->state = ctx.s; return MO_MATCHES_PENDING; } sp = local_ep; } if (sp >= ep) { goto scan_done; } /* do main buffer region */ u64a final_look = 0; assert(ep - offset <= q->length); if (STREAMFIRST_FN(limex, q->buffer + sp - offset, ep - sp, &ctx, sp, &final_look) == MO_HALT_MATCHING) { DEBUG_PRINTF("final_look:%llu sp:%llu end_abs:%llu offset:%llu\n", final_look, sp, end_abs, offset); assert(q->cur); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = sp + final_look - offset; *(STATE_T *)q->state = ctx.s; return MO_MATCHES_PENDING; } scan_done: sp = ep; if (sp != offset + q->items[q->cur].location) { assert(q->cur); DEBUG_PRINTF("bail: sp = %llu end_abs == %llu offset == %llu\n", sp, end_abs, offset); assert(sp == end_abs); q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = sp - offset; DEBUG_PRINTF("bailing q->cur %u q->end %u\n", q->cur, q->end); *(STATE_T *)q->state = ctx.s; return MO_ALIVE; } JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, &ctx, sp); q->cur++; } EXPIRE_ESTATE_FN(limex, &ctx, sp); DEBUG_PRINTF("END\n"); *(STATE_T *)q->state = ctx.s; if (q->cur != q->end) { q->cur--; q->items[q->cur].type = MQE_START; q->items[q->cur].location = sp - offset; return MO_ALIVE; } return ISNONZERO_STATE(ctx.s); } // Used for execution Rose prefix/infixes. char JOIN(LIMEX_API_ROOT, _QR)(const struct NFA *n, struct mq *q, ReportID report) { const IMPL_NFA_T *limex = getImplNfa(n); if (q->cur == q->end) { return 1; } assert(q->cur + 1 < q->end); /* require at least two items */ struct CONTEXT_T ctx; ctx.repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T)); ctx.repeat_state = q->streamState + limex->stateSize; ctx.callback = NULL; ctx.context = NULL; ctx.cached_estate = ZERO_STATE; ctx.cached_br = 0; DEBUG_PRINTF("LOAD STATE\n"); ctx.s = *(STATE_T *)q->state; assert(q->items[q->cur].type == MQE_START); u64a offset = q->offset; u64a sp = offset + q->items[q->cur].location; q->cur++; while (q->cur < q->end) { u64a ep = offset + q->items[q->cur].location; if (n->maxWidth) { if (ep - sp > n->maxWidth) { sp = ep - n->maxWidth; ctx.s = INITIAL_FN(limex, !!sp); } } assert(ep >= sp); if (sp < offset) { DEBUG_PRINTF("HISTORY BUFFER SCAN\n"); assert(offset - sp <= q->hlength); u64a local_ep = MIN(offset, ep); /* we are starting inside the history buffer */ STREAMSILENT_FN(limex, q->history + q->hlength + sp - offset, local_ep - sp, &ctx, sp); sp = local_ep; } if (sp >= ep) { goto scan_done; } /* do main buffer region */ DEBUG_PRINTF("MAIN BUFFER SCAN\n"); assert(ep - offset <= q->length); STREAMSILENT_FN(limex, q->buffer + sp - offset, ep - sp, &ctx, sp); DEBUG_PRINTF("SCAN DONE\n"); scan_done: sp = ep; JOIN(LIMEX_API_ROOT, _HandleEvent)(limex, q, &ctx, sp); q->cur++; } EXPIRE_ESTATE_FN(limex, &ctx, sp); DEBUG_PRINTF("END, nfa is %s\n", ISNONZERO_STATE(ctx.s) ? "still alive" : "dead"); *(STATE_T *)q->state = ctx.s; if (JOIN(limexInAccept, SIZE)(limex, ctx.s, ctx.repeat_ctrl, ctx.repeat_state, sp + 1, report)) { return MO_MATCHES_PENDING; } return ISNONZERO_STATE(ctx.s); } char JOIN(LIMEX_API_ROOT, _testEOD)(const struct NFA *n, const char *state, const char *streamState, u64a offset, NfaCallback callback, void *context) { assert(n && state); const IMPL_NFA_T *limex = getImplNfa(n); const STATE_T *sptr = (const STATE_T *)state; const union RepeatControl *repeat_ctrl = getRepeatControlBaseConst(state, sizeof(STATE_T)); const char *repeat_state = streamState + limex->stateSize; return TESTEOD_FN(limex, sptr, repeat_ctrl, repeat_state, offset, callback, context); } char JOIN(LIMEX_API_ROOT, _reportCurrent)(const struct NFA *n, struct mq *q) { const IMPL_NFA_T *limex = getImplNfa(n); REPORTCURRENT_FN(limex, q); return 1; } // Block mode reverse scan. char JOIN(LIMEX_API_ROOT, _B_Reverse)(const struct NFA *n, u64a offset, const u8 *buf, size_t buflen, const u8 *hbuf, size_t hlen, NfaCallback cb, void *context) { assert(buf || hbuf); assert(buflen || hlen); struct CONTEXT_T ctx; ctx.repeat_ctrl = NULL; ctx.repeat_state = NULL; ctx.callback = cb; ctx.context = context; ctx.cached_estate = ZERO_STATE; ctx.cached_br = 0; const IMPL_NFA_T *limex = getImplNfa(n); ctx.s = INITIAL_FN(limex, 0); // always anchored // 'buf' may be null, for example when we're scanning at EOD time. if (buflen) { assert(buf); DEBUG_PRINTF("MAIN BUFFER SCAN, %zu bytes\n", buflen); offset -= buflen; REV_STREAM_FN(limex, buf, buflen, &ctx, offset); } if (hlen) { assert(hbuf); DEBUG_PRINTF("HISTORY BUFFER SCAN, %zu bytes\n", hlen); offset -= hlen; REV_STREAM_FN(limex, hbuf, hlen, &ctx, offset); } if (offset == 0 && limex->acceptEodCount && ISNONZERO_STATE(ctx.s)) { const union RepeatControl *repeat_ctrl = NULL; const char *repeat_state = NULL; TESTEOD_FN(limex, &ctx.s, repeat_ctrl, repeat_state, offset, cb, context); } // NOTE: return value is unused. return 0; } char JOIN(LIMEX_API_ROOT, _inAccept)(const struct NFA *nfa, ReportID report, struct mq *q) { assert(nfa && q); assert(q->state && q->streamState); const IMPL_NFA_T *limex = getImplNfa(nfa); union RepeatControl *repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T)); char *repeat_state = q->streamState + limex->stateSize; STATE_T state = *(STATE_T *)q->state; u64a offset = q->offset + q_last_loc(q) + 1; return JOIN(limexInAccept, SIZE)(limex, state, repeat_ctrl, repeat_state, offset, report); } char JOIN(LIMEX_API_ROOT, _inAnyAccept)(const struct NFA *nfa, struct mq *q) { assert(nfa && q); assert(q->state && q->streamState); const IMPL_NFA_T *limex = getImplNfa(nfa); union RepeatControl *repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T)); char *repeat_state = q->streamState + limex->stateSize; STATE_T state = *(STATE_T *)q->state; u64a offset = q->offset + q_last_loc(q) + 1; return JOIN(limexInAnyAccept, SIZE)(limex, state, repeat_ctrl, repeat_state, offset); } enum nfa_zombie_status JOIN(LIMEX_API_ROOT, _zombie_status)( const struct NFA *nfa, struct mq *q, s64a loc) { assert(nfa->flags & NFA_ZOMBIE); const IMPL_NFA_T *limex = getImplNfa(nfa); STATE_T state = *(STATE_T *)q->state; STATE_T zmask = LOAD_FROM_ENG(&limex->zombieMask); if (limex->repeatCount) { u64a offset = q->offset + loc + 1; union RepeatControl *repeat_ctrl = getRepeatControlBase(q->state, sizeof(STATE_T)); char *repeat_state = q->streamState + limex->stateSize; SQUASH_UNTUG_BR_FN(limex, repeat_ctrl, repeat_state, offset, &state); } if (ISNONZERO_STATE(AND_STATE(state, zmask))) { return NFA_ZOMBIE_ALWAYS_YES; } return NFA_ZOMBIE_NO; } #undef TESTEOD_FN #undef INITIAL_FN #undef TOP_FN #undef TOPN_FN #undef REPORTCURRENT_FN #undef COMPRESS_FN #undef EXPAND_FN #undef COMPRESS_REPEATS_FN #undef EXPAND_REPEATS_FN #undef PROCESS_ACCEPTS_FN #undef PROCESS_ACCEPTS_NOSQUASH_FN #undef GET_NFA_REPEAT_INFO_FN #undef RUN_ACCEL_FN #undef RUN_EXCEPTIONS_FN #undef REV_STREAM_FN #undef STREAM_FN #undef STREAMCB_FN #undef STREAMFIRST_FN #undef STREAMSILENT_FN #undef CONTEXT_T #undef EXCEPTION_T #undef AND_STATE #undef ANDNOT_STATE #undef OR_STATE #undef LSHIFT_STATE #undef TESTBIT_STATE #undef CLEARBIT_STATE #undef ZERO_STATE #undef ISNONZERO_STATE #undef ISZERO_STATE #undef NOTEQ_STATE #undef DIFFRICH_STATE #undef INLINE_ATTR_INT #undef IMPL_NFA_T #undef SQUASH_UNTUG_BR_FN #undef ACCEL_MASK #undef ACCEL_AND_FRIENDS_MASK #undef EXCEPTION_MASK #undef LIMEX_API_ROOT hyperscan-4.4.1/src/nfa/multishufti.h0000644000175000017500000000540513055426554020364 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Multishufti: multibyte version of Shufti * * Utilises the SSSE3 pshufb shuffle instruction */ #ifndef MULTISHUFTI_H #define MULTISHUFTI_H #include "ue2common.h" #include "util/simd_types.h" #ifdef __cplusplus extern "C" { #endif const u8 *long_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *longgrab_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *shift_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *shiftgrab_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const u8 run_len); const u8 *doubleshift_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const u8 run_len, const u8 run2_len); const u8 *doubleshiftgrab_shuftiExec(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, const u8 run_len, const u8 run2_len); #ifdef __cplusplus } #endif #endif hyperscan-4.4.1/src/nfa/sheng_impl4.h0000644000175000017500000003111413055426554020214 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /* * In order to use this macro, the following things need to be defined: * * - SHENG_IMPL (name of the Sheng implementation function) * - INTERESTING_FUNC (name of the function checking for accept, accel or dead * states) * - INNER_DEAD_FUNC (name of the inner function checking for dead states) * - OUTER_DEAD_FUNC (name of the outer function checking for dead states) * - INNER_ACCEL_FUNC (name of the inner function checking for accel states) * - OUTER_ACCEL_FUNC (name of the outer function checking for accel states) * - ACCEPT_FUNC (name of the function checking for accept state) * - STOP_AT_MATCH (can be 1 or 0, enable or disable stop at match) */ /* unrolled 4-byte-at-a-time version. * * we put innerDeadFunc inside interestingFunc() block so that we don't pay for * dead states checking. however, if interestingFunc is dummy, innerDeadFunc * gets lost with it, so we need an additional check outside the * interestingFunc() branch - it's normally dummy so we don't pay for it, but * when interestingFunc is dummy, outerDeadFunc should be set if we want to * check for dead states. * * also, deadFunc only checks the last known state, but since we can't ever get * out of the dead state and we don't really care where we died, it's not a * problem. */ static really_inline char SHENG_IMPL(u8 *state, NfaCallback cb, void *ctxt, const struct sheng *s, u8 *const cached_accept_state, ReportID *const cached_accept_id, u8 single, u64a base_offset, const u8 *buf, const u8 *start, const u8 *end, const u8 **scan_end) { DEBUG_PRINTF("Starting DFAx4 execution in state %u\n", *state & SHENG_STATE_MASK); const u8 *cur_buf = start; const u8 *min_accel_dist = start; base_offset++; DEBUG_PRINTF("Scanning %llu bytes\n", (u64a)(end - start)); if (INNER_ACCEL_FUNC(*state) || OUTER_ACCEL_FUNC(*state)) { DEBUG_PRINTF("Accel state reached @ 0\n"); const union AccelAux *aaux = get_accel(s, *state & SHENG_STATE_MASK); const u8 *new_offset = run_accel(aaux, cur_buf, end); if (new_offset < cur_buf + BAD_ACCEL_DIST) { min_accel_dist = new_offset + BIG_ACCEL_PENALTY; } else { min_accel_dist = new_offset + SMALL_ACCEL_PENALTY; } DEBUG_PRINTF("Next accel chance: %llu\n", (u64a)(min_accel_dist - start)); DEBUG_PRINTF("Accel scanned %zu bytes\n", new_offset - cur_buf); cur_buf = new_offset; DEBUG_PRINTF("New offset: %lli\n", (s64a)(cur_buf - start)); } if (INNER_DEAD_FUNC(*state) || OUTER_DEAD_FUNC(*state)) { DEBUG_PRINTF("Dead on arrival\n"); *scan_end = end; return MO_CONTINUE_MATCHING; } m128 cur_state = set16x8(*state); const m128 *masks = s->shuffle_masks; while (likely(end - cur_buf >= 4)) { const u8 *b1 = cur_buf; const u8 *b2 = cur_buf + 1; const u8 *b3 = cur_buf + 2; const u8 *b4 = cur_buf + 3; const u8 c1 = *b1; const u8 c2 = *b2; const u8 c3 = *b3; const u8 c4 = *b4; const m128 shuffle_mask1 = masks[c1]; cur_state = pshufb(shuffle_mask1, cur_state); const u8 a1 = movd(cur_state); const m128 shuffle_mask2 = masks[c2]; cur_state = pshufb(shuffle_mask2, cur_state); const u8 a2 = movd(cur_state); const m128 shuffle_mask3 = masks[c3]; cur_state = pshufb(shuffle_mask3, cur_state); const u8 a3 = movd(cur_state); const m128 shuffle_mask4 = masks[c4]; cur_state = pshufb(shuffle_mask4, cur_state); const u8 a4 = movd(cur_state); DEBUG_PRINTF("c: %02hhx '%c'\n", c1, ourisprint(c1) ? c1 : '?'); DEBUG_PRINTF("s: %u (hi: %u lo: %u)\n", a1, (a1 & 0xF0) >> 4, a1 & 0xF); DEBUG_PRINTF("c: %02hhx '%c'\n", c2, ourisprint(c2) ? c2 : '?'); DEBUG_PRINTF("s: %u (hi: %u lo: %u)\n", a2, (a2 & 0xF0) >> 4, a2 & 0xF); DEBUG_PRINTF("c: %02hhx '%c'\n", c3, ourisprint(c3) ? c3 : '?'); DEBUG_PRINTF("s: %u (hi: %u lo: %u)\n", a3, (a3 & 0xF0) >> 4, a3 & 0xF); DEBUG_PRINTF("c: %02hhx '%c'\n", c4, ourisprint(c4) ? c4 : '?'); DEBUG_PRINTF("s: %u (hi: %u lo: %u)\n", a4, (a4 & 0xF0) >> 4, a4 & 0xF); if (unlikely(INTERESTING_FUNC(a1, a2, a3, a4))) { if (ACCEPT_FUNC(a1)) { u64a match_offset = base_offset + b1 - buf; DEBUG_PRINTF("Accept state %u reached\n", a1 & SHENG_STATE_MASK); DEBUG_PRINTF("Match @ %llu\n", match_offset); if (STOP_AT_MATCH) { DEBUG_PRINTF("Stopping at match @ %lli\n", (s64a)(b1 - start)); *scan_end = b1; *state = a1; return MO_MATCHES_PENDING; } if (single) { if (fireSingleReport(cb, ctxt, s->report, match_offset) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } else { if (fireReports(s, cb, ctxt, a1, match_offset, cached_accept_state, cached_accept_id, 0) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } } if (ACCEPT_FUNC(a2)) { u64a match_offset = base_offset + b2 - buf; DEBUG_PRINTF("Accept state %u reached\n", a2 & SHENG_STATE_MASK); DEBUG_PRINTF("Match @ %llu\n", match_offset); if (STOP_AT_MATCH) { DEBUG_PRINTF("Stopping at match @ %lli\n", (s64a)(b2 - start)); *scan_end = b2; *state = a2; return MO_MATCHES_PENDING; } if (single) { if (fireSingleReport(cb, ctxt, s->report, match_offset) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } else { if (fireReports(s, cb, ctxt, a2, match_offset, cached_accept_state, cached_accept_id, 0) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } } if (ACCEPT_FUNC(a3)) { u64a match_offset = base_offset + b3 - buf; DEBUG_PRINTF("Accept state %u reached\n", a3 & SHENG_STATE_MASK); DEBUG_PRINTF("Match @ %llu\n", match_offset); if (STOP_AT_MATCH) { DEBUG_PRINTF("Stopping at match @ %lli\n", (s64a)(b3 - start)); *scan_end = b3; *state = a3; return MO_MATCHES_PENDING; } if (single) { if (fireSingleReport(cb, ctxt, s->report, match_offset) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } else { if (fireReports(s, cb, ctxt, a3, match_offset, cached_accept_state, cached_accept_id, 0) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } } if (ACCEPT_FUNC(a4)) { u64a match_offset = base_offset + b4 - buf; DEBUG_PRINTF("Accept state %u reached\n", a4 & SHENG_STATE_MASK); DEBUG_PRINTF("Match @ %llu\n", match_offset); if (STOP_AT_MATCH) { DEBUG_PRINTF("Stopping at match @ %lli\n", (s64a)(b4 - start)); *scan_end = b4; *state = a4; return MO_MATCHES_PENDING; } if (single) { if (fireSingleReport(cb, ctxt, s->report, match_offset) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } else { if (fireReports(s, cb, ctxt, a4, match_offset, cached_accept_state, cached_accept_id, 0) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } } if (INNER_DEAD_FUNC(a4)) { DEBUG_PRINTF("Dead state reached @ %lli\n", (s64a)(b4 - buf)); *scan_end = end; *state = a4; return MO_CONTINUE_MATCHING; } if (cur_buf > min_accel_dist && INNER_ACCEL_FUNC(a4)) { DEBUG_PRINTF("Accel state reached @ %lli\n", (s64a)(b4 - buf)); const union AccelAux *aaux = get_accel(s, a4 & SHENG_STATE_MASK); const u8 *new_offset = run_accel(aaux, cur_buf + 4, end); if (new_offset < cur_buf + 4 + BAD_ACCEL_DIST) { min_accel_dist = new_offset + BIG_ACCEL_PENALTY; } else { min_accel_dist = new_offset + SMALL_ACCEL_PENALTY; } DEBUG_PRINTF("Next accel chance: %llu\n", (u64a)(min_accel_dist - start)); DEBUG_PRINTF("Accel scanned %llu bytes\n", (u64a)(new_offset - cur_buf - 4)); cur_buf = new_offset; DEBUG_PRINTF("New offset: %llu\n", (u64a)(cur_buf - buf)); continue; } } if (OUTER_DEAD_FUNC(a4)) { DEBUG_PRINTF("Dead state reached @ %lli\n", (s64a)(cur_buf - buf)); *scan_end = end; *state = a4; return MO_CONTINUE_MATCHING; }; if (cur_buf > min_accel_dist && OUTER_ACCEL_FUNC(a4)) { DEBUG_PRINTF("Accel state reached @ %lli\n", (s64a)(b4 - buf)); const union AccelAux *aaux = get_accel(s, a4 & SHENG_STATE_MASK); const u8 *new_offset = run_accel(aaux, cur_buf + 4, end); if (new_offset < cur_buf + 4 + BAD_ACCEL_DIST) { min_accel_dist = new_offset + BIG_ACCEL_PENALTY; } else { min_accel_dist = new_offset + SMALL_ACCEL_PENALTY; } DEBUG_PRINTF("Next accel chance: %llu\n", (u64a)(min_accel_dist - start)); DEBUG_PRINTF("Accel scanned %llu bytes\n", (u64a)(new_offset - cur_buf - 4)); cur_buf = new_offset; DEBUG_PRINTF("New offset: %llu\n", (u64a)(cur_buf - buf)); continue; }; cur_buf += 4; } *state = movd(cur_state); *scan_end = cur_buf; return MO_CONTINUE_MATCHING; } hyperscan-4.4.1/src/nfa/mcclellandump.h0000644000175000017500000000450413055426554020626 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MCCLELLAN_DUMP_H #define MCCLELLAN_DUMP_H #ifdef DUMP_SUPPORT #include "rdfa.h" #include #include struct mcclellan; struct mstate_aux; struct NFA; union AccelAux; namespace ue2 { void nfaExecMcClellan8_dump(const struct NFA *nfa, const std::string &base); void nfaExecMcClellan16_dump(const struct NFA *nfa, const std::string &base); /* These functions are shared with the Gough dump code. */ const mstate_aux *getAux(const NFA *n, dstate_id_t i); void describeEdge(FILE *f, const u16 *t, u16 i); void dumpAccelText(FILE *f, const union AccelAux *accel); void dumpAccelDot(FILE *f, u16 i, const union AccelAux *accel); void describeAlphabet(FILE *f, const mcclellan *m); void dumpDotPreambleDfa(FILE *f); } // namespace ue2 #endif // DUMP_SUPPORT #endif // MCCLELLAN_DUMP_H hyperscan-4.4.1/src/nfa/mcclellancompile.h0000644000175000017500000000663513055426554021320 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MCCLELLANCOMPILE_H #define MCCLELLANCOMPILE_H #include "accel_dfa_build_strat.h" #include "rdfa.h" #include "ue2common.h" #include "util/alloc.h" #include "util/ue2_containers.h" #include #include #include struct NFA; namespace ue2 { class ReportManager; struct CompileContext; class mcclellan_build_strat : public accel_dfa_build_strat { public: mcclellan_build_strat(raw_dfa &rdfa_in, const ReportManager &rm_in) : accel_dfa_build_strat(rm_in), rdfa(rdfa_in) {} raw_dfa &get_raw() const override { return rdfa; } std::unique_ptr gatherReports( std::vector &reports /* out */, std::vector &reports_eod /* out */, u8 *isSingleReport /* out */, ReportID *arbReport /* out */) const override; size_t accelSize(void) const override; u32 max_allowed_offset_accel() const override; u32 max_stop_char() const override; u32 max_floating_stop_char() const override; private: raw_dfa &rdfa; }; /* accel_states: (optional) on success, is filled with the set of accelerable * states */ ue2::aligned_unique_ptr mcclellanCompile(raw_dfa &raw, const CompileContext &cc, const ReportManager &rm, std::set *accel_states = nullptr); /* used internally by mcclellan/haig/gough compile process */ ue2::aligned_unique_ptr mcclellanCompile_i(raw_dfa &raw, accel_dfa_build_strat &strat, const CompileContext &cc, std::set *accel_states = nullptr); /** * \brief Returns the width of the character reach at start. */ u32 mcclellanStartReachSize(const raw_dfa *raw); std::set all_reports(const raw_dfa &rdfa); bool has_accel_mcclellan(const NFA *nfa); } // namespace ue2 #endif hyperscan-4.4.1/src/nfa/mpv.h0000644000175000017500000000533413055426554016612 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 MPV_H #define MPV_H #include "ue2common.h" struct mq; struct NFA; char nfaExecMpv_Q(const struct NFA *n, struct mq *q, s64a end); char nfaExecMpv_reportCurrent(const struct NFA *n, struct mq *q); char nfaExecMpv_queueInitState(const struct NFA *n, struct mq *q); char nfaExecMpv_initCompressedState(const struct NFA *n, u64a offset, void *state, u8 key); char nfaExecMpv_queueCompressState(const struct NFA *nfa, const struct mq *q, s64a loc); char nfaExecMpv_expandState(const struct NFA *nfa, void *dest, const void *src, u64a offset, u8 key); #define nfaExecMpv_testEOD NFA_API_NO_IMPL #define nfaExecMpv_inAccept NFA_API_NO_IMPL #define nfaExecMpv_inAnyAccept NFA_API_NO_IMPL #define nfaExecMpv_QR NFA_API_NO_IMPL #define nfaExecMpv_Q2 NFA_API_NO_IMPL /* for non-chained suffixes. */ #define nfaExecMpv_B_Reverse NFA_API_NO_IMPL #define nfaExecMpv_zombie_status NFA_API_ZOMBIE_NO_IMPL /** * return 0 if the mpv dies, otherwise returns the location of the next possible * match (given the currently known events). */ s64a nfaExecMpv_QueueExecRaw(const struct NFA *nfa, struct mq *q, s64a end); #endif hyperscan-4.4.1/src/nfa/accel_dfa_build_strat.cpp0000644000175000017500000004362213055426554022622 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "accel_dfa_build_strat.h" #include "accel.h" #include "grey.h" #include "nfagraph/ng_limex_accel.h" #include "shufticompile.h" #include "trufflecompile.h" #include "util/charreach.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/verify_types.h" #include #include #define PATHS_LIMIT 500 using namespace std; namespace ue2 { namespace { struct path { vector reach; dstate_id_t dest = DEAD_STATE; explicit path(dstate_id_t base) : dest(base) { } }; }; static void dump_paths(const vector &paths) { for (UNUSED const auto &p : paths) { DEBUG_PRINTF("[%s] -> %u\n", describeClasses(p.reach).c_str(), p.dest); } DEBUG_PRINTF("%zu paths\n", paths.size()); } static bool is_useful_path(const vector &good, const path &p) { for (const auto &g : good) { assert(g.dest == p.dest); assert(g.reach.size() <= p.reach.size()); auto git = g.reach.rbegin(); auto pit = p.reach.rbegin(); for (; git != g.reach.rend(); ++git, ++pit) { if (!pit->isSubsetOf(*git)) { goto next; } } DEBUG_PRINTF("better: [%s] -> %u\n", describeClasses(g.reach).c_str(), g.dest); return false; next:; } return true; } static path append(const path &orig, const CharReach &cr, u32 new_dest) { path p(new_dest); p.reach = orig.reach; p.reach.push_back(cr); return p; } static void extend(const raw_dfa &rdfa, const path &p, map> &all, vector &out) { dstate s = rdfa.states[p.dest]; if (!p.reach.empty() && p.reach.back().none()) { out.push_back(p); return; } if (!s.reports.empty()) { if (generates_callbacks(rdfa.kind)) { out.push_back(p); return; } else { path pp = append(p, CharReach(), p.dest); all[p.dest].push_back(pp); out.push_back(pp); } } if (!s.reports_eod.empty()) { path pp = append(p, CharReach(), p.dest); all[p.dest].push_back(pp); out.push_back(pp); } map dest; for (unsigned i = 0; i < N_CHARS; i++) { u32 succ = s.next[rdfa.alpha_remap[i]]; dest[succ].set(i); } for (const auto &e : dest) { path pp = append(p, e.second, e.first); if (!is_useful_path(all[e.first], pp)) { DEBUG_PRINTF("not useful: [%s] -> %u\n", describeClasses(pp.reach).c_str(), pp.dest); continue; } DEBUG_PRINTF("----good: [%s] -> %u\n", describeClasses(pp.reach).c_str(), pp.dest); all[e.first].push_back(pp); out.push_back(pp); } } static vector> generate_paths(const raw_dfa &rdfa, dstate_id_t base, u32 len) { vector paths{path(base)}; map> all; all[base].push_back(path(base)); for (u32 i = 0; i < len && paths.size() < PATHS_LIMIT; i++) { vector next_gen; for (const auto &p : paths) { extend(rdfa, p, all, next_gen); } paths = move(next_gen); } dump_paths(paths); vector> rv; for (auto &p : paths) { rv.push_back(move(p.reach)); } return rv; } static AccelScheme look_for_offset_accel(const raw_dfa &rdfa, dstate_id_t base, u32 max_allowed_accel_offset) { DEBUG_PRINTF("looking for accel for %hu\n", base); vector> paths = generate_paths(rdfa, base, max_allowed_accel_offset + 1); AccelScheme as = findBestAccelScheme(paths, CharReach(), true); DEBUG_PRINTF("found %s + %u\n", describeClass(as.cr).c_str(), as.offset); return as; } static UNUSED bool better(const AccelScheme &a, const AccelScheme &b) { if (!a.double_byte.empty() && b.double_byte.empty()) { return true; } if (!b.double_byte.empty()) { return false; } return a.cr.count() < b.cr.count(); } static vector reverse_alpha_remapping(const raw_dfa &rdfa) { vector rv(rdfa.alpha_size - 1); /* TOP not required */ for (u32 i = 0; i < N_CHARS; i++) { rv.at(rdfa.alpha_remap[i]).set(i); } return rv; } static bool double_byte_ok(const AccelScheme &info) { return !info.double_byte.empty() && info.double_cr.count() < info.double_byte.size() && info.double_cr.count() <= 2 && !info.double_byte.empty(); } static bool has_self_loop(dstate_id_t s, const raw_dfa &raw) { u16 top_remap = raw.alpha_remap[TOP]; for (u32 i = 0; i < raw.states[s].next.size(); i++) { if (i != top_remap && raw.states[s].next[i] == s) { return true; } } return false; } static vector find_nonexit_symbols(const raw_dfa &rdfa, const CharReach &escape) { set rv; CharReach nonexit = ~escape; for (auto i = nonexit.find_first(); i != CharReach::npos; i = nonexit.find_next(i)) { rv.insert(rdfa.alpha_remap[i]); } return vector(rv.begin(), rv.end()); } static dstate_id_t get_sds_or_proxy(const raw_dfa &raw) { if (raw.start_floating != DEAD_STATE) { DEBUG_PRINTF("has floating start\n"); return raw.start_floating; } DEBUG_PRINTF("looking for SDS proxy\n"); dstate_id_t s = raw.start_anchored; if (has_self_loop(s, raw)) { return s; } u16 top_remap = raw.alpha_remap[TOP]; ue2::unordered_set seen; while (true) { seen.insert(s); DEBUG_PRINTF("basis %hu\n", s); /* check if we are connected to a state with a self loop */ for (u32 i = 0; i < raw.states[s].next.size(); i++) { dstate_id_t t = raw.states[s].next[i]; if (i != top_remap && t != DEAD_STATE && has_self_loop(t, raw)) { return t; } } /* find a neighbour to use as a basis for looking for the sds proxy */ dstate_id_t t = DEAD_STATE; for (u32 i = 0; i < raw.states[s].next.size(); i++) { dstate_id_t tt = raw.states[s].next[i]; if (i != top_remap && tt != DEAD_STATE && !contains(seen, tt)) { t = tt; break; } } if (t == DEAD_STATE) { /* we were unable to find a state to use as a SDS proxy */ return DEAD_STATE; } s = t; } } static set find_region(const raw_dfa &rdfa, dstate_id_t base, const AccelScheme &ei) { DEBUG_PRINTF("looking for region around %hu\n", base); set region = {base}; if (!ei.double_byte.empty()) { return region; } DEBUG_PRINTF("accel %s+%u\n", describeClass(ei.cr).c_str(), ei.offset); const CharReach &escape = ei.cr; auto nonexit_symbols = find_nonexit_symbols(rdfa, escape); vector pending = {base}; while (!pending.empty()) { dstate_id_t curr = pending.back(); pending.pop_back(); for (auto s : nonexit_symbols) { dstate_id_t t = rdfa.states[curr].next[s]; if (contains(region, t)) { continue; } DEBUG_PRINTF(" %hu is in region\n", t); region.insert(t); pending.push_back(t); } } return region; } AccelScheme accel_dfa_build_strat::find_escape_strings(dstate_id_t this_idx) const { AccelScheme rv; const raw_dfa &rdfa = get_raw(); rv.cr.clear(); rv.offset = 0; const dstate &raw = rdfa.states[this_idx]; const vector rev_map = reverse_alpha_remapping(rdfa); bool outs2_broken = false; map succs; for (u32 i = 0; i < rev_map.size(); i++) { if (raw.next[i] == this_idx) { continue; } const CharReach &cr_i = rev_map.at(i); rv.cr |= cr_i; dstate_id_t next_id = raw.next[i]; DEBUG_PRINTF("next is %hu\n", next_id); const dstate &raw_next = rdfa.states[next_id]; if (outs2_broken) { continue; } if (!raw_next.reports.empty() && generates_callbacks(rdfa.kind)) { DEBUG_PRINTF("leads to report\n"); outs2_broken = true; /* cannot accelerate over reports */ continue; } succs[next_id] |= cr_i; } if (!outs2_broken) { for (const auto &e : succs) { const CharReach &cr_i = e.second; const dstate &raw_next = rdfa.states[e.first]; CharReach cr_all_j; for (u32 j = 0; j < rev_map.size(); j++) { if (raw_next.next[j] == raw.next[j]) { continue; } DEBUG_PRINTF("state %hu: adding sym %u -> %hu to 2 \n", e.first, j, raw_next.next[j]); cr_all_j |= rev_map.at(j); } if (cr_i.count() * cr_all_j.count() > 8) { DEBUG_PRINTF("adding %zu to double_cr\n", cr_i.count()); rv.double_cr |= cr_i; } else { for (auto ii = cr_i.find_first(); ii != CharReach::npos; ii = cr_i.find_next(ii)) { for (auto jj = cr_all_j.find_first(); jj != CharReach::npos; jj = cr_all_j.find_next(jj)) { rv.double_byte.emplace((u8)ii, (u8)jj); } } } } if (rv.double_byte.size() > 8) { DEBUG_PRINTF("outs2 too big\n"); outs2_broken = true; } if (outs2_broken) { rv.double_byte.clear(); } } DEBUG_PRINTF("this %u, sds proxy %hu\n", this_idx, get_sds_or_proxy(rdfa)); DEBUG_PRINTF("broken %d\n", outs2_broken); if (!double_byte_ok(rv) && !is_triggered(rdfa.kind) && this_idx == rdfa.start_floating && this_idx != DEAD_STATE) { DEBUG_PRINTF("looking for offset accel at %u\n", this_idx); auto offset = look_for_offset_accel(rdfa, this_idx, max_allowed_offset_accel()); DEBUG_PRINTF("width %zu vs %zu\n", offset.cr.count(), rv.cr.count()); if (double_byte_ok(offset) || offset.cr.count() < rv.cr.count()) { DEBUG_PRINTF("using offset accel\n"); rv = offset; } } return rv; } void accel_dfa_build_strat::buildAccel(UNUSED dstate_id_t this_idx, const AccelScheme &info, void *accel_out) { AccelAux *accel = (AccelAux *)accel_out; DEBUG_PRINTF("accelerations scheme has offset s%u/d%u\n", info.offset, info.double_offset); accel->generic.offset = verify_u8(info.offset); if (double_byte_ok(info) && info.double_cr.none() && info.double_byte.size() == 1) { accel->accel_type = ACCEL_DVERM; accel->dverm.c1 = info.double_byte.begin()->first; accel->dverm.c2 = info.double_byte.begin()->second; accel->dverm.offset = verify_u8(info.double_offset); DEBUG_PRINTF("state %hu is double vermicelli\n", this_idx); return; } if (double_byte_ok(info) && info.double_cr.none() && (info.double_byte.size() == 2 || info.double_byte.size() == 4)) { bool ok = true; assert(!info.double_byte.empty()); u8 firstC = info.double_byte.begin()->first & CASE_CLEAR; u8 secondC = info.double_byte.begin()->second & CASE_CLEAR; for (const pair &p : info.double_byte) { if ((p.first & CASE_CLEAR) != firstC || (p.second & CASE_CLEAR) != secondC) { ok = false; break; } } if (ok) { accel->accel_type = ACCEL_DVERM_NOCASE; accel->dverm.c1 = firstC; accel->dverm.c2 = secondC; accel->dverm.offset = verify_u8(info.double_offset); DEBUG_PRINTF("state %hu is nc double vermicelli\n", this_idx); return; } u8 m1; u8 m2; if (buildDvermMask(info.double_byte, &m1, &m2)) { accel->accel_type = ACCEL_DVERM_MASKED; accel->dverm.offset = verify_u8(info.double_offset); accel->dverm.c1 = info.double_byte.begin()->first & m1; accel->dverm.c2 = info.double_byte.begin()->second & m2; accel->dverm.m1 = m1; accel->dverm.m2 = m2; DEBUG_PRINTF( "building maskeddouble-vermicelli for 0x%02hhx%02hhx\n", accel->dverm.c1, accel->dverm.c2); return; } } if (double_byte_ok(info) && shuftiBuildDoubleMasks( info.double_cr, info.double_byte, (u8 *)&accel->dshufti.lo1, (u8 *)&accel->dshufti.hi1, (u8 *)&accel->dshufti.lo2, (u8 *)&accel->dshufti.hi2)) { accel->accel_type = ACCEL_DSHUFTI; accel->dshufti.offset = verify_u8(info.double_offset); DEBUG_PRINTF("state %hu is double shufti\n", this_idx); return; } if (info.cr.none()) { accel->accel_type = ACCEL_RED_TAPE; DEBUG_PRINTF("state %hu is a dead end full of bureaucratic red tape" " from which there is no escape\n", this_idx); return; } if (info.cr.count() == 1) { accel->accel_type = ACCEL_VERM; accel->verm.c = info.cr.find_first(); DEBUG_PRINTF("state %hu is vermicelli\n", this_idx); return; } if (info.cr.count() == 2 && info.cr.isCaselessChar()) { accel->accel_type = ACCEL_VERM_NOCASE; accel->verm.c = info.cr.find_first() & CASE_CLEAR; DEBUG_PRINTF("state %hu is caseless vermicelli\n", this_idx); return; } if (info.cr.count() > max_floating_stop_char()) { accel->accel_type = ACCEL_NONE; DEBUG_PRINTF("state %hu is too broad\n", this_idx); return; } accel->accel_type = ACCEL_SHUFTI; if (-1 != shuftiBuildMasks(info.cr, (u8 *)&accel->shufti.lo, (u8 *)&accel->shufti.hi)) { DEBUG_PRINTF("state %hu is shufti\n", this_idx); return; } assert(!info.cr.none()); accel->accel_type = ACCEL_TRUFFLE; truffleBuildMasks(info.cr, (u8 *)&accel->truffle.mask1, (u8 *)&accel->truffle.mask2); DEBUG_PRINTF("state %hu is truffle\n", this_idx); } map accel_dfa_build_strat::getAccelInfo(const Grey &grey) { map rv; raw_dfa &rdfa = get_raw(); if (!grey.accelerateDFA) { return rv; } dstate_id_t sds_proxy = get_sds_or_proxy(rdfa); DEBUG_PRINTF("sds %hu\n", sds_proxy); for (size_t i = 0; i < rdfa.states.size(); i++) { if (i == DEAD_STATE) { continue; } /* Note on report acceleration states: While we can't accelerate while * we * are spamming out callbacks, the QR code paths don't raise reports * during scanning so they can accelerate report states. */ if (generates_callbacks(rdfa.kind) && !rdfa.states[i].reports.empty()) { continue; } size_t single_limit = i == sds_proxy ? max_floating_stop_char() : max_stop_char(); DEBUG_PRINTF("inspecting %zu/%hu: %zu\n", i, sds_proxy, single_limit); AccelScheme ei = find_escape_strings(i); if (ei.cr.count() > single_limit) { DEBUG_PRINTF("state %zu is not accelerable has %zu\n", i, ei.cr.count()); continue; } DEBUG_PRINTF("state %zu should be accelerable %zu\n", i, ei.cr.count()); rv[i] = ei; } /* provide accleration states to states in the region of sds */ if (contains(rv, sds_proxy)) { AccelScheme sds_ei = rv[sds_proxy]; sds_ei.double_byte.clear(); /* region based on single byte scheme * may differ from double byte */ DEBUG_PRINTF("looking to expand offset accel to nearby states, %zu\n", sds_ei.cr.count()); auto sds_region = find_region(rdfa, sds_proxy, sds_ei); for (auto s : sds_region) { if (!contains(rv, s) || better(sds_ei, rv[s])) { rv[s] = sds_ei; } } } return rv; } }; hyperscan-4.4.1/src/nfa/truffle.h0000644000175000017500000000413213055426554017452 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Truffle: fully general character class acceleration. * * Utilises the SSSE3 pshufb or AVX2 vpshufb shuffle instructions */ #ifndef TRUFFLE_H #define TRUFFLE_H #include "util/simd_types.h" #ifdef __cplusplus extern "C" { #endif const u8 *truffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end); const u8 *rtruffleExec(m128 shuf_mask_lo_highclear, m128 shuf_mask_lo_highset, const u8 *buf, const u8 *buf_end); #ifdef __cplusplus } #endif #endif /* TRUFFLE_H */ hyperscan-4.4.1/src/nfa/goughcompile_dump.cpp0000644000175000017500000002373413055426554022056 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "goughcompile_dump.h" #include "goughcompile_internal.h" #include "grey.h" #include "util/container.h" #include "util/graph_range.h" #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { string dump_name(const GoughVertexProps &vp) { stringstream ss; ss << "vertex_" << vp.state_id; return ss.str(); } static string dump_name(const GoughGraph &g, const GoughEdge &e) { stringstream ss; ss << "edge_" << g[source(e, g)].state_id << "_" << g[target(e, g)].state_id; return ss.str(); } string dump_name(const gough_edge_id &e) { stringstream ss; ss << "edge_" << e.src << "_" << e.dest; return ss.str(); } static void dump_graph(const GoughGraph &g, const string &base, const Grey &grey) { stringstream ss; ss << grey.dumpPath << "gough_" << base << ".dot"; FILE *f = fopen(ss.str().c_str(), "w"); fprintf(f, "digraph NFA {\n"); fprintf(f, "rankdir=LR;\n"); fprintf(f, "size=\"11.5,8\"\n"); fprintf(f, "node [ shape = circle ];\n"); fprintf(f, "START [style=invis];\n"); for (auto v : vertices_range(g)) { fprintf(f, "%s [ width = 1, fixedsize = true, fontsize = 12, ", dump_name(g[v]).c_str()); if (!g[v].reports.empty() || !g[v].reports_eod.empty()) { fprintf(f, "shape = doublecircle "); } fprintf(f, "label = \"%u\"];\n", g[v].state_id); } for (const auto &e : edges_range(g)) { GoughVertex s = source(e, g); GoughVertex t = target(e, g); fprintf(f, "%s -> %s\n", dump_name(g[s]).c_str(), dump_name(g[t]).c_str()); } fprintf(f, "}\n"); fclose(f); } static set uses(const GoughVertexProps &vp) { set rv; for (const auto &r : vp.reports) { if (r.second) { rv.insert(r.second); } } for (const auto &r : vp.reports_eod) { if (r.second) { rv.insert(r.second); } } for (const auto &var : vp.vars) { insert(&rv, var->get_inputs()); } return rv; } static set uses(const GoughEdgeProps &ep) { set rv; for (const auto &var : ep.vars) { insert(&rv, var->get_inputs()); } return rv; } static void dump_var_mapping(const GoughGraph &g, const string &base, const Grey &grey) { stringstream ss; ss << grey.dumpPath << "gough_" << base << "_vars.txt"; FILE *f = fopen(ss.str().c_str(), "w"); for (auto v : vertices_range(g)) { set used = uses(g[v]); if (g[v].vars.empty() && used.empty()) { continue; } fprintf(f, "%s\n", dump_name(g[v]).c_str()); for (u32 i = 0; i < g[v].vars.size(); i++) { const GoughSSAVar *vp = g[v].vars[i].get(); fprintf(f, "\t%u: slot %u\n", i, vp->slot); } if (!used.empty()) { fprintf(f, "\tuses:"); vector used_id; for (const GoughSSAVar *var : used) { used_id.push_back(var->slot); } for (const u32 &id : used_id) { fprintf(f, " %u", id); } fprintf(f, "\n"); } } for (const auto &e : edges_range(g)) { set used = uses(g[e]); if (g[e].vars.empty() && used.empty()) { continue; } fprintf(f, "%s\n", dump_name(g, e).c_str()); for (u32 i = 0; i < g[e].vars.size(); i++) { const GoughSSAVar *vp = g[e].vars[i].get(); fprintf(f, "\t%u: slot %u\n", i, vp->slot); } if (!used.empty()) { fprintf(f, "\tuses:"); vector used_id; for (const GoughSSAVar *var : used) { used_id.push_back(var->slot); } for (const u32 &id : used_id) { fprintf(f, " %u", id); } fprintf(f, "\n"); } } fclose(f); } static void gather_vars(const GoughGraph &g, vector *vars, map *names, map *src_label, set *reporters) { for (auto v : vertices_range(g)) { for (const auto &r : g[v].reports) { reporters->insert(r.second); } for (const auto &r : g[v].reports_eod) { reporters->insert(r.second); } for (u32 i = 0; i < g[v].vars.size(); i++) { const GoughSSAVar *vp = g[v].vars[i].get(); stringstream ss; ss << dump_name(g[v]) << "_" << i; vars->push_back(vp); names->insert(make_pair(vp, ss.str())); src_label->insert(make_pair(vp, dump_name(g[v]))); } } for (const auto &e : edges_range(g)) { for (u32 i = 0; i < g[e].vars.size(); i++) { const GoughSSAVar *vp = g[e].vars[i].get(); stringstream ss; ss << dump_name(g, e) << "_" << i; vars->push_back(vp); names->insert(make_pair(vp, ss.str())); src_label->insert(make_pair(vp, dump_name(g, e))); } } } static void dump_vars(const GoughGraph &g, const string &base, const Grey &grey) { FILE *f; { stringstream ss; ss << grey.dumpPath << "gough_" << base << "_vars.dot"; f = fopen(ss.str().c_str(), "w"); } fprintf(f, "digraph NFA {\n"); fprintf(f, "rankdir=LR;\n"); fprintf(f, "size=\"11.5,8\"\n"); fprintf(f, "node [ shape = circle ];\n"); fprintf(f, "START [style=invis];\n"); vector vars; map names; map src_label; set reporters; gather_vars(g, &vars, &names, &src_label, &reporters); for (const GoughSSAVar *vp : vars) { fprintf(f, "%s [ width = 1, fixedsize = true, fontsize = 12, ", names[vp].c_str()); fprintf(f, "label = \"%s\\n", src_label[vp].c_str()); if (dynamic_cast(vp)) { fprintf(f, "MIN"); } else if (dynamic_cast(vp)) { fprintf(f, "JOIN"); } else if (dynamic_cast(vp)) { fprintf(f, "NEW"); } else { fprintf(f, "???"); } fprintf(f, "\"];\n"); } for (const GoughSSAVar *vp : reporters) { if (vp) { fprintf(f, "%s [ shape = doublecircle]\n", names[vp].c_str()); } else { fprintf(f, "eps [ label = \"eps\" shape = doublecircle]\n"); } } for (const GoughSSAVar *vp : vars) { const flat_set &inputs = vp->get_inputs(); for (const GoughSSAVar *v_in : inputs) { fprintf(f, "%s -> %s\n", names[v_in].c_str(), names[vp].c_str()); } } fprintf(f, "}\n"); fclose(f); } void dump(const GoughGraph &g, const string &base, const Grey &grey) { if (!(grey.dumpFlags & Grey::DUMP_INT_GRAPH)) { return; } dump_graph(g, base, grey); dump_var_mapping(g, base, grey); dump_vars(g, base, grey); } static void dump_block(FILE *f, const gough_edge_id &e, const vector &block) { fprintf(f, "%s:\n", dump_name(e).c_str()); for (const gough_ins &ins : block) { fprintf(f, "\t"); switch (ins.op) { case GOUGH_INS_END: fprintf(f, "END"); break; case GOUGH_INS_MOV: fprintf(f, "MOV %u %u", ins.dest, ins.src); break; case GOUGH_INS_NEW: fprintf(f, "NEW %u (+%u)", ins.dest, ins.src); break; case GOUGH_INS_MIN: fprintf(f, "MIN %u %u", ins.dest, ins.src); break; default: fprintf(f, ""); break; } fprintf(f, "\n"); } } void dump_blocks(const map> &blocks, const string &base, const Grey &grey) { if (!(grey.dumpFlags & Grey::DUMP_INT_GRAPH)) { return; } FILE *f; { stringstream ss; ss << grey.dumpPath << "gough_" << base << "_programs.txt"; f = fopen(ss.str().c_str(), "w"); } for (const auto &m : blocks) { dump_block(f, m.first, m.second); } fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfa/nfa_dump_internal.cpp0000644000175000017500000001121713055426554022025 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "nfa_dump_internal.h" #include "accel.h" #include "nfa_internal.h" #include "ue2common.h" #include // for isprint #include #ifndef DUMP_SUPPORT #error No dump support! #endif namespace ue2 { void dumpDotPreamble(FILE *dotFile) { fprintf(dotFile, "digraph NFA {\n"); fprintf(dotFile, "rankdir=LR;\n"); fprintf(dotFile, "size=\"11.5,8\"\n"); fprintf(dotFile, "node [ shape = circle ];\n"); fprintf(dotFile, "START [style=invis];\n"); } void dumpDotTrailer(FILE *dotFile) { fprintf(dotFile, "}\n"); } static void dumpFlags(const struct NFA *nfa, FILE *f) { fprintf(f, "Flags : "); if (nfa->flags & NFA_ACCEPTS_EOD) { fprintf(f, "ACCEPTS_EOD "); } if (nfa->flags & NFA_ZOMBIE) { fprintf(f, "ZOMBIE "); } fprintf(f, "\n"); } // Render an unsigned integer as a string, returning "inf/unknown" if it's // zero. static std::string value_or_inf(const u64a v) { std::ostringstream oss; if (v) { oss << v; } else { oss << "inf/unknown"; } return oss.str(); } void dumpTextReverse(const struct NFA *nfa, FILE *f) { bool twofer = false; fprintf(f, "Queue : %u\n", nfa->queueIndex); fprintf(f, "Length : %u bytes\n", nfa->length); fprintf(f, "Num Positions : %u\n", nfa->nPositions); fprintf(f, "Scratch State : %u bytes\n", nfa->scratchStateSize); fprintf(f, "Stream State : %u bytes\n", nfa->streamStateSize); dumpFlags(nfa, f); fprintf(f, "Max Width : %s\n", value_or_inf(nfa->maxWidth).c_str()); fprintf(f, "Min Width : %u\n", nfa->minWidth); fprintf(f, "BiAnchored Width : %s\n", value_or_inf(nfa->maxBiAnchoredWidth).c_str()); fprintf(f, "Max Offset : %s\n", value_or_inf(nfa->maxOffset).c_str()); fprintf(f, "Reverse Acceleration : "); switch (nfa->rAccelType) { case ACCEL_NONE: fprintf(f, "NONE\n"); return; case ACCEL_RVERM: fprintf(f, "R VERM"); break; case ACCEL_RVERM_NOCASE: fprintf(f, "R VERM NOCASE"); break; case ACCEL_RDVERM: fprintf(f, "R VERM x2"); twofer = true; break; case ACCEL_RDVERM_NOCASE: fprintf(f, "R VERM NOCASE x2"); twofer = true; break; case ACCEL_REOD: fprintf(f, "R EOD"); break; case ACCEL_REOD_NOCASE: fprintf(f, "R EOD NOCASE"); break; case ACCEL_RDEOD: fprintf(f, "R EOD x2"); twofer = true; break; case ACCEL_RDEOD_NOCASE: fprintf(f, "R EOD x2 NOCASE"); twofer = true; break; default: fprintf(f, "UNKNOWN\n"); return; } char c1 = nfa->rAccelData.array[0]; char c2 = nfa->rAccelData.array[1]; if (!twofer) { fprintf(f, " \\x%02hhx (%c) ", c1, isprint(c1) ? c1 : '?'); } else { fprintf(f, " \\x%02hhx\\x%02hhx (%c%c) ", c1, c2, isprint(c1) ? c1 : '?', isprint(c2) ? c2 : '?'); } fprintf(f, "offset %hhd\n", nfa->rAccelOffset); } } // namespace ue2 hyperscan-4.4.1/src/nfa/goughdump.h0000644000175000017500000000351313055426554020004 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 GOUGH_DUMP_H #define GOUGH_DUMP_H #ifdef DUMP_SUPPORT #include "ue2common.h" #include struct NFA; namespace ue2 { void nfaExecGough8_dump(const NFA *nfa, const std::string &base); void nfaExecGough16_dump(const NFA *nfa, const std::string &base); } // namespace ue2 #endif #endif hyperscan-4.4.1/src/nfa/sheng_impl.h0000644000175000017500000001032113055426554020125 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /* * In order to use this macro, the following things need to be defined: * * - SHENG_IMPL (name of the Sheng implementation function) * - DEAD_FUNC (name of the function checking for dead states) * - ACCEPT_FUNC (name of the function checking for accept state) * - STOP_AT_MATCH (can be 1 or 0, enable or disable stop at match) */ /* byte-by-byte version. we don't do byte-by-byte death checking as it's * pretty pointless to do it over a buffer that's at most 3 bytes long */ static really_inline char SHENG_IMPL(u8 *state, NfaCallback cb, void *ctxt, const struct sheng *s, u8 *const cached_accept_state, ReportID *const cached_accept_id, u8 single, u64a base_offset, const u8 *buf, const u8 *start, const u8 *end, const u8 **scan_end) { DEBUG_PRINTF("Starting DFA execution in state %u\n", *state & SHENG_STATE_MASK); const u8 *cur_buf = start; if (DEAD_FUNC(*state)) { DEBUG_PRINTF("Dead on arrival\n"); *scan_end = end; return MO_CONTINUE_MATCHING; } DEBUG_PRINTF("Scanning %lli bytes\n", (s64a)(end - start)); m128 cur_state = set16x8(*state); const m128 *masks = s->shuffle_masks; while (likely(cur_buf != end)) { const u8 c = *cur_buf; const m128 shuffle_mask = masks[c]; cur_state = pshufb(shuffle_mask, cur_state); const u8 tmp = movd(cur_state); DEBUG_PRINTF("c: %02hhx '%c'\n", c, ourisprint(c) ? c : '?'); DEBUG_PRINTF("s: %u (hi: %u lo: %u)\n", tmp, (tmp & 0xF0) >> 4, tmp & 0xF); if (unlikely(ACCEPT_FUNC(tmp))) { DEBUG_PRINTF("Accept state %u reached\n", tmp & SHENG_STATE_MASK); u64a match_offset = base_offset + (cur_buf - buf) + 1; DEBUG_PRINTF("Match @ %llu\n", match_offset); if (STOP_AT_MATCH) { DEBUG_PRINTF("Stopping at match @ %lli\n", (u64a)(cur_buf - start)); *state = tmp; *scan_end = cur_buf; return MO_MATCHES_PENDING; } if (single) { if (fireSingleReport(cb, ctxt, s->report, match_offset) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } else { if (fireReports(s, cb, ctxt, tmp, match_offset, cached_accept_state, cached_accept_id, 0) == MO_HALT_MATCHING) { return MO_HALT_MATCHING; } } } cur_buf++; } *state = movd(cur_state); *scan_end = cur_buf; return MO_CONTINUE_MATCHING; } hyperscan-4.4.1/src/nfa/multishufti_avx2.h0000644000175000017500000001111713055426554021321 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "shufti_common.h" #include "ue2common.h" #include "util/bitutils.h" #include "util/simd_utils.h" static really_inline const u8 *JOIN(MATCH_ALGO, fwdBlock)(m256 mask_lo, m256 mask_hi, m256 chars, const u8 *buf, const m256 low4bits, const m256 zeroes, const u8 run_len #ifdef MULTIACCEL_DOUBLE , const u8 run_len2 #endif ) { u32 z = block(mask_lo, mask_hi, chars, low4bits, zeroes); return (*JOIN4(MATCH_ALGO, match_funcs, _, 64)[run_len])(buf, ~z #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); } const u8 *JOIN(MATCH_ALGO, shuftiExec)(m128 mask_lo, m128 mask_hi, const u8 *buf, const u8 *buf_end, u8 run_len #ifdef MULTIACCEL_DOUBLE , u8 run_len2 #endif ) { assert(buf && buf_end); assert(buf < buf_end); // Slow path for small cases. if (buf_end - buf < 32) { return shuftiFwdSlow((const u8 *)&mask_lo, (const u8 *)&mask_hi, buf, buf_end); } const m256 zeroes = zeroes256(); const m256 low4bits = set32x8(0xf); const m256 wide_mask_lo = set2x128(mask_lo); const m256 wide_mask_hi = set2x128(mask_hi); const u8 *rv; size_t min = (size_t)buf % 32; assert(buf_end - buf >= 32); // Preconditioning: most of the time our buffer won't be aligned. m256 chars = loadu256(buf); rv = JOIN(MATCH_ALGO, fwdBlock)(wide_mask_lo, wide_mask_hi, chars, buf, low4bits, zeroes, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } buf += (32 - min); // Unrolling was here, but it wasn't doing anything but taking up space. // Reroll FTW. const u8 *last_block = buf_end - 32; while (buf < last_block) { m256 lchars = load256(buf); rv = JOIN(MATCH_ALGO, fwdBlock)(wide_mask_lo, wide_mask_hi, lchars, buf, low4bits, zeroes, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } buf += 32; } // Use an unaligned load to mop up the last 32 bytes and get an accurate // picture to buf_end. assert(buf <= buf_end && buf >= buf_end - 32); chars = loadu256(buf_end - 32); rv = JOIN(MATCH_ALGO, fwdBlock)(wide_mask_lo, wide_mask_hi, chars, buf_end - 32, low4bits, zeroes, run_len #ifdef MULTIACCEL_DOUBLE , run_len2 #endif ); if (rv) { return rv; } return buf_end; } hyperscan-4.4.1/src/scratch_dump.cpp0000644000175000017500000000516413055426554020254 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "scratch.h" #include "scratch_dump.h" #include "hs_internal.h" #include "ue2common.h" #include "util/multibit_build.h" #include "nfa/nfa_api_queue.h" #include "rose/rose_internal.h" #include #include #ifdef DUMP_SUPPORT using namespace std; namespace ue2 { void dumpScratch(const struct hs_scratch *s, FILE *f) { assert(s); fprintf(f, "Scratch space required : %u bytes\n", s->scratchSize); fprintf(f, " hs_scratch structure : %zu bytes\n", sizeof(*s)); fprintf(f, " tctxt structure : %zu bytes\n", sizeof(s->tctxt)); fprintf(f, " queues : %zu bytes\n", s->queueCount * sizeof(struct mq)); fprintf(f, " bStateSize : %u bytes\n", s->bStateSize); fprintf(f, " active queue array : %u bytes\n", s->activeQueueArraySize); fprintf(f, " qmpq : %zu bytes\n", s->queueCount * sizeof(struct queue_match)); fprintf(f, " delay info : %u bytes\n", s->delay_fatbit_size * DELAY_SLOT_COUNT); } } // namespace ue2 #endif // DUMP_SUPPORT hyperscan-4.4.1/src/crc32.c0000644000175000017500000010640013055426554016147 0ustar sleuthkidsleuthkid/* * 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. */ #include "crc32.h" #include "config.h" #include "ue2common.h" #if defined(HAVE_C_X86INTRIN_H) #include #elif defined(HAVE_C_INTRIN_H) #include #endif #ifndef __SSE4_2__ /*** *** What follows is derived from Intel's Slicing-by-8 CRC32 impl, which is BSD *** licensed and available from http://sourceforge.net/projects/slicing-by-8/ ***/ /* * Copyright (c) 2004-2006 Intel Corporation - All Rights Reserved * * * This software program is licensed subject to the BSD License, * available at http://www.opensource.org/licenses/bsd-license.html. * * Abstract: * * Tables for software CRC generation */ /* * The following CRC lookup table was generated automagically * using the following model parameters: * * Generator Polynomial = ................. 0x1EDC6F41 * Generator Polynomial Length = .......... 32 bits * Reflected Bits = ....................... TRUE * Table Generation Offset = .............. 32 bits * Number of Slices = ..................... 8 slices * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 * Directory Name = ....................... .\ * File Name = ............................ 8x256_tables.c */ static u32 crc_tableil8_o32[256] = { 0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4, 0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB, 0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B, 0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24, 0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B, 0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384, 0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54, 0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B, 0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A, 0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35, 0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5, 0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA, 0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45, 0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A, 0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A, 0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595, 0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48, 0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957, 0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687, 0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198, 0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927, 0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38, 0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8, 0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7, 0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096, 0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789, 0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859, 0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46, 0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9, 0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6, 0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36, 0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829, 0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C, 0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93, 0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043, 0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C, 0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3, 0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC, 0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C, 0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033, 0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652, 0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D, 0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D, 0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982, 0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D, 0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622, 0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2, 0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED, 0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530, 0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F, 0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF, 0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0, 0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F, 0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540, 0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90, 0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F, 0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE, 0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1, 0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321, 0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E, 0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81, 0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E, 0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E, 0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351 }; /* * end of the CRC lookup table crc_tableil8_o32 */ /* * The following CRC lookup table was generated automagically * using the following model parameters: * * Generator Polynomial = ................. 0x1EDC6F41 * Generator Polynomial Length = .......... 32 bits * Reflected Bits = ....................... TRUE * Table Generation Offset = .............. 32 bits * Number of Slices = ..................... 8 slices * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 * Directory Name = ....................... .\ * File Name = ............................ 8x256_tables.c */ static u32 crc_tableil8_o40[256] = { 0x00000000, 0x13A29877, 0x274530EE, 0x34E7A899, 0x4E8A61DC, 0x5D28F9AB, 0x69CF5132, 0x7A6DC945, 0x9D14C3B8, 0x8EB65BCF, 0xBA51F356, 0xA9F36B21, 0xD39EA264, 0xC03C3A13, 0xF4DB928A, 0xE7790AFD, 0x3FC5F181, 0x2C6769F6, 0x1880C16F, 0x0B225918, 0x714F905D, 0x62ED082A, 0x560AA0B3, 0x45A838C4, 0xA2D13239, 0xB173AA4E, 0x859402D7, 0x96369AA0, 0xEC5B53E5, 0xFFF9CB92, 0xCB1E630B, 0xD8BCFB7C, 0x7F8BE302, 0x6C297B75, 0x58CED3EC, 0x4B6C4B9B, 0x310182DE, 0x22A31AA9, 0x1644B230, 0x05E62A47, 0xE29F20BA, 0xF13DB8CD, 0xC5DA1054, 0xD6788823, 0xAC154166, 0xBFB7D911, 0x8B507188, 0x98F2E9FF, 0x404E1283, 0x53EC8AF4, 0x670B226D, 0x74A9BA1A, 0x0EC4735F, 0x1D66EB28, 0x298143B1, 0x3A23DBC6, 0xDD5AD13B, 0xCEF8494C, 0xFA1FE1D5, 0xE9BD79A2, 0x93D0B0E7, 0x80722890, 0xB4958009, 0xA737187E, 0xFF17C604, 0xECB55E73, 0xD852F6EA, 0xCBF06E9D, 0xB19DA7D8, 0xA23F3FAF, 0x96D89736, 0x857A0F41, 0x620305BC, 0x71A19DCB, 0x45463552, 0x56E4AD25, 0x2C896460, 0x3F2BFC17, 0x0BCC548E, 0x186ECCF9, 0xC0D23785, 0xD370AFF2, 0xE797076B, 0xF4359F1C, 0x8E585659, 0x9DFACE2E, 0xA91D66B7, 0xBABFFEC0, 0x5DC6F43D, 0x4E646C4A, 0x7A83C4D3, 0x69215CA4, 0x134C95E1, 0x00EE0D96, 0x3409A50F, 0x27AB3D78, 0x809C2506, 0x933EBD71, 0xA7D915E8, 0xB47B8D9F, 0xCE1644DA, 0xDDB4DCAD, 0xE9537434, 0xFAF1EC43, 0x1D88E6BE, 0x0E2A7EC9, 0x3ACDD650, 0x296F4E27, 0x53028762, 0x40A01F15, 0x7447B78C, 0x67E52FFB, 0xBF59D487, 0xACFB4CF0, 0x981CE469, 0x8BBE7C1E, 0xF1D3B55B, 0xE2712D2C, 0xD69685B5, 0xC5341DC2, 0x224D173F, 0x31EF8F48, 0x050827D1, 0x16AABFA6, 0x6CC776E3, 0x7F65EE94, 0x4B82460D, 0x5820DE7A, 0xFBC3FAF9, 0xE861628E, 0xDC86CA17, 0xCF245260, 0xB5499B25, 0xA6EB0352, 0x920CABCB, 0x81AE33BC, 0x66D73941, 0x7575A136, 0x419209AF, 0x523091D8, 0x285D589D, 0x3BFFC0EA, 0x0F186873, 0x1CBAF004, 0xC4060B78, 0xD7A4930F, 0xE3433B96, 0xF0E1A3E1, 0x8A8C6AA4, 0x992EF2D3, 0xADC95A4A, 0xBE6BC23D, 0x5912C8C0, 0x4AB050B7, 0x7E57F82E, 0x6DF56059, 0x1798A91C, 0x043A316B, 0x30DD99F2, 0x237F0185, 0x844819FB, 0x97EA818C, 0xA30D2915, 0xB0AFB162, 0xCAC27827, 0xD960E050, 0xED8748C9, 0xFE25D0BE, 0x195CDA43, 0x0AFE4234, 0x3E19EAAD, 0x2DBB72DA, 0x57D6BB9F, 0x447423E8, 0x70938B71, 0x63311306, 0xBB8DE87A, 0xA82F700D, 0x9CC8D894, 0x8F6A40E3, 0xF50789A6, 0xE6A511D1, 0xD242B948, 0xC1E0213F, 0x26992BC2, 0x353BB3B5, 0x01DC1B2C, 0x127E835B, 0x68134A1E, 0x7BB1D269, 0x4F567AF0, 0x5CF4E287, 0x04D43CFD, 0x1776A48A, 0x23910C13, 0x30339464, 0x4A5E5D21, 0x59FCC556, 0x6D1B6DCF, 0x7EB9F5B8, 0x99C0FF45, 0x8A626732, 0xBE85CFAB, 0xAD2757DC, 0xD74A9E99, 0xC4E806EE, 0xF00FAE77, 0xE3AD3600, 0x3B11CD7C, 0x28B3550B, 0x1C54FD92, 0x0FF665E5, 0x759BACA0, 0x663934D7, 0x52DE9C4E, 0x417C0439, 0xA6050EC4, 0xB5A796B3, 0x81403E2A, 0x92E2A65D, 0xE88F6F18, 0xFB2DF76F, 0xCFCA5FF6, 0xDC68C781, 0x7B5FDFFF, 0x68FD4788, 0x5C1AEF11, 0x4FB87766, 0x35D5BE23, 0x26772654, 0x12908ECD, 0x013216BA, 0xE64B1C47, 0xF5E98430, 0xC10E2CA9, 0xD2ACB4DE, 0xA8C17D9B, 0xBB63E5EC, 0x8F844D75, 0x9C26D502, 0x449A2E7E, 0x5738B609, 0x63DF1E90, 0x707D86E7, 0x0A104FA2, 0x19B2D7D5, 0x2D557F4C, 0x3EF7E73B, 0xD98EEDC6, 0xCA2C75B1, 0xFECBDD28, 0xED69455F, 0x97048C1A, 0x84A6146D, 0xB041BCF4, 0xA3E32483 }; /* * end of the CRC lookup table crc_tableil8_o40 */ /* * The following CRC lookup table was generated automagically * using the following model parameters: * * Generator Polynomial = ................. 0x1EDC6F41 * Generator Polynomial Length = .......... 32 bits * Reflected Bits = ....................... TRUE * Table Generation Offset = .............. 32 bits * Number of Slices = ..................... 8 slices * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 * Directory Name = ....................... .\ * File Name = ............................ 8x256_tables.c */ static u32 crc_tableil8_o48[256] = { 0x00000000, 0xA541927E, 0x4F6F520D, 0xEA2EC073, 0x9EDEA41A, 0x3B9F3664, 0xD1B1F617, 0x74F06469, 0x38513EC5, 0x9D10ACBB, 0x773E6CC8, 0xD27FFEB6, 0xA68F9ADF, 0x03CE08A1, 0xE9E0C8D2, 0x4CA15AAC, 0x70A27D8A, 0xD5E3EFF4, 0x3FCD2F87, 0x9A8CBDF9, 0xEE7CD990, 0x4B3D4BEE, 0xA1138B9D, 0x045219E3, 0x48F3434F, 0xEDB2D131, 0x079C1142, 0xA2DD833C, 0xD62DE755, 0x736C752B, 0x9942B558, 0x3C032726, 0xE144FB14, 0x4405696A, 0xAE2BA919, 0x0B6A3B67, 0x7F9A5F0E, 0xDADBCD70, 0x30F50D03, 0x95B49F7D, 0xD915C5D1, 0x7C5457AF, 0x967A97DC, 0x333B05A2, 0x47CB61CB, 0xE28AF3B5, 0x08A433C6, 0xADE5A1B8, 0x91E6869E, 0x34A714E0, 0xDE89D493, 0x7BC846ED, 0x0F382284, 0xAA79B0FA, 0x40577089, 0xE516E2F7, 0xA9B7B85B, 0x0CF62A25, 0xE6D8EA56, 0x43997828, 0x37691C41, 0x92288E3F, 0x78064E4C, 0xDD47DC32, 0xC76580D9, 0x622412A7, 0x880AD2D4, 0x2D4B40AA, 0x59BB24C3, 0xFCFAB6BD, 0x16D476CE, 0xB395E4B0, 0xFF34BE1C, 0x5A752C62, 0xB05BEC11, 0x151A7E6F, 0x61EA1A06, 0xC4AB8878, 0x2E85480B, 0x8BC4DA75, 0xB7C7FD53, 0x12866F2D, 0xF8A8AF5E, 0x5DE93D20, 0x29195949, 0x8C58CB37, 0x66760B44, 0xC337993A, 0x8F96C396, 0x2AD751E8, 0xC0F9919B, 0x65B803E5, 0x1148678C, 0xB409F5F2, 0x5E273581, 0xFB66A7FF, 0x26217BCD, 0x8360E9B3, 0x694E29C0, 0xCC0FBBBE, 0xB8FFDFD7, 0x1DBE4DA9, 0xF7908DDA, 0x52D11FA4, 0x1E704508, 0xBB31D776, 0x511F1705, 0xF45E857B, 0x80AEE112, 0x25EF736C, 0xCFC1B31F, 0x6A802161, 0x56830647, 0xF3C29439, 0x19EC544A, 0xBCADC634, 0xC85DA25D, 0x6D1C3023, 0x8732F050, 0x2273622E, 0x6ED23882, 0xCB93AAFC, 0x21BD6A8F, 0x84FCF8F1, 0xF00C9C98, 0x554D0EE6, 0xBF63CE95, 0x1A225CEB, 0x8B277743, 0x2E66E53D, 0xC448254E, 0x6109B730, 0x15F9D359, 0xB0B84127, 0x5A968154, 0xFFD7132A, 0xB3764986, 0x1637DBF8, 0xFC191B8B, 0x595889F5, 0x2DA8ED9C, 0x88E97FE2, 0x62C7BF91, 0xC7862DEF, 0xFB850AC9, 0x5EC498B7, 0xB4EA58C4, 0x11ABCABA, 0x655BAED3, 0xC01A3CAD, 0x2A34FCDE, 0x8F756EA0, 0xC3D4340C, 0x6695A672, 0x8CBB6601, 0x29FAF47F, 0x5D0A9016, 0xF84B0268, 0x1265C21B, 0xB7245065, 0x6A638C57, 0xCF221E29, 0x250CDE5A, 0x804D4C24, 0xF4BD284D, 0x51FCBA33, 0xBBD27A40, 0x1E93E83E, 0x5232B292, 0xF77320EC, 0x1D5DE09F, 0xB81C72E1, 0xCCEC1688, 0x69AD84F6, 0x83834485, 0x26C2D6FB, 0x1AC1F1DD, 0xBF8063A3, 0x55AEA3D0, 0xF0EF31AE, 0x841F55C7, 0x215EC7B9, 0xCB7007CA, 0x6E3195B4, 0x2290CF18, 0x87D15D66, 0x6DFF9D15, 0xC8BE0F6B, 0xBC4E6B02, 0x190FF97C, 0xF321390F, 0x5660AB71, 0x4C42F79A, 0xE90365E4, 0x032DA597, 0xA66C37E9, 0xD29C5380, 0x77DDC1FE, 0x9DF3018D, 0x38B293F3, 0x7413C95F, 0xD1525B21, 0x3B7C9B52, 0x9E3D092C, 0xEACD6D45, 0x4F8CFF3B, 0xA5A23F48, 0x00E3AD36, 0x3CE08A10, 0x99A1186E, 0x738FD81D, 0xD6CE4A63, 0xA23E2E0A, 0x077FBC74, 0xED517C07, 0x4810EE79, 0x04B1B4D5, 0xA1F026AB, 0x4BDEE6D8, 0xEE9F74A6, 0x9A6F10CF, 0x3F2E82B1, 0xD50042C2, 0x7041D0BC, 0xAD060C8E, 0x08479EF0, 0xE2695E83, 0x4728CCFD, 0x33D8A894, 0x96993AEA, 0x7CB7FA99, 0xD9F668E7, 0x9557324B, 0x3016A035, 0xDA386046, 0x7F79F238, 0x0B899651, 0xAEC8042F, 0x44E6C45C, 0xE1A75622, 0xDDA47104, 0x78E5E37A, 0x92CB2309, 0x378AB177, 0x437AD51E, 0xE63B4760, 0x0C158713, 0xA954156D, 0xE5F54FC1, 0x40B4DDBF, 0xAA9A1DCC, 0x0FDB8FB2, 0x7B2BEBDB, 0xDE6A79A5, 0x3444B9D6, 0x91052BA8 }; /* * end of the CRC lookup table crc_tableil8_o48 */ /* * The following CRC lookup table was generated automagically * using the following model parameters: * * Generator Polynomial = ................. 0x1EDC6F41 * Generator Polynomial Length = .......... 32 bits * Reflected Bits = ....................... TRUE * Table Generation Offset = .............. 32 bits * Number of Slices = ..................... 8 slices * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 * Directory Name = ....................... .\ * File Name = ............................ 8x256_tables.c */ static u32 crc_tableil8_o56[256] = { 0x00000000, 0xDD45AAB8, 0xBF672381, 0x62228939, 0x7B2231F3, 0xA6679B4B, 0xC4451272, 0x1900B8CA, 0xF64463E6, 0x2B01C95E, 0x49234067, 0x9466EADF, 0x8D665215, 0x5023F8AD, 0x32017194, 0xEF44DB2C, 0xE964B13D, 0x34211B85, 0x560392BC, 0x8B463804, 0x924680CE, 0x4F032A76, 0x2D21A34F, 0xF06409F7, 0x1F20D2DB, 0xC2657863, 0xA047F15A, 0x7D025BE2, 0x6402E328, 0xB9474990, 0xDB65C0A9, 0x06206A11, 0xD725148B, 0x0A60BE33, 0x6842370A, 0xB5079DB2, 0xAC072578, 0x71428FC0, 0x136006F9, 0xCE25AC41, 0x2161776D, 0xFC24DDD5, 0x9E0654EC, 0x4343FE54, 0x5A43469E, 0x8706EC26, 0xE524651F, 0x3861CFA7, 0x3E41A5B6, 0xE3040F0E, 0x81268637, 0x5C632C8F, 0x45639445, 0x98263EFD, 0xFA04B7C4, 0x27411D7C, 0xC805C650, 0x15406CE8, 0x7762E5D1, 0xAA274F69, 0xB327F7A3, 0x6E625D1B, 0x0C40D422, 0xD1057E9A, 0xABA65FE7, 0x76E3F55F, 0x14C17C66, 0xC984D6DE, 0xD0846E14, 0x0DC1C4AC, 0x6FE34D95, 0xB2A6E72D, 0x5DE23C01, 0x80A796B9, 0xE2851F80, 0x3FC0B538, 0x26C00DF2, 0xFB85A74A, 0x99A72E73, 0x44E284CB, 0x42C2EEDA, 0x9F874462, 0xFDA5CD5B, 0x20E067E3, 0x39E0DF29, 0xE4A57591, 0x8687FCA8, 0x5BC25610, 0xB4868D3C, 0x69C32784, 0x0BE1AEBD, 0xD6A40405, 0xCFA4BCCF, 0x12E11677, 0x70C39F4E, 0xAD8635F6, 0x7C834B6C, 0xA1C6E1D4, 0xC3E468ED, 0x1EA1C255, 0x07A17A9F, 0xDAE4D027, 0xB8C6591E, 0x6583F3A6, 0x8AC7288A, 0x57828232, 0x35A00B0B, 0xE8E5A1B3, 0xF1E51979, 0x2CA0B3C1, 0x4E823AF8, 0x93C79040, 0x95E7FA51, 0x48A250E9, 0x2A80D9D0, 0xF7C57368, 0xEEC5CBA2, 0x3380611A, 0x51A2E823, 0x8CE7429B, 0x63A399B7, 0xBEE6330F, 0xDCC4BA36, 0x0181108E, 0x1881A844, 0xC5C402FC, 0xA7E68BC5, 0x7AA3217D, 0x52A0C93F, 0x8FE56387, 0xEDC7EABE, 0x30824006, 0x2982F8CC, 0xF4C75274, 0x96E5DB4D, 0x4BA071F5, 0xA4E4AAD9, 0x79A10061, 0x1B838958, 0xC6C623E0, 0xDFC69B2A, 0x02833192, 0x60A1B8AB, 0xBDE41213, 0xBBC47802, 0x6681D2BA, 0x04A35B83, 0xD9E6F13B, 0xC0E649F1, 0x1DA3E349, 0x7F816A70, 0xA2C4C0C8, 0x4D801BE4, 0x90C5B15C, 0xF2E73865, 0x2FA292DD, 0x36A22A17, 0xEBE780AF, 0x89C50996, 0x5480A32E, 0x8585DDB4, 0x58C0770C, 0x3AE2FE35, 0xE7A7548D, 0xFEA7EC47, 0x23E246FF, 0x41C0CFC6, 0x9C85657E, 0x73C1BE52, 0xAE8414EA, 0xCCA69DD3, 0x11E3376B, 0x08E38FA1, 0xD5A62519, 0xB784AC20, 0x6AC10698, 0x6CE16C89, 0xB1A4C631, 0xD3864F08, 0x0EC3E5B0, 0x17C35D7A, 0xCA86F7C2, 0xA8A47EFB, 0x75E1D443, 0x9AA50F6F, 0x47E0A5D7, 0x25C22CEE, 0xF8878656, 0xE1873E9C, 0x3CC29424, 0x5EE01D1D, 0x83A5B7A5, 0xF90696D8, 0x24433C60, 0x4661B559, 0x9B241FE1, 0x8224A72B, 0x5F610D93, 0x3D4384AA, 0xE0062E12, 0x0F42F53E, 0xD2075F86, 0xB025D6BF, 0x6D607C07, 0x7460C4CD, 0xA9256E75, 0xCB07E74C, 0x16424DF4, 0x106227E5, 0xCD278D5D, 0xAF050464, 0x7240AEDC, 0x6B401616, 0xB605BCAE, 0xD4273597, 0x09629F2F, 0xE6264403, 0x3B63EEBB, 0x59416782, 0x8404CD3A, 0x9D0475F0, 0x4041DF48, 0x22635671, 0xFF26FCC9, 0x2E238253, 0xF36628EB, 0x9144A1D2, 0x4C010B6A, 0x5501B3A0, 0x88441918, 0xEA669021, 0x37233A99, 0xD867E1B5, 0x05224B0D, 0x6700C234, 0xBA45688C, 0xA345D046, 0x7E007AFE, 0x1C22F3C7, 0xC167597F, 0xC747336E, 0x1A0299D6, 0x782010EF, 0xA565BA57, 0xBC65029D, 0x6120A825, 0x0302211C, 0xDE478BA4, 0x31035088, 0xEC46FA30, 0x8E647309, 0x5321D9B1, 0x4A21617B, 0x9764CBC3, 0xF54642FA, 0x2803E842 }; /* * end of the CRC lookup table crc_tableil8_o56 */ /* * The following CRC lookup table was generated automagically * using the following model parameters: * * Generator Polynomial = ................. 0x1EDC6F41 * Generator Polynomial Length = .......... 32 bits * Reflected Bits = ....................... TRUE * Table Generation Offset = .............. 32 bits * Number of Slices = ..................... 8 slices * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 * Directory Name = ....................... .\ * File Name = ............................ 8x256_tables.c */ static u32 crc_tableil8_o64[256] = { 0x00000000, 0x38116FAC, 0x7022DF58, 0x4833B0F4, 0xE045BEB0, 0xD854D11C, 0x906761E8, 0xA8760E44, 0xC5670B91, 0xFD76643D, 0xB545D4C9, 0x8D54BB65, 0x2522B521, 0x1D33DA8D, 0x55006A79, 0x6D1105D5, 0x8F2261D3, 0xB7330E7F, 0xFF00BE8B, 0xC711D127, 0x6F67DF63, 0x5776B0CF, 0x1F45003B, 0x27546F97, 0x4A456A42, 0x725405EE, 0x3A67B51A, 0x0276DAB6, 0xAA00D4F2, 0x9211BB5E, 0xDA220BAA, 0xE2336406, 0x1BA8B557, 0x23B9DAFB, 0x6B8A6A0F, 0x539B05A3, 0xFBED0BE7, 0xC3FC644B, 0x8BCFD4BF, 0xB3DEBB13, 0xDECFBEC6, 0xE6DED16A, 0xAEED619E, 0x96FC0E32, 0x3E8A0076, 0x069B6FDA, 0x4EA8DF2E, 0x76B9B082, 0x948AD484, 0xAC9BBB28, 0xE4A80BDC, 0xDCB96470, 0x74CF6A34, 0x4CDE0598, 0x04EDB56C, 0x3CFCDAC0, 0x51EDDF15, 0x69FCB0B9, 0x21CF004D, 0x19DE6FE1, 0xB1A861A5, 0x89B90E09, 0xC18ABEFD, 0xF99BD151, 0x37516AAE, 0x0F400502, 0x4773B5F6, 0x7F62DA5A, 0xD714D41E, 0xEF05BBB2, 0xA7360B46, 0x9F2764EA, 0xF236613F, 0xCA270E93, 0x8214BE67, 0xBA05D1CB, 0x1273DF8F, 0x2A62B023, 0x625100D7, 0x5A406F7B, 0xB8730B7D, 0x806264D1, 0xC851D425, 0xF040BB89, 0x5836B5CD, 0x6027DA61, 0x28146A95, 0x10050539, 0x7D1400EC, 0x45056F40, 0x0D36DFB4, 0x3527B018, 0x9D51BE5C, 0xA540D1F0, 0xED736104, 0xD5620EA8, 0x2CF9DFF9, 0x14E8B055, 0x5CDB00A1, 0x64CA6F0D, 0xCCBC6149, 0xF4AD0EE5, 0xBC9EBE11, 0x848FD1BD, 0xE99ED468, 0xD18FBBC4, 0x99BC0B30, 0xA1AD649C, 0x09DB6AD8, 0x31CA0574, 0x79F9B580, 0x41E8DA2C, 0xA3DBBE2A, 0x9BCAD186, 0xD3F96172, 0xEBE80EDE, 0x439E009A, 0x7B8F6F36, 0x33BCDFC2, 0x0BADB06E, 0x66BCB5BB, 0x5EADDA17, 0x169E6AE3, 0x2E8F054F, 0x86F90B0B, 0xBEE864A7, 0xF6DBD453, 0xCECABBFF, 0x6EA2D55C, 0x56B3BAF0, 0x1E800A04, 0x269165A8, 0x8EE76BEC, 0xB6F60440, 0xFEC5B4B4, 0xC6D4DB18, 0xABC5DECD, 0x93D4B161, 0xDBE70195, 0xE3F66E39, 0x4B80607D, 0x73910FD1, 0x3BA2BF25, 0x03B3D089, 0xE180B48F, 0xD991DB23, 0x91A26BD7, 0xA9B3047B, 0x01C50A3F, 0x39D46593, 0x71E7D567, 0x49F6BACB, 0x24E7BF1E, 0x1CF6D0B2, 0x54C56046, 0x6CD40FEA, 0xC4A201AE, 0xFCB36E02, 0xB480DEF6, 0x8C91B15A, 0x750A600B, 0x4D1B0FA7, 0x0528BF53, 0x3D39D0FF, 0x954FDEBB, 0xAD5EB117, 0xE56D01E3, 0xDD7C6E4F, 0xB06D6B9A, 0x887C0436, 0xC04FB4C2, 0xF85EDB6E, 0x5028D52A, 0x6839BA86, 0x200A0A72, 0x181B65DE, 0xFA2801D8, 0xC2396E74, 0x8A0ADE80, 0xB21BB12C, 0x1A6DBF68, 0x227CD0C4, 0x6A4F6030, 0x525E0F9C, 0x3F4F0A49, 0x075E65E5, 0x4F6DD511, 0x777CBABD, 0xDF0AB4F9, 0xE71BDB55, 0xAF286BA1, 0x9739040D, 0x59F3BFF2, 0x61E2D05E, 0x29D160AA, 0x11C00F06, 0xB9B60142, 0x81A76EEE, 0xC994DE1A, 0xF185B1B6, 0x9C94B463, 0xA485DBCF, 0xECB66B3B, 0xD4A70497, 0x7CD10AD3, 0x44C0657F, 0x0CF3D58B, 0x34E2BA27, 0xD6D1DE21, 0xEEC0B18D, 0xA6F30179, 0x9EE26ED5, 0x36946091, 0x0E850F3D, 0x46B6BFC9, 0x7EA7D065, 0x13B6D5B0, 0x2BA7BA1C, 0x63940AE8, 0x5B856544, 0xF3F36B00, 0xCBE204AC, 0x83D1B458, 0xBBC0DBF4, 0x425B0AA5, 0x7A4A6509, 0x3279D5FD, 0x0A68BA51, 0xA21EB415, 0x9A0FDBB9, 0xD23C6B4D, 0xEA2D04E1, 0x873C0134, 0xBF2D6E98, 0xF71EDE6C, 0xCF0FB1C0, 0x6779BF84, 0x5F68D028, 0x175B60DC, 0x2F4A0F70, 0xCD796B76, 0xF56804DA, 0xBD5BB42E, 0x854ADB82, 0x2D3CD5C6, 0x152DBA6A, 0x5D1E0A9E, 0x650F6532, 0x081E60E7, 0x300F0F4B, 0x783CBFBF, 0x402DD013, 0xE85BDE57, 0xD04AB1FB, 0x9879010F, 0xA0686EA3 }; /* * end of the CRC lookup table crc_tableil8_o64 */ /* * The following CRC lookup table was generated automagically * using the following model parameters: * * Generator Polynomial = ................. 0x1EDC6F41 * Generator Polynomial Length = .......... 32 bits * Reflected Bits = ....................... TRUE * Table Generation Offset = .............. 32 bits * Number of Slices = ..................... 8 slices * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 * Directory Name = ....................... .\ * File Name = ............................ 8x256_tables.c */ static u32 crc_tableil8_o72[256] = { 0x00000000, 0xEF306B19, 0xDB8CA0C3, 0x34BCCBDA, 0xB2F53777, 0x5DC55C6E, 0x697997B4, 0x8649FCAD, 0x6006181F, 0x8F367306, 0xBB8AB8DC, 0x54BAD3C5, 0xD2F32F68, 0x3DC34471, 0x097F8FAB, 0xE64FE4B2, 0xC00C303E, 0x2F3C5B27, 0x1B8090FD, 0xF4B0FBE4, 0x72F90749, 0x9DC96C50, 0xA975A78A, 0x4645CC93, 0xA00A2821, 0x4F3A4338, 0x7B8688E2, 0x94B6E3FB, 0x12FF1F56, 0xFDCF744F, 0xC973BF95, 0x2643D48C, 0x85F4168D, 0x6AC47D94, 0x5E78B64E, 0xB148DD57, 0x370121FA, 0xD8314AE3, 0xEC8D8139, 0x03BDEA20, 0xE5F20E92, 0x0AC2658B, 0x3E7EAE51, 0xD14EC548, 0x570739E5, 0xB83752FC, 0x8C8B9926, 0x63BBF23F, 0x45F826B3, 0xAAC84DAA, 0x9E748670, 0x7144ED69, 0xF70D11C4, 0x183D7ADD, 0x2C81B107, 0xC3B1DA1E, 0x25FE3EAC, 0xCACE55B5, 0xFE729E6F, 0x1142F576, 0x970B09DB, 0x783B62C2, 0x4C87A918, 0xA3B7C201, 0x0E045BEB, 0xE13430F2, 0xD588FB28, 0x3AB89031, 0xBCF16C9C, 0x53C10785, 0x677DCC5F, 0x884DA746, 0x6E0243F4, 0x813228ED, 0xB58EE337, 0x5ABE882E, 0xDCF77483, 0x33C71F9A, 0x077BD440, 0xE84BBF59, 0xCE086BD5, 0x213800CC, 0x1584CB16, 0xFAB4A00F, 0x7CFD5CA2, 0x93CD37BB, 0xA771FC61, 0x48419778, 0xAE0E73CA, 0x413E18D3, 0x7582D309, 0x9AB2B810, 0x1CFB44BD, 0xF3CB2FA4, 0xC777E47E, 0x28478F67, 0x8BF04D66, 0x64C0267F, 0x507CEDA5, 0xBF4C86BC, 0x39057A11, 0xD6351108, 0xE289DAD2, 0x0DB9B1CB, 0xEBF65579, 0x04C63E60, 0x307AF5BA, 0xDF4A9EA3, 0x5903620E, 0xB6330917, 0x828FC2CD, 0x6DBFA9D4, 0x4BFC7D58, 0xA4CC1641, 0x9070DD9B, 0x7F40B682, 0xF9094A2F, 0x16392136, 0x2285EAEC, 0xCDB581F5, 0x2BFA6547, 0xC4CA0E5E, 0xF076C584, 0x1F46AE9D, 0x990F5230, 0x763F3929, 0x4283F2F3, 0xADB399EA, 0x1C08B7D6, 0xF338DCCF, 0xC7841715, 0x28B47C0C, 0xAEFD80A1, 0x41CDEBB8, 0x75712062, 0x9A414B7B, 0x7C0EAFC9, 0x933EC4D0, 0xA7820F0A, 0x48B26413, 0xCEFB98BE, 0x21CBF3A7, 0x1577387D, 0xFA475364, 0xDC0487E8, 0x3334ECF1, 0x0788272B, 0xE8B84C32, 0x6EF1B09F, 0x81C1DB86, 0xB57D105C, 0x5A4D7B45, 0xBC029FF7, 0x5332F4EE, 0x678E3F34, 0x88BE542D, 0x0EF7A880, 0xE1C7C399, 0xD57B0843, 0x3A4B635A, 0x99FCA15B, 0x76CCCA42, 0x42700198, 0xAD406A81, 0x2B09962C, 0xC439FD35, 0xF08536EF, 0x1FB55DF6, 0xF9FAB944, 0x16CAD25D, 0x22761987, 0xCD46729E, 0x4B0F8E33, 0xA43FE52A, 0x90832EF0, 0x7FB345E9, 0x59F09165, 0xB6C0FA7C, 0x827C31A6, 0x6D4C5ABF, 0xEB05A612, 0x0435CD0B, 0x308906D1, 0xDFB96DC8, 0x39F6897A, 0xD6C6E263, 0xE27A29B9, 0x0D4A42A0, 0x8B03BE0D, 0x6433D514, 0x508F1ECE, 0xBFBF75D7, 0x120CEC3D, 0xFD3C8724, 0xC9804CFE, 0x26B027E7, 0xA0F9DB4A, 0x4FC9B053, 0x7B757B89, 0x94451090, 0x720AF422, 0x9D3A9F3B, 0xA98654E1, 0x46B63FF8, 0xC0FFC355, 0x2FCFA84C, 0x1B736396, 0xF443088F, 0xD200DC03, 0x3D30B71A, 0x098C7CC0, 0xE6BC17D9, 0x60F5EB74, 0x8FC5806D, 0xBB794BB7, 0x544920AE, 0xB206C41C, 0x5D36AF05, 0x698A64DF, 0x86BA0FC6, 0x00F3F36B, 0xEFC39872, 0xDB7F53A8, 0x344F38B1, 0x97F8FAB0, 0x78C891A9, 0x4C745A73, 0xA344316A, 0x250DCDC7, 0xCA3DA6DE, 0xFE816D04, 0x11B1061D, 0xF7FEE2AF, 0x18CE89B6, 0x2C72426C, 0xC3422975, 0x450BD5D8, 0xAA3BBEC1, 0x9E87751B, 0x71B71E02, 0x57F4CA8E, 0xB8C4A197, 0x8C786A4D, 0x63480154, 0xE501FDF9, 0x0A3196E0, 0x3E8D5D3A, 0xD1BD3623, 0x37F2D291, 0xD8C2B988, 0xEC7E7252, 0x034E194B, 0x8507E5E6, 0x6A378EFF, 0x5E8B4525, 0xB1BB2E3C }; /* * end of the CRC lookup table crc_tableil8_o72 */ /* * The following CRC lookup table was generated automagically * using the following model parameters: * * Generator Polynomial = ................. 0x1EDC6F41 * Generator Polynomial Length = .......... 32 bits * Reflected Bits = ....................... TRUE * Table Generation Offset = .............. 32 bits * Number of Slices = ..................... 8 slices * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 * Directory Name = ....................... .\ * File Name = ............................ 8x256_tables.c */ static u32 crc_tableil8_o80[256] = { 0x00000000, 0x68032CC8, 0xD0065990, 0xB8057558, 0xA5E0C5D1, 0xCDE3E919, 0x75E69C41, 0x1DE5B089, 0x4E2DFD53, 0x262ED19B, 0x9E2BA4C3, 0xF628880B, 0xEBCD3882, 0x83CE144A, 0x3BCB6112, 0x53C84DDA, 0x9C5BFAA6, 0xF458D66E, 0x4C5DA336, 0x245E8FFE, 0x39BB3F77, 0x51B813BF, 0xE9BD66E7, 0x81BE4A2F, 0xD27607F5, 0xBA752B3D, 0x02705E65, 0x6A7372AD, 0x7796C224, 0x1F95EEEC, 0xA7909BB4, 0xCF93B77C, 0x3D5B83BD, 0x5558AF75, 0xED5DDA2D, 0x855EF6E5, 0x98BB466C, 0xF0B86AA4, 0x48BD1FFC, 0x20BE3334, 0x73767EEE, 0x1B755226, 0xA370277E, 0xCB730BB6, 0xD696BB3F, 0xBE9597F7, 0x0690E2AF, 0x6E93CE67, 0xA100791B, 0xC90355D3, 0x7106208B, 0x19050C43, 0x04E0BCCA, 0x6CE39002, 0xD4E6E55A, 0xBCE5C992, 0xEF2D8448, 0x872EA880, 0x3F2BDDD8, 0x5728F110, 0x4ACD4199, 0x22CE6D51, 0x9ACB1809, 0xF2C834C1, 0x7AB7077A, 0x12B42BB2, 0xAAB15EEA, 0xC2B27222, 0xDF57C2AB, 0xB754EE63, 0x0F519B3B, 0x6752B7F3, 0x349AFA29, 0x5C99D6E1, 0xE49CA3B9, 0x8C9F8F71, 0x917A3FF8, 0xF9791330, 0x417C6668, 0x297F4AA0, 0xE6ECFDDC, 0x8EEFD114, 0x36EAA44C, 0x5EE98884, 0x430C380D, 0x2B0F14C5, 0x930A619D, 0xFB094D55, 0xA8C1008F, 0xC0C22C47, 0x78C7591F, 0x10C475D7, 0x0D21C55E, 0x6522E996, 0xDD279CCE, 0xB524B006, 0x47EC84C7, 0x2FEFA80F, 0x97EADD57, 0xFFE9F19F, 0xE20C4116, 0x8A0F6DDE, 0x320A1886, 0x5A09344E, 0x09C17994, 0x61C2555C, 0xD9C72004, 0xB1C40CCC, 0xAC21BC45, 0xC422908D, 0x7C27E5D5, 0x1424C91D, 0xDBB77E61, 0xB3B452A9, 0x0BB127F1, 0x63B20B39, 0x7E57BBB0, 0x16549778, 0xAE51E220, 0xC652CEE8, 0x959A8332, 0xFD99AFFA, 0x459CDAA2, 0x2D9FF66A, 0x307A46E3, 0x58796A2B, 0xE07C1F73, 0x887F33BB, 0xF56E0EF4, 0x9D6D223C, 0x25685764, 0x4D6B7BAC, 0x508ECB25, 0x388DE7ED, 0x808892B5, 0xE88BBE7D, 0xBB43F3A7, 0xD340DF6F, 0x6B45AA37, 0x034686FF, 0x1EA33676, 0x76A01ABE, 0xCEA56FE6, 0xA6A6432E, 0x6935F452, 0x0136D89A, 0xB933ADC2, 0xD130810A, 0xCCD53183, 0xA4D61D4B, 0x1CD36813, 0x74D044DB, 0x27180901, 0x4F1B25C9, 0xF71E5091, 0x9F1D7C59, 0x82F8CCD0, 0xEAFBE018, 0x52FE9540, 0x3AFDB988, 0xC8358D49, 0xA036A181, 0x1833D4D9, 0x7030F811, 0x6DD54898, 0x05D66450, 0xBDD31108, 0xD5D03DC0, 0x8618701A, 0xEE1B5CD2, 0x561E298A, 0x3E1D0542, 0x23F8B5CB, 0x4BFB9903, 0xF3FEEC5B, 0x9BFDC093, 0x546E77EF, 0x3C6D5B27, 0x84682E7F, 0xEC6B02B7, 0xF18EB23E, 0x998D9EF6, 0x2188EBAE, 0x498BC766, 0x1A438ABC, 0x7240A674, 0xCA45D32C, 0xA246FFE4, 0xBFA34F6D, 0xD7A063A5, 0x6FA516FD, 0x07A63A35, 0x8FD9098E, 0xE7DA2546, 0x5FDF501E, 0x37DC7CD6, 0x2A39CC5F, 0x423AE097, 0xFA3F95CF, 0x923CB907, 0xC1F4F4DD, 0xA9F7D815, 0x11F2AD4D, 0x79F18185, 0x6414310C, 0x0C171DC4, 0xB412689C, 0xDC114454, 0x1382F328, 0x7B81DFE0, 0xC384AAB8, 0xAB878670, 0xB66236F9, 0xDE611A31, 0x66646F69, 0x0E6743A1, 0x5DAF0E7B, 0x35AC22B3, 0x8DA957EB, 0xE5AA7B23, 0xF84FCBAA, 0x904CE762, 0x2849923A, 0x404ABEF2, 0xB2828A33, 0xDA81A6FB, 0x6284D3A3, 0x0A87FF6B, 0x17624FE2, 0x7F61632A, 0xC7641672, 0xAF673ABA, 0xFCAF7760, 0x94AC5BA8, 0x2CA92EF0, 0x44AA0238, 0x594FB2B1, 0x314C9E79, 0x8949EB21, 0xE14AC7E9, 0x2ED97095, 0x46DA5C5D, 0xFEDF2905, 0x96DC05CD, 0x8B39B544, 0xE33A998C, 0x5B3FECD4, 0x333CC01C, 0x60F48DC6, 0x08F7A10E, 0xB0F2D456, 0xD8F1F89E, 0xC5144817, 0xAD1764DF, 0x15121187, 0x7D113D4F }; /* * end of the CRC lookup table crc_tableil8_o80 */ /* * The following CRC lookup table was generated automagically * using the following model parameters: * * Generator Polynomial = ................. 0x1EDC6F41 * Generator Polynomial Length = .......... 32 bits * Reflected Bits = ....................... TRUE * Table Generation Offset = .............. 32 bits * Number of Slices = ..................... 8 slices * Slice Lengths = ........................ 8 8 8 8 8 8 8 8 * Directory Name = ....................... .\ * File Name = ............................ 8x256_tables.c */ static u32 crc_tableil8_o88[256] = { 0x00000000, 0x493C7D27, 0x9278FA4E, 0xDB448769, 0x211D826D, 0x6821FF4A, 0xB3657823, 0xFA590504, 0x423B04DA, 0x0B0779FD, 0xD043FE94, 0x997F83B3, 0x632686B7, 0x2A1AFB90, 0xF15E7CF9, 0xB86201DE, 0x847609B4, 0xCD4A7493, 0x160EF3FA, 0x5F328EDD, 0xA56B8BD9, 0xEC57F6FE, 0x37137197, 0x7E2F0CB0, 0xC64D0D6E, 0x8F717049, 0x5435F720, 0x1D098A07, 0xE7508F03, 0xAE6CF224, 0x7528754D, 0x3C14086A, 0x0D006599, 0x443C18BE, 0x9F789FD7, 0xD644E2F0, 0x2C1DE7F4, 0x65219AD3, 0xBE651DBA, 0xF759609D, 0x4F3B6143, 0x06071C64, 0xDD439B0D, 0x947FE62A, 0x6E26E32E, 0x271A9E09, 0xFC5E1960, 0xB5626447, 0x89766C2D, 0xC04A110A, 0x1B0E9663, 0x5232EB44, 0xA86BEE40, 0xE1579367, 0x3A13140E, 0x732F6929, 0xCB4D68F7, 0x827115D0, 0x593592B9, 0x1009EF9E, 0xEA50EA9A, 0xA36C97BD, 0x782810D4, 0x31146DF3, 0x1A00CB32, 0x533CB615, 0x8878317C, 0xC1444C5B, 0x3B1D495F, 0x72213478, 0xA965B311, 0xE059CE36, 0x583BCFE8, 0x1107B2CF, 0xCA4335A6, 0x837F4881, 0x79264D85, 0x301A30A2, 0xEB5EB7CB, 0xA262CAEC, 0x9E76C286, 0xD74ABFA1, 0x0C0E38C8, 0x453245EF, 0xBF6B40EB, 0xF6573DCC, 0x2D13BAA5, 0x642FC782, 0xDC4DC65C, 0x9571BB7B, 0x4E353C12, 0x07094135, 0xFD504431, 0xB46C3916, 0x6F28BE7F, 0x2614C358, 0x1700AEAB, 0x5E3CD38C, 0x857854E5, 0xCC4429C2, 0x361D2CC6, 0x7F2151E1, 0xA465D688, 0xED59ABAF, 0x553BAA71, 0x1C07D756, 0xC743503F, 0x8E7F2D18, 0x7426281C, 0x3D1A553B, 0xE65ED252, 0xAF62AF75, 0x9376A71F, 0xDA4ADA38, 0x010E5D51, 0x48322076, 0xB26B2572, 0xFB575855, 0x2013DF3C, 0x692FA21B, 0xD14DA3C5, 0x9871DEE2, 0x4335598B, 0x0A0924AC, 0xF05021A8, 0xB96C5C8F, 0x6228DBE6, 0x2B14A6C1, 0x34019664, 0x7D3DEB43, 0xA6796C2A, 0xEF45110D, 0x151C1409, 0x5C20692E, 0x8764EE47, 0xCE589360, 0x763A92BE, 0x3F06EF99, 0xE44268F0, 0xAD7E15D7, 0x572710D3, 0x1E1B6DF4, 0xC55FEA9D, 0x8C6397BA, 0xB0779FD0, 0xF94BE2F7, 0x220F659E, 0x6B3318B9, 0x916A1DBD, 0xD856609A, 0x0312E7F3, 0x4A2E9AD4, 0xF24C9B0A, 0xBB70E62D, 0x60346144, 0x29081C63, 0xD3511967, 0x9A6D6440, 0x4129E329, 0x08159E0E, 0x3901F3FD, 0x703D8EDA, 0xAB7909B3, 0xE2457494, 0x181C7190, 0x51200CB7, 0x8A648BDE, 0xC358F6F9, 0x7B3AF727, 0x32068A00, 0xE9420D69, 0xA07E704E, 0x5A27754A, 0x131B086D, 0xC85F8F04, 0x8163F223, 0xBD77FA49, 0xF44B876E, 0x2F0F0007, 0x66337D20, 0x9C6A7824, 0xD5560503, 0x0E12826A, 0x472EFF4D, 0xFF4CFE93, 0xB67083B4, 0x6D3404DD, 0x240879FA, 0xDE517CFE, 0x976D01D9, 0x4C2986B0, 0x0515FB97, 0x2E015D56, 0x673D2071, 0xBC79A718, 0xF545DA3F, 0x0F1CDF3B, 0x4620A21C, 0x9D642575, 0xD4585852, 0x6C3A598C, 0x250624AB, 0xFE42A3C2, 0xB77EDEE5, 0x4D27DBE1, 0x041BA6C6, 0xDF5F21AF, 0x96635C88, 0xAA7754E2, 0xE34B29C5, 0x380FAEAC, 0x7133D38B, 0x8B6AD68F, 0xC256ABA8, 0x19122CC1, 0x502E51E6, 0xE84C5038, 0xA1702D1F, 0x7A34AA76, 0x3308D751, 0xC951D255, 0x806DAF72, 0x5B29281B, 0x1215553C, 0x230138CF, 0x6A3D45E8, 0xB179C281, 0xF845BFA6, 0x021CBAA2, 0x4B20C785, 0x906440EC, 0xD9583DCB, 0x613A3C15, 0x28064132, 0xF342C65B, 0xBA7EBB7C, 0x4027BE78, 0x091BC35F, 0xD25F4436, 0x9B633911, 0xA777317B, 0xEE4B4C5C, 0x350FCB35, 0x7C33B612, 0x866AB316, 0xCF56CE31, 0x14124958, 0x5D2E347F, 0xE54C35A1, 0xAC704886, 0x7734CFEF, 0x3E08B2C8, 0xC451B7CC, 0x8D6DCAEB, 0x56294D82, 0x1F1530A5 }; /* * end of the CRC lookup table crc_tableil8_o88 */ //#define VERIFY_ASSERTION #ifdef VERIFY_ASSERTION // Trivial byte-by-byte version: you can switch on the assertion in the // Crc32_ComputeBuf function (by defining VERIFY_ASSERTION) to check this // against the slicing variant. static really_inline u32 crc32c(u32 running_crc, const unsigned char* p_buf, size_t length) { u32 crc = running_crc; while (length--) { crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); } return crc; } #endif // VERIFY_ASSERTION // Slicing-by-8 approach, which is much faster. Derived from Intel's // BSD-licensed code, with additions to handled aligned case automatically. static really_inline u32 crc32c_sb8_64_bit(u32 running_crc, const unsigned char* p_buf, const size_t length) { u32 crc = running_crc; // Process byte-by-byte until p_buf is aligned const unsigned char *aligned_buf = ROUNDUP_PTR(p_buf, 4); size_t init_bytes = aligned_buf - p_buf; size_t running_length = ((length - init_bytes)/8)*8; size_t end_bytes = length - init_bytes - running_length; while (p_buf < aligned_buf) { crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); } // Main aligned loop, processes eight bytes at a time. u32 term1, term2; for (size_t li = 0; li < running_length/8; li++) { u32 block = *(const u32 *)p_buf; crc ^= block; p_buf += 4; term1 = crc_tableil8_o88[crc & 0x000000FF] ^ crc_tableil8_o80[(crc >> 8) & 0x000000FF]; term2 = crc >> 16; crc = term1 ^ crc_tableil8_o72[term2 & 0x000000FF] ^ crc_tableil8_o64[(term2 >> 8) & 0x000000FF]; block = *(const u32 *)p_buf; term1 = crc_tableil8_o56[block & 0x000000FF] ^ crc_tableil8_o48[(block >> 8) & 0x000000FF]; term2 = block >> 16; crc = crc ^ term1 ^ crc_tableil8_o40[term2 & 0x000000FF] ^ crc_tableil8_o32[(term2 >> 8) & 0x000000FF]; p_buf += 4; } // Remaining bytes for(size_t li = 0; li < end_bytes; li++) { crc = crc_tableil8_o32[(crc ^ *p_buf++) & 0x000000FF] ^ (crc >> 8); } return crc; } #else // __SSE4_2__ #ifdef ARCH_64_BIT #define CRC_WORD 8 #define CRC_TYPE u64a #define CRC_FUNC _mm_crc32_u64 #else #define CRC_WORD 4 #define CRC_TYPE u32 #define CRC_FUNC _mm_crc32_u32 #endif /* * Use the crc32 instruction from SSE4.2 to compute our checksum - same * polynomial as the above function. */ static really_inline u32 crc32c_sse42(u32 running_crc, const unsigned char* p_buf, const size_t length) { u32 crc = running_crc; // Process byte-by-byte until p_buf is aligned const unsigned char *aligned_buf = ROUNDUP_PTR(p_buf, CRC_WORD); size_t init_bytes = aligned_buf - p_buf; size_t running_length = ((length - init_bytes)/CRC_WORD)*CRC_WORD; size_t end_bytes = length - init_bytes - running_length; while (p_buf < aligned_buf) { crc = _mm_crc32_u8(crc, *p_buf++); } // Main aligned loop, processes a word at a time. for (size_t li = 0; li < running_length/CRC_WORD; li++) { CRC_TYPE block = *(const CRC_TYPE *)p_buf; crc = CRC_FUNC(crc, block); p_buf += CRC_WORD; } // Remaining bytes for(size_t li = 0; li < end_bytes; li++) { crc = _mm_crc32_u8(crc, *p_buf++); } return crc; } #endif #ifdef VERIFY_ASSERTION #include #endif // Externally visible function u32 Crc32c_ComputeBuf(u32 inCrc32, const void *buf, size_t bufLen) { #ifdef __SSE4_2__ u32 crc = crc32c_sse42(inCrc32, (const unsigned char *)buf, bufLen); #else u32 crc = crc32c_sb8_64_bit(inCrc32, (const unsigned char *)buf, bufLen); #endif #ifdef VERIFY_ASSERTION assert(crc == crc32c(inCrc32, (const unsigned char *)buf, bufLen)); #endif return crc; } hyperscan-4.4.1/src/hs_internal.h0000644000175000017500000000551113055426554017547 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Internal-use only definitions. Available to internal tools. */ #ifndef HS_INTERNAL_H #define HS_INTERNAL_H #include "ue2common.h" #include "hs.h" #ifdef __cplusplus namespace ue2 { struct Grey; /** \brief Internal use only: takes a Grey argument so that we can use it in * tools. */ hs_error_t hs_compile_multi_int(const char *const *expressions, const unsigned *flags, const unsigned *ids, const hs_expr_ext *const *ext, unsigned elements, unsigned mode, const hs_platform_info_t *platform, hs_database_t **db, hs_compile_error_t **comp_error, const Grey &g); } // namespace ue2 extern "C" { #endif #define HS_MATCH_FLAG_ADJUSTED 1U /** \brief Bitmask of all valid Hyperscan flags. */ #define HS_FLAG_ALL ( HS_FLAG_CASELESS \ | HS_FLAG_DOTALL \ | HS_FLAG_MULTILINE \ | HS_FLAG_UTF8 \ | HS_FLAG_UCP \ | HS_FLAG_PREFILTER \ | HS_FLAG_SINGLEMATCH \ | HS_FLAG_ALLOWEMPTY \ | HS_FLAG_SOM_LEFTMOST) #ifdef __cplusplus } /* extern "C" */ #endif #endif hyperscan-4.4.1/src/grey.cpp0000644000175000017500000003645013055426554016550 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "grey.h" #include "ue2common.h" #include #include // exit #include #include #define DEFAULT_MAX_HISTORY 110 using namespace std; namespace ue2 { Grey::Grey(void) : optimiseComponentTree(true), performGraphSimplification(true), prefilterReductions(true), removeEdgeRedundancy(true), allowGough(true), allowHaigLit(true), allowLitHaig(true), allowLbr(true), allowMcClellan(true), allowSheng(true), allowMcSheng(true), allowPuff(true), allowLiteral(true), allowRose(true), allowViolet(true), allowExtendedNFA(true), /* bounded repeats of course */ allowLimExNFA(true), allowAnchoredAcyclic(true), allowSmallLiteralSet(true), allowCastle(true), allowDecoratedLiteral(true), allowNoodle(true), fdrAllowTeddy(true), violetAvoidSuffixes(true), violetAvoidWeakInfixes(true), violetDoubleCut(true), violetExtractStrongLiterals(true), violetLiteralChains(true), violetDoubleCutLiteralLen(3), violetEarlyCleanLiteralLen(6), puffImproveHead(true), castleExclusive(true), mergeSEP(true), /* short exhaustible passthroughs */ mergeRose(true), // roses inside rose mergeSuffixes(true), // suffix nfas inside rose mergeOutfixes(true), onlyOneOutfix(false), allowShermanStates(true), allowMcClellan8(true), highlanderPruneDFA(true), minimizeDFA(true), accelerateDFA(true), accelerateNFA(true), reverseAccelerate(true), squashNFA(true), compressNFAState(true), numberNFAStatesWrong(false), /* debugging only */ highlanderSquash(true), allowZombies(true), floodAsPuffette(false), nfaForceSize(0), maxHistoryAvailable(DEFAULT_MAX_HISTORY), minHistoryAvailable(0), /* debugging only */ maxAnchoredRegion(63), /* for rose's atable to run over */ minRoseLiteralLength(3), minRoseNetflowLiteralLength(2), maxRoseNetflowEdges(50000), /* otherwise no netflow pass. */ minExtBoundedRepeatSize(32), goughCopyPropagate(true), goughRegisterAllocate(true), shortcutLiterals(true), roseGraphReduction(true), roseRoleAliasing(true), roseMasks(true), roseMaxBadLeafLength(5), roseConvertInfBadLeaves(true), roseConvertFloodProneSuffixes(true), roseMergeRosesDuringAliasing(true), roseMultiTopRoses(true), roseHamsterMasks(true), roseLookaroundMasks(true), roseMcClellanPrefix(1), roseMcClellanSuffix(1), roseMcClellanOutfix(2), roseTransformDelay(true), roseDesiredSplit(4), earlyMcClellanPrefix(true), earlyMcClellanInfix(true), earlyMcClellanSuffix(true), allowCountingMiracles(true), allowSomChain(true), somMaxRevNfaLength(126), hamsterAccelForward(true), hamsterAccelReverse(false), miracleHistoryBonus(16), equivalenceEnable(true), allowSmallWrite(true), // McClellan dfas for small patterns allowSmallWriteSheng(false), // allow use of Sheng for SMWR smallWriteLargestBuffer(70), // largest buffer that can be // considered a small write // all blocks larger than this // are given to rose &co smallWriteLargestBufferBad(35), limitSmallWriteOutfixSize(1048576), // 1 MB smallWriteMaxPatterns(10000), smallWriteMaxLiterals(10000), allowTamarama(true), // Tamarama engine tamaChunkSize(100), dumpFlags(0), limitPatternCount(8000000), // 8M patterns limitPatternLength(16000), // 16K bytes limitGraphVertices(500000), // 500K vertices limitGraphEdges(1000000), // 1M edges limitReportCount(4*8000000), limitLiteralCount(8000000), // 8M literals limitLiteralLength(16000), limitLiteralMatcherChars(1073741824), // 1 GB limitLiteralMatcherSize(1073741824), // 1 GB limitRoseRoleCount(4*8000000), limitRoseEngineCount(8000000), // 8M engines limitRoseAnchoredSize(1073741824), // 1 GB limitEngineSize(1073741824), // 1 GB limitDFASize(1073741824), // 1 GB limitNFASize(1048576), // 1 MB limitLBRSize(1048576) // 1 MB { assert(maxAnchoredRegion < 64); /* a[lm]_log_sum have limited capacity */ } } // namespace ue2 #ifndef RELEASE_BUILD #include using boost::lexical_cast; namespace ue2 { void applyGreyOverrides(Grey *g, const string &s) { string::const_iterator p = s.begin(); string::const_iterator pe = s.end(); string help = "help:0"; bool invalid_key_seen = false; Grey defaultg; if (s == "help" || s == "help:") { printf("Valid grey overrides:\n"); p = help.begin(); pe = help.end(); } while (p != pe) { string::const_iterator ke = find(p, pe, ':'); if (ke == pe) { break; } string key(p, ke); string::const_iterator ve = find(ke, pe, ';'); unsigned int value = lexical_cast(string(ke + 1, ve)); bool done = false; /* surely there exists a nice template to go with this macro to make * all the boring code disappear */ #define G_UPDATE(k) do { \ if (key == ""#k) { g->k = value; done = 1;} \ if (key == "help") { \ printf("\t%-30s\tdefault: %s\n", #k, \ lexical_cast(defaultg.k).c_str()); \ } \ } while (0) G_UPDATE(optimiseComponentTree); G_UPDATE(performGraphSimplification); G_UPDATE(prefilterReductions); G_UPDATE(removeEdgeRedundancy); G_UPDATE(allowGough); G_UPDATE(allowHaigLit); G_UPDATE(allowLitHaig); G_UPDATE(allowLbr); G_UPDATE(allowMcClellan); G_UPDATE(allowSheng); G_UPDATE(allowMcSheng); G_UPDATE(allowPuff); G_UPDATE(allowLiteral); G_UPDATE(allowRose); G_UPDATE(allowViolet); G_UPDATE(allowExtendedNFA); G_UPDATE(allowLimExNFA); G_UPDATE(allowAnchoredAcyclic); G_UPDATE(allowSmallLiteralSet); G_UPDATE(allowCastle); G_UPDATE(allowDecoratedLiteral); G_UPDATE(allowNoodle); G_UPDATE(fdrAllowTeddy); G_UPDATE(violetAvoidSuffixes); G_UPDATE(violetAvoidWeakInfixes); G_UPDATE(violetDoubleCut); G_UPDATE(violetExtractStrongLiterals); G_UPDATE(violetLiteralChains); G_UPDATE(violetDoubleCutLiteralLen); G_UPDATE(violetEarlyCleanLiteralLen); G_UPDATE(puffImproveHead); G_UPDATE(castleExclusive); G_UPDATE(mergeSEP); G_UPDATE(mergeRose); G_UPDATE(mergeSuffixes); G_UPDATE(mergeOutfixes); G_UPDATE(onlyOneOutfix); G_UPDATE(allowShermanStates); G_UPDATE(allowMcClellan8); G_UPDATE(highlanderPruneDFA); G_UPDATE(minimizeDFA); G_UPDATE(accelerateDFA); G_UPDATE(accelerateNFA); G_UPDATE(reverseAccelerate); G_UPDATE(squashNFA); G_UPDATE(compressNFAState); G_UPDATE(numberNFAStatesWrong); G_UPDATE(allowZombies); G_UPDATE(floodAsPuffette); G_UPDATE(nfaForceSize); G_UPDATE(highlanderSquash); G_UPDATE(maxHistoryAvailable); G_UPDATE(minHistoryAvailable); G_UPDATE(maxAnchoredRegion); G_UPDATE(minRoseLiteralLength); G_UPDATE(minRoseNetflowLiteralLength); G_UPDATE(maxRoseNetflowEdges); G_UPDATE(minExtBoundedRepeatSize); G_UPDATE(goughCopyPropagate); G_UPDATE(goughRegisterAllocate); G_UPDATE(shortcutLiterals); G_UPDATE(roseGraphReduction); G_UPDATE(roseRoleAliasing); G_UPDATE(roseMasks); G_UPDATE(roseMaxBadLeafLength); G_UPDATE(roseConvertInfBadLeaves); G_UPDATE(roseConvertFloodProneSuffixes); G_UPDATE(roseMergeRosesDuringAliasing); G_UPDATE(roseMultiTopRoses); G_UPDATE(roseHamsterMasks); G_UPDATE(roseLookaroundMasks); G_UPDATE(roseMcClellanPrefix); G_UPDATE(roseMcClellanSuffix); G_UPDATE(roseMcClellanOutfix); G_UPDATE(roseTransformDelay); G_UPDATE(roseDesiredSplit); G_UPDATE(earlyMcClellanPrefix); G_UPDATE(earlyMcClellanInfix); G_UPDATE(earlyMcClellanSuffix); G_UPDATE(allowSomChain); G_UPDATE(allowCountingMiracles); G_UPDATE(somMaxRevNfaLength); G_UPDATE(hamsterAccelForward); G_UPDATE(hamsterAccelReverse); G_UPDATE(miracleHistoryBonus); G_UPDATE(equivalenceEnable); G_UPDATE(allowSmallWrite); G_UPDATE(allowSmallWriteSheng); G_UPDATE(smallWriteLargestBuffer); G_UPDATE(smallWriteLargestBufferBad); G_UPDATE(limitSmallWriteOutfixSize); G_UPDATE(smallWriteMaxPatterns); G_UPDATE(smallWriteMaxLiterals); G_UPDATE(allowTamarama); G_UPDATE(tamaChunkSize); G_UPDATE(limitPatternCount); G_UPDATE(limitPatternLength); G_UPDATE(limitGraphVertices); G_UPDATE(limitGraphEdges); G_UPDATE(limitReportCount); G_UPDATE(limitLiteralCount); G_UPDATE(limitLiteralLength); G_UPDATE(limitLiteralMatcherChars); G_UPDATE(limitLiteralMatcherSize); G_UPDATE(limitRoseRoleCount); G_UPDATE(limitRoseEngineCount); G_UPDATE(limitRoseAnchoredSize); G_UPDATE(limitEngineSize); G_UPDATE(limitDFASize); G_UPDATE(limitNFASize); G_UPDATE(limitLBRSize); #undef G_UPDATE if (key == "simple_som") { g->allowHaigLit = false; g->allowLitHaig = false; g->allowSomChain = false; g->somMaxRevNfaLength = 0; done = true; } if (key == "forceOutfixesNFA") { g->allowAnchoredAcyclic = false; g->allowCastle = false; g->allowDecoratedLiteral = false; g->allowGough = false; g->allowHaigLit = false; g->allowLbr = false; g->allowLimExNFA = true; g->allowLitHaig = false; g->allowMcClellan = false; g->allowPuff = false; g->allowLiteral = false; g->allowRose = false; g->allowViolet = false; g->allowSmallLiteralSet = false; g->roseMasks = false; done = true; } if (key == "forceOutfixesDFA") { g->allowAnchoredAcyclic = false; g->allowCastle = false; g->allowDecoratedLiteral = false; g->allowGough = false; g->allowHaigLit = false; g->allowLbr = false; g->allowLimExNFA = false; g->allowLitHaig = false; g->allowMcClellan = true; g->allowPuff = false; g->allowLiteral = false; g->allowRose = false; g->allowViolet = false; g->allowSmallLiteralSet = false; g->roseMasks = false; done = true; } if (key == "forceOutfixes") { g->allowAnchoredAcyclic = false; g->allowCastle = false; g->allowDecoratedLiteral = false; g->allowGough = true; g->allowHaigLit = false; g->allowLbr = false; g->allowLimExNFA = true; g->allowLitHaig = false; g->allowMcClellan = true; g->allowPuff = false; g->allowLiteral = false; g->allowRose = false; g->allowViolet = false; g->allowSmallLiteralSet = false; g->roseMasks = false; done = true; } if (!done && key != "help") { printf("Invalid grey override key %s:%u\n", key.c_str(), value); invalid_key_seen = true; } p = ve; if (p != pe) { ++p; } } if (invalid_key_seen) { applyGreyOverrides(g, "help"); exit(1); } assert(g->maxAnchoredRegion < 64); /* a[lm]_log_sum have limited capacity */ } } // namespace ue2 #endif hyperscan-4.4.1/src/hs_runtime.h0000644000175000017500000004314413055426554017422 0ustar sleuthkidsleuthkid/* * 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 HS_RUNTIME_H_ #define HS_RUNTIME_H_ #include /** * @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 @a 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 (*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 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 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 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 @a 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 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 @a 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 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 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 @a 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 @a 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 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); /** * 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 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 @a data and @a 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 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 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 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 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 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_RUNTIME_H_ */ hyperscan-4.4.1/src/compiler/0000755000175000017500000000000013055426554016700 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/compiler/compiler.h0000644000175000017500000001165413055426554020672 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Compiler front-end interface */ #ifndef COMPILER_H #define COMPILER_H #include "ue2common.h" #include "database.h" #include "parser/Component.h" #include "som/som.h" #include #include struct hs_database; struct hs_expr_ext; namespace ue2 { struct CompileContext; struct Grey; struct target_t; class NG; class ReportManager; class NGWrapper; /** Class gathering together the pieces of a parsed expression. * Note: Owns the provided component. */ class ParsedExpression : boost::noncopyable { public: ParsedExpression(unsigned index, const char *expression, unsigned flags, ReportID actionId, const hs_expr_ext *ext = nullptr); bool utf8; //!< UTF-8 mode flag specified /** \brief root node of parsed component tree. */ std::unique_ptr component; const bool allow_vacuous; //!< HS_FLAG_ALLOWEMPTY specified const bool highlander; //!< HS_FLAG_SINGLEMATCH specified const bool prefilter; //!< HS_FLAG_PREFILTER specified som_type som; //!< chosen SOM mode, or SOM_NONE /** \brief index in expressions array passed to \ref hs_compile_multi */ const unsigned index; const ReportID id; //!< user-specified pattern ID u64a min_offset; //!< 0 if not used u64a max_offset; //!< MAX_OFFSET if not used u64a min_length; //!< 0 if not used }; /** * Add an expression to the compiler. * * @param ng * The global NG object. * @param index * The index of the expression (used for errors) * @param expression * NULL-terminated PCRE expression * @param flags * The full set of Hyperscan flags associated with this rule. * @param ext * Struct containing extra parameters for this expression, or NULL if * none. * @param actionId * The identifier to associate with the expression; returned by engine on * match. */ void addExpression(NG &ng, unsigned index, const char *expression, unsigned flags, const hs_expr_ext *ext, ReportID actionId); /** * Build a Hyperscan database out of the expressions we've been given. A * fatal error will result in an exception being thrown. * * @param ng * The global NG object. * @param[out] length * The number of bytes occupied by the compiled structure. * @return * The compiled structure. Should be deallocated with the * hs_database_free() function. */ struct hs_database *build(NG &ng, unsigned int *length); /** * Constructs an NFA graph from the given expression tree. * * @param rm * Global ReportManager for this compile. * @param cc * Global compile context for this compile. * @param expr * ParsedExpression object. * @return * nullptr on error. */ std::unique_ptr buildWrapper(ReportManager &rm, const CompileContext &cc, const ParsedExpression &expr); /** * Build a platform_t out of a target_t. */ platform_t target_to_platform(const target_t &target_info); #if defined(DUMP_SUPPORT) || defined(DEBUG) void dumpExpression(const ParsedExpression &expr, const char *stage, const Grey &grey); #else static really_inline void dumpExpression(UNUSED const ParsedExpression &expr, UNUSED const char *stage, UNUSED const Grey &grey) { } #endif } // namespace #endif // COMPILER_H hyperscan-4.4.1/src/compiler/compiler.cpp0000644000175000017500000003674713055426554021237 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Compiler front-end interface. */ #include "allocator.h" #include "asserts.h" #include "compiler.h" #include "crc32.h" #include "database.h" #include "grey.h" #include "hs_internal.h" #include "hs_runtime.h" #include "ue2common.h" #include "nfagraph/ng_builder.h" #include "nfagraph/ng_dump.h" #include "nfagraph/ng.h" #include "nfagraph/ng_util.h" #include "parser/buildstate.h" #include "parser/dump.h" #include "parser/Component.h" #include "parser/parse_error.h" #include "parser/Parser.h" // for flags #include "parser/position.h" #include "parser/position_dump.h" #include "parser/position_info.h" #include "parser/prefilter.h" #include "parser/shortcut_literal.h" #include "parser/unsupported.h" #include "parser/utf8_validate.h" #include "rose/rose_build.h" #include "rose/rose_build_dump.h" #include "som/slot_manager_dump.h" #include "util/alloc.h" #include "util/compile_error.h" #include "util/target_info.h" #include "util/verify_types.h" #include #include #include #include #include #include #include using namespace std; namespace ue2 { static void validateExt(const hs_expr_ext &ext) { static const unsigned long long ALL_EXT_FLAGS = HS_EXT_FLAG_MIN_OFFSET | HS_EXT_FLAG_MAX_OFFSET | HS_EXT_FLAG_MIN_LENGTH; if (ext.flags & ~ALL_EXT_FLAGS) { throw CompileError("Invalid hs_expr_ext flag set."); } if ((ext.flags & HS_EXT_FLAG_MIN_OFFSET) && (ext.flags & HS_EXT_FLAG_MAX_OFFSET) && (ext.min_offset > ext.max_offset)) { throw CompileError("In hs_expr_ext, min_offset must be less than or " "equal to max_offset."); } if ((ext.flags & HS_EXT_FLAG_MIN_LENGTH) && (ext.flags & HS_EXT_FLAG_MAX_OFFSET) && (ext.min_length > ext.max_offset)) { throw CompileError("In hs_expr_ext, min_length must be less than or " "equal to max_offset."); } } ParsedExpression::ParsedExpression(unsigned index_in, const char *expression, unsigned flags, ReportID actionId, const hs_expr_ext *ext) : utf8(false), allow_vacuous(flags & HS_FLAG_ALLOWEMPTY), highlander(flags & HS_FLAG_SINGLEMATCH), prefilter(flags & HS_FLAG_PREFILTER), som(SOM_NONE), index(index_in), id(actionId), min_offset(0), max_offset(MAX_OFFSET), min_length(0) { ParseMode mode(flags); component = parse(expression, mode); utf8 = mode.utf8; /* utf8 may be set by parse() */ if (utf8 && !isValidUtf8(expression)) { throw ParseError("Expression is not valid UTF-8."); } if (!component) { assert(0); // parse() should have thrown a ParseError. throw ParseError("Parse error."); } if (flags & ~HS_FLAG_ALL) { DEBUG_PRINTF("Unrecognised flag, flags=%u.\n", flags); throw CompileError("Unrecognised flag."); } // FIXME: we disallow highlander + SOM, see UE-1850. if ((flags & HS_FLAG_SINGLEMATCH) && (flags & HS_FLAG_SOM_LEFTMOST)) { throw CompileError("HS_FLAG_SINGLEMATCH is not supported in " "combination with HS_FLAG_SOM_LEFTMOST."); } // FIXME: we disallow prefilter + SOM, see UE-1899. if ((flags & HS_FLAG_PREFILTER) && (flags & HS_FLAG_SOM_LEFTMOST)) { throw CompileError("HS_FLAG_PREFILTER is not supported in " "combination with HS_FLAG_SOM_LEFTMOST."); } // Set SOM type. if (flags & HS_FLAG_SOM_LEFTMOST) { som = SOM_LEFT; } // Set extended parameters, if we have them. if (ext) { // Ensure that the given parameters make sense. validateExt(*ext); if (ext->flags & HS_EXT_FLAG_MIN_OFFSET) { min_offset = ext->min_offset; } if (ext->flags & HS_EXT_FLAG_MAX_OFFSET) { max_offset = ext->max_offset; } if (ext->flags & HS_EXT_FLAG_MIN_LENGTH) { min_length = ext->min_length; } } // These are validated in validateExt, so an error will already have been // thrown if these conditions don't hold. assert(max_offset >= min_offset); assert(max_offset >= min_length); // Since prefiltering and SOM aren't supported together, we must squash any // min_length constraint as well. if (flags & HS_FLAG_PREFILTER && min_length) { DEBUG_PRINTF("prefiltering mode: squashing min_length constraint\n"); min_length = 0; } } #if defined(DUMP_SUPPORT) || defined(DEBUG) /** * \brief Dumps the parse tree to screen in debug mode and to disk in dump * mode. */ void dumpExpression(UNUSED const ParsedExpression &expr, UNUSED const char *stage, UNUSED const Grey &grey) { #if defined(DEBUG) DEBUG_PRINTF("===== Rule ID: %u (internalID: %u) =====\n", expr.id, expr.index); ostringstream debug_tree; dumpTree(debug_tree, expr.component.get()); printf("%s\n", debug_tree.str().c_str()); #endif // DEBUG #if defined(DUMP_SUPPORT) if (grey.dumpFlags & Grey::DUMP_PARSE) { stringstream ss; ss << grey.dumpPath << "Expr_" << expr.index << "_componenttree_" << stage << ".txt"; ofstream out(ss.str().c_str()); out << "Component Tree for " << expr.id << endl; dumpTree(out, expr.component.get()); if (expr.utf8) { out << "UTF8 mode" << endl; } } #endif // DEBUG } #endif /** \brief Run Component tree optimisations on \a expr. */ static void optimise(ParsedExpression &expr) { if (expr.min_length || expr.som) { return; } DEBUG_PRINTF("optimising\n"); expr.component->optimise(true /* root is connected to sds */); } void addExpression(NG &ng, unsigned index, const char *expression, unsigned flags, const hs_expr_ext *ext, ReportID id) { assert(expression); const CompileContext &cc = ng.cc; DEBUG_PRINTF("index=%u, id=%u, flags=%u, expr='%s'\n", index, id, flags, expression); // Ensure that our pattern isn't too long (in characters). if (strlen(expression) > cc.grey.limitPatternLength) { throw CompileError("Pattern length exceeds limit."); } // Do per-expression processing: errors here will result in an exception // being thrown up to our caller ParsedExpression expr(index, expression, flags, id, ext); dumpExpression(expr, "orig", cc.grey); // Apply prefiltering transformations if desired. if (expr.prefilter) { prefilterTree(expr.component, ParseMode(flags)); dumpExpression(expr, "prefiltered", cc.grey); } // Expressions containing zero-width assertions and other extended pcre // types aren't supported yet. This call will throw a ParseError exception // if the component tree contains such a construct. checkUnsupported(*expr.component); expr.component->checkEmbeddedStartAnchor(true); expr.component->checkEmbeddedEndAnchor(true); if (cc.grey.optimiseComponentTree) { optimise(expr); dumpExpression(expr, "opt", cc.grey); } DEBUG_PRINTF("component=%p, nfaId=%u, reportId=%u\n", expr.component.get(), expr.index, expr.id); // You can only use the SOM flags if you've also specified an SOM // precision mode. if (expr.som != SOM_NONE && cc.streaming && !ng.ssm.somPrecision()) { throw CompileError("To use a SOM expression flag in streaming mode, " "an SOM precision mode (e.g. " "HS_MODE_SOM_HORIZON_LARGE) must be specified."); } // If this expression is a literal, we can feed it directly to Rose rather // than building the NFA graph. if (shortcutLiteral(ng, expr)) { DEBUG_PRINTF("took literal short cut\n"); return; } unique_ptr g = buildWrapper(ng.rm, cc, expr); if (!g) { DEBUG_PRINTF("NFA build failed on ID %u, but no exception was " "thrown.\n", expr.id); throw CompileError("Internal error."); } if (!expr.allow_vacuous && matches_everywhere(*g)) { throw CompileError("Pattern matches empty buffer; use " "HS_FLAG_ALLOWEMPTY to enable support."); } if (!ng.addGraph(*g)) { DEBUG_PRINTF("NFA addGraph failed on ID %u.\n", expr.id); throw CompileError("Error compiling expression."); } } static aligned_unique_ptr generateRoseEngine(NG &ng) { const u32 minWidth = ng.minWidth.is_finite() ? verify_u32(ng.minWidth) : ROSE_BOUND_INF; auto rose = ng.rose->buildRose(minWidth); if (!rose) { DEBUG_PRINTF("error building rose\n"); assert(0); return nullptr; } dumpRose(*ng.rose, rose.get(), ng.cc.grey); dumpReportManager(ng.rm, ng.cc.grey); dumpSomSlotManager(ng.ssm, ng.cc.grey); dumpSmallWrite(rose.get(), ng.cc.grey); return rose; } platform_t target_to_platform(const target_t &target_info) { platform_t p; p = 0; if (!target_info.has_avx2()) { p |= HS_PLATFORM_NOAVX2; } return p; } /** \brief Encapsulate the given bytecode (RoseEngine) in a newly-allocated * \ref hs_database, ensuring that it is padded correctly to give cacheline * alignment. */ static hs_database_t *dbCreate(const char *in_bytecode, size_t len, u64a platform) { size_t db_len = sizeof(struct hs_database) + len; DEBUG_PRINTF("db size %zu\n", db_len); DEBUG_PRINTF("db platform %llx\n", platform); struct hs_database *db = (struct hs_database *)hs_database_alloc(db_len); if (hs_check_alloc(db) != HS_SUCCESS) { hs_database_free(db); return nullptr; } // So that none of our database is uninitialized memset(db, 0, db_len); // we need to align things manually size_t shift = (uintptr_t)db->bytes & 0x3f; DEBUG_PRINTF("shift is %zu\n", shift); db->bytecode = offsetof(struct hs_database, bytes) - shift; char *bytecode = (char *)db + db->bytecode; assert(ISALIGNED_CL(bytecode)); db->magic = HS_DB_MAGIC; db->version = HS_DB_VERSION; db->length = len; db->platform = platform; // Copy bytecode memcpy(bytecode, in_bytecode, len); db->crc32 = Crc32c_ComputeBuf(0, bytecode, db->length); return db; } struct hs_database *build(NG &ng, unsigned int *length) { assert(length); auto rose = generateRoseEngine(ng); if (!rose) { throw CompileError("Unable to generate bytecode."); } *length = roseSize(rose.get()); if (!*length) { DEBUG_PRINTF("RoseEngine has zero length\n"); assert(0); throw CompileError("Internal error."); } const char *bytecode = (const char *)(rose.get()); const platform_t p = target_to_platform(ng.cc.target_info); struct hs_database *db = dbCreate(bytecode, *length, p); if (!db) { throw CompileError("Could not allocate memory for bytecode."); } return db; } static void stripFromPositions(vector &v, Position pos) { auto removed = remove(v.begin(), v.end(), PositionInfo(pos)); v.erase(removed, v.end()); } static void connectInitialStates(GlushkovBuildState &bs, const ParsedExpression &expr) { vector initials = expr.component->first(); const NFABuilder &builder = bs.getBuilder(); const Position startState = builder.getStart(); const Position startDotStarState = builder.getStartDotStar(); DEBUG_PRINTF("wiring initials = %s\n", dumpPositions(initials.begin(), initials.end()).c_str()); vector starts = {startState, startDotStarState}; // strip start and startDs, which can be present due to boundaries stripFromPositions(initials, startState); stripFromPositions(initials, startDotStarState); // replace epsilons with accepts for (const auto &s : initials) { if (s.pos != GlushkovBuildState::POS_EPSILON) { continue; } assert(starts.size() == 2); /* start, startds */ vector starts_temp = starts; starts_temp[0].flags = s.flags; starts_temp[1].flags = s.flags; bs.connectAccepts(starts_temp); } if (!initials.empty()) { bs.connectRegions(starts, initials); } } static void connectFinalStates(GlushkovBuildState &bs, const ParsedExpression &expr) { vector finals = expr.component->last(); DEBUG_PRINTF("wiring finals = %s\n", dumpPositions(finals.begin(), finals.end()).c_str()); bs.connectAccepts(finals); } #ifndef NDEBUG static bool isSupported(const Component &c) { try { checkUnsupported(c); return true; } catch (ParseError &) { return false; } } #endif unique_ptr buildWrapper(ReportManager &rm, const CompileContext &cc, const ParsedExpression &expr) { assert(isSupported(*expr.component)); const unique_ptr builder = makeNFABuilder(rm, cc, expr); assert(builder); // Set up START and ACCEPT states; retrieve the special states const auto bs = makeGlushkovBuildState(*builder, expr.prefilter); // Map position IDs to characters/components expr.component->notePositions(*bs); // Wire the start dotstar state to the firsts connectInitialStates(*bs, expr); DEBUG_PRINTF("wire up body of expr\n"); // Build the rest of the FOLLOW set vector initials = {builder->getStartDotStar(), builder->getStart()}; expr.component->buildFollowSet(*bs, initials); // Wire the lasts to the accept state connectFinalStates(*bs, expr); // Create our edges bs->buildEdges(); auto g = builder->getGraph(); assert(g); dumpDotWrapper(*g, "00_before_asserts", cc.grey); removeAssertVertices(rm, *g); return g; } } // namespace ue2 hyperscan-4.4.1/src/compiler/asserts.cpp0000644000175000017500000002505413055426554021076 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Convert temporary assert vertices (from construction method) to * edge-based flags. * * This pass converts the temporary assert vertices created by the Glushkov * construction process above (vertices with special assertions flags) into * edges between those vertices' neighbours in the graph. * * These edges have the appropriate flags applied to them -- a path (u,t,v) * through an assert vertex t will be replaced with the edge (u,v) with the * assertion flags from t. * * Edges with mutually incompatible flags (such as the conjunction of * word-to-word and word-to-nonword) are dropped. */ #include "asserts.h" #include "nfagraph/ng.h" #include "nfagraph/ng_prune.h" #include "nfagraph/ng_redundancy.h" #include "nfagraph/ng_util.h" #include "parser/position.h" // for POS flags #include "util/compile_error.h" #include "util/graph_range.h" #include #include using namespace std; namespace ue2 { /** Hard limit on the maximum number of edges we'll clone before we throw up * our hands and report 'Pattern too large.' */ static const size_t MAX_ASSERT_EDGES = 300000; /** Flags representing the word-boundary assertions, \\b or \\B. */ static const int WORDBOUNDARY_FLAGS = POS_FLAG_ASSERT_WORD_TO_WORD | POS_FLAG_ASSERT_WORD_TO_NONWORD | POS_FLAG_ASSERT_NONWORD_TO_WORD | POS_FLAG_ASSERT_NONWORD_TO_NONWORD | POS_FLAG_ASSERT_WORD_TO_WORD_UCP | POS_FLAG_ASSERT_WORD_TO_NONWORD_UCP | POS_FLAG_ASSERT_NONWORD_TO_WORD_UCP | POS_FLAG_ASSERT_NONWORD_TO_NONWORD_UCP; #define OPEN_EDGE 0U #define DEAD_EDGE (~0U) static u32 disjunct(u32 flags1, u32 flags2) { /* from two asserts in parallel */ DEBUG_PRINTF("disjunct %x %x\n", flags1, flags2); u32 rv; if (flags1 == DEAD_EDGE) { rv = flags2; } else if (flags2 == DEAD_EDGE) { rv = flags1; } else if (flags1 == OPEN_EDGE || flags2 == OPEN_EDGE) { rv = OPEN_EDGE; } else { rv = flags1 | flags2; } DEBUG_PRINTF("--> %x\n", rv); return rv; } static u32 conjunct(u32 flags1, u32 flags2) { /* from two asserts in series */ DEBUG_PRINTF("conjunct %x %x\n", flags1, flags2); u32 rv; if (flags1 == OPEN_EDGE) { rv = flags2; } else if (flags2 == OPEN_EDGE) { rv = flags1; } else if (flags1 & flags2) { rv = flags1 & flags2; } else { rv = DEAD_EDGE; /* the conjunction of two different word boundary * assertion is impassable */ } DEBUG_PRINTF("--> %x\n", rv); return rv; } typedef map, NFAEdge> edge_cache_t; static void replaceAssertVertex(NGWrapper &g, NFAVertex t, edge_cache_t &edge_cache, u32 &assert_edge_count) { DEBUG_PRINTF("replacing assert vertex %zu\n", g[t].index); const u32 flags = g[t].assert_flags; DEBUG_PRINTF("consider assert vertex %zu with flags %u\n", g[t].index, flags); // Wire up all the predecessors to all the successors. for (const auto &inEdge : in_edges_range(t, g)) { NFAVertex u = source(inEdge, g); if (u == t) { continue; // ignore self-loops } const u32 flags_inc_in = conjunct(g[inEdge].assert_flags, flags); if (flags_inc_in == DEAD_EDGE) { DEBUG_PRINTF("fail, in-edge has bad flags %d\n", g[inEdge].assert_flags); continue; } for (const auto &outEdge : out_edges_range(t, g)) { NFAVertex v = target(outEdge, g); DEBUG_PRINTF("consider path [%zu,%zu,%zu]\n", g[u].index, g[t].index, g[v].index); if (v == t) { continue; // ignore self-loops } const u32 flags_final = conjunct(g[outEdge].assert_flags, flags_inc_in); if (flags_final == DEAD_EDGE) { DEBUG_PRINTF("fail, out-edge has bad flags %d\n", g[outEdge].assert_flags); continue; } if ((g[u].assert_flags & POS_FLAG_MULTILINE_START) && v == g.acceptEod) { DEBUG_PRINTF("fail, (?m)^ does not match \\n at eod\n"); continue; } /* Replace path (u,t,v) with direct edge (u,v), unless the edge * already exists, in which case we just need to edit its * properties. * * Use edge_cache to prevent us going O(N). */ auto cache_key = make_pair(u, v); auto ecit = edge_cache.find(cache_key); if (ecit == edge_cache.end()) { DEBUG_PRINTF("adding edge %zu %zu\n", g[u].index, g[v].index); NFAEdge e = add_edge(u, v, g); edge_cache.emplace(cache_key, e); g[e].assert_flags = flags; if (++assert_edge_count > MAX_ASSERT_EDGES) { throw CompileError(g.expressionIndex, "Pattern is too large."); } } else { NFAEdge e = ecit->second; DEBUG_PRINTF("updating edge %zu %zu [a %zu]\n", g[u].index, g[v].index, g[t].index); // Edge already exists. u32 &e_flags = g[e].assert_flags; e_flags = disjunct(e_flags, flags_final); assert(e_flags != DEAD_EDGE); } } } // Clear vertex t to remove all the old edges. /* no need to clear the cache, as we will never look up its edge as it is * unreachable */ clear_vertex(t, g); } static void setReportId(ReportManager &rm, NGWrapper &g, NFAVertex v, s32 adj) { // Don't try and set the report ID of a special vertex. assert(!is_special(v, g)); // There should be no reports set already. assert(g[v].reports.empty()); Report r = rm.getBasicInternalReport(g, adj); g[v].reports.insert(rm.getInternalId(r)); DEBUG_PRINTF("set report id for vertex %zu, adj %d\n", g[v].index, adj); } static void checkForMultilineStart(ReportManager &rm, NGWrapper &g) { vector dead; for (auto v : adjacent_vertices_range(g.start, g)) { if (!(g[v].assert_flags & POS_FLAG_MULTILINE_START)) { continue; } DEBUG_PRINTF("mls %zu %08x\n", g[v].index, g[v].assert_flags); /* we have found a multi-line start (maybe more than one) */ /* we need to interpose a dummy dot vertex between v and accept if * required so that ^ doesn't match trailing \n */ for (const auto &e : out_edges_range(v, g)) { if (target(e, g) == g.accept) { dead.push_back(e); } } /* assert has been resolved; clear flag */ g[v].assert_flags &= ~POS_FLAG_MULTILINE_START; } for (const auto &e : dead) { NFAVertex dummy = add_vertex(g); g[dummy].char_reach.setall(); setReportId(rm, g, dummy, -1); add_edge(source(e, g), dummy, g[e], g); add_edge(dummy, g.accept, g); } remove_edges(dead, g); } static bool hasAssertVertices(const NGHolder &g) { for (auto v : vertices_range(g)) { int flags = g[v].assert_flags; if (flags & WORDBOUNDARY_FLAGS) { return true; } } return false; } /** \brief Convert temporary assert vertices (from construction method) to * edge-based flags. * * Remove the horrors that are the temporary assert vertices which arise from * our construction method. Allows the rest of our code base to live in * blissful ignorance of their existence. */ void removeAssertVertices(ReportManager &rm, NGWrapper &g) { size_t num = 0; DEBUG_PRINTF("before: graph has %zu vertices\n", num_vertices(g)); // Sweep over the graph and ascertain that we do actually have vertices // with assertion flags set. Otherwise, we're done. if (!hasAssertVertices(g)) { DEBUG_PRINTF("no assert vertices, done\n"); return; } u32 assert_edge_count = 0; // Build a cache of (u, v) vertex pairs to edge descriptors. edge_cache_t edge_cache; for (const auto &e : edges_range(g)) { edge_cache[make_pair(source(e, g), target(e, g))] = e; } for (auto v : vertices_range(g)) { if (g[v].assert_flags & WORDBOUNDARY_FLAGS) { replaceAssertVertex(g, v, edge_cache, assert_edge_count); num++; } } checkForMultilineStart(rm, g); if (num) { DEBUG_PRINTF("resolved %zu assert vertices\n", num); pruneUseless(g); pruneEmptyVertices(g); renumber_vertices(g); renumber_edges(g); } DEBUG_PRINTF("after: graph has %zu vertices\n", num_vertices(g)); assert(!hasAssertVertices(g)); } } // namespace ue2 hyperscan-4.4.1/src/compiler/error.h0000644000175000017500000000407513055426554020210 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Compile-time error utils. */ #ifndef COMPILE_ERROR_H #define COMPILE_ERROR_H #include struct hs_compile_error; // Special errors that aren't allocated with hs_alloc/hs_free. extern const hs_compile_error hs_enomem; extern const hs_compile_error hs_einternal; namespace ue2 { class CompileError; hs_compile_error *generateCompileError(const std::string &err, int expression); hs_compile_error *generateCompileError(const CompileError &e); void freeCompileError(hs_compile_error *error); } // namespace ue2 #endif hyperscan-4.4.1/src/compiler/asserts.h0000644000175000017500000000415113055426554020536 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Convert temporary assert vertices (from construction method) to * edge-based flags. */ #ifndef ASSERTS_H #define ASSERTS_H namespace ue2 { class ReportManager; class NGWrapper; /** \brief Convert temporary assert vertices (from construction method) to * edge-based flags. * * Remove the horrors that are the temporary assert vertices which arise from * our construction method. Allows the rest of our code base to live in * blissful ignorance of their existence. */ void removeAssertVertices(ReportManager &rm, NGWrapper &g); } // namespace ue2 #endif // ASSERTS_H hyperscan-4.4.1/src/compiler/error.cpp0000644000175000017500000000724313055426554020543 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Compile-time error utils. */ #include "allocator.h" #include "error.h" #include "ue2common.h" #include "hs_compile.h" #include "util/compile_error.h" #include #include using std::string; static const char failureNoMemory[] = "Unable to allocate memory."; static const char failureInternal[] = "Internal error."; static const char failureBadAlloc[] = "Allocator returned misaligned memory."; extern const hs_compile_error_t hs_enomem = { const_cast(failureNoMemory), 0 }; extern const hs_compile_error_t hs_einternal = { const_cast(failureInternal), 0 }; extern const hs_compile_error_t hs_badalloc = { const_cast(failureBadAlloc), 0 }; namespace ue2 { hs_compile_error_t *generateCompileError(const string &err, int expression) { hs_compile_error_t *ret = (struct hs_compile_error *)hs_misc_alloc(sizeof(hs_compile_error_t)); if (ret) { hs_error_t e = hs_check_alloc(ret); if (e != HS_SUCCESS) { hs_misc_free(ret); return const_cast(&hs_badalloc); } char *msg = (char *)hs_misc_alloc(err.size() + 1); if (msg) { e = hs_check_alloc(msg); if (e != HS_SUCCESS) { hs_misc_free(msg); return const_cast(&hs_badalloc); } memcpy(msg, err.c_str(), err.size() + 1); ret->message = msg; } else { hs_misc_free(ret); ret = nullptr; } } if (!ret || !ret->message) { return const_cast(&hs_enomem); } ret->expression = expression; return ret; } hs_compile_error_t *generateCompileError(const CompileError &e) { return generateCompileError(e.reason, e.hasIndex ? (int)e.index : -1); } void freeCompileError(hs_compile_error_t *error) { if (!error) { return; } if (error == &hs_enomem || error == &hs_einternal || error == &hs_badalloc) { // These are not allocated. return; } hs_misc_free(error->message); hs_misc_free(error); } } // namespace ue2 hyperscan-4.4.1/src/hs.h0000644000175000017500000000357513055426554015663 0ustar sleuthkidsleuthkid/* * 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 HS_H_ #define HS_H_ /** * @file * @brief The complete Hyperscan API definition. * * Hyperscan is a high speed regular expression engine. * * This header includes both the Hyperscan compiler and runtime components. See * the individual component headers for documentation. */ #include "hs_compile.h" #include "hs_runtime.h" #endif /* HS_H_ */ hyperscan-4.4.1/src/nfagraph/0000755000175000017500000000000013055426554016654 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/nfagraph/ng_is_equal.cpp0000644000175000017500000001573113055426554021655 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Loose equality testing for NGHolder graphs. * * Loose equality check for holders' graph structure and vertex_index, * vertex_char_reach and (optionally reports). */ #include "ng_is_equal.h" #include "grey.h" #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/ue2_containers.h" #include #include using namespace std; namespace ue2 { namespace { struct check_report { virtual ~check_report() {} virtual bool operator()(const flat_set &reports_a, const flat_set &reports_b) const = 0; }; struct full_check_report : public check_report { bool operator()(const flat_set &reports_a, const flat_set &reports_b) const override { return reports_a == reports_b; } }; struct equiv_check_report : public check_report { equiv_check_report(ReportID a_in, ReportID b_in) : a_rep(a_in), b_rep(b_in) {} bool operator()(const flat_set &reports_a, const flat_set &reports_b) const override { return contains(reports_a, a_rep) == contains(reports_b, b_rep); } private: ReportID a_rep; ReportID b_rep; }; /** Comparison functor used to sort by vertex_index. */ template struct VertexIndexOrdering { explicit VertexIndexOrdering(const Graph &g_in) : g(g_in) {} bool operator()(typename Graph::vertex_descriptor a, typename Graph::vertex_descriptor b) const { assert(a == b || g[a].index != g[b].index); return g[a].index < g[b].index; } private: const Graph &g; }; template static VertexIndexOrdering make_index_ordering(const Graph &g) { return VertexIndexOrdering(g); } } static bool is_equal_i(const NGHolder &a, const NGHolder &b, const check_report &check_rep) { assert(hasCorrectlyNumberedVertices(a)); assert(hasCorrectlyNumberedVertices(b)); size_t num_verts = num_vertices(a); if (num_verts != num_vertices(b)) { return false; } vector vert_a; vector vert_b; vector adj_a; vector adj_b; vert_a.reserve(num_verts); vert_b.reserve(num_verts); adj_a.reserve(num_verts); adj_b.reserve(num_verts); insert(&vert_a, vert_a.end(), vertices(a)); insert(&vert_b, vert_b.end(), vertices(b)); sort(vert_a.begin(), vert_a.end(), make_index_ordering(a)); sort(vert_b.begin(), vert_b.end(), make_index_ordering(b)); for (size_t i = 0; i < vert_a.size(); i++) { NFAVertex va = vert_a[i]; NFAVertex vb = vert_b[i]; DEBUG_PRINTF("vertex %zu\n", a[va].index); // Vertex index must be the same. if (a[va].index != b[vb].index) { DEBUG_PRINTF("bad index\n"); return false; } // Reach must be the same. if (a[va].char_reach != b[vb].char_reach) { DEBUG_PRINTF("bad reach\n"); return false; } if (!check_rep(a[va].reports, b[vb].reports)) { DEBUG_PRINTF("bad reports\n"); return false; } // Other vertex properties may vary. /* Check successors */ adj_a.clear(); adj_b.clear(); insert(&adj_a, adj_a.end(), adjacent_vertices(va, a)); insert(&adj_b, adj_b.end(), adjacent_vertices(vb, b)); if (adj_a.size() != adj_b.size()) { DEBUG_PRINTF("bad adj\n"); return false; } sort(adj_a.begin(), adj_a.end(), make_index_ordering(a)); sort(adj_b.begin(), adj_b.end(), make_index_ordering(b)); for (size_t j = 0; j < adj_a.size(); j++) { if (a[adj_a[j]].index != b[adj_b[j]].index) { DEBUG_PRINTF("bad adj\n"); return false; } } } /* check top for edges out of start */ vector>> top_a; vector>> top_b; for (const auto &e : out_edges_range(a.start, a)) { top_a.emplace_back(a[target(e, a)].index, a[e].tops); } for (const auto &e : out_edges_range(b.start, b)) { top_b.emplace_back(b[target(e, b)].index, b[e].tops); } sort(top_a.begin(), top_a.end()); sort(top_b.begin(), top_b.end()); if (top_a != top_b) { DEBUG_PRINTF("bad top\n"); return false; } DEBUG_PRINTF("good\n"); return true; } /** \brief loose hash of an NGHolder; equal if is_equal would return true. */ u64a hash_holder(const NGHolder &g) { size_t rv = 0; for (auto v : vertices_range(g)) { boost::hash_combine(rv, g[v].index); boost::hash_combine(rv, g[v].char_reach); for (auto w : adjacent_vertices_range(v, g)) { boost::hash_combine(rv, g[w].index); } } return rv; } bool is_equal(const NGHolder &a, const NGHolder &b) { DEBUG_PRINTF("testing %p %p\n", &a, &b); if (&a == &b) { return true; } return is_equal_i(a, b, full_check_report()); } bool is_equal(const NGHolder &a, ReportID a_rep, const NGHolder &b, ReportID b_rep) { DEBUG_PRINTF("testing %p %p\n", &a, &b); if (&a == &b && a_rep == b_rep) { return true; } return is_equal_i(a, b, equiv_check_report(a_rep, b_rep)); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_limex.cpp0000644000175000017500000007200613055426554021167 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Limex NFA construction code. */ #include "ng_limex.h" #include "grey.h" #include "ng_equivalence.h" #include "ng_holder.h" #include "ng_misc_opt.h" #include "ng_prune.h" #include "ng_redundancy.h" #include "ng_repeat.h" #include "ng_reports.h" #include "ng_restructuring.h" #include "ng_squash.h" #include "ng_util.h" #include "ng_width.h" #include "ue2common.h" #include "nfa/limex_compile.h" #include "nfa/limex_limits.h" #include "nfa/nfa_internal.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph_range.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include "util/verify_types.h" #include #include #include #include using namespace std; using boost::adaptors::map_values; using boost::adaptors::map_keys; namespace ue2 { #ifndef NDEBUG // Some sanity checking for the graph; returns false if something is wrong. // Only used in assertions. static bool sanityCheckGraph(const NGHolder &g, const ue2::unordered_map &state_ids) { ue2::unordered_set seen_states; for (auto v : vertices_range(g)) { // Non-specials should have non-empty reachability. if (!is_special(v, g)) { if (g[v].char_reach.none()) { DEBUG_PRINTF("vertex %zu has empty reach\n", g[v].index); return false; } } // Vertices with edges to accept or acceptEod must have reports and // other vertices must not have them. if (is_match_vertex(v, g) && v != g.accept) { if (g[v].reports.empty()) { DEBUG_PRINTF("vertex %zu has no reports\n", g[v].index); return false; } } else if (!g[v].reports.empty()) { DEBUG_PRINTF("vertex %zu has reports but no accept edge\n", g[v].index); return false; } // Participant vertices should have distinct state indices. if (!contains(state_ids, v)) { DEBUG_PRINTF("vertex %zu has no state index!\n", g[v].index); return false; } u32 s = state_ids.at(v); if (s != NO_STATE && !seen_states.insert(s).second) { DEBUG_PRINTF("vertex %zu has dupe state %u\n", g[v].index, s); return false; } } return true; } #endif static void findSquashStates(const NGHolder &g, const vector &repeats, map &squashMap) { squashMap = findSquashers(g); filterSquashers(g, squashMap); /* We also filter out the cyclic states representing bounded repeats, as * they are not really cyclic -- they may turn off unexpectedly. */ for (const auto &br : repeats) { if (br.repeatMax.is_finite()) { squashMap.erase(br.cyclic); } } } /** * \brief Drop edges from start to vertices that also have an edge from * startDs. * * Note that this also includes the (start, startDs) edge, which is not * necessary for actual NFA implementation (and is actually something we don't * want to affect state numbering, etc). */ static void dropRedundantStartEdges(NGHolder &g) { remove_out_edge_if(g.start, [&](const NFAEdge &e) { return edge(g.startDs, target(e, g), g).second; }, g); // Ensure that we always remove (start, startDs), even if startDs has had // its self-loop removed as an optimization. remove_edge(g.start, g.startDs, g); } static CharReach calcTopVertexReach(const flat_set &tops, const map &top_reach) { CharReach top_cr; for (u32 t : tops) { if (contains(top_reach, t)) { top_cr |= top_reach.at(t); } else { top_cr = CharReach::dot(); break; } } return top_cr; } static NFAVertex makeTopStartVertex(NGHolder &g, const flat_set &tops, const flat_set &succs, const map &top_reach) { assert(!succs.empty()); assert(!tops.empty()); bool reporter = false; NFAVertex u = add_vertex(g[g.start], g); CharReach top_cr = calcTopVertexReach(tops, top_reach); g[u].char_reach = top_cr; for (auto v : succs) { if (v == g.accept || v == g.acceptEod) { reporter = true; } add_edge(u, v, g); } // Only retain reports (which we copied on add_vertex above) for new top // vertices connected to accepts. if (!reporter) { g[u].reports.clear(); } return u; } static void pickNextTopStateToHandle(const map> &top_succs, const map> &succ_tops, flat_set *picked_tops, flat_set *picked_succs) { /* pick top or vertex we want to handle */ if (top_succs.size() < succ_tops.size()) { auto best = top_succs.end(); for (auto it = top_succs.begin(); it != top_succs.end(); ++it) { if (best == top_succs.end() || it->second.size() < best->second.size()) { best = it; } } assert(best != top_succs.end()); assert(!best->second.empty()); /* should already been pruned */ *picked_tops = { best->first }; *picked_succs = best->second; } else { auto best = succ_tops.end(); for (auto it = succ_tops.begin(); it != succ_tops.end(); ++it) { /* have to worry about determinism for this one */ if (best == succ_tops.end() || it->second.size() < best->second.size() || (it->second.size() == best->second.size() && it->second < best->second)) { best = it; } } assert(best != succ_tops.end()); assert(!best->second.empty()); /* should already been pruned */ *picked_succs = { best->first }; *picked_tops = best->second; } } static void expandCbsByTops(const map> &unhandled_top_succs, const map> &top_succs, const map> &succ_tops, flat_set &picked_tops, flat_set &picked_succs) { NFAVertex v = *picked_succs.begin(); /* arbitrary successor - all equiv */ const auto &cand_tops = succ_tops.at(v); for (u32 t : cand_tops) { if (!contains(unhandled_top_succs, t)) { continue; } if (!has_intersection(unhandled_top_succs.at(t), picked_succs)) { continue; /* not adding any useful work that hasn't already been * done */ } if (!is_subset_of(picked_succs, top_succs.at(t))) { continue; /* will not form a cbs */ } picked_tops.insert(t); } } static void expandCbsBySuccs(const map> &unhandled_succ_tops, const map> &top_succs, const map> &succ_tops, flat_set &picked_tops, flat_set &picked_succs) { u32 t = *picked_tops.begin(); /* arbitrary top - all equiv */ const auto &cand_succs = top_succs.at(t); for (NFAVertex v : cand_succs) { if (!contains(unhandled_succ_tops, v)) { continue; } if (!has_intersection(unhandled_succ_tops.at(v), picked_tops)) { continue; /* not adding any useful work that hasn't already been * done */ } if (!is_subset_of(picked_tops, succ_tops.at(v))) { continue; /* will not form a cbs */ } picked_succs.insert(v); } } /* See if we can expand the complete bipartite subgraph (cbs) specified by the * picked tops/succs by adding more to either of the tops or succs. */ static void expandTopSuccCbs(const map> &top_succs, const map> &succ_tops, const map> &unhandled_top_succs, const map> &unhandled_succ_tops, flat_set &picked_tops, flat_set &picked_succs) { /* Note: all picked (tops|succs) are equivalent */ /* Try to expand first (as we are more likely to succeed) on the side * with fewest remaining things to be handled */ if (unhandled_top_succs.size() < unhandled_succ_tops.size()) { expandCbsByTops(unhandled_top_succs, top_succs, succ_tops, picked_tops, picked_succs); expandCbsBySuccs(unhandled_succ_tops, top_succs, succ_tops, picked_tops, picked_succs); } else { expandCbsBySuccs(unhandled_succ_tops, top_succs, succ_tops, picked_tops, picked_succs); expandCbsByTops(unhandled_top_succs, top_succs, succ_tops, picked_tops, picked_succs); } } static void markTopSuccAsHandled(NFAVertex start_v, const flat_set &handled_tops, const flat_set &handled_succs, map> &tops_out, map> &unhandled_top_succs, map> &unhandled_succ_tops) { for (u32 t : handled_tops) { tops_out[t].insert(start_v); assert(contains(unhandled_top_succs, t)); erase_all(&unhandled_top_succs[t], handled_succs); if (unhandled_top_succs[t].empty()) { unhandled_top_succs.erase(t); } } for (NFAVertex v : handled_succs) { assert(contains(unhandled_succ_tops, v)); erase_all(&unhandled_succ_tops[v], handled_tops); if (unhandled_succ_tops[v].empty()) { unhandled_succ_tops.erase(v); } } } static void attemptToUseAsStart(const NGHolder &g, NFAVertex u, const map &top_reach, map> &unhandled_top_succs, map> &unhandled_succ_tops, map> &tops_out) { flat_set top_inter = unhandled_succ_tops.at(u); flat_set succs; for (NFAVertex v : adjacent_vertices_range(u, g)) { if (!contains(unhandled_succ_tops, v)) { return; } /* if it has vacuous reports we need to make sure that the report sets * are the same */ if ((v == g.accept || v == g.acceptEod) && g[g.start].reports != g[u].reports) { DEBUG_PRINTF("different report behaviour\n"); return; } const flat_set &v_tops = unhandled_succ_tops.at(v); flat_set new_inter; auto ni_inserter = inserter(new_inter, new_inter.end()); set_intersection(top_inter.begin(), top_inter.end(), v_tops.begin(), v_tops.end(), ni_inserter); top_inter = move(new_inter); succs.insert(v); } if (top_inter.empty()) { return; } auto top_cr = calcTopVertexReach(top_inter, top_reach); if (!top_cr.isSubsetOf(g[u].char_reach)) { return; } DEBUG_PRINTF("reusing %zu is a start vertex\n", g[u].index); markTopSuccAsHandled(u, top_inter, succs, tops_out, unhandled_top_succs, unhandled_succ_tops); } /* We may have cases where a top triggers something that starts with a .* (or * similar state). In these cases we can make use of that state as a start * state. */ static void reusePredsAsStarts(const NGHolder &g, const map &top_reach, map> &unhandled_top_succs, map> &unhandled_succ_tops, map> &tops_out) { /* create list of candidates first, to avoid issues of iter invalidation */ DEBUG_PRINTF("attempting to reuse vertices for top starts\n"); vector cand_starts; for (NFAVertex u : unhandled_succ_tops | map_keys) { if (hasSelfLoop(u, g)) { cand_starts.push_back(u); } } for (NFAVertex u : cand_starts) { if (!contains(unhandled_succ_tops, u)) { continue; } attemptToUseAsStart(g, u, top_reach, unhandled_top_succs, unhandled_succ_tops, tops_out); } } static void makeTopStates(NGHolder &g, map> &tops_out, const map &top_reach) { /* Ideally, we want to add the smallest number of states to the graph for * tops to turn on so that they can accurately trigger their successors. * * The relationships between tops and their successors forms a bipartite * graph. Finding the optimal number of start states to add is equivalent to * finding a minimal biclique coverings. Unfortunately, this is known to be * NP-complete. * * Given this, we will just do something simple to avoid creating something * truly wasteful: * 1) Try to find any cyclic states which can act as their own start states * 2) Pick a top or a succ to create a start state for and then try to find * the largest complete bipartite subgraph that it is part of. */ map> top_succs; map> succ_tops; for (const auto &e : out_edges_range(g.start, g)) { NFAVertex v = target(e, g); for (u32 t : g[e].tops) { top_succs[t].insert(v); succ_tops[v].insert(t); } } auto unhandled_top_succs = top_succs; auto unhandled_succ_tops = succ_tops; reusePredsAsStarts(g, top_reach, unhandled_top_succs, unhandled_succ_tops, tops_out); /* Note: there may be successors which are equivalent (in terms of top-triggering), it may be more efficient to discover this and treat them as a unit. TODO */ while (!unhandled_succ_tops.empty()) { assert(!unhandled_top_succs.empty()); DEBUG_PRINTF("creating top start vertex\n"); flat_set u_tops; flat_set u_succs; pickNextTopStateToHandle(unhandled_top_succs, unhandled_succ_tops, &u_tops, &u_succs); expandTopSuccCbs(top_succs, succ_tops, unhandled_top_succs, unhandled_succ_tops, u_tops, u_succs); /* create start vertex to handle this top/succ combination */ NFAVertex u = makeTopStartVertex(g, u_tops, u_succs, top_reach); /* update maps */ markTopSuccAsHandled(u, u_tops, u_succs, tops_out, unhandled_top_succs, unhandled_succ_tops); } assert(unhandled_top_succs.empty()); // We are completely replacing the start vertex, so clear its reports. clear_out_edges(g.start, g); add_edge(g.start, g.startDs, g); g[g.start].reports.clear(); } static set findZombies(const NGHolder &h, const map &br_cyclic, const ue2::unordered_map &state_ids, const CompileContext &cc) { set zombies; if (!cc.grey.allowZombies) { return zombies; } // We only use zombie masks in streaming mode. if (!cc.streaming) { return zombies; } if (in_degree(h.acceptEod, h) != 1 || all_reports(h).size() != 1) { DEBUG_PRINTF("cannot be made undead - bad reports\n"); return zombies; } for (auto u : inv_adjacent_vertices_range(h.accept, h)) { assert(h[u].reports.size() == 1); for (auto v : adjacent_vertices_range(u, h)) { if (edge(v, h.accept, h).second && h[v].char_reach.all()) { if (!contains(br_cyclic, v)) { goto ok; } const BoundedRepeatSummary &sum = br_cyclic.at(v); if (u == v && sum.repeatMax.is_infinite()) { goto ok; } } } DEBUG_PRINTF("does not go to dot accept\n"); return zombies; ok:; } for (const auto &v : inv_adjacent_vertices_range(h.accept, h)) { if (state_ids.at(v) != NO_STATE) { zombies.insert(v); } } return zombies; } static void reverseStateOrdering(ue2::unordered_map &state_ids) { vector ordering; for (auto &e : state_ids) { if (e.second == NO_STATE) { continue; } ordering.push_back(e.first); } // Sort in reverse order by state ID. sort(ordering.begin(), ordering.end(), [&state_ids](NFAVertex a, NFAVertex b) { return state_ids.at(a) > state_ids.at(b); }); u32 stateNum = 0; for (const auto &v : ordering) { DEBUG_PRINTF("renumber, %u -> %u\n", state_ids.at(v), stateNum); state_ids[v] = stateNum++; } } static map findTopReach(const map>> &triggers) { map top_reach; for (const auto &m : triggers) { const auto top = m.first; CharReach cr; for (const auto &trigger : m.second) { if (trigger.empty()) { // We don't know anything about this trigger. Assume it can // have any reach. cr.setall(); break; } cr |= *trigger.rbegin(); } top_reach.emplace(top, cr); } return top_reach; } static unique_ptr prepareGraph(const NGHolder &h_in, const ReportManager *rm, const map &fixed_depth_tops, const map>> &triggers, bool impl_test_only, const CompileContext &cc, ue2::unordered_map &state_ids, vector &repeats, map> &tops) { assert(is_triggered(h_in) || fixed_depth_tops.empty()); unique_ptr h = cloneHolder(h_in); // Bounded repeat handling. analyseRepeats(*h, rm, fixed_depth_tops, triggers, &repeats, cc.streaming, impl_test_only, cc.grey); // If we're building a rose/suffix, do the top dance. flat_set topVerts; if (is_triggered(*h)) { makeTopStates(*h, tops, findTopReach(triggers)); for (const auto &vv : tops | map_values) { insert(&topVerts, vv); } } dropRedundantStartEdges(*h); // Do state numbering state_ids = numberStates(*h, topVerts); // In debugging, we sometimes like to reverse the state numbering to stress // the NFA construction code. if (cc.grey.numberNFAStatesWrong) { reverseStateOrdering(state_ids); } assert(sanityCheckGraph(*h, state_ids)); return h; } static void remapReportsToPrograms(NGHolder &h, const ReportManager &rm) { for (const auto &v : vertices_range(h)) { auto &reports = h[v].reports; if (reports.empty()) { continue; } auto old_reports = reports; reports.clear(); for (const ReportID &id : old_reports) { u32 program = rm.getProgramOffset(id); reports.insert(program); } DEBUG_PRINTF("vertex %zu: remapped reports {%s} to programs {%s}\n", h[v].index, as_string_list(old_reports).c_str(), as_string_list(reports).c_str()); } } static aligned_unique_ptr constructNFA(const NGHolder &h_in, const ReportManager *rm, const map &fixed_depth_tops, const map>> &triggers, bool compress_state, bool do_accel, bool impl_test_only, u32 hint, const CompileContext &cc) { if (!has_managed_reports(h_in)) { rm = nullptr; } else { assert(rm); } ue2::unordered_map state_ids; vector repeats; map> tops; unique_ptr h = prepareGraph(h_in, rm, fixed_depth_tops, triggers, impl_test_only, cc, state_ids, repeats, tops); // Quick exit: if we've got an embarrassment of riches, i.e. more states // than we can implement in our largest NFA model, bail here. u32 numStates = countStates(state_ids); if (numStates > NFA_MAX_STATES) { DEBUG_PRINTF("Can't build an NFA with %u states\n", numStates); return nullptr; } map br_cyclic; for (const auto &br : repeats) { br_cyclic[br.cyclic] = BoundedRepeatSummary(br.repeatMin, br.repeatMax); } map reportSquashMap; map squashMap; // build map of squashed and squashers if (cc.grey.squashNFA) { findSquashStates(*h, repeats, squashMap); if (rm && cc.grey.highlanderSquash) { reportSquashMap = findHighlanderSquashers(*h, *rm); } } set zombies = findZombies(*h, br_cyclic, state_ids, cc); if (has_managed_reports(*h)) { assert(rm); remapReportsToPrograms(*h, *rm); } if (!cc.streaming || !cc.grey.compressNFAState) { compress_state = false; } return generate(*h, state_ids, repeats, reportSquashMap, squashMap, tops, zombies, do_accel, compress_state, hint, cc); } aligned_unique_ptr constructNFA(const NGHolder &h_in, const ReportManager *rm, const map &fixed_depth_tops, const map>> &triggers, bool compress_state, const CompileContext &cc) { const u32 hint = INVALID_NFA; const bool do_accel = cc.grey.accelerateNFA; const bool impl_test_only = false; return constructNFA(h_in, rm, fixed_depth_tops, triggers, compress_state, do_accel, impl_test_only, hint, cc); } #ifndef RELEASE_BUILD // Variant that allows a hint to be specified. aligned_unique_ptr constructNFA(const NGHolder &h_in, const ReportManager *rm, const map &fixed_depth_tops, const map>> &triggers, bool compress_state, u32 hint, const CompileContext &cc) { const bool do_accel = cc.grey.accelerateNFA; const bool impl_test_only = false; return constructNFA(h_in, rm, fixed_depth_tops, triggers, compress_state, do_accel, impl_test_only, hint, cc); } #endif // RELEASE_BUILD static aligned_unique_ptr constructReversedNFA_i(const NGHolder &h_in, u32 hint, const CompileContext &cc) { // Make a mutable copy of the graph that we can renumber etc. NGHolder h; cloneHolder(h, h_in); assert(h.kind == NFA_REV_PREFIX); /* triggered, raises internal callbacks */ // Do state numbering. auto state_ids = numberStates(h, {}); // Quick exit: if we've got an embarrassment of riches, i.e. more states // than we can implement in our largest NFA model, bail here. u32 numStates = countStates(state_ids); if (numStates > NFA_MAX_STATES) { DEBUG_PRINTF("Can't build an NFA with %u states\n", numStates); return nullptr; } assert(sanityCheckGraph(h, state_ids)); map> tops; /* only the standards tops for nfas */ set zombies; vector repeats; map reportSquashMap; map squashMap; return generate(h, state_ids, repeats, reportSquashMap, squashMap, tops, zombies, false, false, hint, cc); } aligned_unique_ptr constructReversedNFA(const NGHolder &h_in, const CompileContext &cc) { u32 hint = INVALID_NFA; // no hint return constructReversedNFA_i(h_in, hint, cc); } #ifndef RELEASE_BUILD // Variant that allows a hint to be specified. aligned_unique_ptr constructReversedNFA(const NGHolder &h_in, u32 hint, const CompileContext &cc) { return constructReversedNFA_i(h_in, hint, cc); } #endif // RELEASE_BUILD u32 isImplementableNFA(const NGHolder &g, const ReportManager *rm, const CompileContext &cc) { if (!cc.grey.allowLimExNFA) { return false; } assert(!can_never_match(g)); // Quick check: we can always implement an NFA with less than NFA_MAX_STATES // states. Note that top masks can generate extra states, so we account for // those here too. if (num_vertices(g) + getTops(g).size() < NFA_MAX_STATES) { return true; } if (!has_managed_reports(g)) { rm = nullptr; } else { assert(rm); } // The BEST way to tell if an NFA is implementable is to implement it! const bool impl_test_only = true; const map fixed_depth_tops; // empty const map>> triggers; // empty /* Perform the first part of the construction process and see if the * resultant NGHolder has <= NFA_MAX_STATES. If it does, we know we can * implement it as an NFA. */ ue2::unordered_map state_ids; vector repeats; map> tops; unique_ptr h = prepareGraph(g, rm, fixed_depth_tops, triggers, impl_test_only, cc, state_ids, repeats, tops); assert(h); u32 numStates = countStates(state_ids); if (numStates <= NFA_MAX_STATES) { return numStates; } return 0; } void reduceImplementableGraph(NGHolder &g, som_type som, const ReportManager *rm, const CompileContext &cc) { NGHolder g_pristine; cloneHolder(g_pristine, g); reduceGraphEquivalences(g, cc); removeRedundancy(g, som); if (rm && has_managed_reports(g)) { pruneHighlanderDominated(g, *rm); } if (!isImplementableNFA(g, rm, cc)) { DEBUG_PRINTF("reductions made graph unimplementable, roll back\n"); clear_graph(g); cloneHolder(g, g_pristine); } } u32 countAccelStates(const NGHolder &g, const ReportManager *rm, const CompileContext &cc) { if (!has_managed_reports(g)) { rm = nullptr; } else { assert(rm); } const bool impl_test_only = true; const map fixed_depth_tops; // empty const map>> triggers; // empty ue2::unordered_map state_ids; vector repeats; map> tops; unique_ptr h = prepareGraph(g, rm, fixed_depth_tops, triggers, impl_test_only, cc, state_ids, repeats, tops); if (!h || countStates(state_ids) > NFA_MAX_STATES) { DEBUG_PRINTF("not constructible\n"); return NFA_MAX_ACCEL_STATES + 1; } assert(h->kind == g.kind); // Should have no bearing on accel calculation, so we leave these empty. const set zombies; const map reportSquashMap; const map squashMap; return countAccelStates(*h, state_ids, repeats, reportSquashMap, squashMap, tops, zombies, cc); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_width.h0000644000175000017500000000512613055426554020634 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Functions for finding the min/max width of the input required to * match a pattern. */ #ifndef NG_WIDTH_H #define NG_WIDTH_H #include "ue2common.h" #include "util/depth.h" namespace ue2 { class NGHolder; /** * \brief Compute the minimum width in bytes of an input that will match the * given graph. */ depth findMinWidth(const NGHolder &h); /** * \brief Compute the minimum width in bytes of an input that will match the * given graph, considering only paths activated by the given top. */ depth findMinWidth(const NGHolder &h, u32 top); /** * \brief Compute the maximum width in bytes of an input that will match the * given graph. * * If there is no bound on the maximum width, returns infinity. */ depth findMaxWidth(const NGHolder &h); /** * \brief Compute the maximum width in bytes of an input that will match the * given graph, considering only paths activated by the given top. * * If there is no bound on the maximum width, returns infinity. */ depth findMaxWidth(const NGHolder &h, u32 top); } // namespace ue2 #endif // NG_WIDTH_H hyperscan-4.4.1/src/nfagraph/ng_literal_analysis.cpp0000644000175000017500000006556013055426554023417 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Literal analysis and scoring. */ #include "ng_literal_analysis.h" #include "ng_holder.h" #include "ng_split.h" #include "ng_util.h" #include "ue2common.h" #include "rose/rose_common.h" #include "util/compare.h" #include "util/depth.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/ue2_graph.h" #include "util/ue2string.h" #include #include #include #include using namespace std; namespace ue2 { /** Maximum number of paths to generate. */ static const u32 MAX_WIDTH = 11; /** Scoring adjustment for 'uniqueness' in literal. */ static const u64a WEIGHT_OF_UNIQUENESS = 250; namespace { /* Small literal graph type used for the suffix tree used in * compressAndScore. */ struct LitGraphVertexProps { LitGraphVertexProps() = default; explicit LitGraphVertexProps(ue2_literal::elem c_in) : c(move(c_in)) {} ue2_literal::elem c; // string element (char + bool) size_t index; // managed by ue2_graph }; struct LitGraphEdgeProps { LitGraphEdgeProps() = default; explicit LitGraphEdgeProps(u64a score_in) : score(score_in) {} u64a score = NO_LITERAL_AT_EDGE_SCORE; size_t index; // managed by ue2_graph }; struct LitGraph : public ue2_graph { LitGraph() : root(add_vertex(*this)), sink(add_vertex(*this)) {} const vertex_descriptor root; const vertex_descriptor sink; }; typedef LitGraph::vertex_descriptor LitVertex; typedef LitGraph::edge_descriptor LitEdge; typedef pair VertexPair; typedef std::queue LitVertexQ; } // namespace #ifdef DUMP_SUPPORT /** \brief Dump the literal graph in Graphviz format. */ static UNUSED void dumpGraph(const char *filename, const LitGraph &lg) { ofstream fout(filename); fout << "digraph G {" << endl; for (auto v : vertices_range(lg)) { fout << lg[v].index; if (v == lg.root) { fout << "[label=\"ROOT\"];"; } else if (v == lg.sink) { fout << "[label=\"SINK\"];"; } else { ue2_literal s; s.push_back(lg[v].c); fout << "[label=\"" << dumpString(s) << "\"];"; } fout << endl; } for (const auto &e : edges_range(lg)) { LitVertex u = source(e, lg), v = target(e, lg); fout << lg[u].index << " -> " << lg[v].index << "[label=\"" << lg[e].score << "\"]" << ";" << endl; } fout << "}" << endl; } #endif // DUMP_SUPPORT static bool allowExpand(size_t numItems, size_t totalPathsSoFar) { if (numItems == 0) { return false; } if (numItems + totalPathsSoFar > MAX_WIDTH) { return false; } return true; } static LitVertex addToLitGraph(LitGraph &lg, LitVertex pred, const ue2_literal::elem &c) { // Check if we already have this in the graph. for (auto v : adjacent_vertices_range(pred, lg)) { if (v == lg.sink) { continue; } if (lg[v].c == c) { return v; } } LitVertex lv = add_vertex(LitGraphVertexProps(c), lg); add_edge(pred, lv, lg); return lv; } static void addToQueue(LitVertexQ &workQ, LitGraph &lg, LitVertex pred, const CharReach &cr, NFAVertex v) { for (size_t i = cr.find_first(); i != CharReach::npos; i = cr.find_next(i)) { if (myisupper(i) && cr.test(mytolower(i))) { // ignore upper half of a nocase pair continue; } bool nocase = myislower(i) && cr.test(mytoupper(i)); ue2_literal::elem c((char)i, nocase); LitVertex lv = addToLitGraph(lg, pred, c); workQ.push(VertexPair(lv, v)); } } static void initWorkQueue(LitVertexQ &workQ, LitGraph &lg, const NGHolder &g, const NFAEdge &e) { NFAVertex u = source(e, g); NFAVertex v = target(e, g); const CharReach &cr = g[v].char_reach; if (!allowExpand(cr.count(), 0)) { return; } addToQueue(workQ, lg, lg.root, cr, u); } static u32 crCardinality(const CharReach &cr) { // Special-case for handling dots, much faster than running the find_next // loop below. if (cr.all()) { return 230; // [^A-Z] } u32 rv = 0; for (size_t i = cr.find_first(); i != CharReach::npos; i = cr.find_next(i)) { if (myisupper(i) && cr.test(mytolower(i))) { // ignore upper half of a nocase pair continue; } rv++; } return rv; } /** Filter out literals that include other literals as suffixes. We do this by * identifying vertices connected to the sink and removing their other * out-edges. */ static void filterLitGraph(LitGraph &lg) { for (auto v : inv_adjacent_vertices_range(lg.sink, lg)) { remove_out_edge_if(v, [&lg](const LitEdge &e) { return target(e, lg) != lg.sink; }, lg); } // We could do a DFS-and-prune here, if we wanted. Right now, we just // handle it in extractLiterals by throwing away paths that don't run all // the way from sink to root. } /** Extracts all the literals from the given literal graph. Walks the graph * from each predecessor of the sink (note: it's a suffix tree except for this * convenience) towards the source, storing each string as we go. */ static void extractLiterals(const LitGraph &lg, set &s) { ue2_literal lit; for (auto u : inv_adjacent_vertices_range(lg.sink, lg)) { lit.clear(); while (u != lg.root) { lit.push_back(lg[u].c); assert(in_degree(u, lg) <= 1); LitGraph::inv_adjacency_iterator ai2, ae2; tie(ai2, ae2) = inv_adjacent_vertices(u, lg); if (ai2 == ae2) { // Path has been cut, time for the next literal. goto next_literal; } u = *ai2; } s.insert(lit); next_literal: ; } } #ifndef NDEBUG static bool hasSuffixLiterals(const set &s) { for (auto it = s.begin(), ite = s.end(); it != ite; ++it) { for (auto jt = std::next(it); jt != ite; ++jt) { if (isSuffix(*it, *jt) || isSuffix(*jt, *it)) { DEBUG_PRINTF("'%s' and '%s' have suffix issues\n", dumpString(*it).c_str(), dumpString(*jt).c_str()); return true; } } } return false; } #endif static void processWorkQueue(const NGHolder &g, const NFAEdge &e, set &s) { if (is_special(target(e, g), g)) { return; } LitGraph lg; LitVertexQ workQ; initWorkQueue(workQ, lg, g, e); while (!workQ.empty()) { const LitVertex lv = workQ.front().first; const NFAVertex &t = workQ.front().second; const CharReach &cr = g[t].char_reach; u32 cr_card = crCardinality(cr); size_t numItems = cr_card * in_degree(t, g); size_t committed_count = workQ.size() + in_degree(lg.sink, lg) - 1; if (g[t].index == NODE_START) { // reached start, add to literal set add_edge_if_not_present(lv, lg.sink, lg); goto next_work_elem; } // Expand next vertex if (allowExpand(numItems, committed_count)) { for (auto u : inv_adjacent_vertices_range(t, g)) { addToQueue(workQ, lg, lv, cr, u); } goto next_work_elem; } // Expand this vertex if (allowExpand(cr_card, committed_count)) { for (size_t i = cr.find_first(); i != CharReach::npos; i = cr.find_next(i)) { if (myisupper(i) && cr.test(mytolower(i))) { // ignore upper half of a nocase pair continue; } bool nocase = myislower(i) && cr.test(mytoupper(i)); ue2_literal::elem c((char)i, nocase); LitVertex lt = addToLitGraph(lg, lv, c); add_edge_if_not_present(lt, lg.sink, lg); } goto next_work_elem; } // add to literal set add_edge_if_not_present(lv, lg.sink, lg); next_work_elem: workQ.pop(); } filterLitGraph(lg); //dumpGraph("litgraph.dot", lg); extractLiterals(lg, s); // Our literal set should contain no literal that is a suffix of another. assert(!hasSuffixLiterals(s)); DEBUG_PRINTF("edge %zu (%zu->%zu) produced %zu literals\n", g[e].index, g[source(e, g)].index, g[target(e, g)].index, s.size()); } bool bad_mixed_sensitivity(const ue2_literal &s) { /* TODO: if the mixed cases is entirely within MAX_MASK2_WIDTH of the end, * we should be able to handle it */ return mixed_sensitivity(s) && s.length() > MAX_MASK2_WIDTH; } static u64a litUniqueness(const string &s) { CharReach seen(s); return seen.count(); } /** Count the significant bits of this literal (i.e. seven for nocase alpha, * eight for everything else). */ static u64a litCountBits(const ue2_literal &lit) { u64a n = 0; for (const auto &c : lit) { n += c.nocase ? 7 : 8; } return n; } /** Returns a fairly arbitrary score for the given literal, used to compare the * suitability of different candidates. */ static u64a scoreLiteral(const ue2_literal &s) { // old scoring scheme: SUM(s in S: 1/s.len()^2) // now weight (currently 75/25) with number of unique chars // in the string u64a len = litCountBits(s); u64a lenUnique = litUniqueness(s.get_string()) * 8; u64a weightedLen = (1000ULL - WEIGHT_OF_UNIQUENESS) * len + WEIGHT_OF_UNIQUENESS * lenUnique; weightedLen /= 8; DEBUG_PRINTF("scored literal '%s' %llu\n", escapeString(s.get_string()).c_str(), weightedLen); return weightedLen; } /** * calculateScore has the following properties: * - score of literal is the same as the score of the reversed literal; * - score of substring of literal is worse than the original literal's score; * - score of any literal should be non-zero. */ static u64a calculateScore(const ue2_literal &s) { if (s.empty()) { return NO_LITERAL_AT_EDGE_SCORE; } u64a weightedLen = scoreLiteral(s); DEBUG_PRINTF("len %zu, wl %llu\n", s.length(), weightedLen); u64a rv = 1000000000000000ULL/(weightedLen * weightedLen * weightedLen); if (!rv) { rv = 1; } DEBUG_PRINTF("len %zu, score %llu\n", s.length(), rv); return rv; } /** Adds a literal in reverse order, building up a suffix tree. */ static void addReversedLiteral(const ue2_literal &lit, LitGraph &lg) { DEBUG_PRINTF("literal: '%s'\n", escapeString(lit).c_str()); ue2_literal suffix; LitVertex v = lg.root; for (auto it = lit.rbegin(), ite = lit.rend(); it != ite; ++it) { suffix.push_back(*it); LitVertex w; for (auto v2 : adjacent_vertices_range(v, lg)) { if (v2 != lg.sink && lg[v2].c == *it) { w = v2; goto next_char; } } w = add_vertex(LitGraphVertexProps(*it), lg); add_edge(v, w, LitGraphEdgeProps(calculateScore(suffix)), lg); next_char: v = w; } // Wire the last vertex to the sink. add_edge(v, lg.sink, lg); } static void extractLiterals(const vector &cutset, const LitGraph &lg, set &s) { for (const auto &e : cutset) { LitVertex u = source(e, lg); LitVertex v = target(e, lg); ue2_literal lit; lit.push_back(lg[v].c); while (u != lg.root) { lit.push_back(lg[u].c); assert(in_degree(u, lg) == 1); LitGraph::inv_adjacency_iterator ai, ae; tie(ai, ae) = inv_adjacent_vertices(u, lg); if (ai == ae) { // Path has been cut, time for the next literal. goto next_literal; } u = *ai; } DEBUG_PRINTF("extracted: '%s'\n", escapeString(lit).c_str()); s.insert(lit); next_literal: ; } } #ifdef DEBUG static UNUSED const char *describeColor(boost::default_color_type c) { switch (c) { case boost::white_color: return "white"; case boost::gray_color: return "gray"; case boost::green_color: return "green"; case boost::red_color: return "red"; case boost::black_color: return "black"; default: return "unknown"; } } #endif /** * The BGL's boykov_kolmogorov_max_flow requires that all edges have their * reverse edge in the graph. This function adds them, returning a vector * mapping edge index to reverse edge. Note: LitGraph should be a DAG so there * should be no existing reverse_edges. */ static vector add_reverse_edges_and_index(LitGraph &lg) { vector fwd_edges; for (const auto &e : edges_range(lg)) { fwd_edges.push_back(e); } vector rev_map(2 * num_edges(lg)); for (const auto &e : fwd_edges) { LitVertex u = source(e, lg); LitVertex v = target(e, lg); assert(!edge(v, u, lg).second); LitEdge rev = add_edge(v, u, LitGraphEdgeProps(0), lg).first; rev_map[lg[e].index] = rev; rev_map[lg[rev].index] = e; } return rev_map; } static void findMinCut(LitGraph &lg, vector &cutset) { cutset.clear(); //dumpGraph("litgraph.dot", lg); assert(!in_degree(lg.root, lg)); assert(!out_degree(lg.sink, lg)); size_t num_real_edges = num_edges(lg); // Add reverse edges for the convenience of the BGL's max flow algorithm. vector rev_edges = add_reverse_edges_and_index(lg); const auto v_index_map = get(&LitGraphVertexProps::index, lg); const auto e_index_map = get(&LitGraphEdgeProps::index, lg); const size_t num_verts = num_vertices(lg); vector colors(num_verts); vector distances(num_verts); vector predecessors(num_verts); vector residuals(num_edges(lg)); UNUSED u64a flow = boykov_kolmogorov_max_flow(lg, get(&LitGraphEdgeProps::score, lg), make_iterator_property_map(residuals.begin(), e_index_map), make_iterator_property_map(rev_edges.begin(), e_index_map), make_iterator_property_map(predecessors.begin(), v_index_map), make_iterator_property_map(colors.begin(), v_index_map), make_iterator_property_map(distances.begin(), v_index_map), v_index_map, lg.root, lg.sink); DEBUG_PRINTF("done, flow = %llu\n", flow); /* remove reverse edges */ remove_edge_if([&](const LitEdge &e) { return lg[e].index >= num_real_edges; }, lg); vector white_cut, black_cut; u64a white_flow = 0, black_flow = 0; for (const auto &e : edges_range(lg)) { const LitVertex u = source(e, lg), v = target(e, lg); const auto ucolor = colors[lg[u].index]; const auto vcolor = colors[lg[v].index]; DEBUG_PRINTF("edge %zu:%s -> %zu:%s score %llu\n", lg[u].index, describeColor(ucolor), lg[v].index, describeColor(vcolor), lg[e].score); if (ucolor != boost::white_color && vcolor == boost::white_color) { assert(v != lg.sink); white_cut.push_back(e); white_flow += lg[e].score; } if (ucolor == boost::black_color && vcolor != boost::black_color) { assert(v != lg.sink); black_cut.push_back(e); black_flow += lg[e].score; } } DEBUG_PRINTF("white flow = %llu, black flow = %llu\n", white_flow, black_flow); assert(white_flow && black_flow); if (white_flow <= black_flow) { DEBUG_PRINTF("selected white cut\n"); cutset.swap(white_cut); } else { DEBUG_PRINTF("selected black cut\n"); cutset.swap(black_cut); } DEBUG_PRINTF("min cut has %zu edges\n", cutset.size()); assert(!cutset.empty()); } /** Takes a set of literals and derives a better one from them, returning its * score. Literals with a common suffix S will be replaced with S. (for * example, {foobar, fooobar} -> {oobar}). */ u64a compressAndScore(set &s) { if (s.empty()) { return NO_LITERAL_AT_EDGE_SCORE; } if (s.size() == 1) { return calculateScore(*s.begin()); } UNUSED u64a initialScore = scoreSet(s); DEBUG_PRINTF("begin, initial literals have score %llu\n", initialScore); LitGraph lg; for (const auto &lit : s) { addReversedLiteral(lit, lg); } DEBUG_PRINTF("suffix tree has %zu vertices and %zu edges\n", num_vertices(lg), num_edges(lg)); vector cutset; findMinCut(lg, cutset); s.clear(); extractLiterals(cutset, lg, s); u64a score = scoreSet(s); DEBUG_PRINTF("compressed score is %llu\n", score); assert(score <= initialScore); return score; } /* like compressAndScore, but replaces long mixed sensitivity literals with * something weaker. */ u64a sanitizeAndCompressAndScore(set &lits) { const size_t maxExploded = 8; // only case-explode this far /* TODO: the whole compression thing could be made better by systematically * considering replacing literal sets not just by common suffixes but also * by nocase literals. */ vector replacements; for (auto it = lits.begin(); it != lits.end();) { auto jt = it; ++it; if (!bad_mixed_sensitivity(*jt)) { continue; } /* we have to replace *jt with something... */ ue2_literal s = *jt; lits.erase(jt); vector exploded; for (auto cit = caseIterateBegin(s); cit != caseIterateEnd(); ++cit) { exploded.emplace_back(*cit, false); if (exploded.size() > maxExploded) { goto dont_explode; } } insert(&replacements, replacements.end(), exploded); continue; dont_explode: make_nocase(&s); replacements.push_back(s); } insert(&lits, replacements); return compressAndScore(lits); } u64a scoreSet(const set &s) { if (s.empty()) { return NO_LITERAL_AT_EDGE_SCORE; } u64a score = 1ULL; for (const auto &lit : s) { score += calculateScore(lit); } return score; } set getLiteralSet(const NGHolder &g, const NFAEdge &e) { set s; processWorkQueue(g, e, s); return s; } set getLiteralSet(const NGHolder &g, const NFAVertex &v, bool only_first_encounter) { set s; if (is_special(v, g)) { return s; } set ls; for (const auto &e : in_edges_range(v, g)) { if (source(e, g) == v && only_first_encounter) { continue; /* ignore self loop on root vertex as we are interested in * the first time we visit the vertex on the way to * accept. In fact, we can ignore any back edges - but * they would require a bit of effort to discover. */ } ls = getLiteralSet(g, e); if (ls.empty()) { s.clear(); return s; } else { s.insert(ls.begin(), ls.end()); } } return s; } vector scoreEdges(const NGHolder &g, const flat_set &known_bad) { assert(hasCorrectlyNumberedEdges(g)); vector scores(num_edges(g)); for (const auto &e : edges_range(g)) { u32 eidx = g[e].index; assert(eidx < scores.size()); if (contains(known_bad, e)) { scores[eidx] = NO_LITERAL_AT_EDGE_SCORE; } else { set ls = getLiteralSet(g, e); scores[eidx] = compressAndScore(ls); } } return scores; } static bool splitOffLeadingLiteral_i(const NGHolder &g, bool anch, ue2_literal *lit_out, NGHolder *rhs) { NFAVertex u; NFAVertex v; if (!anch) { DEBUG_PRINTF("looking for leading floating literal\n"); set s_succ; insert(&s_succ, adjacent_vertices(g.start, g)); set sds_succ; insert(&sds_succ, adjacent_vertices(g.startDs, g)); bool floating = is_subset_of(s_succ, sds_succ); if (!floating) { DEBUG_PRINTF("not floating\n"); return false; } sds_succ.erase(g.startDs); if (sds_succ.size() != 1) { DEBUG_PRINTF("branchy root\n"); return false; } u = g.startDs; v = *sds_succ.begin(); } else { DEBUG_PRINTF("looking for leading anchored literal\n"); if (proper_out_degree(g.startDs, g)) { DEBUG_PRINTF("not anchored\n"); return false; } set s_succ; insert(&s_succ, adjacent_vertices(g.start, g)); s_succ.erase(g.startDs); if (s_succ.size() != 1) { DEBUG_PRINTF("branchy root\n"); return false; } u = g.start; v = *s_succ.begin(); } while (true) { DEBUG_PRINTF("validating vertex %zu\n", g[v].index); assert(v != g.acceptEod && v != g.accept); const CharReach &cr = g[v].char_reach; if (cr.count() != 1 && !cr.isCaselessChar()) { break; } // Rose can only handle mixed-sensitivity literals up to the max mask // length. if (lit_out->length() >= MAX_MASK2_WIDTH) { if (mixed_sensitivity(*lit_out)) { DEBUG_PRINTF("long and mixed sensitivity\n"); break; } if (ourisalpha((char)cr.find_first())) { if (cr.isCaselessChar() != lit_out->any_nocase()) { DEBUG_PRINTF("stop at mixed sensitivity on '%c'\n", (char)cr.find_first()); break; } } } if (edge(v, g.accept, g).second || edge(v, g.acceptEod, g).second) { DEBUG_PRINTF("connection to accept\n"); break; } lit_out->push_back(cr.find_first(), cr.isCaselessChar()); u = v; if (out_degree(v, g) != 1) { DEBUG_PRINTF("out_degree != 1\n"); break; } v = *adjacent_vertices(v, g).first; if (in_degree(v, g) != 1) { DEBUG_PRINTF("blargh\n"); /* picks up cases where there is no path * to case accept (large cycles), * ensures term */ break; } } if (lit_out->empty()) { return false; } assert(u != g.startDs); ue2::unordered_map rhs_map; vector pivots; insert(&pivots, pivots.end(), adjacent_vertices(u, g)); splitRHS(g, pivots, rhs, &rhs_map); DEBUG_PRINTF("literal is '%s' (len %zu)\n", dumpString(*lit_out).c_str(), lit_out->length()); assert(is_triggered(*rhs)); return true; } bool splitOffLeadingLiteral(const NGHolder &g, ue2_literal *lit_out, NGHolder *rhs) { return splitOffLeadingLiteral_i(g, false, lit_out, rhs); } bool splitOffAnchoredLeadingLiteral(const NGHolder &g, ue2_literal *lit_out, NGHolder *rhs) { return splitOffLeadingLiteral_i(g, true, lit_out, rhs); } bool getTrailingLiteral(const NGHolder &g, ue2_literal *lit_out) { if (in_degree(g.acceptEod, g) != 1) { return false; } NFAVertex v = getSoleSourceVertex(g, g.accept); if (!v) { return false; } set s = getLiteralSet(g, v, false); if (s.size() != 1) { return false; } const ue2_literal &lit = *s.begin(); if (lit.length() > MAX_MASK2_WIDTH && mixed_sensitivity(lit)) { DEBUG_PRINTF("long & mixed-sensitivity, Rose can't handle this.\n"); return false; } *lit_out = lit; return true; } bool literalIsWholeGraph(const NGHolder &g, const ue2_literal &lit) { NFAVertex v = g.accept; for (auto it = lit.rbegin(), ite = lit.rend(); it != ite; ++it) { NGHolder::inv_adjacency_iterator ai, ae; tie(ai, ae) = inv_adjacent_vertices(v, g); if (ai == ae) { assert(0); // no predecessors? return false; } v = *ai++; if (ai != ae) { DEBUG_PRINTF("branch, fail\n"); return false; } if (is_special(v, g)) { DEBUG_PRINTF("special found, fail\n"); return false; } const CharReach &cr_g = g[v].char_reach; const CharReach &cr_l = *it; if (!cr_l.isSubsetOf(cr_g)) { /* running over the prefix is needed to prevent false postives */ DEBUG_PRINTF("reach fail\n"); return false; } } // Our last value for v should have only start states for predecessors. for (auto u : inv_adjacent_vertices_range(v, g)) { if (!is_any_start(u, g)) { DEBUG_PRINTF("pred is not start\n"); return false; } } assert(num_vertices(g) == lit.length() + N_SPECIALS); DEBUG_PRINTF("ok\n"); return true; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_restructuring.h0000644000175000017500000000441413055426554022434 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief State numbering and late graph restructuring code. */ #ifndef NG_RESTRUCTURING_H #define NG_RESTRUCTURING_H #include "ng_holder.h" #include "ue2common.h" #include "util/ue2_containers.h" namespace ue2 { /** * \brief Special state index value meaning that the vertex will not * participate in an (NFA/DFA/etc) implementation. */ static constexpr u32 NO_STATE = ~0; /** * \brief Gives each participating vertex in the graph a unique state index. */ unordered_map numberStates(NGHolder &h, const flat_set &tops); /** * \brief Counts the number of states (vertices with state indices) in the * graph. */ u32 countStates(const unordered_map &state_ids); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_depth.cpp0000644000175000017500000003204113055426554021150 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA graph vertex depth calculations. */ #include "ng_depth.h" #include "ng_util.h" #include "ue2common.h" #include "util/graph_range.h" #include #include #include #include #include #include #include #include #include #include using namespace std; using boost::filtered_graph; using boost::make_filtered_graph; using boost::make_constant_property; using boost::reverse_graph; using boost::adaptors::reverse; namespace ue2 { namespace { /** Distance value used to indicate that the vertex can't be reached. */ static constexpr int DIST_UNREACHABLE = INT_MAX; /** * Distance value used to indicate that the distance to a vertex is infinite * (for example, it's the max distance and there's a cycle in the path) or so * large that we should consider it effectively infinite. */ static constexpr int DIST_INFINITY = INT_MAX - 1; // // Filters // template struct NodeFilter { typedef typename GraphT::edge_descriptor EdgeT; NodeFilter() {} // BGL filters must be default-constructible. NodeFilter(const vector *bad_in, const GraphT *g_in) : bad(bad_in), g(g_in) { } bool operator()(const EdgeT &e) const { assert(g && bad); u32 src_idx = (*g)[source(e, *g)].index; u32 tar_idx = (*g)[target(e, *g)].index; if (tar_idx == NODE_START_DOTSTAR) { return false; } return !(*bad)[src_idx] && !(*bad)[tar_idx]; } private: const vector *bad = nullptr; const GraphT *g = nullptr; }; template struct StartFilter { typedef typename GraphT::edge_descriptor EdgeT; StartFilter() {} // BGL filters must be default-constructible. explicit StartFilter(const GraphT *g_in) : g(g_in) { } bool operator()(const EdgeT &e) const { assert(g); u32 src_idx = (*g)[source(e, *g)].index; u32 tar_idx = (*g)[target(e, *g)].index; // Remove our stylised edges from anchored start to startDs. if (src_idx == NODE_START && tar_idx == NODE_START_DOTSTAR) { return false; } // Also remove the equivalent in the reversed direction. if (src_idx == NODE_ACCEPT_EOD && tar_idx == NODE_ACCEPT) { return false; } return true; } private: const GraphT *g = nullptr; }; } // namespace template static void findLoopReachable(const GraphT &g, const typename GraphT::vertex_descriptor srcVertex, vector &deadNodes) { typedef typename GraphT::edge_descriptor EdgeT; typedef typename GraphT::vertex_descriptor VertexT; typedef set EdgeSet; EdgeSet deadEdges; BackEdges be(deadEdges); depth_first_search(g, visitor(be).root_vertex(srcVertex)); auto af = make_bad_edge_filter(&deadEdges); auto acyclic_g = make_filtered_graph(g, af); vector topoOrder; /* actually reverse topological order */ topoOrder.reserve(deadNodes.size()); topological_sort(acyclic_g, back_inserter(topoOrder)); for (const auto &e : deadEdges) { u32 srcIdx = g[source(e, g)].index; if (srcIdx != NODE_START_DOTSTAR) { deadNodes[srcIdx] = true; } } for (VertexT v : reverse(topoOrder)) { for (const auto &e : in_edges_range(v, g)) { if (deadNodes[g[source(e, g)].index]) { deadNodes[g[v].index] = true; break; } } } } template static void calcDepthFromSource(const GraphT &g, typename GraphT::vertex_descriptor srcVertex, const vector &deadNodes, vector &dMin, vector &dMax) { typedef typename GraphT::edge_descriptor EdgeT; const size_t numVerts = num_vertices(g); NodeFilter nf(&deadNodes, &g); StartFilter sf(&g); /* minimum distance needs to run on a graph with .*start unreachable * from start */ typedef filtered_graph > StartFilteredGraph; const StartFilteredGraph mindist_g(g, sf); /* maximum distance needs to run on a graph without cycles & nodes * reachable from cycles */ typedef filtered_graph > NodeFilteredGraph; const NodeFilteredGraph maxdist_g(g, nf); // Record distance of each vertex from source using one of the following // algorithms. /* note: filtered graphs have same num_{vertices,edges} as base */ dMin.assign(numVerts, DIST_UNREACHABLE); dMax.assign(numVerts, DIST_UNREACHABLE); dMin[mindist_g[srcVertex].index] = 0; using boost::make_iterator_property_map; auto min_index_map = get(vertex_index, mindist_g); breadth_first_search(mindist_g, srcVertex, visitor(make_bfs_visitor(record_distances( make_iterator_property_map(dMin.begin(), min_index_map), boost::on_tree_edge())))); auto max_index_map = get(vertex_index, maxdist_g); dag_shortest_paths(maxdist_g, srcVertex, distance_map(make_iterator_property_map(dMax.begin(), max_index_map)) .weight_map(make_constant_property(-1))); for (size_t i = 0; i < numVerts; i++) { if (dMin[i] > DIST_UNREACHABLE) { dMin[i] = DIST_UNREACHABLE; } DEBUG_PRINTF("%zu: dm %d %d\n", i, dMin[i], dMax[i]); if (dMax[i] >= DIST_UNREACHABLE && dMin[i] < DIST_UNREACHABLE) { dMax[i] = -DIST_INFINITY; /* max depths currently negative */ DEBUG_PRINTF("bumping max to %d\n", dMax[i]); } else if (dMax[i] >= DIST_UNREACHABLE || dMax[i] < -DIST_UNREACHABLE) { dMax[i] = -DIST_UNREACHABLE; DEBUG_PRINTF("bumping max to %d\n", dMax[i]); } } } /** * \brief Convert the integer distance we use in our shortest path calculations * to a \ref depth value. */ static depth depthFromDistance(int val) { assert(val >= 0); if (val >= DIST_UNREACHABLE) { return depth::unreachable(); } else if (val == DIST_INFINITY) { return depth::infinity(); } return depth((u32)val); } static DepthMinMax getDepths(u32 idx, const vector &dMin, const vector &dMax) { DepthMinMax d(depthFromDistance(dMin[idx]), depthFromDistance(-1 * dMax[idx])); DEBUG_PRINTF("idx=%u, depths=%s\n", idx, d.str().c_str()); assert(d.min <= d.max); return d; } template static void calcAndStoreDepth(const Graph &g, const typename Graph::vertex_descriptor src, const vector &deadNodes, vector &dMin /* util */, vector &dMax /* util */, vector &depths, DepthMinMax Output::*store) { calcDepthFromSource(g, src, deadNodes, dMin, dMax); for (auto v : vertices_range(g)) { u32 idx = g[v].index; assert(idx < depths.size()); Output &d = depths.at(idx); d.*store = getDepths(idx, dMin, dMax); } } void calcDepths(const NGHolder &g, std::vector &depths) { assert(hasCorrectlyNumberedVertices(g)); const size_t numVertices = num_vertices(g); depths.clear(); depths.resize(numVertices); vector dMin; vector dMax; /* * create a filtered graph for max depth calculations: all nodes/edges * reachable from a loop need to be removed */ vector deadNodes(numVertices); findLoopReachable(g, g.start, deadNodes); DEBUG_PRINTF("doing start\n"); calcAndStoreDepth(g, g.start, deadNodes, dMin, dMax, depths, &NFAVertexDepth::fromStart); DEBUG_PRINTF("doing startds\n"); calcAndStoreDepth(g, g.startDs, deadNodes, dMin, dMax, depths, &NFAVertexDepth::fromStartDotStar); } void calcDepths(const NGHolder &g, std::vector &depths) { assert(hasCorrectlyNumberedVertices(g)); const size_t numVertices = num_vertices(g); depths.clear(); depths.resize(numVertices); vector dMin; vector dMax; /* reverse the graph before walking it */ typedef reverse_graph RevNFAGraph; const RevNFAGraph rg(g); assert(num_vertices(g) == num_vertices(rg)); /* * create a filtered graph for max depth calculations: all nodes/edges * reachable from a loop need to be removed */ vector deadNodes(numVertices); findLoopReachable(rg, g.acceptEod, deadNodes); DEBUG_PRINTF("doing accept\n"); calcAndStoreDepth( rg, g.accept, deadNodes, dMin, dMax, depths, &NFAVertexRevDepth::toAccept); DEBUG_PRINTF("doing accepteod\n"); deadNodes[NODE_ACCEPT] = true; // Hide accept->acceptEod edge. calcAndStoreDepth( rg, g.acceptEod, deadNodes, dMin, dMax, depths, &NFAVertexRevDepth::toAcceptEod); } void calcDepths(const NGHolder &g, vector &depths) { assert(hasCorrectlyNumberedVertices(g)); const size_t numVertices = num_vertices(g); depths.clear(); depths.resize(numVertices); vector dMin; vector dMax; /* * create a filtered graph for max depth calculations: all nodes/edges * reachable from a loop need to be removed */ vector deadNodes(numVertices); findLoopReachable(g, g.start, deadNodes); DEBUG_PRINTF("doing start\n"); calcAndStoreDepth( g, g.start, deadNodes, dMin, dMax, depths, &NFAVertexBidiDepth::fromStart); DEBUG_PRINTF("doing startds\n"); calcAndStoreDepth( g, g.startDs, deadNodes, dMin, dMax, depths, &NFAVertexBidiDepth::fromStartDotStar); /* Now go backwards */ typedef reverse_graph RevNFAGraph; const RevNFAGraph rg(g); deadNodes.assign(numVertices, false); findLoopReachable(rg, g.acceptEod, deadNodes); DEBUG_PRINTF("doing accept\n"); calcAndStoreDepth( rg, g.accept, deadNodes, dMin, dMax, depths, &NFAVertexBidiDepth::toAccept); DEBUG_PRINTF("doing accepteod\n"); deadNodes[NODE_ACCEPT] = true; // Hide accept->acceptEod edge. calcAndStoreDepth( rg, g.acceptEod, deadNodes, dMin, dMax, depths, &NFAVertexBidiDepth::toAcceptEod); } void calcDepthsFrom(const NGHolder &g, const NFAVertex src, vector &depths) { assert(hasCorrectlyNumberedVertices(g)); const size_t numVertices = num_vertices(g); vector deadNodes(numVertices); findLoopReachable(g, g.start, deadNodes); vector dMin, dMax; calcDepthFromSource(g, src, deadNodes, dMin, dMax); depths.clear(); depths.resize(numVertices); for (auto v : vertices_range(g)) { u32 idx = g[v].index; depths.at(idx) = getDepths(idx, dMin, dMax); } } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_puff.h0000644000175000017500000000431713055426554020456 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Puff construction from NGHolder. */ #ifndef NG_PUFF_H #define NG_PUFF_H namespace ue2 { struct CompileContext; struct Grey; class RoseBuild; class NGHolder; class ReportManager; /** \brief Split off portions of the graph that are implementable as Puff * engines. Returns true if the entire graph is consumed. */ bool splitOffPuffs(RoseBuild &rose, ReportManager &rm, NGHolder &g, bool prefilter, const CompileContext &cc); /** \brief True if the entire graph in \a g could be constructed as a Puff * engine. */ bool isPuffable(const NGHolder &g, bool fixed_depth, const ReportManager &rm, const Grey &grey); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_dominators.cpp0000644000175000017500000000720513055426554022227 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Calculate dominator and post-dominator trees. * * A small wrapper around the BGL's lengauer_tarjan_dominator_tree algorithm. */ #include "ng_dominators.h" #include "ue2common.h" #include "ng_holder.h" #include "ng_util.h" #include "util/ue2_containers.h" #include // locally patched version #include using namespace std; using boost::make_assoc_property_map; using boost::make_iterator_property_map; namespace ue2 { template unordered_map calcDominators(const Graph &g, typename Graph::vertex_descriptor source) { using Vertex = typename Graph::vertex_descriptor; const size_t num_verts = num_vertices(g); auto index_map = get(&NFAGraphVertexProps::index, g); vector dfnum(num_verts, 0); vector parents(num_verts, Graph::null_vertex()); auto dfnum_map = make_iterator_property_map(dfnum.begin(), index_map); auto parent_map = make_iterator_property_map(parents.begin(), index_map); vector vertices_by_dfnum(num_verts, Graph::null_vertex()); // Output map. unordered_map doms; auto dom_map = make_assoc_property_map(doms); boost_ue2::lengauer_tarjan_dominator_tree(g, source, index_map, dfnum_map, parent_map, vertices_by_dfnum, dom_map); /* Translate back to an NFAVertex map */ unordered_map doms2; for (const auto &e : doms) { NFAVertex f(e.first); NFAVertex s(e.second); doms2[f] = s; } return doms2; } unordered_map findDominators(const NGHolder &g) { assert(hasCorrectlyNumberedVertices(g)); return calcDominators(g, g.start); } unordered_map findPostDominators(const NGHolder &g) { assert(hasCorrectlyNumberedVertices(g)); return calcDominators(boost::reverse_graph(g), g.acceptEod); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_holder.cpp0000644000175000017500000000642613055426554021331 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" using namespace std; namespace ue2 { // internal use only static NFAVertex addSpecialVertex(NGHolder &g, SpecialNodes id) { NFAVertex v(add_vertex(g)); g[v].index = id; return v; } NGHolder::NGHolder(nfa_kind k) : kind (k), // add initial special nodes start(addSpecialVertex(*this, NODE_START)), startDs(addSpecialVertex(*this, NODE_START_DOTSTAR)), accept(addSpecialVertex(*this, NODE_ACCEPT)), acceptEod(addSpecialVertex(*this, NODE_ACCEPT_EOD)) { // wire up some fake edges for the stylized bits of the NFA add_edge(start, startDs, *this); add_edge(startDs, startDs, *this); add_edge(accept, acceptEod, *this); (*this)[start].char_reach.setall(); (*this)[startDs].char_reach.setall(); } NGHolder::~NGHolder(void) { DEBUG_PRINTF("destroying holder @ %p\n", this); } void clear_graph(NGHolder &h) { NGHolder::vertex_iterator vi, ve; for (tie(vi, ve) = vertices(h); vi != ve;) { NFAVertex v = *vi; ++vi; clear_vertex(v, h); if (!is_special(v, h)) { remove_vertex(v, h); } } assert(num_vertices(h) == N_SPECIALS); renumber_vertices(h); /* ensure that we reset our next allocated index */ renumber_edges(h); // Recreate special stylised edges. add_edge(h.start, h.startDs, h); add_edge(h.startDs, h.startDs, h); add_edge(h.accept, h.acceptEod, h); } NFAVertex NGHolder::getSpecialVertex(u32 id) const { switch (id) { case NODE_START: return start; case NODE_START_DOTSTAR: return startDs; case NODE_ACCEPT: return accept; case NODE_ACCEPT_EOD: return acceptEod; default: return null_vertex(); } } } hyperscan-4.4.1/src/nfagraph/ng_expr_info.h0000644000175000017500000000361513055426554021507 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Code for discovering properties of an NGWrapper used by * hs_expression_info. */ #ifndef NG_EXPR_INFO_H #define NG_EXPR_INFO_H struct hs_expr_info; #include "ue2common.h" namespace ue2 { class NGWrapper; class ReportManager; void fillExpressionInfo(ReportManager &rm, NGWrapper &w, hs_expr_info *info); } // namespace ue2 #endif // NG_EXPR_INFO_H hyperscan-4.4.1/src/nfagraph/ng_squash.h0000644000175000017500000000527613055426554021027 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief NFA graph state squashing analysis. */ #ifndef NG_SQUASH_H #define NG_SQUASH_H #include "ng_holder.h" #include "som/som.h" #include "ue2common.h" #include "util/ue2_containers.h" #include #include namespace ue2 { class NGHolder; class ReportManager; /** Dynamically-sized bitset, as an NFA can have an arbitrary number of states. */ typedef boost::dynamic_bitset<> NFAStateSet; /** * Populates the squash mask for each vertex (i.e. the set of states to be left * on during squashing). * * The NFAStateSet in the output map is indexed by vertex_index. */ std::map findSquashers(const NGHolder &g, som_type som = SOM_NONE); /** Filters out squash states intended only for use in DFA construction. */ void filterSquashers(const NGHolder &g, std::map &squash); /** Populates squash masks for states that can be switched off by highlander * (single match) reporters. */ std::map findHighlanderSquashers(const NGHolder &g, const ReportManager &rm); } // namespace ue2 #endif // NG_SQUASH_H hyperscan-4.4.1/src/nfagraph/ng_is_equal.h0000644000175000017500000000465413055426554021324 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Loose equality testing for NGHolder graphs. * * Loose equality check for holders' graph structure and vertex_index, * vertex_char_reach and (optionally reports). */ #ifndef NG_IS_EQUAL_H #define NG_IS_EQUAL_H #include "ue2common.h" #include #include namespace ue2 { class NGHolder; bool is_equal(const NGHolder &a, const NGHolder &b); bool is_equal(const NGHolder &a, ReportID a_r, const NGHolder &b, ReportID b_r); u64a hash_holder(const NGHolder &g); // Util Functors struct NGHolderHasher { size_t operator()(const std::shared_ptr &h) const { return hash_holder(*h); } }; struct NGHolderEqual { bool operator()(const std::shared_ptr &a, const std::shared_ptr &b) const { return is_equal(*a, *b); } }; } // namespace ue2 #endif // NG_IS_EQUAL_H hyperscan-4.4.1/src/nfagraph/ng_misc_opt.h0000644000175000017500000000637113055426554021335 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Miscellaneous optimisations. */ #ifndef NG_MISC_OPT_H #define NG_MISC_OPT_H #include #include #include "ng_holder.h" #include "som/som.h" #include "util/depth.h" namespace ue2 { /** Small structure describing the bounds on a repeat. */ struct BoundedRepeatSummary { BoundedRepeatSummary(void) : repeatMin(0), repeatMax(depth::infinity()) {} BoundedRepeatSummary(const depth &min_in, const depth &max_in) : repeatMin(min_in), repeatMax(max_in) { assert(repeatMin <= repeatMax); assert(repeatMax.is_reachable()); } bool unbounded(void) const { return repeatMax.is_infinite(); } depth repeatMin; //!< minimum repeat bound. depth repeatMax; //!< maximum repeat bound. }; /* returns true if anything changed */ bool improveGraph(NGHolder &g, som_type som); /** Sometimes the reach of a vertex is greater than it needs to be to reduce * stop chars for the benefit of the rest of our code base (accel, etc). In * these circumstances, we can treat the reach as the smaller one as * the graphs are equivalent. */ CharReach reduced_cr(NFAVertex v, const NGHolder &g, const std::map &br_cyclic); std::vector reduced_cr(const NGHolder &g, const std::map &br_cyclic); /** Remove cyclic stars connected to start */ bool mergeCyclicDotStars(NGHolder &g); /** * Given a cyclic state 'c' with a broad reach and a later state 'v' that is * only reachable if c is still on, then any edges to a successor of a direct * successor of c with reach a superset of v are redundant. */ bool prunePathsRedundantWithSuccessorOfCyclics(NGHolder &h, som_type som); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_som.h0000644000175000017500000000546713055426554020323 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief SOM ("Start of Match") analysis. */ #ifndef NG_SOM_H #define NG_SOM_H #include "som/som.h" namespace ue2 { class NG; class NGHolder; class NGWrapper; struct Grey; enum sombe_rv { SOMBE_FAIL, SOMBE_HANDLED_INTERNAL, SOMBE_HANDLED_ALL }; /** \brief Perform SOM analysis on the given graph. * * This function will replace report IDs and mutate the graph, then return * SOMBE_HANDLED_INTERNAL if SOM can be established and the full graph still * needs to be handled (rose, etc). * * Returns SOMBE_HANDLED_ALL if everything has been done and the pattern has * been handled in all its glory. * * Returns SOMBE_FAIL and does not mutate the graph if SOM cannot be * established. * * May throw a "Pattern too large" exception if prefixes of the * pattern are too large to compile. */ sombe_rv doSom(NG &ng, NGHolder &h, const NGWrapper &w, u32 comp_id, som_type som); /** Returns SOMBE_FAIL (and the original graph) if SOM cannot be established. * May also throw pattern too large if prefixes of the pattern are too large to * compile. */ sombe_rv doSomWithHaig(NG &ng, NGHolder &h, const NGWrapper &w, u32 comp_id, som_type som); void makeReportsSomPass(ReportManager &rm, NGHolder &g); } // namespace ue2 #endif // NG_SOM_H hyperscan-4.4.1/src/nfagraph/ng_anchored_acyclic.cpp0000644000175000017500000000453213055426554023322 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Anchored acyclic graph -> DFA analysis. */ #include "ng_anchored_acyclic.h" #include "ng_holder.h" #include "ng_reports.h" #include "ng_util.h" #include "ue2common.h" #include "rose/rose_build.h" #include "util/compile_context.h" namespace ue2 { bool splitOffAnchoredAcyclic(RoseBuild &rose, const NGHolder &h, const CompileContext &cc) { if (!cc.grey.allowAnchoredAcyclic) { return false; } if (!isAnchored(h)) { DEBUG_PRINTF("fail, not anchored\n"); return false; } if (!isAcyclic(h)) { DEBUG_PRINTF("fail, not acyclic\n"); return false; } if (rose.addAnchoredAcyclic(h)) { return true; } else { DEBUG_PRINTF("failed to add anchored nfa\n"); return false; } } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_uncalc_components.cpp0000644000175000017500000004642413055426554023570 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA graph merging ("uncalc") * * The file contains our collection of NFA graph merging strategies. * * NFAGraph merging is generally guided by the length of the common prefix * between NFAGraph pairs. */ #include "grey.h" #include "ng_holder.h" #include "ng_limex.h" #include "ng_redundancy.h" #include "ng_region.h" #include "ng_uncalc_components.h" #include "ng_util.h" #include "ue2common.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph_range.h" #include "util/ue2string.h" #include #include #include #include #include #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { static const u32 FAST_STATE_LIMIT = 256; /**< largest possible desirable NFA */ /** Sentinel value meaning no component has yet been selected. */ static const u32 NO_COMPONENT = ~0U; static const u32 UNUSED_STATE = ~0U; namespace { struct ranking_info { explicit ranking_info(const NGHolder &h) : to_vertex(getTopoOrdering(h)) { u32 rank = 0; reverse(to_vertex.begin(), to_vertex.end()); for (NFAVertex v : to_vertex) { to_rank[v] = rank++; } for (NFAVertex v : vertices_range(h)) { if (!contains(to_rank, v)) { to_rank[v] = UNUSED_STATE; } } } NFAVertex at(u32 ranking) const { return to_vertex.at(ranking); } u32 get(NFAVertex v) const { return to_rank.at(v); } u32 size() const { return (u32)to_vertex.size(); } u32 add_to_tail(NFAVertex v) { u32 rank = size(); to_rank[v] = rank; to_vertex.push_back(v); return rank; } private: vector to_vertex; unordered_map to_rank; }; } static never_inline bool cplVerticesMatch(const NGHolder &ga, NFAVertex va, const NGHolder &gb, NFAVertex vb) { // Must have the same reachability. if (ga[va].char_reach != gb[vb].char_reach) { return false; } // If they're start vertices, they must be the same one. if (is_any_start(va, ga) || is_any_start(vb, gb)) { if (ga[va].index != gb[vb].index) { return false; } } bool va_accept = edge(va, ga.accept, ga).second; bool vb_accept = edge(vb, gb.accept, gb).second; bool va_acceptEod = edge(va, ga.acceptEod, ga).second; bool vb_acceptEod = edge(vb, gb.acceptEod, gb).second; // Must have the same accept/acceptEod edges. if (va_accept != vb_accept || va_acceptEod != vb_acceptEod) { return false; } return true; } static never_inline u32 cplCommonReachAndSimple(const NGHolder &ga, const ranking_info &a_ranking, const NGHolder &gb, const ranking_info &b_ranking) { u32 ml = min(a_ranking.size(), b_ranking.size()); if (ml > 65535) { ml = 65535; } // Count the number of common vertices which share reachability, report and // "startedness" properties. u32 max = 0; for (; max < ml; max++) { if (!cplVerticesMatch(ga, a_ranking.at(max), gb, b_ranking.at(max))) { break; } } return max; } static u32 commonPrefixLength(const NGHolder &ga, const ranking_info &a_ranking, const NGHolder &gb, const ranking_info &b_ranking) { /* upper bound on the common region based on local properties */ u32 max = cplCommonReachAndSimple(ga, a_ranking, gb, b_ranking); DEBUG_PRINTF("cpl upper bound %u\n", max); while (max > 0) { /* shrink max region based on in-edges from outside the region */ for (size_t j = max; j > 0; j--) { NFAVertex a_v = a_ranking.at(j - 1); NFAVertex b_v = b_ranking.at(j - 1); for (auto u : inv_adjacent_vertices_range(a_v, ga)) { u32 state_id = a_ranking.get(u); if (state_id != UNUSED_STATE && state_id >= max) { max = j - 1; DEBUG_PRINTF("lowering max to %u\n", max); goto next_vertex; } } for (auto u : inv_adjacent_vertices_range(b_v, gb)) { u32 state_id = b_ranking.get(u); if (state_id != UNUSED_STATE && state_id >= max) { max = j - 1; DEBUG_PRINTF("lowering max to %u\n", max); goto next_vertex; } } next_vertex:; } /* Ensure that every pair of vertices has same out-edges to vertices in the region. */ for (size_t i = 0; i < max; i++) { size_t a_count = 0; size_t b_count = 0; for (NFAEdge a_edge : out_edges_range(a_ranking.at(i), ga)) { u32 sid = a_ranking.get(target(a_edge, ga)); if (sid == UNUSED_STATE || sid >= max) { continue; } a_count++; NFAEdge b_edge = edge(b_ranking.at(i), b_ranking.at(sid), gb); if (!b_edge) { max = i; DEBUG_PRINTF("lowering max to %u due to edge %zu->%u\n", max, i, sid); goto try_smaller; } if (ga[a_edge].tops != gb[b_edge].tops) { max = i; DEBUG_PRINTF("tops don't match on edge %zu->%u\n", i, sid); goto try_smaller; } } for (NFAVertex b_v : adjacent_vertices_range(b_ranking.at(i), gb)) { u32 sid = b_ranking.get(b_v); if (sid == UNUSED_STATE || sid >= max) { continue; } b_count++; } if (a_count != b_count) { max = i; DEBUG_PRINTF("lowering max to %u due to a,b count (a_count=%zu," " b_count=%zu)\n", max, a_count, b_count); goto try_smaller; } } DEBUG_PRINTF("survived checks, returning cpl %u\n", max); return max; try_smaller:; } DEBUG_PRINTF("failed to find any common region\n"); return 0; } u32 commonPrefixLength(const NGHolder &ga, const NGHolder &gb) { return commonPrefixLength(ga, ranking_info(ga), gb, ranking_info(gb)); } static never_inline void mergeNfaComponent(NGHolder &dest, const NGHolder &vic, size_t common_len) { assert(&dest != &vic); auto dest_info = ranking_info(dest); auto vic_info = ranking_info(vic); map vmap; // vic -> dest vmap[vic.start] = dest.start; vmap[vic.startDs] = dest.startDs; vmap[vic.accept] = dest.accept; vmap[vic.acceptEod] = dest.acceptEod; vmap[NGHolder::null_vertex()] = NGHolder::null_vertex(); // For vertices in the common len, add to vmap and merge in the reports, if // any. for (u32 i = 0; i < common_len; i++) { NFAVertex v_old = vic_info.at(i); NFAVertex v = dest_info.at(i); vmap[v_old] = v; const auto &reports = vic[v_old].reports; dest[v].reports.insert(reports.begin(), reports.end()); } // Add in vertices beyond the common len for (u32 i = common_len; i < vic_info.size(); i++) { NFAVertex v_old = vic_info.at(i); if (is_special(v_old, vic)) { // Dest already has start vertices, just merge the reports. u32 idx = vic[v_old].index; NFAVertex v = dest.getSpecialVertex(idx); const auto &reports = vic[v_old].reports; dest[v].reports.insert(reports.begin(), reports.end()); continue; } NFAVertex v = add_vertex(vic[v_old], dest); dest_info.add_to_tail(v); vmap[v_old] = v; } /* add edges */ DEBUG_PRINTF("common_len=%zu\n", common_len); for (const auto &e : edges_range(vic)) { NFAVertex u_old = source(e, vic); NFAVertex v_old = target(e, vic); NFAVertex u = vmap[u_old]; NFAVertex v = vmap[v_old]; bool uspecial = is_special(u, dest); bool vspecial = is_special(v, dest); // Skip stylised edges that are already present. if (uspecial && vspecial && edge(u, v, dest).second) { continue; } // We're in the common region if v's state ID is low enough, unless v // is a special (an accept), in which case we use u's state ID. bool in_common_region = dest_info.get(v) < common_len; if (vspecial && dest_info.get(u) < common_len) { in_common_region = true; } DEBUG_PRINTF("adding idx=%zu (state %u) -> idx=%zu (state %u)%s\n", dest[u].index, dest_info.get(u), dest[v].index, dest_info.get(v), in_common_region ? " [common]" : ""); if (in_common_region) { if (!is_special(v, dest)) { DEBUG_PRINTF("skipping common edge\n"); assert(edge(u, v, dest).second); // Should never merge edges with different top values. assert(vic[e].tops == dest[edge(u, v, dest)].tops); continue; } else { assert(is_any_accept(v, dest)); // If the edge exists in both graphs, skip it. if (edge(u, v, dest).second) { DEBUG_PRINTF("skipping common edge to accept\n"); continue; } } } assert(!edge(u, v, dest).second); add_edge(u, v, vic[e], dest); } renumber_edges(dest); renumber_vertices(dest); } namespace { struct NfaMergeCandidateH { NfaMergeCandidateH(size_t cpl_in, NGHolder *first_in, NGHolder *second_in, u32 tb_in) : cpl(cpl_in), first(first_in), second(second_in), tie_breaker(tb_in) {} size_t cpl; //!< common prefix length NGHolder *first; //!< first component to merge NGHolder *second; //!< second component to merge u32 tie_breaker; //!< for determinism bool operator<(const NfaMergeCandidateH &other) const { if (cpl != other.cpl) { return cpl < other.cpl; } else { return tie_breaker < other.tie_breaker; } } }; } // end namespace /** Returns true if graphs \p h1 and \p h2 can (and should) be merged. */ static bool shouldMerge(const NGHolder &ha, const NGHolder &hb, size_t cpl, const ReportManager *rm, const CompileContext &cc) { size_t combinedStateCount = num_vertices(ha) + num_vertices(hb) - cpl; combinedStateCount -= 2 * 2; /* discount accepts from both */ if (is_triggered(ha)) { /* allow for a state for each top, ignore existing starts */ combinedStateCount -= 2; /* for start, startDs */ auto tops = getTops(ha); insert(&tops, getTops(hb)); combinedStateCount += tops.size(); } if (combinedStateCount > FAST_STATE_LIMIT) { // More complex implementability check. NGHolder h_temp; cloneHolder(h_temp, ha); assert(h_temp.kind == hb.kind); mergeNfaComponent(h_temp, hb, cpl); reduceImplementableGraph(h_temp, SOM_NONE, rm, cc); u32 numStates = isImplementableNFA(h_temp, rm, cc); DEBUG_PRINTF("isImplementableNFA returned %u states\n", numStates); if (!numStates) { DEBUG_PRINTF("not implementable\n"); return false; } else if (numStates > FAST_STATE_LIMIT) { DEBUG_PRINTF("too many states to merge\n"); return false; } } return true; } /** Returns true if the graph has start vertices that are compatible for * merging. Rose may generate all sorts of wacky vacuous cases, and the merge * code isn't currently up to handling them. */ static bool compatibleStarts(const NGHolder &ga, const NGHolder &gb) { // Start and startDs must have the same self-loops. return (edge(ga.startDs, ga.startDs, ga).second == edge(gb.startDs, gb.startDs, gb).second) && (edge(ga.start, ga.start, ga).second == edge(gb.start, gb.start, gb).second); } static never_inline void buildNfaMergeQueue(const vector &cluster, priority_queue *pq) { const size_t cs = cluster.size(); assert(cs < NO_COMPONENT); // First, make sure all holders have numbered states and collect their // counts. vector states_map; states_map.reserve(cs); for (size_t i = 0; i < cs; i++) { assert(cluster[i]); assert(states_map.size() == i); const NGHolder &g = *(cluster[i]); states_map.emplace_back(g); } vector seen_cpl(cs * cs, 0); vector best_comp(cs, NO_COMPONENT); /* TODO: understand, explain */ for (u32 ci = 0; ci < cs; ci++) { for (u32 cj = ci + 1; cj < cs; cj++) { u16 cpl = 0; bool calc = false; if (best_comp[ci] != NO_COMPONENT) { u32 bc = best_comp[ci]; if (seen_cpl[bc + cs * cj] < seen_cpl[bc + cs * ci]) { cpl = seen_cpl[bc + cs * cj]; DEBUG_PRINTF("using cached cpl from %u %u\n", bc, cpl); calc = true; } } if (!calc && best_comp[cj] != NO_COMPONENT) { u32 bc = best_comp[cj]; if (seen_cpl[bc + cs * ci] < seen_cpl[bc + cs * cj]) { cpl = seen_cpl[bc + cs * ci]; DEBUG_PRINTF("using cached cpl from %u %u\n", bc, cpl); calc = true; } } NGHolder &g_i = *(cluster[ci]); NGHolder &g_j = *(cluster[cj]); if (!compatibleStarts(g_i, g_j)) { continue; } if (!calc) { cpl = commonPrefixLength(g_i, states_map[ci], g_j, states_map[cj]); } seen_cpl[ci + cs * cj] = cpl; seen_cpl[cj + cs * ci] = cpl; if (best_comp[cj] == NO_COMPONENT || seen_cpl[best_comp[cj] + cs * cj] < cpl) { best_comp[cj] = ci; } DEBUG_PRINTF("cpl %u %u = %u\n", ci, cj, cpl); pq->push(NfaMergeCandidateH(cpl, cluster[ci], cluster[cj], ci * cs + cj)); } } } /** * True if the graphs have mergeable starts. * * Nowadays, this means that any vacuous edges must have the same tops. In * addition, mixed-accept cases need to have matching reports. */ static bool mergeableStarts(const NGHolder &h1, const NGHolder &h2) { if (!isVacuous(h1) || !isVacuous(h2)) { return true; } // Vacuous edges from startDs should not occur: we have better ways to // implement true dot-star relationships. Just in case they do, ban them // from being merged unless they have identical reports. if (is_match_vertex(h1.startDs, h1) || is_match_vertex(h2.startDs, h2)) { assert(0); return false; } /* TODO: relax top checks if reports match */ // If both graphs have edge (start, accept), the tops must match. NFAEdge e1_accept = edge(h1.start, h1.accept, h1); NFAEdge e2_accept = edge(h2.start, h2.accept, h2); if (e1_accept && e2_accept && h1[e1_accept].tops != h2[e2_accept].tops) { return false; } // If both graphs have edge (start, acceptEod), the tops must match. NFAEdge e1_eod = edge(h1.start, h1.acceptEod, h1); NFAEdge e2_eod = edge(h2.start, h2.acceptEod, h2); if (e1_eod && e2_eod && h1[e1_eod].tops != h2[e2_eod].tops) { return false; } // If one graph has an edge to accept and the other has an edge to // acceptEod, the reports must match for the merge to be safe. if ((e1_accept && e2_eod) || (e2_accept && e1_eod)) { if (h1[h1.start].reports != h2[h2.start].reports) { return false; } } return true; } /** Merge graph \p ga into graph \p gb. Returns false on failure. */ bool mergeNfaPair(const NGHolder &ga, NGHolder &gb, const ReportManager *rm, const CompileContext &cc) { assert(ga.kind == gb.kind); // Vacuous NFAs require special checks on their starts to ensure that tops // match, and that reports match for mixed-accept cases. if (!mergeableStarts(ga, gb)) { DEBUG_PRINTF("starts aren't mergeable\n"); return false; } u32 cpl = commonPrefixLength(ga, gb); if (!shouldMerge(gb, ga, cpl, rm, cc)) { return false; } mergeNfaComponent(gb, ga, cpl); reduceImplementableGraph(gb, SOM_NONE, rm, cc); return true; } map mergeNfaCluster(const vector &cluster, const ReportManager *rm, const CompileContext &cc) { map merged; if (cluster.size() < 2) { return merged; } DEBUG_PRINTF("new cluster, size %zu\n", cluster.size()); priority_queue pq; buildNfaMergeQueue(cluster, &pq); while (!pq.empty()) { NGHolder &pholder = *pq.top().first; NGHolder &vholder = *pq.top().second; pq.pop(); if (contains(merged, &pholder) || contains(merged, &vholder)) { DEBUG_PRINTF("dead\n"); continue; } if (!mergeNfaPair(vholder, pholder, rm, cc)) { DEBUG_PRINTF("merge failed\n"); continue; } merged.emplace(&vholder, &pholder); // Seek closure. for (auto &m : merged) { if (m.second == &vholder) { m.second = &pholder; } } } return merged; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_literal_decorated.h0000644000175000017500000000412313055426554023157 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Analysis for literals decorated by leading/trailing assertions or * character classes. */ #ifndef NFAGRAPH_NG_LITERAL_DECORATED_H #define NFAGRAPH_NG_LITERAL_DECORATED_H namespace ue2 { class RoseBuild; class NGHolder; struct CompileContext; /** * \brief If the graph contains only a decorated literal, feed it to the Rose * builder. Returns true on success. */ bool handleDecoratedLiterals(RoseBuild &rose, const NGHolder &g, const CompileContext &cc); } // namespace ue2 #endif // NFAGRAPH_NG_LITERAL_DECORATED_H hyperscan-4.4.1/src/nfagraph/ng_som_util.h0000644000175000017500000000606513055426554021353 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Utility functions related to SOM ("Start of Match"). */ #ifndef NG_SOM_UTIL_H #define NG_SOM_UTIL_H #include "ng_util.h" #include "util/depth.h" #include "util/ue2_containers.h" #include #include namespace ue2 { class NGHolder; /** * Returns min/max distance from start of match, index by vertex_id. */ std::vector getDistancesFromSOM(const NGHolder &g); /** * Returns true if the first match by end-offset must always be the first match * by start-offset. */ bool firstMatchIsFirst(const NGHolder &p); struct smgb_cache : public mbsb_cache { explicit smgb_cache(const NGHolder &gg) : mbsb_cache(gg) {} std::map smgb; }; bool somMayGoBackwards(NFAVertex u, const NGHolder &g, const ue2::unordered_map ®ion_map, smgb_cache &cache); /** * Returns true if matching 'sent' causes all tail states in the main graph \a * g to go dead. A tail state is any state with a region greater than * \a last_head_region. * * - The graph \a sent must be a "kinda-DAG", where the only back-edges present * are self-loops. * - If the result is false, \a bad_region will be updated with the smallest * region ID associated with a tail state that is still on. */ bool sentClearsTail(const NGHolder &g, const ue2::unordered_map ®ion_map, const NGHolder &sent, u32 last_head_region, u32 *bad_region); } // namespace ue2 #endif // NG_SOM_UTIL_H hyperscan-4.4.1/src/nfagraph/ng_anchored_dots.cpp0000644000175000017500000004630513055426554022670 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Analysis pass to reform leading dots. * * We have found that many regexes found in the wild use an anchored dot-repeat * to represent an unanchored pattern, particularly if they have been used with * a regex engine that assumes that a pattern is anchored. This pass reforms * patterns that begin with sequences of dots into a more standard form. * * In addition, both anchored and unanchored patterns with dot repeats as * prefixes will have these prefixes reformed into a canonical form, which some * later analyses depend upon. */ #include "ng_anchored_dots.h" #include "grey.h" #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/depth.h" #include "util/graph_range.h" #include #include #include #include using namespace std; namespace ue2 { static bool findStarts(const NGHolder &g, set &anchored, set &unanchored) { // Populate unanchored map for (auto v : adjacent_vertices_range(g.startDs, g)) { if (is_special(v, g)) { continue; } unanchored.insert(v); } // Populate anchored map for (auto v : adjacent_vertices_range(g.start, g)) { if (is_special(v, g)) { continue; } anchored.insert(v); } if (unanchored == anchored) { anchored.clear(); } else if (!unanchored.empty() && !anchored.empty()) { return false; } return !anchored.empty() || !unanchored.empty(); } namespace { class DotInfo { public: DotInfo(NFAVertex v, bool se, u32 idx) : vertex(v), hasSelfLoop(se), index(idx) {} bool operator<(const DotInfo &other) const { if (hasSelfLoop != other.hasSelfLoop) return hasSelfLoop < other.hasSelfLoop; // tie break with vertex id: lowest ID wins return index > other.index; } NFAVertex vertex; bool hasSelfLoop; u32 index; }; } // Returns nullptr if all vertices in the given set are not dots. // We can only pick one dot vertex, so we go for a dot-star if it exists, // otherwise the dot without a self-edge with the lowest ID. static NFAVertex findReformable(const NGHolder &g, const set &starts, set &otherV) { priority_queue dotq; for (auto v : starts) { if (is_dot(v, g)) { u32 idx = g[v].index; dotq.push(DotInfo(v, hasSelfLoop(v, g), idx)); } } if (dotq.empty()) { return NGHolder::null_vertex(); } const DotInfo &dot = dotq.top(); otherV = starts; otherV.erase(dot.vertex); DEBUG_PRINTF("selected dot vertex %u (%s)\n", dot.index, dot.hasSelfLoop ? "has self-edge" : "no self-edge"); DEBUG_PRINTF("%zu other vertices\n", otherV.size()); return dot.vertex; } // Returns true if the given vertex is only preceded by start. If start is // graph.startDs (i.e. unanchored), the given vertex can also be connected to // graph.start. If selfLoopIsAcceptable is set, self-loops are ignored. static bool isStartNode(NFAVertex v, NFAVertex start, const NGHolder &g, bool selfLoopIsAcceptable) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (selfLoopIsAcceptable && u == v) { continue; } else if (u == start) { continue; } else if (start == g.startDs && u == g.start) { continue; } else { return false; } } return true; } // Note: this will only remove the anchored first dot in the chain -- any other // removable nodes will be handled by the unanchored case below. static void reformAnchoredRepeatsComponent(NGHolder &g, set &compAnchoredStarts, set &compUnanchoredStarts, set &dead, depth *startBegin, depth *startEnd) { // anchored cases can not have any unanchored starts if (!compUnanchoredStarts.empty()) { DEBUG_PRINTF("we have unanchored starts, skipping\n"); return; } NFAVertex dotV = NGHolder::null_vertex(); set otherV; dotV = findReformable(g, compAnchoredStarts, otherV); if (dotV == NGHolder::null_vertex()) { DEBUG_PRINTF("no candidate reformable dot found.\n"); return; } NFAEdge loopEdge; bool selfLoop = false; bool bustOut = false; for (const auto &e : out_edges_range(dotV, g)) { NFAVertex t = target(e, g); if (t == dotV) { selfLoop = true; loopEdge = e; continue; } if (is_special(t, g)) { bustOut = true; break; } if (!otherV.empty() && otherV.find(t) == otherV.end()) { bustOut = true; break; } } if (bustOut) { DEBUG_PRINTF("busting out\n"); return; } if (!isStartNode(dotV, g.start, g, true)) { DEBUG_PRINTF("fleeing: vertex %zu has other preds\n", g[dotV].index); return; } /* get bounds */ depth min; depth max = 1; if (selfLoop) { // A self-loop indicates that this is a '.+' or '.*' max = depth::infinity(); } if (!otherV.empty()) { /* We require that the successors of the dot node are are the same * as the start vertex. TODO: remember why. */ if (selfLoop) { if (otherV.size() != out_degree(dotV, g) - 1) { return; } } else { if (otherV.size() != out_degree(dotV, g)) { return; } } min = 0; } else { min = 1; } *startBegin = min; *startEnd = max; for (auto t : adjacent_vertices_range(dotV, g)) { if (t != dotV) { add_edge_if_not_present(g.startDs, t, g); add_edge_if_not_present(g.start, t, g); compUnanchoredStarts.insert(t); } } for (auto v : otherV) { remove_edge(g.start, v, g); } DEBUG_PRINTF("removing vertex %zu\n", g[dotV].index); clear_vertex(dotV, g); dead.insert(dotV); compAnchoredStarts.erase(dotV); } static void reformUnanchoredRepeatsComponent(NGHolder &g, set &compAnchoredStarts, set &compUnanchoredStarts, set &dead, depth *startBegin, depth *startEnd) { // unanchored cases can not have any anchored starts if (!compAnchoredStarts.empty()) { DEBUG_PRINTF("we have anchored starts, skipping\n"); return; } while (true) { NFAVertex dotV = NGHolder::null_vertex(); set otherV; dotV = findReformable(g, compUnanchoredStarts, otherV); if (dotV == NGHolder::null_vertex()) { DEBUG_PRINTF("no candidate reformable dot found.\n"); return; } NFAEdge loopEdge; bool selfLoop = false; bool bustOut = false; for (const auto &e : out_edges_range(dotV, g)) { NFAVertex t = target(e, g); if (t == dotV) { selfLoop = true; loopEdge = e; continue; } if (is_special(t, g)) { bustOut = true; break; } if (!otherV.empty() && otherV.find(t) == otherV.end()) { bustOut = true; break; } } if (bustOut) { DEBUG_PRINTF("busting out\n"); if (!selfLoop) { return; } for (auto v : otherV) { if (!edge(dotV, v, g).second) { return; } } // A self-loop indicates that this is a '.+' or '.*' DEBUG_PRINTF("self-loop detected on %zu\n", g[dotV].index); *startEnd = depth::infinity(); remove_edge(dotV, dotV, g); return; } if (!isStartNode(dotV, g.startDs, g, true)) { DEBUG_PRINTF("fleeing: vertex %zu has other preds\n", g[dotV].index); return; } /* get bounds */ depth min = 1; depth max = 1; if (selfLoop) { // A self-loop indicates that this is a '.+' or '.*' DEBUG_PRINTF("self-loop detected\n"); max = depth::infinity(); } if (!otherV.empty()) { if (!selfLoop && otherV.size() != out_degree(dotV, g)) { return; } if (selfLoop && otherV.size() != out_degree(dotV, g) - 1) { return; } if (min > depth(1)) { /* this is not a case we can handle */ DEBUG_PRINTF("min greater than one, skipping\n"); return; } min = 0; } *startBegin += min; *startEnd += max; for (auto v : otherV) { remove_edge(g.start, v, g); remove_edge(g.startDs, v, g); } compUnanchoredStarts.clear(); for (auto t : adjacent_vertices_range(dotV, g)) { if (t != dotV) { DEBUG_PRINTF("connecting sds -> %zu\n", g[t].index); add_edge(g.startDs, t, g); add_edge(g.start, t, g); compUnanchoredStarts.insert(t); } } DEBUG_PRINTF("removing vertex %zu\n", g[dotV].index); dead.insert(dotV); clear_vertex(dotV, g); compUnanchoredStarts.erase(dotV); } } // for t to be another optional dot, it must have only in-edges from v and from // starts static bool isOptionalDot(NFAVertex t, NFAVertex v, const NGHolder &g) { if (!is_dot(t, g)) { return false; } bool found_v = false, found_start = false; for (auto u : inv_adjacent_vertices_range(t, g)) { if (u == v) { found_v = true; } else if (u == g.start || u == g.startDs) { found_start = true; } else { return false; } } return found_v && found_start; } static bool gatherParticipants(const NGHolder &g, NFAVertex start, NFAVertex initialDot, set &dots, set &succ) { // Walk the graph downwards from the initial dot; each dot will have: // 1) a single optional dot successor, or // 2) N successors (our terminating case) dots.insert(initialDot); NFAVertex v = initialDot; while (out_degree(v, g) == 1) { NFAVertex t = *(adjacent_vertices(v, g).first); // for t to be another optional dot, it must have only in-edges from v // and from starts if (isOptionalDot(t, v, g)) { // another dot; bail if we've seen it once already if (dots.find(t) != dots.end()) { DEBUG_PRINTF("cycle detected at vertex %zu\n", g[t].index); return false; } dots.insert(t); v = t; continue; } // otherwise, we found a terminating dot state break; } // Our terminating states are the successors of v. // All of these MUST have an edge from start as well. for (auto w : adjacent_vertices_range(v, g)) { succ.insert(w); if (!edge(start, w, g).second) { DEBUG_PRINTF("failing, vertex %zu does not have edge from start\n", g[w].index); return false; } } /* All the non chained v connected to start must be in succ as well * TODO: remember why (and document). */ for (auto u : adjacent_vertices_range(start, g)) { if (is_special(u, g)) { continue; } if (!contains(dots, u) && !contains(succ, u)) { return false; } } return !succ.empty(); } static void collapseVariableDotRepeat(NGHolder &g, NFAVertex start, set &dead, UNUSED depth *startBegin, depth *startEnd) { // Handle optional dot repeat prefixes, e.g. // /^.{0,30}foo/s, /^.{0,5}foo/s, unanchored equivs // Note that this code assumes that fixed repeats ('^.{5,20}') have been // pruned already, down (in this case) to '^.{0,15}'. // The first of our optional dots must be connected to start. The jump edge // past it will be verified in gatherParticipants(). If start is // graph.start, it should not be connected to startDs. NFAVertex initialDot = NGHolder::null_vertex(); for (auto v : adjacent_vertices_range(start, g)) { if (is_special(v, g)) { continue; } if (is_dot(v, g) && isStartNode(v, start, g, false)) { if (initialDot) { return; } initialDot = v; DEBUG_PRINTF("initial dot vertex is %zu\n", g[v].index); } } if (!initialDot) { return; } // Collect all the other optional dot vertices and the successor vertices // by walking down the graph from initialDot set dots, succ; if (!gatherParticipants(g, start, initialDot, dots, succ)) { DEBUG_PRINTF("gatherParticipants failed\n"); return; } DEBUG_PRINTF("optional dot repeat with %zu participants, " "terminating in %zu non-dot nodes\n", dots.size(), succ.size()); // Remove all the participants and set the start offset dead.insert(dots.begin(), dots.end()); DEBUG_PRINTF("current offsets: %s-%s\n", startBegin->str().c_str(), startEnd->str().c_str()); if (start == g.start && startEnd->is_infinite()) { *startEnd = dots.size(); } else if (startEnd->is_finite()) { *startEnd += dots.size(); } assert(startEnd->is_reachable()); // Connect our successor vertices to both start and startDs. for (auto v : succ) { add_edge_if_not_present(g.start, v, g); add_edge_if_not_present(g.startDs, v, g); } } static void deleteVertices(set &dead, NGHolder &g) { if (!dead.empty()) { DEBUG_PRINTF("pruning %zu vertices\n", dead.size()); remove_vertices(dead, g); } dead.clear(); } static void reformAnchoredRepeats(NGHolder &g, depth *startBegin, depth *startEnd) { DEBUG_PRINTF("component\n"); set anchored, unanchored, dead; if (!findStarts(g, anchored, unanchored)) { DEBUG_PRINTF("no starts\n"); return; } reformAnchoredRepeatsComponent(g, anchored, unanchored, dead, startBegin, startEnd); deleteVertices(dead, g); reformUnanchoredRepeatsComponent(g, anchored, unanchored, dead, startBegin, startEnd); deleteVertices(dead, g); } static void collapseVariableRepeats(NGHolder &g, depth *startBegin, depth *startEnd) { DEBUG_PRINTF("collapseVariableRepeats\n"); set dead; collapseVariableDotRepeat(g, g.start, dead, startBegin, startEnd); deleteVertices(dead, g); collapseVariableDotRepeat(g, g.startDs, dead, startBegin, startEnd); deleteVertices(dead, g); } static void addDotsBetween(NGHolder &g, NFAVertex lhs, vector &rhs, depth min_repeat, depth max_repeat) { const bool unbounded = max_repeat.is_infinite(); if (unbounded) { max_repeat = min_repeat; } assert(max_repeat.is_finite()); NFAVertex u = lhs; if (!min_repeat && unbounded) { NFAVertex v = add_vertex(g); add_edge(u, v, g); g[v].char_reach.setall(); for (auto w : rhs) { add_edge(lhs, w, g); } } for (u32 i = 0; i < min_repeat; i++) { NFAVertex v = add_vertex(g); add_edge(u, v, g); g[v].char_reach.setall(); u = v; } NFAVertex split = u; /* lhs now split point for optional */ for (u32 i = min_repeat; i < max_repeat; i++) { NFAVertex v = add_vertex(g); add_edge(u, v, g); if (u != split) { add_edge(split, v, g); } g[v].char_reach.setall(); u = v; } if (unbounded) { add_edge(u, u, g); } for (auto w : rhs) { add_edge(u, w, g); if (split != u) { add_edge(split, w, g); } } } static void restoreLeadingDots(NGHolder &g, const depth &startBegin, const depth &startEnd) { if (startBegin == depth(0) && startEnd.is_infinite()) { return; } DEBUG_PRINTF("ungobble (%s, %s)\n", startBegin.str().c_str(), startEnd.str().c_str()); for (UNUSED auto v : adjacent_vertices_range(g.start, g)) { assert(edge(g.startDs, v, g).second); } clear_out_edges(g.start, g); add_edge(g.start, g.startDs, g); const bool unbounded = startEnd.is_infinite(); NFAVertex root = unbounded ? g.startDs : g.start; vector rhs; insert(&rhs, rhs.end(), adjacent_vertices(g.startDs, g)); rhs.erase(remove(rhs.begin(), rhs.end(), g.startDs), rhs.end()); for (auto v : rhs) { remove_edge(g.startDs, v, g); } addDotsBetween(g, root, rhs, startBegin, startEnd); renumber_vertices(g); renumber_edges(g); } // Entry point. void reformLeadingDots(NGHolder &g) { depth startBegin(0); depth startEnd = depth::infinity(); reformAnchoredRepeats(g, &startBegin, &startEnd); collapseVariableRepeats(g, &startBegin, &startEnd); restoreLeadingDots(g, startBegin, startEnd); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_revacc.h0000644000175000017500000000462113055426554020757 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Reverse acceleration analysis. */ #ifndef NG_REVACC_H #define NG_REVACC_H #include "util/charreach.h" #include struct NFA; namespace ue2 { class NGHolder; #define MAX_RACCEL_OFFSET 16 struct RevAccInfo { RevAccInfo(void); bool valid; std::vector acceptReach; /**< bytes which can appear n * bytes before a match */ std::vector acceptEodReach; /**< bytes which can appear n * bytes before eod match */ }; void buildReverseAcceleration(struct NFA *nfa, const RevAccInfo &rev_info, u32 min_width, bool eod_only = false); void populateReverseAccelerationInfo(RevAccInfo &rai, const NGHolder &g); void mergeReverseAccelerationInfo(RevAccInfo &dest, const RevAccInfo &vic); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_calc_components.cpp0000644000175000017500000003262513055426554023223 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Splits an NFA graph into its connected components. * * This pass takes a NGHolder and splits its graph into a set of connected * components, returning them as individual NGHolder graphs. For example, the * graph for the regex /foo.*bar|[a-z]{7,13}|hatstand|teakettle$/ will be split * into four NGHolders, representing these four components: * * - /foo.*bar/ * - /[a-z]{7,13}/ * - /hatstand/ * - /teakettle$/ * * The pass operates by creating an undirected graph from the input graph, and * then using the BGL's connected_components algorithm to do the work, cloning * the identified components into their own graphs. A "shell" of vertices * is identified and removed first from the head and tail of the graph, in * order to handle cases where there is a common head/tail region. * * Trivial cases, such as an alternation of single vertices like /a|b|c|d|e|f/, * are not split, as later optimisations will handle these cases efficiently. */ #include "ng_calc_components.h" #include "ng_depth.h" #include "ng_holder.h" #include "ng_prune.h" #include "ng_undirected.h" #include "ng_util.h" #include "ue2common.h" #include "util/graph_range.h" #include "util/make_unique.h" #include #include #include using namespace std; namespace ue2 { static constexpr u32 MAX_HEAD_SHELL_DEPTH = 3; static constexpr u32 MAX_TAIL_SHELL_DEPTH = 3; /** * \brief Returns true if the whole graph is just an alternation of character * classes. */ bool isAlternationOfClasses(const NGHolder &g) { for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } // Vertex must have in edges from starts only. for (auto u : inv_adjacent_vertices_range(v, g)) { if (!is_any_start(u, g)) { return false; } } // Vertex must have out edges to accepts only. for (auto w : adjacent_vertices_range(v, g)) { if (!is_any_accept(w, g)) { return false; } } } DEBUG_PRINTF("alternation of single states, treating as one comp\n"); return true; } /** * \brief Compute initial max distance to v from start (i.e. ignoring its own * self-loop). */ static depth max_dist_from_start(const NGHolder &g, const vector &depths, NFAVertex v) { depth max_depth(0); for (const auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; } const auto &d = depths.at(g[u].index); if (d.fromStart.max.is_reachable()) { max_depth = max(max_depth, d.fromStart.max); } if (d.fromStartDotStar.max.is_reachable()) { max_depth = max(max_depth, d.fromStartDotStar.max); } } return max_depth + 1; } /** * \brief Compute initial max depth from v from accept (i.e. ignoring its own * self-loop). */ static depth max_dist_to_accept(const NGHolder &g, const vector &depths, NFAVertex v) { depth max_depth(0); for (const auto w : adjacent_vertices_range(v, g)) { if (w == v) { continue; } const auto &d = depths.at(g[w].index); if (d.toAccept.max.is_reachable()) { max_depth = max(max_depth, d.toAccept.max); } if (d.toAcceptEod.max.is_reachable()) { max_depth = max(max_depth, d.toAcceptEod.max); } } return max_depth + 1; } static flat_set findHeadShell(const NGHolder &g, const vector &depths, const depth &max_dist) { flat_set shell; for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } if (max_dist_from_start(g, depths, v) <= max_dist) { shell.insert(v); } } for (UNUSED auto v : shell) { DEBUG_PRINTF("shell: %zu\n", g[v].index); } return shell; } static flat_set findTailShell(const NGHolder &g, const vector &depths, const depth &max_dist) { flat_set shell; for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } if (max_dist_to_accept(g, depths, v) <= max_dist) { shell.insert(v); } } for (UNUSED auto v : shell) { DEBUG_PRINTF("shell: %zu\n", g[v].index); } return shell; } static vector findShellEdges(const NGHolder &g, const flat_set &head_shell, const flat_set &tail_shell) { vector shell_edges; for (const auto &e : edges_range(g)) { auto u = source(e, g); auto v = target(e, g); if (v == g.startDs && is_any_start(u, g)) { continue; } if (u == g.accept && v == g.acceptEod) { continue; } if ((is_special(u, g) || contains(head_shell, u)) && (is_special(v, g) || contains(tail_shell, v))) { DEBUG_PRINTF("edge (%zu,%zu) is a shell edge\n", g[u].index, g[v].index); shell_edges.push_back(e); } } return shell_edges; } static void removeVertices(const flat_set &verts, NFAUndirectedGraph &ug, ue2::unordered_map &old2new, ue2::unordered_map &new2old) { for (auto v : verts) { assert(contains(old2new, v)); auto uv = old2new.at(v); clear_vertex(uv, ug); remove_vertex(uv, ug); old2new.erase(v); new2old.erase(uv); } } static void renumberVertices(NFAUndirectedGraph &ug) { u32 vertexIndex = 0; for (auto uv : vertices_range(ug)) { put(boost::vertex_index, ug, uv, vertexIndex++); } } /** * Common code called by calc- and recalc- below. Splits the given holder into * one or more connected components, adding them to the comps deque. */ static void splitIntoComponents(const NGHolder &g, deque> &comps, const depth &max_head_depth, const depth &max_tail_depth, bool *shell_comp) { DEBUG_PRINTF("graph has %zu vertices\n", num_vertices(g)); assert(shell_comp); *shell_comp = false; // Compute "shell" head and tail subgraphs. vector depths; calcDepths(g, depths); auto head_shell = findHeadShell(g, depths, max_head_depth); auto tail_shell = findTailShell(g, depths, max_tail_depth); for (auto v : head_shell) { tail_shell.erase(v); } if (head_shell.size() + tail_shell.size() + N_SPECIALS >= num_vertices(g)) { DEBUG_PRINTF("all in shell component\n"); comps.push_back(cloneHolder(g)); *shell_comp = true; return; } vector shell_edges = findShellEdges(g, head_shell, tail_shell); DEBUG_PRINTF("%zu vertices in head, %zu in tail, %zu shell edges\n", head_shell.size(), tail_shell.size(), shell_edges.size()); NFAUndirectedGraph ug; ue2::unordered_map old2new; createUnGraph(g, true, true, ug, old2new); // Construct reverse mapping. ue2::unordered_map new2old; for (const auto &m : old2new) { new2old.emplace(m.second, m.first); } // Remove shells from undirected graph and renumber so we have dense // vertex indices. removeVertices(head_shell, ug, old2new, new2old); removeVertices(tail_shell, ug, old2new, new2old); renumberVertices(ug); map split_components; const u32 num = connected_components( ug, boost::make_assoc_property_map(split_components)); assert(num > 0); if (num == 1 && shell_edges.empty()) { DEBUG_PRINTF("single component\n"); comps.push_back(cloneHolder(g)); return; } DEBUG_PRINTF("broke graph into %u components\n", num); vector> verts(num); // Collect vertex lists per component. for (const auto &m : split_components) { NFAUndirectedVertex uv = m.first; u32 c = m.second; assert(contains(new2old, uv)); NFAVertex v = new2old.at(uv); verts[c].push_back(v); DEBUG_PRINTF("vertex %zu is in comp %u\n", g[v].index, c); } ue2::unordered_map v_map; // temp map for fillHolder for (auto &vv : verts) { // Shells are in every component. vv.insert(vv.end(), begin(head_shell), end(head_shell)); vv.insert(vv.end(), begin(tail_shell), end(tail_shell)); /* Sort for determinism. Still required as NFAUndirectedVertex have * no deterministic ordering (split_components map). */ sort(begin(vv), end(vv)); auto gc = ue2::make_unique(); v_map.clear(); fillHolder(gc.get(), g, vv, &v_map); // Remove shell edges, which will get their own component. for (const auto &e : shell_edges) { auto cu = v_map.at(source(e, g)); auto cv = v_map.at(target(e, g)); assert(edge(cu, cv, *gc).second); remove_edge(cu, cv, *gc); } pruneUseless(*gc); DEBUG_PRINTF("component %zu has %zu vertices\n", comps.size(), num_vertices(*gc)); comps.push_back(move(gc)); } // Another component to handle the direct shell-to-shell edges. if (!shell_edges.empty()) { deque vv; vv.insert(vv.end(), begin(head_shell), end(head_shell)); vv.insert(vv.end(), begin(tail_shell), end(tail_shell)); auto gc = ue2::make_unique(); v_map.clear(); fillHolder(gc.get(), g, vv, &v_map); pruneUseless(*gc); DEBUG_PRINTF("shell edge component %zu has %zu vertices\n", comps.size(), num_vertices(*gc)); comps.push_back(move(gc)); *shell_comp = true; } // Ensure that only vertices with accept edges have reports. for (auto &gc : comps) { assert(gc); clearReports(*gc); } // We should never produce empty component graphs. assert(all_of(begin(comps), end(comps), [](const unique_ptr &g_comp) { return num_vertices(*g_comp) > N_SPECIALS; })); } deque> calcComponents(const NGHolder &g) { deque> comps; // For trivial cases, we needn't bother running the full // connected_components algorithm. if (isAlternationOfClasses(g)) { comps.push_back(cloneHolder(g)); return comps; } bool shell_comp = false; splitIntoComponents(g, comps, MAX_HEAD_SHELL_DEPTH, MAX_TAIL_SHELL_DEPTH, &shell_comp); if (shell_comp) { DEBUG_PRINTF("re-running on shell comp\n"); assert(!comps.empty()); auto sc = move(comps.back()); comps.pop_back(); splitIntoComponents(*sc, comps, 0, 0, &shell_comp); } DEBUG_PRINTF("finished; split into %zu components\n", comps.size()); return comps; } void recalcComponents(deque> &comps) { deque> out; for (auto &gc : comps) { if (!gc) { continue; // graph has been consumed already. } if (isAlternationOfClasses(*gc)) { out.push_back(move(gc)); continue; } auto gc_comps = calcComponents(*gc); for (auto &elem : gc_comps) { out.push_back(move(elem)); } } // Replace comps with our recalculated list. comps.swap(out); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_reports.h0000644000175000017500000000425713055426554021217 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Utility functions for working with Report ID sets. */ #ifndef NG_REPORTS_H #define NG_REPORTS_H #include "ue2common.h" #include namespace ue2 { class NGHolder; class ReportManager; /** Returns the set of all reports in the graph. */ std::set all_reports(const NGHolder &g); /** True if *all* reports in the graph are exhaustible. */ bool can_exhaust(const NGHolder &g, const ReportManager &rm); /** Derive a maximum offset for the graph from the max_offset values of its * reports. Returns MAX_OFFSET for inf. */ u64a findMaxOffset(const NGHolder &g, const ReportManager &rm); } // namespace ue2 #endif // NG_REPORTS_H hyperscan-4.4.1/src/nfagraph/ng_asserts.h0000644000175000017500000000355013055426554021200 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Resolve special assert vertices. */ #ifndef NG_ASSERTS_H #define NG_ASSERTS_H namespace ue2 { struct BoundaryReports; class NGWrapper; class ReportManager; void resolveAsserts(ReportManager &rm, NGWrapper &g); void ensureCodePointStart(ReportManager &rm, NGWrapper &g); } // namespace ue2 #endif // NG_ASSERTS_H hyperscan-4.4.1/src/nfagraph/ng_execute.h0000644000175000017500000000605213055426554021156 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Execute an NFA over a given input, returning the set of states that * are active afterwards. */ #ifndef NG_EXECUTE_H #define NG_EXECUTE_H #include "ng_holder.h" #include "util/ue2_containers.h" #include namespace ue2 { class CharReach; struct ue2_literal; flat_set execute_graph(const NGHolder &g, const ue2_literal &input, const flat_set &initial, bool kill_sds = false); flat_set execute_graph(const NGHolder &g, const std::vector &input, const flat_set &initial); /** on exit, states contains any state which may still be enabled after * receiving an input which corresponds to some path through the input_dag from * start or startDs to accept. input_dag MUST be acyclic aside from self-loops. */ flat_set execute_graph(const NGHolder &g, const NGHolder &input_dag, const flat_set &initial); /* as above, but able to specify the source states for the input graph */ flat_set execute_graph(const NGHolder &g, const NGHolder &input_dag, const flat_set &input_start_states, const flat_set &initial); /* returns true if it is possible for the nfa to die within age_limit bytes */ bool can_die_early(const NGHolder &g, u32 age_limit); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_expr_info.cpp0000644000175000017500000001301613055426554022036 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Code for discovering properties of an NGWrapper used by * hs_expression_info. */ #include "ng_expr_info.h" #include "hs_internal.h" #include "ng.h" #include "ng_asserts.h" #include "ng_depth.h" #include "ng_edge_redundancy.h" #include "ng_holder.h" #include "ng_reports.h" #include "ng_util.h" #include "ue2common.h" #include "parser/position.h" // for POS flags #include "util/boundary_reports.h" #include "util/compile_context.h" #include "util/depth.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/report_manager.h" #include #include using namespace std; namespace ue2 { /* get rid of leading \b and multiline ^ vertices */ static void removeLeadingVirtualVerticesFromRoot(NGWrapper &w, NFAVertex root) { vector victims; for (auto v : adjacent_vertices_range(root, w)) { if (w[v].assert_flags & POS_FLAG_VIRTUAL_START) { DEBUG_PRINTF("(?m)^ vertex or leading \\[bB] vertex\n"); victims.push_back(v); } } for (auto u : victims) { for (auto v : adjacent_vertices_range(u, w)) { add_edge_if_not_present(root, v, w); } } remove_vertices(victims, w); } static void checkVertex(const ReportManager &rm, const NGWrapper &w, NFAVertex v, const vector &depths, DepthMinMax &info) { if (is_any_accept(v, w)) { return; } if (is_any_start(v, w)) { info.min = 0; info.max = max(info.max, depth(0)); return; } u32 idx = w[v].index; assert(idx < depths.size()); const DepthMinMax &d = depths.at(idx); for (ReportID report_id : w[v].reports) { const Report &report = rm.getReport(report_id); assert(report.type == EXTERNAL_CALLBACK); DepthMinMax rd = d; // Compute graph width to this report, taking any offset adjustment // into account. rd.min += report.offsetAdjust; rd.max += report.offsetAdjust; // A min_length param is a lower bound for match width. if (report.minLength && report.minLength <= depth::max_value()) { depth min_len((u32)report.minLength); rd.min = max(rd.min, min_len); rd.max = max(rd.max, min_len); } // A max_offset param is an upper bound for match width. if (report.maxOffset && report.maxOffset <= depth::max_value()) { depth max_offset((u32)report.maxOffset); rd.min = min(rd.min, max_offset); rd.max = min(rd.max, max_offset); } DEBUG_PRINTF("vertex %zu report %u: %s\n", w[v].index, report_id, rd.str().c_str()); info = unionDepthMinMax(info, rd); } } static bool hasOffsetAdjust(const ReportManager &rm, const NGWrapper &w) { for (const auto &report_id : all_reports(w)) { if (rm.getReport(report_id).offsetAdjust) { return true; } } return false; } void fillExpressionInfo(ReportManager &rm, NGWrapper &w, hs_expr_info *info) { assert(info); /* ensure utf8 starts at cp boundary */ ensureCodePointStart(rm, w); resolveAsserts(rm, w); optimiseVirtualStarts(w); removeLeadingVirtualVerticesFromRoot(w, w.start); removeLeadingVirtualVerticesFromRoot(w, w.startDs); vector depths; calcDepthsFrom(w, w.start, depths); DepthMinMax d; for (auto u : inv_adjacent_vertices_range(w.accept, w)) { checkVertex(rm, w, u, depths, d); } for (auto u : inv_adjacent_vertices_range(w.acceptEod, w)) { checkVertex(rm, w, u, depths, d); } if (d.max.is_finite()) { info->max_width = d.max; } else { info->max_width = UINT_MAX; } if (d.min.is_finite()) { info->min_width = d.min; } else { info->min_width = UINT_MAX; } info->unordered_matches = hasOffsetAdjust(rm, w); info->matches_at_eod = can_match_at_eod(w); info->matches_only_at_eod = can_only_match_at_eod(w); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_mcclellan.h0000644000175000017500000000577213055426554021456 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Build code for McClellan DFA. */ #ifndef NG_MCCLELLAN_H #define NG_MCCLELLAN_H #include "ue2common.h" #include #include namespace ue2 { class CharReach; class NGHolder; class ReportManager; struct Grey; struct raw_dfa; /** * \brief Determinises an NFA Graph into a raw_dfa. * * \param g * The NGHolder. * \param rm * A pointer to the ReportManager, if managed reports are used (e.g. * for outfixes/suffixes). Otherwise nullptr. * \param single_trigger * True if it is known that the nfa will only ever be trigger once. * \param triggers * Representing when tops may arrive. Only used by NFA_INFIX and * NFA_SUFFIX, should be empty for other types. * \param grey * Grey box object. * \param finalChance * Allows us to build bigger DFAs as the only alternative is an outfix. * * \return A raw_dfa, or nullptr on failure (state limit blown). */ std::unique_ptr buildMcClellan(const NGHolder &g, const ReportManager *rm, bool single_trigger, const std::vector> &triggers, const Grey &grey, bool finalChance = false); /** Convenience wrapper for non-triggered engines */ std::unique_ptr buildMcClellan(const NGHolder &g, const ReportManager *rm, const Grey &grey); } // namespace ue2 #endif // NG_MCCLELLAN_H hyperscan-4.4.1/src/nfagraph/ng_netflow.cpp0000644000175000017500000002023013055426554021517 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Network flow (min flow, max cut) algorithms. */ #include "ng_netflow.h" #include "ng_holder.h" #include "ng_literal_analysis.h" #include "ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/graph_range.h" #include #include using namespace std; using boost::default_color_type; namespace ue2 { static void addReverseEdge(const NGHolder &g, vector &reverseEdge, NFAEdge fwd, NFAEdge rev) { u32 fwdIndex = g[fwd].index; u32 revIndex = g[rev].index; // Make sure our vector is big enough. size_t sz = max(fwdIndex, revIndex) + 1; if (reverseEdge.size() < sz) { reverseEdge.resize(sz); } // Add entries to list. reverseEdge[fwdIndex] = rev; reverseEdge[revIndex] = fwd; } /** Add temporary reverse edges to the graph \p g, as they are required by the * BGL's boykov_kolmogorov_max_flow algorithm. */ static void addReverseEdges(NGHolder &g, vector &reverseEdge, vector &capacityMap) { // We're probably going to need space for 2x edge count. const size_t numEdges = num_edges(g); reverseEdge.reserve(numEdges * 2); capacityMap.reserve(numEdges * 2); // To avoid walking the graph for _ages_, we build a temporary map of all // edges indexed by vertex pair for existence checks. map, NFAEdge> allEdges; for (const auto &e : edges_range(g)) { NFAVertex u = source(e, g), v = target(e, g); size_t uidx = g[u].index, vidx = g[v].index; allEdges[make_pair(uidx, vidx)] = e; } // Now we walk over all edges and add their reverse edges to the reverseEdge // vector, also adding them to the graph when they don't already exist. for (const auto &m : allEdges) { const NFAEdge &fwd = m.second; const size_t uidx = m.first.first, vidx = m.first.second; auto it = allEdges.find(make_pair(vidx, uidx)); if (it == allEdges.end()) { // No reverse edge, add one. NFAVertex u = source(fwd, g), v = target(fwd, g); NFAEdge rev = add_edge(v, u, g); it = allEdges.insert(make_pair(make_pair(vidx, uidx), rev)).first; // Add to capacity map. u32 revIndex = g[rev].index; if (capacityMap.size() < revIndex + 1) { capacityMap.resize(revIndex + 1); } capacityMap[revIndex] = 0; } addReverseEdge(g, reverseEdge, fwd, it->second); } } /** Remove all edges with indices >= \p idx. */ static void removeEdgesFromIndex(NGHolder &g, vector &capacityMap, u32 idx) { remove_edge_if([&](const NFAEdge &e) { return g[e].index >= idx; }, g); capacityMap.resize(idx); renumber_edges(g); } /** A wrapper around boykov_kolmogorov_max_flow, returns the max flow and * colour map (from which we can find the min cut). */ static u64a getMaxFlow(NGHolder &h, const vector &capacityMap_in, vector &colorMap) { vector capacityMap = capacityMap_in; NFAVertex src = h.start; NFAVertex sink = h.acceptEod; // netflow relies on these stylised edges, as all starts should be covered // by our source and all accepts by our sink. assert(edge(h.start, h.startDs, h).second); assert(edge(h.accept, h.acceptEod, h).second); // The boykov_kolmogorov_max_flow algorithm requires us to have reverse // edges for all edges in the graph, so we create them here (and remove // them after the call). const unsigned int numRealEdges = num_edges(h); vector reverseEdges; addReverseEdges(h, reverseEdges, capacityMap); const unsigned int numTotalEdges = num_edges(h); const unsigned int numVertices = num_vertices(h); vector edgeResiduals(numTotalEdges); vector predecessors(numVertices); vector distances(numVertices); assert(colorMap.size() == numVertices); auto v_index_map = get(vertex_index, h); auto e_index_map = get(edge_index, h); u64a flow = boykov_kolmogorov_max_flow(h, make_iterator_property_map(capacityMap.begin(), e_index_map), make_iterator_property_map(edgeResiduals.begin(), e_index_map), make_iterator_property_map(reverseEdges.begin(), e_index_map), make_iterator_property_map(predecessors.begin(), v_index_map), make_iterator_property_map(colorMap.begin(), v_index_map), make_iterator_property_map(distances.begin(), v_index_map), v_index_map, src, sink); // Remove reverse edges from graph. removeEdgesFromIndex(h, capacityMap, numRealEdges); assert(num_edges(h) == numRealEdges); DEBUG_PRINTF("flow = %llu\n", flow); return flow; } /** Returns a min cut (in \p cutset) for the graph in \p h. */ vector findMinCut(NGHolder &h, const vector &scores) { assert(hasCorrectlyNumberedEdges(h)); assert(hasCorrectlyNumberedVertices(h)); vector colorMap(num_vertices(h)); u64a flow = getMaxFlow(h, scores, colorMap); vector picked_white; vector picked_black; u64a observed_black_flow = 0; u64a observed_white_flow = 0; for (const auto &e : edges_range(h)) { NFAVertex from = source(e, h); NFAVertex to = target(e, h); u64a ec = scores[h[e].index]; if (ec == 0) { continue; // skips, among other things, reverse edges } default_color_type fromColor = colorMap[h[from].index]; default_color_type toColor = colorMap[h[to].index]; if (fromColor != boost::white_color && toColor == boost::white_color) { assert(ec <= INVALID_EDGE_CAP); DEBUG_PRINTF("found white cut edge %zu->%zu cap %llu\n", h[from].index, h[to].index, ec); observed_white_flow += ec; picked_white.push_back(e); } if (fromColor == boost::black_color && toColor != boost::black_color) { assert(ec <= INVALID_EDGE_CAP); DEBUG_PRINTF("found black cut edge %zu->%zu cap %llu\n", h[from].index, h[to].index, ec); observed_black_flow += ec; picked_black.push_back(e); } } DEBUG_PRINTF("min flow = %llu b flow = %llu w flow %llu\n", flow, observed_black_flow, observed_white_flow); if (MIN(observed_white_flow, observed_black_flow) != flow) { DEBUG_PRINTF("bad cut\n"); } if (observed_white_flow < observed_black_flow) { return picked_white; } else { return picked_black; } } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_region.cpp0000644000175000017500000003702313055426554021334 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Region analysis. * * Definition: a \a region is a subset of vertices in a graph such that: * - the edges entering the region are a cutset of the graph * - for every in-edge (u, v) to the region there exist edges (u, w) for all * w in {w : w in region and w has an in-edge} * - the regions in a graph partition the graph * * Note: * - we partition a graph into the maximal number of regions * - similar properties for exit edges should hold as a consequence * - graph == sequence of regions * - a region is considered to have an epsilon vertex to allow jumps * - vertices which only lead to back edges need to be floated up in the topo * order * * Algorithm overview: * -# topo-order over the DAG skeleton; * -# incrementally add vertices to the current region until the boundary edges * form a valid cut-set; * -# for each back-edge, if the source and target are in different regions, * merge the regions (and all intervening regions) into a common region. */ #include "ng_region.h" #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/ue2_containers.h" #include "util/graph_range.h" #include #include #include #include #include using namespace std; namespace ue2 { typedef ue2::unordered_set BackEdgeSet; typedef boost::filtered_graph> AcyclicGraph; namespace { struct exit_info { explicit exit_info(NFAVertex v) : exit(v) {} NFAVertex exit; ue2::unordered_set open; }; } static void checkAndAddExitCandidate(const AcyclicGraph &g, const ue2::unordered_set &r, NFAVertex v, vector *exits) { // set when we find our first candidate. ue2::unordered_set *open = nullptr; /* find the set of vertices reachable from v which are not in r */ for (auto w : adjacent_vertices_range(v, g)) { if (!contains(r, NFAVertex(w))) { if (!open) { exits->push_back(exit_info(NFAVertex(v))); open = &exits->back().open; } open->insert(NFAVertex(w)); } } if (open) { DEBUG_PRINTF("exit %zu\n", g[v].index); } } static void findExits(const AcyclicGraph &g, const ue2::unordered_set &r, vector *exits) { exits->clear(); for (auto v : r) { checkAndAddExitCandidate(g, r, v, exits); } } static void refineExits(const AcyclicGraph &g, const ue2::unordered_set &r, NFAVertex new_v, vector *exits) { for (u32 i = 0; i < exits->size(); i++) { (*exits)[i].open.erase(new_v); /* new_v is no long an open edge */ if ((*exits)[i].open.empty()) { /* no open edges: no longer an exit */ /* shuffle to back and kill */ (*exits)[i] = exits->back(); exits->pop_back(); i--; } } checkAndAddExitCandidate(g, r, new_v, exits); } /** the set of exits from a candidate region are valid if: FIXME: document */ static bool exitValid(UNUSED const AcyclicGraph &g, const vector &exits, const ue2::unordered_set &open_jumps) { if (exits.empty() || (exits.size() < 2 && open_jumps.empty())) { return true; } if (exits.size() == 1 && open_jumps.size() == 1) { DEBUG_PRINTF("oj %zu, e %zu\n", g[*open_jumps.begin()].index, g[exits[0].exit].index); if (*open_jumps.begin() == exits[0].exit) { return true; } } assert(!exits.empty()); const auto &enters = exits.front().open; if (!open_jumps.empty() && enters != open_jumps) { return false; } for (auto it = begin(exits) + 1; it != end(exits); ++it) { if (it->open != enters) { return false; } } return true; } static void setRegion(const ue2::unordered_set &r, u32 rid, ue2::unordered_map ®ions) { for (auto v : r) { regions[v] = rid; } } static void buildInitialCandidate(const AcyclicGraph &g, vector::const_reverse_iterator &it, const vector::const_reverse_iterator &ite, ue2::unordered_set *candidate, /* in exits of prev region; * out exits from candidate */ vector *exits, ue2::unordered_set *open_jumps) { if (it == ite) { candidate->clear(); exits->clear(); return; } if (exits->empty()) { DEBUG_PRINTF("odd\n"); candidate->clear(); DEBUG_PRINTF("adding %zu to initial\n", g[*it].index); candidate->insert(*it); open_jumps->erase(*it); checkAndAddExitCandidate(g, *candidate, *it, exits); ++it; return; } ue2::unordered_set enters = (*exits)[0].open; candidate->clear(); for (; it != ite; ++it) { DEBUG_PRINTF("adding %zu to initial\n", g[*it].index); candidate->insert(*it); if (contains(enters, *it)) { break; } } if (it != ite) { enters.erase(*it); open_jumps->swap(enters); DEBUG_PRINTF("oj size = %zu\n", open_jumps->size()); ++it; } else { open_jumps->clear(); } findExits(g, *candidate, exits); } static void findDagLeaders(const NGHolder &h, const AcyclicGraph &g, const vector &topo, ue2::unordered_map ®ions) { assert(!topo.empty()); u32 curr_id = 0; vector::const_reverse_iterator t_it = topo.rbegin(); vector exits; ue2::unordered_set candidate; ue2::unordered_set open_jumps; DEBUG_PRINTF("adding %zu to current\n", g[*t_it].index); assert(t_it != topo.rend()); candidate.insert(*t_it++); DEBUG_PRINTF("adding %zu to current\n", g[*t_it].index); assert(t_it != topo.rend()); candidate.insert(*t_it++); findExits(g, candidate, &exits); while (t_it != topo.rend()) { assert(!candidate.empty()); if (exitValid(g, exits, open_jumps)) { if (contains(candidate, h.accept) && !open_jumps.empty()) { /* we have tried to make an optional region containing accept as * we have an open jump to eod. This candidate region needs to * be put in with the previous region. */ curr_id--; DEBUG_PRINTF("merging in with region %u\n", curr_id); } else { DEBUG_PRINTF("setting region %u\n", curr_id); } setRegion(candidate, curr_id++, regions); buildInitialCandidate(g, t_it, topo.rend(), &candidate, &exits, &open_jumps); } else { NFAVertex curr = *t_it; DEBUG_PRINTF("adding %zu to current\n", g[curr].index); candidate.insert(curr); open_jumps.erase(curr); refineExits(g, candidate, *t_it, &exits); DEBUG_PRINTF(" open jumps %zu exits %zu\n", open_jumps.size(), exits.size()); ++t_it; } } /* assert exits valid */ setRegion(candidate, curr_id, regions); } static void mergeUnderBackEdges(const NGHolder &g, const vector &topo, const BackEdgeSet &backEdges, ue2::unordered_map ®ions) { for (const auto &e : backEdges) { NFAVertex u = source(e, g); NFAVertex v = target(e, g); u32 ru = regions[u]; u32 rv = regions[v]; if (ru == rv) { continue; } DEBUG_PRINTF("merging v = %zu(%u), u = %zu(%u)\n", g[v].index, rv, g[u].index, ru); assert(rv < ru); for (auto t : topo) { u32 r = regions[t]; if (r <= ru && r > rv) { regions[t] = rv; } else if (r > ru) { regions[t] = rv + r - ru; } } } } static void reorderSpecials(const NGHolder &w, const AcyclicGraph &acyclic_g, vector &topoOrder) { // Start is last element of reverse topo ordering. auto it = find(topoOrder.begin(), topoOrder.end(), w.start); if (it != topoOrder.end() - 1) { DEBUG_PRINTF("repositioning start\n"); assert(it != topoOrder.end()); topoOrder.erase(it); topoOrder.insert(topoOrder.end(), w.start); } // StartDs is second-to-last element of reverse topo ordering. it = find(topoOrder.begin(), topoOrder.end(), w.startDs); if (it != topoOrder.end() - 2) { DEBUG_PRINTF("repositioning start ds\n"); assert(it != topoOrder.end()); topoOrder.erase(it); topoOrder.insert(topoOrder.end() - 1, w.startDs); } // AcceptEOD is first element of reverse topo ordering. it = find(topoOrder.begin(), topoOrder.end(), w.acceptEod); if (it != topoOrder.begin()) { DEBUG_PRINTF("repositioning accept\n"); assert(it != topoOrder.end()); topoOrder.erase(it); topoOrder.insert(topoOrder.begin(), w.acceptEod); } // Accept is second element of reverse topo ordering, if it's connected. it = find(topoOrder.begin(), topoOrder.end(), w.accept); if (it != topoOrder.begin() + 1) { DEBUG_PRINTF("repositioning accept\n"); assert(it != topoOrder.end()); topoOrder.erase(it); if (in_degree(w.accept, acyclic_g) != 0) { topoOrder.insert(topoOrder.begin() + 1, w.accept); } } } static void liftSinks(const AcyclicGraph &acyclic_g, vector &topoOrder) { ue2::unordered_set sinks; for (auto v : vertices_range(acyclic_g)) { if (is_special(v, acyclic_g)) { continue; } if (isLeafNode(v, acyclic_g)) { DEBUG_PRINTF("sink found %zu\n", acyclic_g[v].index); sinks.insert(NFAVertex(v)); } } if (sinks.empty()) { DEBUG_PRINTF("no sinks found\n"); return; } bool changed; do { DEBUG_PRINTF("look\n"); changed = false; for (auto v : vertices_range(acyclic_g)) { if (is_special(v, acyclic_g) || contains(sinks, NFAVertex(v))) { continue; } for (auto w : adjacent_vertices_range(v, acyclic_g)) { if (!contains(sinks, NFAVertex(w))) { goto next; } } DEBUG_PRINTF("sink found %zu\n", acyclic_g[v].index); sinks.insert(NFAVertex(v)); changed = true; next:; } } while (changed); for (auto ri = topoOrder.rbegin() + 1; ri != topoOrder.rend(); ++ri) { if (!contains(sinks, *ri)) { continue; } NFAVertex s = *ri; DEBUG_PRINTF("handling sink %zu\n", acyclic_g[s].index); ue2::unordered_set parents; for (const auto &e : in_edges_range(s, acyclic_g)) { parents.insert(NFAVertex(source(e, acyclic_g))); } /* vertex has no children not reachable on a back edge, bubble the * vertex up the topo order to be near its parents */ vector::reverse_iterator rj = ri; --rj; while (rj != topoOrder.rbegin() && !contains(parents, *rj)) { /* sink is in rj + 1 */ assert(*(rj + 1) == s); DEBUG_PRINTF("lifting\n"); using std::swap; swap(*rj, *(rj + 1)); --rj; } } } /** Build a reverse topo ordering (with only the specials that are in use). We * also want to ensure vertices which only lead to back edges are placed near * their parents. */ static vector buildTopoOrder(const NGHolder &w, const AcyclicGraph &acyclic_g, vector &colours) { vector topoOrder; topological_sort(acyclic_g, back_inserter(topoOrder), color_map(make_iterator_property_map(colours.begin(), get(vertex_index, acyclic_g)))); reorderSpecials(w, acyclic_g, topoOrder); if (topoOrder.empty()) { return topoOrder; } liftSinks(acyclic_g, topoOrder); DEBUG_PRINTF("TOPO ORDER\n"); for (auto ri = topoOrder.rbegin(); ri != topoOrder.rend(); ++ri) { DEBUG_PRINTF("[%zu]\n", acyclic_g[*ri].index); } DEBUG_PRINTF("----------\n"); return topoOrder; } ue2::unordered_map assignRegions(const NGHolder &g) { assert(hasCorrectlyNumberedVertices(g)); const u32 numVertices = num_vertices(g); DEBUG_PRINTF("assigning regions for %u vertices in holder\n", numVertices); vector colours(numVertices); // Build an acyclic graph for this NGHolder. BackEdgeSet deadEdges; depth_first_search(g, visitor(BackEdges(deadEdges)) .root_vertex(g.start) .color_map(make_iterator_property_map(colours.begin(), get(vertex_index, g)))); auto af = make_bad_edge_filter(&deadEdges); AcyclicGraph acyclic_g(g, af); // Build a (reverse) topological ordering. vector topoOrder = buildTopoOrder(g, acyclic_g, colours); // Everybody starts in region 0. ue2::unordered_map regions; regions.reserve(numVertices); for (auto v : vertices_range(g)) { regions.emplace(v, 0); } findDagLeaders(g, acyclic_g, topoOrder, regions); mergeUnderBackEdges(g, topoOrder, deadEdges, regions); return regions; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_undirected.h0000644000175000017500000001015313055426554021637 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Create an undirected graph from an NFAGraph. */ #ifndef NG_UNDIRECTED_H_CB42C71CF38E3D #define NG_UNDIRECTED_H_CB42C71CF38E3D #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include #include namespace ue2 { /** * \brief BGL graph type for the undirected NFA graph. * * Note that we use a set for the out-edge lists: this avoids the construction * of parallel edges. The only vertex property constructed is \a * vertex_index_t. */ typedef boost::adjacency_list > NFAUndirectedGraph; typedef NFAUndirectedGraph::vertex_descriptor NFAUndirectedVertex; /** * Make a copy of an NFAGraph with undirected edges, optionally without start * vertices. Mappings from the original graph to the new one are provided. * * Note that new vertex indices are assigned contiguously in \a vertices(g) * order. */ template void createUnGraph(const GraphT &g, bool excludeStarts, bool excludeAccepts, NFAUndirectedGraph &ug, ue2::unordered_map &old2new) { size_t idx = 0; typedef typename GraphT::vertex_descriptor VertexT; for (auto v : ue2::vertices_range(g)) { // skip all accept nodes if (excludeAccepts && is_any_accept(v, g)) { continue; } // skip starts if required if (excludeStarts && is_any_start(v, g)) { continue; } NFAUndirectedVertex nuv = boost::add_vertex(ug); old2new[v] = nuv; boost::put(boost::vertex_index, ug, nuv, idx++); } for (const auto &e : ue2::edges_range(g)) { VertexT src = source(e, g); VertexT targ = target(e, g); if ((excludeAccepts && is_any_accept(src, g)) || (excludeStarts && is_any_start(src, g))) { continue; } if ((excludeAccepts && is_any_accept(targ, g)) || (excludeStarts && is_any_start(targ, g))) { continue; } NFAUndirectedVertex new_src = old2new[src]; NFAUndirectedVertex new_targ = old2new[targ]; boost::add_edge(new_src, new_targ, ug); } } } // namespace ue2 #endif /* NG_UNDIRECTED_H_CB42C71CF38E3D */ hyperscan-4.4.1/src/nfagraph/ng_utf8.h0000644000175000017500000000444213055426554020403 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief UTF-8 transforms and operations. */ #ifndef NG_UTF8_H #define NG_UTF8_H namespace ue2 { class NGWrapper; class NGHolder; /** \brief Relax forbidden UTF-8 sequences. * * Some byte sequences can not appear in valid UTF-8 as they encode code points * above \\x{10ffff} or they represent overlong encodings. As we require valid * UTF-8 input, we have no defined behaviour in these cases, as a result we can * accept them if it simplifies the graph. */ void relaxForbiddenUtf8(NGWrapper &w); /** \brief Contract cycles of UTF-8 code points down to a single cyclic vertex * where possible, based on the assumption that we will always be matching * against well-formed input. */ void utf8DotRestoration(NGHolder &h, bool som); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_lbr.h0000644000175000017500000000505613055426554020276 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Large Bounded Repeat (LBR) engine build code. */ #ifndef NG_LBR_H #define NG_LBR_H #include "ue2common.h" #include "util/alloc.h" #include #include struct NFA; namespace ue2 { class CharReach; class NGHolder; class ReportManager; struct CastleProto; struct CompileContext; struct Grey; /** \brief Construct an LBR engine from the given graph \p g. */ aligned_unique_ptr constructLBR(const NGHolder &g, const std::vector> &triggers, const CompileContext &cc, const ReportManager &rm); /** \brief Construct an LBR engine from the given CastleProto, which should * contain only one repeat. */ aligned_unique_ptr constructLBR(const CastleProto &proto, const std::vector> &triggers, const CompileContext &cc, const ReportManager &rm); /** \brief True if graph \p g could be turned into an LBR engine. */ bool isLBR(const NGHolder &g, const Grey &grey); } // namespace ue2 #endif // NG_LBR_H hyperscan-4.4.1/src/nfagraph/ng_mcclellan_internal.h0000644000175000017500000001311513055426554023340 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Shared build code for DFAs (McClellan, Haig). */ #ifndef NG_MCCLELLAN_INTERNAL_H #define NG_MCCLELLAN_INTERNAL_H #include "ue2common.h" #include "nfa/mcclellancompile.h" #include "nfagraph/ng_holder.h" #include "util/charreach.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include #include #include namespace ue2 { struct raw_dfa; /** Fills alpha, unalpha and returns alphabet size. */ u16 buildAlphabetFromEquivSets(const std::vector &esets, std::array &alpha, std::array &unalpha); /** \brief Calculates an alphabet remapping based on the symbols which the * graph discriminates on. Throws in some special DFA symbols as well. */ void calculateAlphabet(const NGHolder &g, std::array &alpha, std::array &unalpha, u16 *alphasize); void getFullTransitionFromState(const raw_dfa &n, u16 state, u16 *out_table); /** produce a map of states on which it is valid to receive tops */ void markToppableStarts(const NGHolder &g, const flat_set &unused, bool single_trigger, const std::vector> &triggers, boost::dynamic_bitset<> *out); /** * \brief Returns a set of start vertices that will not participate in an * implementation of this graph. These are either starts with no successors or * starts which are redundant with startDs. */ flat_set getRedundantStarts(const NGHolder &g); template void transition_graph(autom &nfa, const std::vector &vByStateId, const typename autom::StateSet &in, typename autom::StateSet *next) { typedef typename autom::StateSet StateSet; const NGHolder &graph = nfa.graph; const auto &unused = nfa.unused; const auto &alpha = nfa.alpha; const StateSet &squash = nfa.squash; const std::map &squash_mask = nfa.squash_mask; const std::vector &cr_by_index = nfa.cr_by_index; for (symbol_t s = 0; s < nfa.alphasize; s++) { next[s].reset(); } /* generate top transitions, false -> top = selfloop */ bool top_allowed = is_triggered(graph); StateSet succ = nfa.dead; for (size_t i = in.find_first(); i != in.npos; i = in.find_next(i)) { NFAVertex u = vByStateId[i]; for (const auto &v : adjacent_vertices_range(u, graph)) { if (contains(unused, v)) { continue; } succ.set(graph[v].index); } if (top_allowed && !nfa.toppable.test(i)) { /* we don't need to generate a top at this location as we are in * an nfa state which cannot be on when a trigger arrives. */ top_allowed = false; } } StateSet active_squash = succ & squash; if (active_squash.any()) { for (size_t j = active_squash.find_first(); j != active_squash.npos; j = active_squash.find_next(j)) { succ &= squash_mask.find(j)->second; } } for (size_t j = succ.find_first(); j != succ.npos; j = succ.find_next(j)) { const CharReach &cr = cr_by_index[j]; for (size_t s = cr.find_first(); s != cr.npos; s = cr.find_next(s)) { next[s].set(j); /* already alpha'ed */ } } next[alpha[TOP]] = in; if (top_allowed) { /* we don't add in the anchored starts as the only case as the only * time it is appropriate is if no characters have been consumed.*/ next[alpha[TOP]] |= nfa.initDS; active_squash = next[alpha[TOP]] & squash; if (active_squash.any()) { for (size_t j = active_squash.find_first(); j != active_squash.npos; j = active_squash.find_next(j)) { next[alpha[TOP]] &= squash_mask.find(j)->second; } } } } } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_asserts.cpp0000644000175000017500000005065113055426554021537 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Resolve special assert vertices. * * The assert resolution algorithm proceeds by iterating over those edges with * assertion flags, considering source and target vertices of each edge. If a * vertex has a superset of the reachability demanded by the assertion on the * edge, it is split into alternatives providing the word and non-word paths * through that vertex. * * A great deal of the complexity in the resolveAsserts pass is devoted to * handling these assertions when the UCP flag is specified (meaning \\w and \\W * are implemented with Unicode properties, rather than their ASCII * interpretation) and the prefiltering flag is also used. Complete, * non-prefiltering UCP support is not available yet. */ #include "ng_asserts.h" #include "ng.h" #include "ng_prune.h" #include "ng_redundancy.h" #include "ng_util.h" #include "parser/position.h" // for POS flags #include "util/bitutils.h" // for findAndClearLSB_32 #include "util/boundary_reports.h" #include "util/container.h" #include "util/compile_context.h" #include "util/compile_error.h" #include "util/graph_range.h" #include "util/report_manager.h" #include "util/unicode_def.h" #include using namespace std; namespace ue2 { /** \brief Hard limit on the maximum number of vertices we'll clone before we * throw up our hands and report 'Pattern too large.' */ static const size_t MAX_CLONED_VERTICES = 2048; /** \brief The definition of \\w, since we use it everywhere in here. */ static const CharReach CHARREACH_WORD(CharReach('a', 'z') | CharReach('A', 'Z') | CharReach('0', '9') | CharReach('_')); /** \brief \\W is the inverse of \\w */ static const CharReach CHARREACH_NONWORD(~CHARREACH_WORD); /** \brief Prefiltering definition of \\w for UCP mode. * * Includes all high bytes as to capture all non-ASCII, however depending on * direction only continuers or starters are strictly required - as the input * is well-formed, this laxness will not cost us. */ static const CharReach CHARREACH_WORD_UCP_PRE(CHARREACH_WORD | CharReach(128, 255)); /** \brief Prefiltering definition of \\W for UCP Mode. * * (non-word already includes high bytes) */ static const CharReach CHARREACH_NONWORD_UCP_PRE(CHARREACH_NONWORD); /** \brief Find all the edges with assertion flags. */ static vector getAsserts(const NGHolder &g) { vector out; for (const auto &e : edges_range(g)) { if (g[e].assert_flags) { out.push_back(e); } } return out; } static void addToSplit(const NGHolder &g, NFAVertex v, map *to_split) { DEBUG_PRINTF("%zu needs splitting\n", g[v].index); to_split->emplace(g[v].index, v); } /** \brief Find vertices that need to be split due to an assertion edge. * * A vertex needs to be split if has an edge to/from it with an assert with a * restriction on the relevant end. */ static void findSplitters(const NGHolder &g, const vector &asserts, map *to_split, map *to_split_ucp) { for (const auto &e : asserts) { NFAVertex u = source(e, g); NFAVertex v = target(e, g); u32 flags = g[e].assert_flags; assert(flags); const CharReach &u_cr = g[u].char_reach; const CharReach &v_cr = g[v].char_reach; bool ucp_assert = flags & UCP_ASSERT_FLAGS; bool normal_assert = flags & NON_UCP_ASSERT_FLAGS; /* In reality, an expression can only be entirely ucp or not ucp */ assert(ucp_assert != normal_assert); if (normal_assert) { /* assume any flag results in us have to split if the vertex is not * a subset of word or completely disjoint from it. We could be more * nuanced if flags is a disjunction of multiple assertions. */ if (!u_cr.isSubsetOf(CHARREACH_WORD) && !u_cr.isSubsetOf(CHARREACH_NONWORD) && u != g.start) { /* start is always considered a nonword */ addToSplit(g, u, to_split); } if (!v_cr.isSubsetOf(CHARREACH_WORD) && !v_cr.isSubsetOf(CHARREACH_NONWORD) && v != g.accept /* accept require special handling, done on a * per edge basis in resolve asserts */ && v != g.acceptEod) { /* eod is always considered a nonword */ addToSplit(g, v, to_split); } } if (ucp_assert) { /* note: the ucp prefilter crs overlap - requires a bit more care */ if (u == g.start) { /* start never needs to be split, * treat nonword */ } else if (flags & POS_FLAG_ASSERT_WORD_TO_ANY_UCP) { if (!u_cr.isSubsetOf(CHARREACH_WORD_UCP_PRE) && !u_cr.isSubsetOf(~CHARREACH_WORD_UCP_PRE)) { addToSplit(g, u, to_split_ucp); } } else { assert(flags & POS_FLAG_ASSERT_NONWORD_TO_ANY_UCP); if (!u_cr.isSubsetOf(CHARREACH_NONWORD_UCP_PRE) && !u_cr.isSubsetOf(~CHARREACH_NONWORD_UCP_PRE)) { addToSplit(g, u, to_split_ucp); } } if (v == g.acceptEod /* eod is always considered a nonword */ || v == g.accept) { /* accept require special handling, done on * a per edge basis in resolve asserts */ } else if (flags & POS_FLAG_ASSERT_ANY_TO_WORD_UCP) { if (!v_cr.isSubsetOf(CHARREACH_WORD_UCP_PRE) && !v_cr.isSubsetOf(~CHARREACH_WORD_UCP_PRE)) { addToSplit(g, v, to_split_ucp); } } else { assert(flags & POS_FLAG_ASSERT_ANY_TO_NONWORD_UCP); if (!v_cr.isSubsetOf(CHARREACH_NONWORD_UCP_PRE) && !v_cr.isSubsetOf(~CHARREACH_NONWORD_UCP_PRE)) { addToSplit(g, v, to_split_ucp); } } } } } static void setReportId(ReportManager &rm, NGWrapper &g, NFAVertex v, s32 adj) { // Don't try and set the report ID of a special vertex. assert(!is_special(v, g)); // If there's a report set already, we're replacing it. g[v].reports.clear(); Report ir = rm.getBasicInternalReport(g, adj); g[v].reports.insert(rm.getInternalId(ir)); DEBUG_PRINTF("set report id for vertex %zu, adj %d\n", g[v].index, adj); } static NFAVertex makeClone(ReportManager &rm, NGWrapper &g, NFAVertex v, const CharReach &cr_mask) { NFAVertex clone = clone_vertex(g, v); g[clone].char_reach &= cr_mask; clone_out_edges(g, v, clone); clone_in_edges(g, v, clone); if (v == g.startDs) { if (g.utf8) { g[clone].char_reach &= ~UTF_START_CR; } DEBUG_PRINTF("marked as virt\n"); g[clone].assert_flags = POS_FLAG_VIRTUAL_START; setReportId(rm, g, clone, 0); } return clone; } static void splitVertex(ReportManager &rm, NGWrapper &g, NFAVertex v, bool ucp) { assert(v != g.start); assert(v != g.accept); assert(v != g.acceptEod); DEBUG_PRINTF("partitioning vertex %zu ucp:%d\n", g[v].index, (int)ucp); CharReach cr_word = ucp ? CHARREACH_WORD_UCP_PRE : CHARREACH_WORD; CharReach cr_nonword = ucp ? CHARREACH_NONWORD_UCP_PRE : CHARREACH_NONWORD; auto has_no_assert = [&g](const NFAEdge &e) { return !g[e].assert_flags; }; // Split v into word/nonword vertices with only asserting out-edges. NFAVertex w_out = makeClone(rm, g, v, cr_word); NFAVertex nw_out = makeClone(rm, g, v, cr_nonword); remove_out_edge_if(w_out, has_no_assert, g); remove_out_edge_if(nw_out, has_no_assert, g); // Split v into word/nonword vertices with only asserting in-edges. NFAVertex w_in = makeClone(rm, g, v, cr_word); NFAVertex nw_in = makeClone(rm, g, v, cr_nonword); remove_in_edge_if(w_in, has_no_assert, g); remove_in_edge_if(nw_in, has_no_assert, g); // Prune edges with asserts from original v. auto has_assert = [&g](const NFAEdge &e) { return g[e].assert_flags; }; remove_in_edge_if(v, has_assert, g); remove_out_edge_if(v, has_assert, g); } static void resolveEdges(ReportManager &rm, NGWrapper &g, set *dead) { for (const auto &e : edges_range(g)) { u32 flags = g[e].assert_flags; if (!flags) { continue; } NFAVertex u = source(e, g); NFAVertex v = target(e, g); assert(u != g.startDs); const CharReach &u_cr = g[u].char_reach; const CharReach &v_cr = g[v].char_reach; bool impassable = true; bool ucp = flags & UCP_ASSERT_FLAGS; DEBUG_PRINTF("resolving edge %zu->%zu (flags=0x%x, ucp=%d)\n", g[u].index, g[v].index, flags, (int)ucp); while (flags && impassable) { u32 flag = 1U << findAndClearLSB_32(&flags); switch (flag) { case POS_FLAG_ASSERT_NONWORD_TO_NONWORD: case POS_FLAG_ASSERT_NONWORD_TO_WORD: if ((u_cr & CHARREACH_NONWORD).none() && u != g.start) { continue; } break; case POS_FLAG_ASSERT_WORD_TO_NONWORD: case POS_FLAG_ASSERT_WORD_TO_WORD: if ((u_cr & CHARREACH_WORD).none() || u == g.start) { continue; } break; case POS_FLAG_ASSERT_NONWORD_TO_NONWORD_UCP: case POS_FLAG_ASSERT_NONWORD_TO_WORD_UCP: if ((u_cr & ~CHARREACH_NONWORD_UCP_PRE).any() && u != g.start) { continue; } break; case POS_FLAG_ASSERT_WORD_TO_NONWORD_UCP: case POS_FLAG_ASSERT_WORD_TO_WORD_UCP: if ((u_cr & ~CHARREACH_WORD_UCP_PRE).any() || u == g.start) { continue; } break; default: assert(0); } if (v == g.accept) { /* accept special will need to be treated specially later */ impassable = false; continue; } switch (flag) { case POS_FLAG_ASSERT_NONWORD_TO_NONWORD: case POS_FLAG_ASSERT_WORD_TO_NONWORD: if ((v_cr & CHARREACH_NONWORD).none() && v != g.acceptEod) { continue; } break; case POS_FLAG_ASSERT_WORD_TO_WORD: case POS_FLAG_ASSERT_NONWORD_TO_WORD: if ((v_cr & CHARREACH_WORD).none() || v == g.acceptEod) { continue; } break; case POS_FLAG_ASSERT_NONWORD_TO_NONWORD_UCP: case POS_FLAG_ASSERT_WORD_TO_NONWORD_UCP: if ((v_cr & ~CHARREACH_NONWORD_UCP_PRE).any() && v != g.acceptEod) { continue; } break; case POS_FLAG_ASSERT_WORD_TO_WORD_UCP: case POS_FLAG_ASSERT_NONWORD_TO_WORD_UCP: if ((v_cr & ~CHARREACH_WORD_UCP_PRE).any() || v == g.acceptEod) { continue; } break; default: assert(0); } impassable = false; } if (impassable) { dead->insert(e); } else if (v == g.accept && !ucp) { bool u_w = (u_cr & CHARREACH_NONWORD).none() && u != g.start; UNUSED bool u_nw = (u_cr & CHARREACH_WORD).none() || u == g.start; assert(u_w != u_nw); bool v_w = false; bool v_nw = false; flags = g[e].assert_flags; if (u_w) { v_w = flags & POS_FLAG_ASSERT_WORD_TO_WORD; v_nw = flags & POS_FLAG_ASSERT_WORD_TO_NONWORD; } else { v_w = flags & POS_FLAG_ASSERT_NONWORD_TO_WORD; v_nw = flags & POS_FLAG_ASSERT_NONWORD_TO_NONWORD; } assert(v_w || v_nw); if (v_w && v_nw) { /* edge is effectively unconditional */ g[e].assert_flags = 0; } else if (v_w) { /* need to add a word byte */ NFAVertex vv = add_vertex(g); setReportId(rm, g, vv, -1); g[vv].char_reach = CHARREACH_WORD; add_edge(vv, g.accept, g); g[e].assert_flags = 0; add_edge(u, vv, g[e], g); dead->insert(e); } else { /* need to add a non word byte or see eod */ NFAVertex vv = add_vertex(g); setReportId(rm, g, vv, -1); g[vv].char_reach = CHARREACH_NONWORD; add_edge(vv, g.accept, g); g[e].assert_flags = 0; add_edge(u, vv, g[e], g); /* there may already be a different edge from start to eod if so * we need to make it unconditional and alive */ if (NFAEdge start_eod = edge(u, g.acceptEod, g)) { g[start_eod].assert_flags = 0; dead->erase(start_eod); } else { add_edge(u, g.acceptEod, g[e], g); } dead->insert(e); } } else if (v == g.accept && ucp) { DEBUG_PRINTF("resolving ucp assert to accept\n"); assert(u_cr.any()); bool u_w = (u_cr & CHARREACH_WORD_UCP_PRE).any() && u != g.start; bool u_nw = (u_cr & CHARREACH_NONWORD_UCP_PRE).any() || u == g.start; assert(u_w || u_nw); bool v_w = false; bool v_nw = false; flags = g[e].assert_flags; if (u_w) { v_w |= flags & POS_FLAG_ASSERT_WORD_TO_WORD_UCP; v_nw |= flags & POS_FLAG_ASSERT_WORD_TO_NONWORD_UCP; } if (u_nw) { v_w |= flags & POS_FLAG_ASSERT_NONWORD_TO_WORD_UCP; v_nw |= flags & POS_FLAG_ASSERT_NONWORD_TO_NONWORD_UCP; } assert(v_w || v_nw); if (v_w && v_nw) { /* edge is effectively unconditional */ g[e].assert_flags = 0; } else if (v_w) { /* need to add a word byte */ NFAVertex vv = add_vertex(g); setReportId(rm, g, vv, -1); g[vv].char_reach = CHARREACH_WORD_UCP_PRE; add_edge(vv, g.accept, g); g[e].assert_flags = 0; add_edge(u, vv, g[e], g); dead->insert(e); } else { /* need to add a non word byte or see eod */ NFAVertex vv = add_vertex(g); setReportId(rm, g, vv, -1); g[vv].char_reach = CHARREACH_NONWORD_UCP_PRE; add_edge(vv, g.accept, g); g[e].assert_flags = 0; add_edge(u, vv, g[e], g); /* there may already be a different edge from start to eod if so * we need to make it unconditional and alive */ if (NFAEdge start_eod = edge(u, g.acceptEod, g)) { g[start_eod].assert_flags = 0; dead->erase(start_eod); } else { add_edge(u, g.acceptEod, g[e], g); } dead->insert(e); } } else { /* we can remove the asserts as we have partitioned the vertices * into w/nw around the assert edges */ g[e].assert_flags = 0; } } } void resolveAsserts(ReportManager &rm, NGWrapper &g) { vector asserts = getAsserts(g); if (asserts.empty()) { return; } map to_split; /* by index, for determinism */ map to_split_ucp; /* by index, for determinism */ findSplitters(g, asserts, &to_split, &to_split_ucp); if (to_split.size() + to_split_ucp.size() > MAX_CLONED_VERTICES) { throw CompileError(g.expressionIndex, "Pattern is too large."); } for (const auto &m : to_split) { assert(!contains(to_split_ucp, m.first)); splitVertex(rm, g, m.second, false); } for (const auto &m : to_split_ucp) { splitVertex(rm, g, m.second, true); } set dead; resolveEdges(rm, g, &dead); remove_edges(dead, g); renumber_vertices(g); pruneUseless(g); pruneEmptyVertices(g); renumber_vertices(g); renumber_edges(g); clearReports(g); } void ensureCodePointStart(ReportManager &rm, NGWrapper &g) { /* In utf8 mode there is an implicit assertion that we start at codepoint * boundaries. Assert resolution handles the badness coming from asserts. * The only other source of trouble is startDs->accept connections. */ NFAEdge orig = edge(g.startDs, g.accept, g); if (g.utf8 && orig) { DEBUG_PRINTF("rectifying %u\n", g.reportId); Report ir = rm.getBasicInternalReport(g); ReportID rep = rm.getInternalId(ir); NFAVertex v_a = add_vertex(g); g[v_a].assert_flags = POS_FLAG_VIRTUAL_START; g[v_a].char_reach = UTF_ASCII_CR; add_edge(v_a, g.accept, g[orig], g); NFAVertex v_2 = add_vertex(g); g[v_2].assert_flags = POS_FLAG_VIRTUAL_START; g[v_2].char_reach = CharReach(UTF_TWO_BYTE_MIN, UTF_TWO_BYTE_MAX); NFAVertex v_3 = add_vertex(g); g[v_3].assert_flags = POS_FLAG_VIRTUAL_START; g[v_3].char_reach = CharReach(UTF_THREE_BYTE_MIN, UTF_THREE_BYTE_MAX); NFAVertex v_4 = add_vertex(g); g[v_4].assert_flags = POS_FLAG_VIRTUAL_START; g[v_4].char_reach = CharReach(UTF_FOUR_BYTE_MIN, UTF_FOUR_BYTE_MAX); NFAVertex v_c = add_vertex(g); g[v_c].assert_flags = POS_FLAG_VIRTUAL_START; g[v_c].char_reach = UTF_CONT_CR; add_edge(v_c, g.accept, g[orig], g); add_edge(v_2, v_c, g); NFAVertex v_3c = add_vertex(g); g[v_3c].assert_flags = POS_FLAG_VIRTUAL_START; g[v_3c].char_reach = UTF_CONT_CR; add_edge(v_3c, v_c, g); add_edge(v_3, v_3c, g); NFAVertex v_4c = add_vertex(g); g[v_4c].assert_flags = POS_FLAG_VIRTUAL_START; g[v_4c].char_reach = UTF_CONT_CR; add_edge(v_4c, v_3c, g); add_edge(v_4, v_4c, g); g[v_a].reports.insert(rep); g[v_c].reports.insert(rep); add_edge(g.start, v_a, g); add_edge(g.startDs, v_a, g); add_edge(g.start, v_2, g); add_edge(g.startDs, v_2, g); add_edge(g.start, v_3, g); add_edge(g.startDs, v_3, g); add_edge(g.start, v_4, g); add_edge(g.startDs, v_4, g); remove_edge(orig, g); renumber_edges(g); clearReports(g); } } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_split.h0000644000175000017500000000622613055426554020652 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Functions for splitting NFAGraphs into LHS and RHS. */ #ifndef NG_SPLIT_H #define NG_SPLIT_H #include #include "ng_holder.h" #include "util/ue2_containers.h" namespace ue2 { class NGHolder; /** Note: pivot should be a vertex that dominates acceptEod. Treating 'in' * allocated to rhs if they are reachable from the pivot. Conversely, a vertex * is in the lhs if it is reachable from start without going through the * pivot. The pivot ends up in the LHS and any adjacent vertices in the RHS. * * Note: The RHS is setup to be triggered by TOP 0 * * When multiple split vertices are provided: * - RHS contains all vertices reachable from every pivot * - LHS contains all vertices which are reachable from start ignoring any * vertices which have an edge to every pivot */ void splitGraph(const NGHolder &base, NFAVertex pivot, NGHolder *lhs, ue2::unordered_map *lhs_map, NGHolder *rhs, ue2::unordered_map *rhs_map); void splitGraph(const NGHolder &base, const std::vector &pivots, NGHolder *lhs, ue2::unordered_map *lhs_map, NGHolder *rhs, ue2::unordered_map *rhs_map); void splitLHS(const NGHolder &base, NFAVertex pivot, NGHolder *lhs, ue2::unordered_map *lhs_map); void splitRHS(const NGHolder &base, const std::vector &pivots, NGHolder *rhs, ue2::unordered_map *rhs_map); } // namespace ue2 #endif // NG_SPLIT_H hyperscan-4.4.1/src/nfagraph/ng_region_redundancy.cpp0000644000175000017500000002164313055426554023551 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Region Redundancy optimisation pass. * * Identifies and removes entire regions that are adjacent to a cyclic state * with a superset of their character reachability. */ #include "ng_region_redundancy.h" #include "ng_holder.h" #include "ng_region.h" #include "ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/graph_range.h" #include using namespace std; namespace ue2 { namespace { /** Precalculated information about a region. */ struct RegionInfo { NFAVertex entry; //!< arbitrary entry vertex CharReach cr; //!< union of the reach of all vertices in region }; } // namespace static bool regionHasUnexpectedAccept(const NGHolder &g, const u32 region, const flat_set &expected_reports, const ue2::unordered_map ®ion_map) { /* TODO: only check vertices connected to accept/acceptEOD */ for (auto v : vertices_range(g)) { if (region != region_map.at(v)) { continue; } if (is_any_accept(v, g)) { return true; /* encountering an actual special in the region is * possible but definitely unexpected */ } for (auto w : adjacent_vertices_range(v, g)) { if (is_any_accept(w, g) && g[v].reports != expected_reports) { return true; } } } return false; } static void processCyclicStateForward(NGHolder &h, NFAVertex cyc, const map &info, const ue2::unordered_map ®ion_map, set &deadRegions) { u32 region = region_map.at(cyc); CharReach cr = h[cyc].char_reach; auto reports = h[cyc].reports; DEBUG_PRINTF("going forward from %zu/%u\n", h[cyc].index, region); map::const_iterator it; while ((it = info.find(++region)) != info.end()) { NFAVertex v = it->second.entry; const CharReach ®ion_cr = it->second.cr; assert(isRegionEntry(h, v, region_map) && !is_special(v, h)); DEBUG_PRINTF("checking %zu\n", h[v].index); if (!region_cr.isSubsetOf(cr)) { DEBUG_PRINTF("doesn't cover the reach of region %u\n", region); break; } if (isOptionalRegion(h, v, region_map) && !regionHasUnexpectedAccept(h, region, reports, region_map)) { DEBUG_PRINTF("cyclic state %zu leads to optional region leader" " %zu\n", h[cyc].index, h[v].index); deadRegions.insert(region); } else if (isSingletonRegion(h, v, region_map)) { /* we can use this region as straw and suck in optional regions on * the other side. This allows us to transform /a{n,m}/ to /a{n}/ */ cr = h[v].char_reach; reports = h[v].reports; DEBUG_PRINTF("%u is straw\n", region); assert(cr.isSubsetOf(h[cyc].char_reach)); if (hasSelfLoop(v, h)) { DEBUG_PRINTF("%u is straw has a self-loop - kill\n", region); remove_edge(v, v, h); } } else { break; } } } static void processCyclicStateReverse(NGHolder &h, NFAVertex cyc, const map &info, const ue2::unordered_map ®ion_map, set &deadRegions) { u32 region = region_map.at(cyc); CharReach cr = h[cyc].char_reach; auto reports = h[cyc].reports; DEBUG_PRINTF("going back from %zu/%u\n", h[cyc].index, region); map::const_iterator it; while ((it = info.find(--region)) != info.end()) { NFAVertex v = it->second.entry; const CharReach ®ion_cr = it->second.cr; assert(isRegionEntry(h, v, region_map) && !is_special(v, h)); DEBUG_PRINTF("checking %zu\n", h[v].index); if (!region_cr.isSubsetOf(cr)) { DEBUG_PRINTF("doesn't cover the reach of region %u\n", region); break; } if (isOptionalRegion(h, v, region_map) && !regionHasUnexpectedAccept(h, region, reports, region_map)) { DEBUG_PRINTF("cyclic state %zu trails optional region leader %zu\n", h[cyc].index, h[v].index); deadRegions.insert(region); } else if (isSingletonRegion(h, v, region_map)) { /* we can use this region as a reverse straw and suck in optional * regions on the other side. This allows us to transform * /^a?a{n}.*b/ to /^a{n}.*b/ */ cr = h[v].char_reach; reports = h[v].reports; DEBUG_PRINTF("%u is straw\n", region); assert(cr.isSubsetOf(h[cyc].char_reach)); if (hasSelfLoop(v, h)) { DEBUG_PRINTF("%u is straw has a self-loop - kill\n", region); remove_edge(v, v, h); } } else { break; } if (!region) { // No wrapping break; } } } static map buildRegionInfoMap(const NGHolder &g, const ue2::unordered_map ®ion_map) { map info; for (auto v : vertices_range(g)) { u32 region = region_map.at(v); if (is_special(v, g) || region == 0) { continue; } RegionInfo &ri = info[region]; ri.cr |= g[v].char_reach; if (isRegionEntry(g, v, region_map)) { ri.entry = v; } } return info; } static bool hasNoStartAnchoring(const NGHolder &h) { for (auto v : adjacent_vertices_range(h.start, h)) { if (!edge(h.startDs, v, h).second) { return false; } } return true; } void removeRegionRedundancy(NGHolder &g, som_type som) { auto region_map = assignRegions(g); map info = buildRegionInfoMap(g, region_map); set deadRegions; /* if we are not tracking som, we can treat sds as a cyclic region if there * is no anchoring */ if (!som && hasNoStartAnchoring(g)) { processCyclicStateForward(g, g.startDs, info, region_map, deadRegions); } // Walk the region mapping, looking for regions that consist of a single // cyclic node. for (const auto &m : info) { // Must not have already been removed if (contains(deadRegions, m.first)) { continue; } NFAVertex v = m.second.entry; /* require a singleton cyclic region */ if (!hasSelfLoop(v, g) || !isSingletonRegion(g, v, region_map)) { continue; } if (som && is_virtual_start(v, g)) { continue; } processCyclicStateForward(g, v, info, region_map, deadRegions); processCyclicStateReverse(g, v, info, region_map, deadRegions); } if (deadRegions.empty()) { return; } vector dead; for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } u32 region = region_map.at(v); if (contains(deadRegions, region)) { dead.push_back(v); } } if (!dead.empty()) { DEBUG_PRINTF("removing %zu vertices from %zu dead regions\n", dead.size(), deadRegions.size()); remove_vertices(dead, g); } } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_calc_components.h0000644000175000017500000000367513055426554022673 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Splits an NFA graph into its connected components. */ #ifndef NG_CALC_COMPONENTS_H #define NG_CALC_COMPONENTS_H #include #include namespace ue2 { class NGHolder; bool isAlternationOfClasses(const NGHolder &g); std::deque> calcComponents(const NGHolder &g); void recalcComponents(std::deque> &comps); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_literal_decorated.cpp0000644000175000017500000001677613055426554023533 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Analysis for literals decorated by leading/trailing assertions or * character classes. */ #include "ng_literal_decorated.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_util.h" #include "rose/rose_build.h" #include "rose/rose_in_graph.h" #include "rose/rose_in_util.h" #include "util/compile_context.h" #include "util/dump_charclass.h" #include "util/make_unique.h" #include #include #include #include using namespace std; namespace ue2 { namespace { /** \brief Max fixed-width paths to generate from a graph. */ static constexpr size_t MAX_PATHS = 10; /** \brief Max degree for any non-special vertex in the graph. */ static constexpr size_t MAX_VERTEX_DEGREE = 6; using Path = vector; } // namespace static bool findPaths(const NGHolder &g, vector &paths) { vector order = getTopoOrdering(g); vector read_count(num_vertices(g)); vector> built(num_vertices(g)); for (auto it = order.rbegin(); it != order.rend(); ++it) { NFAVertex v = *it; auto &out = built[g[v].index]; assert(out.empty()); read_count[g[v].index] = out_degree(v, g); DEBUG_PRINTF("setting read_count to %zu for %zu\n", read_count[g[v].index], g[v].index); if (v == g.start || v == g.startDs) { out.push_back({v}); continue; } // The paths to v are the paths to v's predecessors, with v added to // the end of each. for (auto u : inv_adjacent_vertices_range(v, g)) { // We have a stylized connection from start -> startDs, but we // don't need anchored and unanchored versions of the same path. if (u == g.start && edge(g.startDs, v, g).second) { continue; } // Similarly, avoid the accept->acceptEod edge. if (u == g.accept) { assert(v == g.acceptEod); continue; } assert(!built[g[u].index].empty()); assert(read_count[g[u].index]); for (const auto &p : built[g[u].index]) { out.push_back(p); out.back().push_back(v); if (out.size() > MAX_PATHS) { // All these paths should eventually end up at a sink, so // we've blown past our limit. DEBUG_PRINTF("path limit exceeded\n"); return false; } } read_count[g[u].index]--; if (!read_count[g[u].index]) { DEBUG_PRINTF("clearing %zu as finished reading\n", g[u].index); built[g[u].index].clear(); built[g[u].index].shrink_to_fit(); } } } insert(&paths, paths.end(), built[NODE_ACCEPT]); insert(&paths, paths.end(), built[NODE_ACCEPT_EOD]); DEBUG_PRINTF("%zu paths generated\n", paths.size()); return paths.size() <= MAX_PATHS; } static bool hasLargeDegreeVertex(const NGHolder &g) { for (const auto &v : vertices_range(g)) { if (is_special(v, g)) { // specials can have large degree continue; } if (degree(v, g) > MAX_VERTEX_DEGREE) { DEBUG_PRINTF("vertex %zu has degree %zu\n", g[v].index, degree(v, g)); return true; } } return false; } #if defined(DEBUG) || defined(DUMP_SUPPORT) static UNUSED string dumpPath(const NGHolder &g, const Path &path) { ostringstream oss; for (const auto &v : path) { switch (g[v].index) { case NODE_START: oss << ""; break; case NODE_START_DOTSTAR: oss << ""; break; case NODE_ACCEPT: oss << ""; break; case NODE_ACCEPT_EOD: oss << ""; break; default: oss << describeClass(g[v].char_reach); break; } } return oss.str(); } #endif struct PathMask { PathMask(const NGHolder &g, const Path &path) : is_anchored(path.front() == g.start), is_eod(path.back() == g.acceptEod) { assert(path.size() >= 2); mask.reserve(path.size() - 2); for (const auto &v : path) { if (is_special(v, g)) { continue; } mask.push_back(g[v].char_reach); } // Reports are attached to the second-to-last vertex. NFAVertex u = *std::next(path.rbegin()); reports = g[u].reports; assert(!reports.empty()); } vector mask; ue2::flat_set reports; bool is_anchored; bool is_eod; }; bool handleDecoratedLiterals(RoseBuild &rose, const NGHolder &g, const CompileContext &cc) { if (!cc.grey.allowDecoratedLiteral) { return false; } if (!isAcyclic(g)) { DEBUG_PRINTF("not acyclic\n"); return false; } if (hasLargeDegreeVertex(g)) { DEBUG_PRINTF("large degree\n"); return false; } vector paths; if (!findPaths(g, paths)) { DEBUG_PRINTF("couldn't split into a small number of paths\n"); return false; } assert(!paths.empty()); assert(paths.size() <= MAX_PATHS); vector masks; masks.reserve(paths.size()); for (const auto &path : paths) { DEBUG_PRINTF("path: %s\n", dumpPath(g, path).c_str()); PathMask pm(g, path); if (!rose.validateMask(pm.mask, pm.reports, pm.is_anchored, pm.is_eod)) { DEBUG_PRINTF("failed validation\n"); return false; } masks.push_back(move(pm)); } for (const auto &pm : masks) { rose.addMask(pm.mask, pm.reports, pm.is_anchored, pm.is_eod); } DEBUG_PRINTF("all ok, %zu masks added\n", masks.size()); return true; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_squash.cpp0000644000175000017500000005611013055426554021353 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA graph state squashing analysis. * * The basic idea behind the state squashing is that when we are in a cyclic * state v there are certain other states which are completely irrelevant. This * is used primarily by the determinisation process to produce smaller DFAs by * not tracking irrelevant states. It's also used by the LimEx NFA model. * * Working out which states we can ignore mainly uses the post-dominator * analysis. * * ### Dot Squash Masks: * * The following vertices are added to the squash mask: * - (1) Any vertex post-dominated by the cyclic dot state * - (2) Any other vertex post-dominated by the cyclic dot state's successors * - (3) Any vertex post-dominated by a predecessor of the cyclic dot state - * provided the predecessor's successors are a subset of the cyclic state's * successors [For (3), the term successor also includes report information] * * (2) and (3) allow us to get squash masks from .* as well as .+ * * The squash masks are not optimal especially in the case where there * alternations on both sides - for example in: * * /foo(bar|baz).*(abc|xyz)/s * * 'foo' is irrelevant once the dot star is hit, but it has no post-dominators * so isn't picked up ('bar' and 'baz' are picked up by (2)). We may be able to * do a more complete analysis based on cutting the graph and seeing which * vertices are unreachable but the current approach is quick and probably * adequate. * * * ### Non-Dot Squash Masks: * * As for dot states. However, if anything in a pdom tree falls outside the * character range of the cyclic state the whole pdom tree is ignored. Also when * considering the predecessor's pdom tree it is necessary to verify that the * predecessor's character reachability falls within that of the cyclic state. * * We could do better in this case by not throwing away the whole pdom tree - * however the bits which we can keep are not clear from the pdom tree of the * cyclic state - it probably can be based on the dom or pdom tree of the bad * vertex. * * An example of us doing badly is: * * /HTTP.*Referer[^\n]*google/s * * as '[\\n]*' doesn't get a squash mask at all due to .* but we should be able * to squash 'Referer'. * * ### Extension: * * If a state leads solely to a squashable state (or its immediate successors) * with the same reachability we can make this state a squash state of any of * the original states squashees which we postdominate. Could probably tighten * this up but it would require thought. May not need to keep the original * squasher around but that would also require thought. * * ### SOM Notes: * * If (left) start of match is required, it is illegal to squash any state which * may result in an early start of match reaching the squashing state. */ #include "config.h" #include "ng_squash.h" #include "ng_dominators.h" #include "ng_dump.h" #include "ng_holder.h" #include "ng_prune.h" #include "ng_region.h" #include "ng_som_util.h" #include "ng_util.h" #include "ng_util.h" #include "util/container.h" #include "util/graph_range.h" #include "util/report_manager.h" #include "ue2common.h" #include #include #include #include using namespace std; namespace ue2 { typedef ue2::unordered_map > PostDomTree; static void buildPDomTree(const NGHolder &g, PostDomTree &tree) { ue2::unordered_map postdominators = findPostDominators(g); for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } NFAVertex pdom = postdominators[v]; if (pdom) { DEBUG_PRINTF("vertex %zu -> %zu\n", g[pdom].index, g[v].index); tree[pdom].insert(v); } } } /** * Builds a squash mask based on the pdom tree of v and the given char reach. * The built squash mask is a bit conservative for non-dot cases and could * be improved with a bit of thought. */ static void buildSquashMask(NFAStateSet &mask, const NGHolder &g, NFAVertex v, const CharReach &cr, const NFAStateSet &init, const vector &vByIndex, const PostDomTree &tree, som_type som, const vector &som_depths, const ue2::unordered_map ®ion_map, smgb_cache &cache) { DEBUG_PRINTF("build base squash mask for vertex %zu)\n", g[v].index); vector q; PostDomTree::const_iterator it = tree.find(v); if (it != tree.end()) { q.insert(q.end(), it->second.begin(), it->second.end()); } const u32 v_index = g[v].index; while (!q.empty()) { NFAVertex u = q.back(); q.pop_back(); const CharReach &cru = g[u].char_reach; if ((cru & ~cr).any()) { /* bail: bad cr on vertex u */ /* TODO: this could be better * * we still need to ensure that we record any paths leading to u. * Hence all vertices R which can reach u must be excluded from the * squash mask. Note: R != pdom(u) and there may exist an x in (R - * pdom(u)) which is in pdom(y) where y is in q. Clear ? */ mask.set(); return; } const u32 u_index = g[u].index; if (som) { /* We cannot add a state u to the squash mask of v if it may have an * earlier start of match offset. ie for us to add a state u to v * maxSomDist(u) <= minSomDist(v) */ const depth &max_som_dist_u = som_depths[u_index].max; const depth &min_som_dist_v = som_depths[v_index].min; if (max_som_dist_u.is_infinite()) { /* it is hard to tell due to the INF if u can actually store an * earlier SOM than w (state we are building the squash mask * for) - need to think more deeply */ if (mustBeSetBefore(u, v, g, cache) && !somMayGoBackwards(u, g, region_map, cache)) { DEBUG_PRINTF("u %u v %u\n", u_index, v_index); goto squash_ok; } } if (max_som_dist_u > min_som_dist_v) { /* u can't be squashed as it may be storing an earlier SOM */ goto add_children_to_queue; } } squash_ok: mask.set(u_index); DEBUG_PRINTF("pdom'ed %u\n", u_index); add_children_to_queue: it = tree.find(u); if (it != tree.end()) { q.insert(q.end(), it->second.begin(), it->second.end()); } } if (cr.all()) { /* the init states aren't in the pdom tree. If all their succ states * are set (or v), we can consider them post dominated */ /* Note: init states will always result in a later som */ for (size_t i = init.find_first(); i != init.npos; i = init.find_next(i)) { /* Yes vacuous patterns do exist */ NFAVertex iv = vByIndex[i]; for (auto w : adjacent_vertices_range(iv, g)) { if (w == g.accept || w == g.acceptEod) { DEBUG_PRINTF("skipping %zu due to vacuous accept\n", i); goto next_init_state; } u32 vert_id = g[w].index; if (w != iv && w != v && !mask.test(vert_id)) { DEBUG_PRINTF("skipping %zu due to %u\n", i, vert_id); goto next_init_state; } } DEBUG_PRINTF("pdom'ed %zu\n", i); mask.set(i); next_init_state:; } } mask.flip(); } static void buildSucc(NFAStateSet &succ, const NGHolder &g, NFAVertex v) { for (auto w : adjacent_vertices_range(v, g)) { if (!is_special(w, g)) { succ.set(g[w].index); } } } static void buildPred(NFAStateSet &pred, const NGHolder &g, NFAVertex v) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (!is_special(u, g)) { pred.set(g[u].index); } } } static void findDerivedSquashers(const NGHolder &g, const vector &vByIndex, const PostDomTree &pdom_tree, const NFAStateSet &init, map *squash, som_type som, const vector &som_depths, const ue2::unordered_map ®ion_map, smgb_cache &cache) { deque remaining; for (const auto &m : *squash) { remaining.push_back(m.first); } while (!remaining.empty()) { NFAVertex v = remaining.back(); remaining.pop_back(); for (auto u : inv_adjacent_vertices_range(v, g)) { if (is_special(u, g)) { continue; } if (g[v].char_reach != g[u].char_reach) { continue; } if (out_degree(u, g) != 1) { continue; } NFAStateSet u_squash(init.size()); size_t u_index = g[u].index; buildSquashMask(u_squash, g, u, g[u].char_reach, init, vByIndex, pdom_tree, som, som_depths, region_map, cache); u_squash.set(u_index); /* never clear ourselves */ if ((~u_squash).any()) { // i.e. some bits unset in mask DEBUG_PRINTF("%zu is an upstream squasher of %zu\n", u_index, g[v].index); (*squash)[u] = u_squash; remaining.push_back(u); } } } } /* If there are redundant states in the graph, it may be possible for two sibling * .* states to try to squash each other -- which should be prevented * * Note: this situation should only happen if ng_equivalence has not been run. */ static void clearMutualSquashers(const NGHolder &g, const vector &vByIndex, map &squash) { for (auto it = squash.begin(); it != squash.end();) { NFAVertex a = it->first; u32 a_index = g[a].index; NFAStateSet a_squash = ~it->second; /* default is mask of survivors */ for (NFAStateSet::size_type b_index = a_squash.find_first(); b_index != a_squash.npos; b_index = a_squash.find_next(b_index)) { assert(b_index != a_index); NFAVertex b = vByIndex[b_index]; if (!contains(squash, b)) { continue; } if (!squash[b].test(a_index)) { /* b and a squash each other, prevent this */ DEBUG_PRINTF("removing mutual squash %u %zu\n", a_index, b_index); squash[b].set(a_index); it->second.set(b_index); } } if (it->second.all()) { DEBUG_PRINTF("%u is no longer an effictive squash state\n", a_index); it = squash.erase(it); } else { ++it; } } } map findSquashers(const NGHolder &g, som_type som) { map squash; // Number of bits to use for all our masks. If we're a triggered graph, // tops have already been assigned, so we don't have to account for them. const u32 numStates = num_vertices(g); // Build post-dominator tree. PostDomTree pdom_tree; buildPDomTree(g, pdom_tree); // Build list of vertices by state ID and a set of init states. vector vByIndex(numStates, NGHolder::null_vertex()); NFAStateSet initStates(numStates); smgb_cache cache(g); // Mappings used for SOM mode calculations, otherwise left empty. unordered_map region_map; vector som_depths; if (som) { region_map = assignRegions(g); som_depths = getDistancesFromSOM(g); } for (auto v : vertices_range(g)) { const u32 vert_id = g[v].index; DEBUG_PRINTF("vertex %u/%u\n", vert_id, numStates); assert(vert_id < numStates); vByIndex[vert_id] = v; if (is_any_start(v, g) || !in_degree(v, g)) { initStates.set(vert_id); } } for (u32 i = 0; i < numStates; i++) { NFAVertex v = vByIndex[i]; assert(v != NGHolder::null_vertex()); const CharReach &cr = g[v].char_reach; /* only non-init cyclics can be squashers */ if (!hasSelfLoop(v, g) || initStates.test(i)) { continue; } DEBUG_PRINTF("state %u is cyclic\n", i); NFAStateSet mask(numStates), succ(numStates), pred(numStates); buildSquashMask(mask, g, v, cr, initStates, vByIndex, pdom_tree, som, som_depths, region_map, cache); buildSucc(succ, g, v); buildPred(pred, g, v); const auto &reports = g[v].reports; for (size_t j = succ.find_first(); j != succ.npos; j = succ.find_next(j)) { NFAVertex vj = vByIndex[j]; NFAStateSet pred2(numStates); buildPred(pred2, g, vj); if (pred2 == pred) { DEBUG_PRINTF("adding the sm from %zu to %u's sm\n", j, i); NFAStateSet tmp(numStates); buildSquashMask(tmp, g, vj, cr, initStates, vByIndex, pdom_tree, som, som_depths, region_map, cache); mask &= tmp; } } for (size_t j = pred.find_first(); j != pred.npos; j = pred.find_next(j)) { NFAVertex vj = vByIndex[j]; NFAStateSet succ2(numStates); buildSucc(succ2, g, vj); /* we can use j as a basis for squashing if its succs are a subset * of ours */ if ((succ2 & ~succ).any()) { continue; } if (som) { /* We cannot use j to add to the squash mask of v if it may * have an earlier start of match offset. ie for us j as a * basis for the squash mask of v we require: * maxSomDist(j) <= minSomDist(v) */ /* ** TODO ** */ const depth &max_som_dist_j = som_depths[g[vj].index].max; const depth &min_som_dist_v = som_depths[g[v].index].min; if (max_som_dist_j > min_som_dist_v || max_som_dist_j.is_infinite()) { /* j can't be used as it may be storing an earlier SOM */ continue; } } const CharReach &crv = g[vj].char_reach; /* we also require that j's report information be a subset of ours */ bool seen_special = false; for (auto w : adjacent_vertices_range(vj, g)) { if (is_special(w, g)) { if (!edge(v, w, g).second) { goto next_j; } seen_special = true; } } // FIXME: should be subset check? if (seen_special && g[vj].reports != reports) { continue; } /* ok we can use j */ if ((crv & ~cr).none()) { NFAStateSet tmp(numStates); buildSquashMask(tmp, g, vj, cr, initStates, vByIndex, pdom_tree, som, som_depths, region_map, cache); mask &= tmp; mask.reset(j); } next_j:; } mask.set(i); /* never clear ourselves */ if ((~mask).any()) { // i.e. some bits unset in mask DEBUG_PRINTF("%u squashes %zu other states\n", i, (~mask).count()); squash.emplace(v, mask); } } findDerivedSquashers(g, vByIndex, pdom_tree, initStates, &squash, som, som_depths, region_map, cache); clearMutualSquashers(g, vByIndex, squash); return squash; } #define MIN_PURE_ACYCLIC_SQUASH 10 /** magic number */ /** Some squash states are clearly not advantageous in the NFA, as they do * incur the cost of an exception: * -# acyclic states * -# squash only a few acyclic states */ void filterSquashers(const NGHolder &g, map &squash) { DEBUG_PRINTF("filtering\n"); map rev; /* vertex_index -> vertex */ for (auto v : vertices_range(g)) { rev[g[v].index] = v; } for (auto v : vertices_range(g)) { if (!contains(squash, v)) { continue; } DEBUG_PRINTF("looking at squash set for vertex %zu\n", g[v].index); if (!hasSelfLoop(v, g)) { DEBUG_PRINTF("acyclic\n"); squash.erase(v); continue; } NFAStateSet squashed = squash[v]; squashed.flip(); /* default sense for mask of survivors */ for (NFAStateSet::size_type sq = squashed.find_first(); sq != squashed.npos; sq = squashed.find_next(sq)) { NFAVertex u = rev[sq]; if (hasSelfLoop(u, g)) { DEBUG_PRINTF("squashing a cyclic (%zu) is always good\n", sq); goto next_vertex; } } if (squashed.count() < MIN_PURE_ACYCLIC_SQUASH) { DEBUG_PRINTF("squash set too small\n"); squash.erase(v); continue; } next_vertex:; DEBUG_PRINTF("squash set ok\n"); } } static void getHighlanderReporters(const NGHolder &g, const NFAVertex accept, const ReportManager &rm, set &verts) { for (auto v : inv_adjacent_vertices_range(accept, g)) { if (v == g.accept) { continue; } const auto &reports = g[v].reports; if (reports.empty()) { assert(0); continue; } // Must be _all_ highlander callback reports. for (auto report : reports) { const Report &ir = rm.getReport(report); if (ir.ekey == INVALID_EKEY || ir.type != EXTERNAL_CALLBACK) { goto next_vertex; } // If there's any bounds, these are handled outside the NFA and // probably shouldn't be pre-empted. if (ir.hasBounds()) { goto next_vertex; } } verts.insert(v); next_vertex: continue; } } static void removeEdgesToAccept(NGHolder &g, NFAVertex v) { const auto &reports = g[v].reports; assert(!reports.empty()); // We remove any accept edge with a non-empty subset of the reports of v. set dead; for (const auto &e : in_edges_range(g.accept, g)) { NFAVertex u = source(e, g); const auto &r = g[u].reports; if (!r.empty() && is_subset_of(r, reports)) { DEBUG_PRINTF("vertex %zu\n", g[u].index); dead.insert(e); } } for (const auto &e : in_edges_range(g.acceptEod, g)) { NFAVertex u = source(e, g); const auto &r = g[u].reports; if (!r.empty() && is_subset_of(r, reports)) { DEBUG_PRINTF("vertex %zu\n", g[u].index); dead.insert(e); } } assert(!dead.empty()); remove_edges(dead, g); } static vector findUnreachable(const NGHolder &g) { const boost::reverse_graph revg(g); ue2::unordered_map colours; colours.reserve(num_vertices(g)); depth_first_visit(revg, g.acceptEod, make_dfs_visitor(boost::null_visitor()), make_assoc_property_map(colours)); // Unreachable vertices are not in the colour map. vector unreach; for (auto v : vertices_range(revg)) { if (!contains(colours, v)) { unreach.push_back(NFAVertex(v)); } } return unreach; } /** Populates squash masks for states that can be switched off by highlander * (single match) reporters. */ map findHighlanderSquashers(const NGHolder &g, const ReportManager &rm) { map squash; set verts; getHighlanderReporters(g, g.accept, rm, verts); getHighlanderReporters(g, g.acceptEod, rm, verts); if (verts.empty()) { DEBUG_PRINTF("no highlander reports\n"); return squash; } const u32 numStates = num_vertices(g); for (auto v : verts) { DEBUG_PRINTF("vertex %zu with %zu reports\n", g[v].index, g[v].reports.size()); // Find the set of vertices that lead to v or any other reporter with a // subset of v's reports. We do this by creating a copy of the graph, // cutting the appropriate out-edges to accept and seeing which // vertices become unreachable. ue2::unordered_map orig_to_copy; NGHolder h; cloneHolder(h, g, &orig_to_copy); removeEdgesToAccept(h, orig_to_copy[v]); vector unreach = findUnreachable(h); DEBUG_PRINTF("can squash %zu vertices\n", unreach.size()); if (unreach.empty()) { continue; } if (!contains(squash, v)) { squash[v] = NFAStateSet(numStates); squash[v].set(); } NFAStateSet &mask = squash[v]; for (auto uv : unreach) { DEBUG_PRINTF("squashes index %zu\n", h[uv].index); mask.reset(h[uv].index); } } return squash; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_edge_redundancy.h0000644000175000017500000000475613055426554022645 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Edge redundancy graph reductions. */ #ifndef NG_EDGE_REDUNDANCY_H #define NG_EDGE_REDUNDANCY_H #include "som/som.h" namespace ue2 { class NGHolder; struct CompileContext; /** \brief Entry point: Runs all the edge redundancy passes. */ bool removeEdgeRedundancy(NGHolder &g, som_type som, const CompileContext &cc); /** \brief Removes optional stuff from the front of floating patterns, since * it's redundant with startDs. * * For each successor of startDs, remove any in-edges that aren't from either * start or startDs. This allows us to prune redundant vertices at the start of * a pattern: * * /(hat)?stand --> /stand/ * */ bool removeSiblingsOfStartDotStar(NGHolder &g); /** \brief Removes all edges into virtual starts other than those from * start/startDs, providing there is an edge from startDs. * * This operation is an optimisation for SOM mode. (see UE-1544) */ bool optimiseVirtualStarts(NGHolder &g); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_som_util.cpp0000644000175000017500000002776513055426554021720 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Utility functions related to SOM ("Start of Match"). */ #include "ng_som_util.h" #include "ng_depth.h" #include "ng_execute.h" #include "ng_holder.h" #include "ng_prune.h" #include "ng_util.h" #include "util/container.h" #include "util/graph_range.h" using namespace std; namespace ue2 { static void wireSuccessorsToStart(NGHolder &g, NFAVertex u) { for (auto v : adjacent_vertices_range(u, g)) { add_edge_if_not_present(g.start, v, g); } } vector getDistancesFromSOM(const NGHolder &g_orig) { // We operate on a temporary copy of the original graph here, so we don't // have to mutate the original. NGHolder g; ue2::unordered_map vmap; // vertex in g_orig to vertex in g cloneHolder(g, g_orig, &vmap); vector vstarts; for (auto v : vertices_range(g)) { if (is_virtual_start(v, g)) { vstarts.push_back(v); } } vstarts.push_back(g.startDs); // wire the successors of every virtual start or startDs to g.start. for (auto v : vstarts) { wireSuccessorsToStart(g, v); } // drop the in-edges of every virtual start so that they don't participate // in the depth calculation. for (auto v : vstarts) { clear_in_edges(v, g); } //dumpGraph("som_depth.dot", g); vector temp_depths; // numbered by vertex index in g calcDepthsFrom(g, g.start, temp_depths); // Transfer depths, indexed by vertex index in g_orig. vector depths(num_vertices(g_orig)); for (auto v_orig : vertices_range(g_orig)) { assert(contains(vmap, v_orig)); NFAVertex v_new = vmap[v_orig]; u32 orig_idx = g_orig[v_orig].index; DepthMinMax &d = depths.at(orig_idx); if (v_orig == g_orig.startDs || is_virtual_start(v_orig, g_orig)) { // StartDs and virtual starts always have zero depth. d = DepthMinMax(0, 0); } else { u32 new_idx = g[v_new].index; d = temp_depths.at(new_idx); } } return depths; } bool firstMatchIsFirst(const NGHolder &p) { /* If the first match (by end offset) is not the first match (by start * offset) then we can't create a lock after it. * * Consider: 4009:/(foobar|ob).*bugger/s * * We don't care about races on the last byte as they can be resolved easily * at runtime /(foobar|obar).*hi/ * * It should be obvious we don't care about one match being a prefix * of another as they share the same start offset. * * Therefore, the case were we cannot establish that the som does not * regress is when there exists s1 and s2 in the language of p and s2 is a * proper infix of s1. * * It is tempting to add the further restriction that there does not exist a * prefix of s1 that is in the language of p (as in which case we would * presume, the lock has already been set). However, we have no way of * knowing if the lock can be cleared by some characters, and if so, if it * is still set. TODO: if we knew the lock's escapes where we could verify * that the rest of s1 does not clear the lock. (1) */ DEBUG_PRINTF("entry\n"); /* If there are any big cycles throw up our hands in despair */ if (hasBigCycles(p)) { DEBUG_PRINTF("fail, big cycles\n"); return false; } ue2::flat_set states; /* turn on all states (except starts - avoid suffix matches) */ /* If we were doing (1) we would also except states leading to accepts - avoid prefix matches */ for (auto v : vertices_range(p)) { assert(!is_virtual_start(v, p)); if (!is_special(v, p)) { DEBUG_PRINTF("turning on %zu\n", p[v].index); states.insert(v); } } /* run the prefix the main graph */ states = execute_graph(p, p, states); for (auto v : states) { /* need to check if this vertex may represent an infix match - ie * it does not have an edge to accept. */ DEBUG_PRINTF("check %zu\n", p[v].index); if (!edge(v, p.accept, p).second) { DEBUG_PRINTF("fail %zu\n", p[v].index); return false; } } DEBUG_PRINTF("done first is first check\n"); return true; } bool somMayGoBackwards(NFAVertex u, const NGHolder &g, const ue2::unordered_map ®ion_map, smgb_cache &cache) { /* Need to ensure all matches of the graph g up to u contain no infixes * which are also matches of the graph to u. * * This is basically the same as firstMatchIsFirst except we g is not * always a dag. As we haven't gotten around to writing an execute_graph * that operates on general graphs, we take some (hopefully) conservative * short cuts. * * Note: if the u can be jumped we will take jump edges * into account as a possibility of som going backwards * * TODO: write a generalised ng_execute_graph/make this less hacky */ assert(&g == &cache.g); if (contains(cache.smgb, u)) { return cache.smgb[u]; } DEBUG_PRINTF("checking if som can go backwards on %zu\n", g[u].index); set be; BackEdges> backEdgeVisitor(be); boost::depth_first_search(g, visitor(backEdgeVisitor).root_vertex(g.start)); bool rv; if (0) { exit: DEBUG_PRINTF("using cached result\n"); cache.smgb[u] = rv; return rv; } assert(contains(region_map, u)); const u32 u_region = region_map.at(u); for (const auto &e : be) { NFAVertex s = source(e, g); NFAVertex t = target(e, g); /* only need to worry about big cycles including/before u */ DEBUG_PRINTF("back edge %zu %zu\n", g[s].index, g[t].index); if (s != t && region_map.at(s) <= u_region) { DEBUG_PRINTF("eek big cycle\n"); rv = true; /* big cycle -> eek */ goto exit; } } ue2::unordered_map orig_to_copy; NGHolder c_g; cloneHolder(c_g, g, &orig_to_copy); /* treat virtual starts as unconditional - wire to startDs instead */ for (NFAVertex v : vertices_range(g)) { if (!is_virtual_start(v, g)) { continue; } NFAVertex c_v = orig_to_copy[v]; orig_to_copy[v] = c_g.startDs; for (NFAVertex c_w : adjacent_vertices_range(c_v, c_g)) { add_edge_if_not_present(c_g.startDs, c_w, c_g); } clear_vertex(c_v, c_g); } /* treat u as the only accept state */ NFAVertex c_u = orig_to_copy[u]; clear_in_edges(c_g.acceptEod, c_g); add_edge(c_g.accept, c_g.acceptEod, c_g); clear_in_edges(c_g.accept, c_g); clear_out_edges(c_u, c_g); if (hasSelfLoop(u, g)) { add_edge(c_u, c_u, c_g); } add_edge(c_u, c_g.accept, c_g); set u_succ; insert(&u_succ, adjacent_vertices(u, g)); u_succ.erase(u); for (auto t : inv_adjacent_vertices_range(u, g)) { if (t == u) { continue; } for (auto v : adjacent_vertices_range(t, g)) { if (contains(u_succ, v)) { /* due to virtual starts being aliased with normal starts in the * copy of the graph, we may have already added the edges. */ add_edge_if_not_present(orig_to_copy[t], c_g.accept, c_g); break; } } } pruneUseless(c_g); be.clear(); boost::depth_first_search(c_g, visitor(backEdgeVisitor) .root_vertex(c_g.start)); for (const auto &e : be) { NFAVertex s = source(e, c_g); NFAVertex t = target(e, c_g); DEBUG_PRINTF("back edge %zu %zu\n", c_g[s].index, c_g[t].index); if (s != t) { assert(0); DEBUG_PRINTF("eek big cycle\n"); rv = true; /* big cycle -> eek */ goto exit; } } DEBUG_PRINTF("checking acyclic+selfloop graph\n"); rv = !firstMatchIsFirst(c_g); DEBUG_PRINTF("som may regress? %d\n", (int)rv); goto exit; } bool sentClearsTail(const NGHolder &g, const ue2::unordered_map ®ion_map, const NGHolder &sent, u32 last_head_region, u32 *bad_region) { /* if a subsequent match from the prefix clears the rest of the pattern * we can just keep track of the last match of the prefix. * To see if this property holds, we could: * * 1A: turn on all states in the tail and run all strings that may * match the prefix past the tail, if we are still in any states then * this property does not hold. * * 1B: we turn on the initial states of the tail and run any strings which * may finish any partial matches in the prefix and see if we end up with * anything which would also imply that this property does not hold. * * OR * * 2: we just turn everything and run the prefix inputs past it and see what * we are left with. I think that is equivalent to scheme 1 and is easier to * implement. TODO: ponder * * Anyway, we are going with scheme 2 until further notice. */ u32 first_bad_region = ~0U; ue2::flat_set states; /* turn on all states */ DEBUG_PRINTF("region %u is cutover\n", last_head_region); for (auto v : vertices_range(g)) { if (v != g.accept && v != g.acceptEod) { states.insert(v); } } for (UNUSED auto v : states) { DEBUG_PRINTF("start state: %zu\n", g[v].index); } /* run the prefix the main graph */ states = execute_graph(g, sent, states); /* .. and check if we are left with anything in the tail region */ for (auto v : states) { if (v == g.start || v == g.startDs) { continue; /* not in tail */ } DEBUG_PRINTF("v %zu is still on\n", g[v].index); assert(v != g.accept && v != g.acceptEod); /* no cr */ assert(contains(region_map, v)); const u32 v_region = region_map.at(v); if (v_region > last_head_region) { DEBUG_PRINTF("bailing, %u > %u\n", v_region, last_head_region); first_bad_region = min(first_bad_region, v_region); } } if (first_bad_region != ~0U) { DEBUG_PRINTF("first bad region is %u\n", first_bad_region); *bad_region = first_bad_region; return false; } return true; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_lbr.cpp0000644000175000017500000003151013055426554020623 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Large Bounded Repeat (LBR) engine build code. */ #include "ng_lbr.h" #include "grey.h" #include "ng_holder.h" #include "ng_repeat.h" #include "ng_reports.h" #include "nfa/castlecompile.h" #include "nfa/lbr_internal.h" #include "nfa/nfa_internal.h" #include "nfa/repeatcompile.h" #include "nfa/shufticompile.h" #include "nfa/trufflecompile.h" #include "util/alloc.h" #include "util/bitutils.h" // for lg2 #include "util/compile_context.h" #include "util/container.h" #include "util/depth.h" #include "util/dump_charclass.h" #include "util/report_manager.h" #include "util/verify_types.h" using namespace std; namespace ue2 { static u32 depth_to_u32(const depth &d) { assert(d.is_reachable()); if (d.is_infinite()) { return REPEAT_INF; } u32 d_val = d; assert(d_val < REPEAT_INF); return d_val; } template static u64a* getTable(NFA *nfa) { char *ptr = (char *)nfa + sizeof(struct NFA) + sizeof(LbrStruct) + sizeof(RepeatInfo); ptr = ROUNDUP_PTR(ptr, alignof(u64a)); return (u64a *)ptr; } template static void fillNfa(NFA *nfa, lbr_common *c, ReportID report, const depth &repeatMin, const depth &repeatMax, u32 minPeriod, enum RepeatType rtype) { assert(nfa); RepeatStateInfo rsi(rtype, repeatMin, repeatMax, minPeriod); DEBUG_PRINTF("selected %s model for {%s,%s} repeat\n", repeatTypeName(rtype), repeatMin.str().c_str(), repeatMax.str().c_str()); // Fill the lbr_common structure first. Note that the RepeatInfo structure // directly follows the LbrStruct. const u32 info_offset = sizeof(LbrStruct); c->repeatInfoOffset = info_offset; c->report = report; RepeatInfo *info = (RepeatInfo *)((char *)c + info_offset); info->type = verify_u8(rtype); info->repeatMin = depth_to_u32(repeatMin); info->repeatMax = depth_to_u32(repeatMax); info->stateSize = rsi.stateSize; info->packedCtrlSize = rsi.packedCtrlSize; info->horizon = rsi.horizon; info->minPeriod = minPeriod; copy_bytes(&info->packedFieldSizes, rsi.packedFieldSizes); info->patchCount = rsi.patchCount; info->patchSize = rsi.patchSize; info->encodingSize = rsi.encodingSize; info->patchesOffset = rsi.patchesOffset; // Fill the NFA structure. nfa->nPositions = repeatMin; nfa->streamStateSize = verify_u32(rsi.packedCtrlSize + rsi.stateSize); nfa->scratchStateSize = (u32)sizeof(lbr_state); nfa->minWidth = verify_u32(repeatMin); nfa->maxWidth = repeatMax.is_finite() ? verify_u32(repeatMax) : 0; // Fill the lbr table for sparse lbr model. if (rtype == REPEAT_SPARSE_OPTIMAL_P) { u64a *table = getTable(nfa); // Adjust table length according to the optimal patch length. size_t len = nfa->length; assert((u32)repeatMax >= rsi.patchSize); len -= sizeof(u64a) * ((u32)repeatMax - rsi.patchSize); nfa->length = verify_u32(len); info->length = verify_u32(sizeof(RepeatInfo) + sizeof(u64a) * (rsi.patchSize + 1)); copy_bytes(table, rsi.table); } } template static aligned_unique_ptr makeLbrNfa(NFAEngineType nfa_type, enum RepeatType rtype, const depth &repeatMax) { size_t tableLen = 0; if (rtype == REPEAT_SPARSE_OPTIMAL_P) { tableLen = sizeof(u64a) * (repeatMax + 1); } size_t len = sizeof(NFA) + sizeof(LbrStruct) + sizeof(RepeatInfo) + tableLen + sizeof(u64a); aligned_unique_ptr nfa = aligned_zmalloc_unique(len); nfa->type = verify_u8(nfa_type); nfa->length = verify_u32(len); return nfa; } static aligned_unique_ptr buildLbrDot(const CharReach &cr, const depth &repeatMin, const depth &repeatMax, u32 minPeriod, bool is_reset, ReportID report) { if (!cr.all()) { return nullptr; } enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod, is_reset); auto nfa = makeLbrNfa(LBR_NFA_DOT, rtype, repeatMax); struct lbr_dot *ld = (struct lbr_dot *)getMutableImplNfa(nfa.get()); fillNfa(nfa.get(), &ld->common, report, repeatMin, repeatMax, minPeriod, rtype); DEBUG_PRINTF("built dot lbr\n"); return nfa; } static aligned_unique_ptr buildLbrVerm(const CharReach &cr, const depth &repeatMin, const depth &repeatMax, u32 minPeriod, bool is_reset, ReportID report) { const CharReach escapes(~cr); if (escapes.count() != 1) { return nullptr; } enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod, is_reset); auto nfa = makeLbrNfa(LBR_NFA_VERM, rtype, repeatMax); struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get()); lv->c = escapes.find_first(); fillNfa(nfa.get(), &lv->common, report, repeatMin, repeatMax, minPeriod, rtype); DEBUG_PRINTF("built verm lbr\n"); return nfa; } static aligned_unique_ptr buildLbrNVerm(const CharReach &cr, const depth &repeatMin, const depth &repeatMax, u32 minPeriod, bool is_reset, ReportID report) { const CharReach escapes(cr); if (escapes.count() != 1) { return nullptr; } enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod, is_reset); auto nfa = makeLbrNfa(LBR_NFA_NVERM, rtype, repeatMax); struct lbr_verm *lv = (struct lbr_verm *)getMutableImplNfa(nfa.get()); lv->c = escapes.find_first(); fillNfa(nfa.get(), &lv->common, report, repeatMin, repeatMax, minPeriod, rtype); DEBUG_PRINTF("built negated verm lbr\n"); return nfa; } static aligned_unique_ptr buildLbrShuf(const CharReach &cr, const depth &repeatMin, const depth &repeatMax, u32 minPeriod, bool is_reset, ReportID report) { enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod, is_reset); auto nfa = makeLbrNfa(LBR_NFA_SHUF, rtype, repeatMax); struct lbr_shuf *ls = (struct lbr_shuf *)getMutableImplNfa(nfa.get()); fillNfa(nfa.get(), &ls->common, report, repeatMin, repeatMax, minPeriod, rtype); if (shuftiBuildMasks(~cr, (u8 *)&ls->mask_lo, (u8 *)&ls->mask_hi) == -1) { return nullptr; } DEBUG_PRINTF("built shuf lbr\n"); return nfa; } static aligned_unique_ptr buildLbrTruf(const CharReach &cr, const depth &repeatMin, const depth &repeatMax, u32 minPeriod, bool is_reset, ReportID report) { enum RepeatType rtype = chooseRepeatType(repeatMin, repeatMax, minPeriod, is_reset); auto nfa = makeLbrNfa(LBR_NFA_TRUF, rtype, repeatMax); struct lbr_truf *lc = (struct lbr_truf *)getMutableImplNfa(nfa.get()); fillNfa(nfa.get(), &lc->common, report, repeatMin, repeatMax, minPeriod, rtype); truffleBuildMasks(~cr, (u8 *)&lc->mask1, (u8 *)&lc->mask2); DEBUG_PRINTF("built truffle lbr\n"); return nfa; } static aligned_unique_ptr constructLBR(const CharReach &cr, const depth &repeatMin, const depth &repeatMax, u32 minPeriod, bool is_reset, ReportID report) { DEBUG_PRINTF("bounds={%s,%s}, cr=%s (count %zu), report=%u\n", repeatMin.str().c_str(), repeatMax.str().c_str(), describeClass(cr, 20, CC_OUT_TEXT).c_str(), cr.count(), report); assert(repeatMin <= repeatMax); assert(repeatMax.is_reachable()); aligned_unique_ptr nfa = buildLbrDot(cr, repeatMin, repeatMax, minPeriod, is_reset, report); if (!nfa) { nfa = buildLbrVerm(cr, repeatMin, repeatMax, minPeriod, is_reset, report); } if (!nfa) { nfa = buildLbrNVerm(cr, repeatMin, repeatMax, minPeriod, is_reset, report); } if (!nfa) { nfa = buildLbrShuf(cr, repeatMin, repeatMax, minPeriod, is_reset, report); } if (!nfa) { nfa = buildLbrTruf(cr, repeatMin, repeatMax, minPeriod, is_reset, report); } if (!nfa) { assert(0); return nullptr; } return nfa; } aligned_unique_ptr constructLBR(const CastleProto &proto, const vector> &triggers, const CompileContext &cc, const ReportManager &rm) { if (!cc.grey.allowLbr) { return nullptr; } if (proto.repeats.size() != 1) { return nullptr; } const PureRepeat &repeat = proto.repeats.begin()->second; assert(!repeat.reach.none()); if (repeat.reports.size() != 1) { DEBUG_PRINTF("too many reports\n"); return nullptr; } bool is_reset; u32 min_period = minPeriod(triggers, repeat.reach, &is_reset); if (depth(min_period) > repeat.bounds.max) { DEBUG_PRINTF("trigger is longer than repeat; only need one offset\n"); is_reset = true; } ReportID report = *repeat.reports.begin(); if (has_managed_reports(proto.kind)) { report = rm.getProgramOffset(report); } DEBUG_PRINTF("building LBR %s\n", repeat.bounds.str().c_str()); return constructLBR(repeat.reach, repeat.bounds.min, repeat.bounds.max, min_period, is_reset, report); } /** \brief Construct an LBR engine from the given graph \p g. */ aligned_unique_ptr constructLBR(const NGHolder &g, const vector> &triggers, const CompileContext &cc, const ReportManager &rm) { if (!cc.grey.allowLbr) { return nullptr; } PureRepeat repeat; if (!isPureRepeat(g, repeat)) { return nullptr; } if (repeat.reports.size() != 1) { DEBUG_PRINTF("too many reports\n"); return nullptr; } CastleProto proto(g.kind, repeat); return constructLBR(proto, triggers, cc, rm); } /** \brief True if graph \p g could be turned into an LBR engine. */ bool isLBR(const NGHolder &g, const Grey &grey) { if (!grey.allowLbr) { return false; } PureRepeat repeat; if (!isPureRepeat(g, repeat)) { DEBUG_PRINTF("not pure bounded repeat\n"); return false; } if (repeat.reports.size() != 1) { DEBUG_PRINTF("too many reports\n"); return false; } return true; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_extparam.cpp0000644000175000017500000006451013055426554021673 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Propagate extended parameters to vertex reports and reduce graph if * possible. * * This code handles the propagation of the extension parameters specified by * the user with the hs_expr_ext structure into the reports on the graph's * vertices. * * There are also some analyses that prune edges that cannot contribute to a * match given these constraints, or transform the graph in order to make a * constraint implicit. */ #include "ng.h" #include "ng_depth.h" #include "ng_dump.h" #include "ng_extparam.h" #include "ng_prune.h" #include "ng_reports.h" #include "ng_som_util.h" #include "ng_width.h" #include "ng_util.h" #include "ue2common.h" #include "parser/position.h" #include "util/compile_context.h" #include "util/compile_error.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include #include using namespace std; namespace ue2 { static const u32 MAX_MAXOFFSET_TO_ANCHOR = 2000; static const u32 MAX_MINLENGTH_TO_CONVERT = 2000; /** \brief Find the (min, max) offset adjustment for the reports on a given * vertex. */ static pair getMinMaxOffsetAdjust(const ReportManager &rm, const NGHolder &g, NFAVertex v) { s32 minAdj = 0, maxAdj = 0; const auto &reports = g[v].reports; for (auto ri = reports.begin(), re = reports.end(); ri != re; ++ri) { const Report &ir = rm.getReport(*ri); if (ri == reports.begin()) { minAdj = ir.offsetAdjust; maxAdj = ir.offsetAdjust; } else { minAdj = min(minAdj, ir.offsetAdjust); maxAdj = max(maxAdj, ir.offsetAdjust); } } return make_pair(minAdj, maxAdj); } /** \brief Find the (min, max) length of any match for the given holder. */ static DepthMinMax findMatchLengths(const ReportManager &rm, const NGHolder &g) { DepthMinMax match_depths; vector depths = getDistancesFromSOM(g); pair adj; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { u32 idx = g[v].index; DepthMinMax d = depths[idx]; // copy adj = getMinMaxOffsetAdjust(rm, g, v); DEBUG_PRINTF("vertex %u: depths=%s, adj=[%d,%d]\n", idx, d.str().c_str(), adj.first, adj.second); d.min += adj.first; d.max += adj.second; match_depths = unionDepthMinMax(match_depths, d); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (v == g.accept) { continue; } u32 idx = g[v].index; DepthMinMax d = depths[idx]; // copy adj = getMinMaxOffsetAdjust(rm, g, v); DEBUG_PRINTF("vertex %u: depths=%s, adj=[%d,%d]\n", idx, d.str().c_str(), adj.first, adj.second); d.min += adj.first; d.max += adj.second; match_depths = unionDepthMinMax(match_depths, d); } DEBUG_PRINTF("match_depths=%s\n", match_depths.str().c_str()); assert(match_depths.min.is_reachable()); assert(match_depths.max.is_reachable()); return match_depths; } /** \brief Replace the graph's reports with new reports that specify bounds. */ static void updateReportBounds(ReportManager &rm, NGWrapper &g, NFAVertex accept, set &done) { for (auto v : inv_adjacent_vertices_range(accept, g)) { // Don't operate on g.accept itself. if (v == g.accept) { assert(accept == g.acceptEod); continue; } // Don't operate on a vertex we've already done. if (contains(done, v)) { continue; } done.insert(v); flat_set new_reports; auto &reports = g[v].reports; for (auto id : reports) { Report ir = rm.getReport(id); // make a copy assert(!ir.hasBounds()); // Note that we need to cope with offset adjustment here. ir.minOffset = g.min_offset - ir.offsetAdjust; if (g.max_offset == MAX_OFFSET) { ir.maxOffset = MAX_OFFSET; } else { ir.maxOffset = g.max_offset - ir.offsetAdjust; } assert(ir.maxOffset >= ir.minOffset); ir.minLength = g.min_length; if (g.min_length && !g.som) { ir.quashSom = true; } DEBUG_PRINTF("id %u -> min_offset=%llu, max_offset=%llu, " "min_length=%llu\n", id, ir.minOffset, ir.maxOffset, ir.minLength); new_reports.insert(rm.getInternalId(ir)); } DEBUG_PRINTF("swapping reports on vertex %zu\n", g[v].index); reports.swap(new_reports); } } static bool hasVirtualStarts(const NGHolder &g) { for (auto v : adjacent_vertices_range(g.start, g)) { if (g[v].assert_flags & POS_FLAG_VIRTUAL_START) { return true; } } return false; } /** If the pattern is unanchored, has a max_offset and has not asked for SOM, * we can use that knowledge to anchor it which will limit its lifespan. Note * that we can't use this transformation if there's a min_length, as it's * currently handled using "sly SOM". * * Note that it is possible to handle graphs that have a combination of * anchored and unanchored paths, but it's too tricky for the moment. */ static bool anchorPatternWithBoundedRepeat(NGWrapper &g, const depth &minWidth, const depth &maxWidth) { assert(!g.som); assert(g.max_offset != MAX_OFFSET); assert(minWidth <= maxWidth); assert(maxWidth.is_reachable()); DEBUG_PRINTF("widths=[%s,%s], min/max offsets=[%llu,%llu]\n", minWidth.str().c_str(), maxWidth.str().c_str(), g.min_offset, g.max_offset); if (g.max_offset > MAX_MAXOFFSET_TO_ANCHOR) { return false; } if (g.max_offset < minWidth) { assert(0); return false; } // If the pattern has virtual starts, we probably don't want to touch it. if (hasVirtualStarts(g)) { DEBUG_PRINTF("virtual starts, bailing\n"); return false; } // Similarly, bail if the pattern is vacuous. TODO: this could be done, we // would just need to be a little careful with reports. if (isVacuous(g)) { DEBUG_PRINTF("vacuous, bailing\n"); return false; } u32 min_bound, max_bound; if (maxWidth.is_infinite()) { min_bound = 0; max_bound = g.max_offset - minWidth; } else { min_bound = g.min_offset > maxWidth ? g.min_offset - maxWidth : 0; max_bound = g.max_offset - minWidth; } DEBUG_PRINTF("prepending ^.{%u,%u}\n", min_bound, max_bound); vector initials; for (auto v : adjacent_vertices_range(g.startDs, g)) { if (v == g.startDs) { continue; } initials.push_back(v); } if (initials.empty()) { DEBUG_PRINTF("no initial vertices\n"); return false; } // Wire up 'min_offset' mandatory dots from anchored start. NFAVertex u = g.start; for (u32 i = 0; i < min_bound; i++) { NFAVertex v = add_vertex(g); g[v].char_reach.setall(); add_edge(u, v, g); u = v; } NFAVertex head = u; // Wire up optional dots for (max_offset - min_offset). for (u32 i = 0; i < max_bound - min_bound; i++) { NFAVertex v = add_vertex(g); g[v].char_reach.setall(); if (head != u) { add_edge(head, v, g); } add_edge(u, v, g); u = v; } // Remove edges from starts and wire both head and u to our initials. for (auto v : initials) { remove_edge(g.startDs, v, g); remove_edge(g.start, v, g); if (head != u) { add_edge(head, v, g); } add_edge(u, v, g); } renumber_vertices(g); renumber_edges(g); return true; } static NFAVertex findSingleCyclic(const NGHolder &g) { NFAVertex v = NGHolder::null_vertex(); for (const auto &e : edges_range(g)) { if (source(e, g) == target(e, g)) { if (source(e, g) == g.startDs) { continue; } if (v != NGHolder::null_vertex()) { // More than one cyclic vertex. return NGHolder::null_vertex(); } v = source(e, g); } } if (v != NGHolder::null_vertex()) { DEBUG_PRINTF("cyclic is %zu\n", g[v].index); assert(!is_special(v, g)); } return v; } static bool hasOffsetAdjust(const ReportManager &rm, NGWrapper &g, int *adjust) { const auto &reports = all_reports(g); if (reports.empty()) { assert(0); return false; } int offsetAdjust = rm.getReport(*reports.begin()).offsetAdjust; for (auto report : reports) { const Report &ir = rm.getReport(report); if (ir.offsetAdjust != offsetAdjust) { DEBUG_PRINTF("different adjusts!\n"); return false; } } *adjust = offsetAdjust; return true; } /** If the pattern has a min_length and is of "ratchet" form with one unbounded * repeat, that repeat can become a bounded repeat. * * /foo.*bar/{min_length=100} --> /foo.{94,}bar/ */ static bool transformMinLengthToRepeat(const ReportManager &rm, NGWrapper &g) { assert(g.min_length); if (g.min_length > MAX_MINLENGTH_TO_CONVERT) { return false; } // If the pattern has virtual starts, we probably don't want to touch it. if (hasVirtualStarts(g)) { DEBUG_PRINTF("virtual starts, bailing\n"); return false; } // The graph must contain a single cyclic vertex (other than startDs), and // that vertex can have one pred and one successor. NFAVertex cyclic = findSingleCyclic(g); if (cyclic == NGHolder::null_vertex()) { return false; } NGHolder::adjacency_iterator ai, ae; tie(ai, ae) = adjacent_vertices(g.start, g); if (*ai == g.startDs) { ++ai; } NFAVertex v = *ai; if (++ai != ae) { DEBUG_PRINTF("more than one initial vertex\n"); return false; } u32 width = 0; // Walk from the start vertex to the cyclic state and ensure we have a // chain of vertices. while (v != cyclic) { DEBUG_PRINTF("vertex %zu\n", g[v].index); width++; auto succ = succs(v, g); if (contains(succ, cyclic)) { if (succ.size() == 1) { v = cyclic; } else if (succ.size() == 2) { // Cyclic and jump edge. succ.erase(cyclic); NFAVertex v2 = *succ.begin(); if (!edge(cyclic, v2, g).second) { DEBUG_PRINTF("bad form\n"); return false; } v = cyclic; } else { DEBUG_PRINTF("bad form\n"); return false; } } else { if (succ.size() != 1) { DEBUG_PRINTF("bad form\n"); return false; } v = *succ.begin(); } } // Check the cyclic state is A-OK. v = getSoleDestVertex(g, cyclic); if (v == NGHolder::null_vertex()) { DEBUG_PRINTF("cyclic has more than one successor\n"); return false; } // Walk from the cyclic state to an accept and ensure we have a chain of // vertices. while (!is_any_accept(v, g)) { DEBUG_PRINTF("vertex %zu\n", g[v].index); width++; auto succ = succs(v, g); if (succ.size() != 1) { DEBUG_PRINTF("bad form\n"); return false; } v = *succ.begin(); } int offsetAdjust = 0; if (!hasOffsetAdjust(rm, g, &offsetAdjust)) { return false; } DEBUG_PRINTF("adjusting width by %d\n", offsetAdjust); width += offsetAdjust; DEBUG_PRINTF("width=%u, vertex %zu is cyclic\n", width, g[cyclic].index); if (width >= g.min_length) { DEBUG_PRINTF("min_length=%llu is guaranteed, as width=%u\n", g.min_length, width); g.min_length = 0; return true; } vector preds; vector dead; for (auto u : inv_adjacent_vertices_range(cyclic, g)) { DEBUG_PRINTF("pred %zu\n", g[u].index); if (u == cyclic) { continue; } preds.push_back(u); // We want to delete the out-edges of each predecessor, but need to // make sure we don't delete the startDs self loop. for (const auto &e : out_edges_range(u, g)) { if (target(e, g) != g.startDs) { dead.push_back(e); } } } remove_edges(dead, g); assert(!preds.empty()); const CharReach &cr = g[cyclic].char_reach; for (u32 i = 0; i < g.min_length - width - 1; ++i) { v = add_vertex(g); g[v].char_reach = cr; for (auto u : preds) { add_edge(u, v, g); } preds.clear(); preds.push_back(v); } assert(!preds.empty()); for (auto u : preds) { add_edge(u, cyclic, g); } renumber_vertices(g); renumber_edges(g); clearReports(g); g.min_length = 0; return true; } static bool hasExtParams(const NGWrapper &g) { if (g.min_length != 0) { return true; } if (g.min_offset != 0) { return true; } if (g.max_offset != MAX_OFFSET) { return true; } return false; } static depth maxDistFromStart(const NFAVertexBidiDepth &d) { if (!d.fromStartDotStar.max.is_unreachable()) { // A path from startDs, any path, implies we can match at any offset. return depth::infinity(); } return d.fromStart.max; } static const depth& maxDistToAccept(const NFAVertexBidiDepth &d) { if (d.toAccept.max.is_unreachable()) { return d.toAcceptEod.max; } else if (d.toAcceptEod.max.is_unreachable()) { return d.toAccept.max; } return max(d.toAccept.max, d.toAcceptEod.max); } static const depth& minDistFromStart(const NFAVertexBidiDepth &d) { return min(d.fromStartDotStar.min, d.fromStart.min); } static const depth& minDistToAccept(const NFAVertexBidiDepth &d) { return min(d.toAccept.min, d.toAcceptEod.min); } static bool isEdgePrunable(const NGWrapper &g, const vector &depths, const NFAEdge &e) { const NFAVertex u = source(e, g); const NFAVertex v = target(e, g); DEBUG_PRINTF("edge (%zu,%zu)\n", g[u].index, g[v].index); // Leave our special-to-special edges alone. if (is_special(u, g) && is_special(v, g)) { DEBUG_PRINTF("ignoring special-to-special\n"); return false; } // We must be careful around start: we don't want to remove (start, v) if // (startDs, v) exists as well, since later code will assume the presence // of both edges, but other cases are OK. if (u == g.start && edge(g.startDs, v, g).second) { DEBUG_PRINTF("ignoring unanchored start edge\n"); return false; } u32 u_idx = g[u].index; u32 v_idx = g[v].index; assert(u_idx < depths.size() && v_idx < depths.size()); const NFAVertexBidiDepth &du = depths.at(u_idx); const NFAVertexBidiDepth &dv = depths.at(v_idx); if (g.min_offset) { depth max_offset = maxDistFromStart(du) + maxDistToAccept(dv); if (max_offset.is_finite() && max_offset < g.min_offset) { DEBUG_PRINTF("max_offset=%s too small\n", max_offset.str().c_str()); return true; } } if (g.max_offset != MAX_OFFSET) { depth min_offset = minDistFromStart(du) + minDistToAccept(dv); assert(min_offset.is_finite()); if (min_offset > g.max_offset) { DEBUG_PRINTF("min_offset=%s too large\n", min_offset.str().c_str()); return true; } } if (g.min_length && is_any_accept(v, g)) { // Simple take on min_length. If we're an edge to accept and our max // dist from start is too small, we can be pruned. const depth &width = du.fromStart.max; if (width.is_finite() && width < g.min_length) { DEBUG_PRINTF("max width %s from start too small for min_length\n", width.str().c_str()); return true; } } return false; } static void pruneExtUnreachable(NGWrapper &g) { vector depths; calcDepths(g, depths); vector dead; for (const auto &e : edges_range(g)) { if (isEdgePrunable(g, depths, e)) { DEBUG_PRINTF("pruning\n"); dead.push_back(e); } } if (dead.empty()) { return; } remove_edges(dead, g); pruneUseless(g); } /** Remove vacuous edges in graphs where the min_offset or min_length * constraints dictate that they can never produce a match. */ static void pruneVacuousEdges(NGWrapper &g) { if (!g.min_length && !g.min_offset) { return; } vector dead; for (const auto &e : edges_range(g)) { const NFAVertex u = source(e, g); const NFAVertex v = target(e, g); // Special case: Crudely remove vacuous edges from start in graphs with a // min_offset. if (g.min_offset && u == g.start && is_any_accept(v, g)) { DEBUG_PRINTF("vacuous edge in graph with min_offset!\n"); dead.push_back(e); continue; } // If a min_length is set, vacuous edges can be removed. if (g.min_length && is_any_start(u, g) && is_any_accept(v, g)) { DEBUG_PRINTF("vacuous edge in graph with min_length!\n"); dead.push_back(e); continue; } } if (dead.empty()) { return; } remove_edges(dead, g); pruneUseless(g); } static void pruneUnmatchable(NGWrapper &g, const vector &depths, const ReportManager &rm, NFAVertex accept) { vector dead; for (const auto &e : in_edges_range(accept, g)) { NFAVertex v = source(e, g); if (v == g.accept) { assert(accept == g.acceptEod); // stylised edge continue; } u32 idx = g[v].index; DepthMinMax d = depths[idx]; // copy pair adj = getMinMaxOffsetAdjust(rm, g, v); DEBUG_PRINTF("vertex %u: depths=%s, adj=[%d,%d]\n", idx, d.str().c_str(), adj.first, adj.second); d.min += adj.first; d.max += adj.second; if (d.max.is_finite() && d.max < g.min_length) { DEBUG_PRINTF("prune, max match length %s < min_length=%llu\n", d.max.str().c_str(), g.min_length); dead.push_back(e); continue; } if (g.max_offset != MAX_OFFSET && d.min > g.max_offset) { DEBUG_PRINTF("prune, min match length %s > max_offset=%llu\n", d.min.str().c_str(), g.max_offset); dead.push_back(e); continue; } } remove_edges(dead, g); } /** Remove edges to accepts that can never produce a match long enough to * satisfy our min_length and max_offset constraints. */ static void pruneUnmatchable(NGWrapper &g, const ReportManager &rm) { if (!g.min_length) { return; } vector depths = getDistancesFromSOM(g); pruneUnmatchable(g, depths, rm, g.accept); pruneUnmatchable(g, depths, rm, g.acceptEod); pruneUseless(g); } static bool isUnanchored(const NGHolder &g) { for (auto v : adjacent_vertices_range(g.start, g)) { if (!edge(g.startDs, v, g).second) { DEBUG_PRINTF("fail, %zu is anchored vertex\n", g[v].index); return false; } } return true; } static bool hasOffsetAdjustments(const ReportManager &rm, const NGHolder &g) { for (auto report : all_reports(g)) { const Report &ir = rm.getReport(report); if (ir.offsetAdjust) { return true; } } return false; } void handleExtendedParams(ReportManager &rm, NGWrapper &g, UNUSED const CompileContext &cc) { if (!hasExtParams(g)) { return; } depth minWidth = findMinWidth(g); depth maxWidth = findMaxWidth(g); bool is_anchored = !has_proper_successor(g.startDs, g) && out_degree(g.start, g); bool has_offset_adj = hasOffsetAdjustments(rm, g); DEBUG_PRINTF("minWidth=%s, maxWidth=%s, anchored=%d, offset_adj=%d\n", minWidth.str().c_str(), maxWidth.str().c_str(), is_anchored, has_offset_adj); DepthMinMax match_depths = findMatchLengths(rm, g); DEBUG_PRINTF("match depths %s\n", match_depths.str().c_str()); if (is_anchored && maxWidth.is_finite() && g.min_offset > maxWidth) { ostringstream oss; oss << "Expression is anchored and cannot satisfy min_offset=" << g.min_offset << " as it can only produce matches of length " << maxWidth << " bytes at most."; throw CompileError(g.expressionIndex, oss.str()); } if (minWidth > g.max_offset) { ostringstream oss; oss << "Expression has max_offset=" << g.max_offset << " but requires " << minWidth << " bytes to match."; throw CompileError(g.expressionIndex, oss.str()); } if (maxWidth.is_finite() && match_depths.max < g.min_length) { ostringstream oss; oss << "Expression has min_length=" << g.min_length << " but can " "only produce matches of length " << match_depths.max << " bytes at most."; throw CompileError(g.expressionIndex, oss.str()); } if (g.min_length && g.min_length <= match_depths.min) { DEBUG_PRINTF("min_length=%llu constraint is unnecessary\n", g.min_length); g.min_length = 0; } if (!hasExtParams(g)) { return; } pruneVacuousEdges(g); pruneUnmatchable(g, rm); if (!has_offset_adj) { pruneExtUnreachable(g); } // We may have removed all the edges to accept, in which case this // expression cannot match. if (in_degree(g.accept, g) == 0 && in_degree(g.acceptEod, g) == 1) { throw CompileError(g.expressionIndex, "Extended parameter " "constraints can not be satisfied for any match from " "this expression."); } // Remove reports on vertices without an edge to accept (which have been // pruned above). clearReports(g); // Recalc. minWidth = findMinWidth(g); maxWidth = findMaxWidth(g); is_anchored = proper_out_degree(g.startDs, g) == 0 && out_degree(g.start, g); has_offset_adj = hasOffsetAdjustments(rm, g); // If the pattern is completely anchored and has a min_length set, this can // be converted to a min_offset. if (g.min_length && (g.min_offset <= g.min_length) && is_anchored) { DEBUG_PRINTF("converting min_length to min_offset=%llu for " "anchored case\n", g.min_length); g.min_offset = g.min_length; g.min_length = 0; } if (g.min_offset && g.min_offset <= minWidth && !has_offset_adj) { DEBUG_PRINTF("min_offset=%llu constraint is unnecessary\n", g.min_offset); g.min_offset = 0; } if (!hasExtParams(g)) { return; } // If the pattern has a min_length and is of "ratchet" form with one // unbounded repeat, that repeat can become a bounded repeat. // e.g. /foo.*bar/{min_length=100} --> /foo.{94,}bar/ if (g.min_length && transformMinLengthToRepeat(rm, g)) { DEBUG_PRINTF("converted min_length to bounded repeat\n"); // recalc minWidth = findMinWidth(g); } // If the pattern is unanchored, has a max_offset and has not asked for // SOM, we can use that knowledge to anchor it which will limit its // lifespan. Note that we can't use this transformation if there's a // min_length, as it's currently handled using "sly SOM". // Note that it is possible to handle graphs that have a combination of // anchored and unanchored paths, but it's too tricky for the moment. if (g.max_offset != MAX_OFFSET && !g.som && !g.min_length && !has_offset_adj && isUnanchored(g)) { if (anchorPatternWithBoundedRepeat(g, minWidth, maxWidth)) { DEBUG_PRINTF("minWidth=%s, maxWidth=%s\n", minWidth.str().c_str(), maxWidth.str().c_str()); if (minWidth == maxWidth) { // For a fixed width pattern, we can retire the offsets as they // are implicit in the graph now. g.min_offset = 0; g.max_offset = MAX_OFFSET; } } } //dumpGraph("final.dot", g); if (!hasExtParams(g)) { return; } set done; updateReportBounds(rm, g, g.accept, done); updateReportBounds(rm, g, g.acceptEod, done); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_literal_component.h0000644000175000017500000000366013055426554023234 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Literal Component Splitting. Identifies literals that span the * graph and moves them into Rose. */ #ifndef NG_LITERAL_COMPONENT_H #define NG_LITERAL_COMPONENT_H namespace ue2 { class NG; class NGWrapper; /** \brief Split off literals. True if any changes were made to the graph. */ bool splitOffLiterals(NG &ng, NGWrapper &graph); } // namespace ue2 #endif // NG_LITERAL_COMPONENT_H hyperscan-4.4.1/src/nfagraph/ng_rose.cpp0000644000175000017500000026433213055426554021026 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ /** \file * \brief Rose construction from NGHolder. */ // #define DEBUG // #define DEBUG_ROSE #include "ng_rose.h" #include "grey.h" #include "ng_depth.h" #include "ng_dominators.h" #include "ng_equivalence.h" #include "ng_holder.h" #include "ng_is_equal.h" #include "ng_literal_analysis.h" #include "ng_netflow.h" #include "ng_prune.h" #include "ng_redundancy.h" #include "ng_region.h" #include "ng_reports.h" #include "ng_split.h" #include "ng_util.h" #include "ng_width.h" #include "rose/rose_build.h" #include "rose/rose_build_util.h" #include "rose/rose_in_dump.h" #include "rose/rose_in_graph.h" #include "rose/rose_in_util.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/ue2string.h" #include "util/ue2_containers.h" #include #include #include #include #define NDEBUG_PRINTF(x, ...) \ do { if (0) { DEBUG_PRINTF(x, ## __VA_ARGS__); } } while (0) using namespace std; namespace ue2 { /** * Maps vertices in the original graph to vertices on edge graphs. Each edge * graph should contain at most one copy of the vertex. Multiple images for a * vertex arise after we split on multiple literals - in this cases all edges * should share a common graph. * * If, when an edge is split, a vertex ends up in both the LHS and RHS then only * the LHS is tracked. This is because in general we want to simplify the LHS * and allow complexity to be pushed further back. */ typedef ue2::unordered_map > > vdest_map_t; typedef ue2::unordered_map > vsrc_map_t; /** * \brief Maximum width of the character class usable as an escape class. */ static const u32 MAX_ESCAPE_CHARS = 20; static u32 maxDelay(const CompileContext &cc) { if (!cc.streaming) { return MO_INVALID_IDX; } return cc.grey.maxHistoryAvailable; } static bool createsAnchoredLHS(const NGHolder &g, const vector &vv, const vector &depths, const Grey &grey, depth max_depth = depth::infinity()) { max_depth = min(max_depth, depth(grey.maxAnchoredRegion)); for (auto v : vv) { /* avoid issues of self loops blowing out depths: * look at preds, add 1 */ for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; } u32 idx = g[u].index; assert(idx < depths.size()); if (maxDistFromStartOfData(depths.at(idx)) >= max_depth) { return false; } } } return true; } static bool createsTransientLHS(const NGHolder &g, const vector &vv, const vector &depths, const Grey &grey) { const depth max_depth(grey.maxHistoryAvailable); for (auto v : vv) { /* avoid issues of self loops blowing out depths: * look at preds, add 1 */ for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; } u32 idx = g[u].index; assert(idx < depths.size()); if (maxDistFromInit(depths.at(idx)) >= max_depth) { return false; } } } return true; } static bool isLHSUsablyAnchored(const NGHolder &g, const vector &depths, const Grey &grey) { assert(in_degree(g.acceptEod, g) == 1); vector accepts; insert(&accepts, accepts.end(), inv_adjacent_vertices(g.accept, g)); bool rv = createsAnchoredLHS(g, accepts, depths, grey); DEBUG_PRINTF("lhs is %susably anchored\n", rv ? "" : "not "); return rv; } static bool isLHSTransient(const NGHolder &g, const vector &depths, const Grey &grey) { assert(in_degree(g.acceptEod, g) == 1); vector accepts; insert(&accepts, accepts.end(), inv_adjacent_vertices(g.accept, g)); bool rv = createsTransientLHS(g, accepts, depths, grey); DEBUG_PRINTF("lhs is %stransient\n", rv ? "" : "not "); return rv; } namespace { /** * Information on a cut: vertices and literals. */ struct VertLitInfo { VertLitInfo(NFAVertex v, const set &litlit) : vv(vector(1, v)), lit(litlit) {} VertLitInfo(const vector &vvvv, const set &litlit) : vv(vvvv), lit(litlit) {} vector vv; set lit; }; /** * A factory for candidate simple cuts (literals/vertices). */ class LitCollection : boost::noncopyable { vector> lits; /**< sorted list of potential cuts */ const NGHolder &g; /**< graph on which cuts are found */ const vector &depths; /**< depth information for g */ const ue2::unordered_map ®ion_map; /**< region map for g */ /** Set of vertices to avoid selecting as end vertices for cuts as previous * cuts overlap them. This is solely to prevent us picking literal sets * which do not add significant value. */ ue2::unordered_set poisoned; /** Back-edges in g. */ ue2::unordered_map > back_edges; const Grey &grey; bool seeking_transient; bool seeking_anchored; void poisonLHS(const VertLitInfo &picked); void poisonLitVerts(const VertLitInfo &picked); void poisonCandidates(const VertLitInfo &picked); friend class LitComparator; public: LitCollection(const NGHolder &g_in, const vector &depths_in, const ue2::unordered_map ®ion_map_in, const set &ap, const set &ap_raw, u32 min_len, bool desperation, const CompileContext &cc, bool override_literal_quality_check = false); /**< Returns the next candidate cut. Cut still needs to be inspected for * complete envelopment. */ unique_ptr pickNext(void); }; /** * \brief Comparator class for sorting LitCollection::lits. * * This is separated out from LitCollection itself as passing LitCollection to * std::sort() would incur a (potentially expensive) copy. */ class LitComparator { public: explicit LitComparator(const LitCollection &lc_in) : lc(lc_in) {} bool operator()(const unique_ptr &a, const unique_ptr &b) const { assert(a && b); if (lc.seeking_anchored) { bool a_anchored = createsAnchoredLHS(lc.g, a->vv, lc.depths, lc.grey); bool b_anchored = createsAnchoredLHS(lc.g, b->vv, lc.depths, lc.grey); if (a_anchored != b_anchored) { return a_anchored < b_anchored; } } if (lc.seeking_transient) { bool a_transient = createsTransientLHS(lc.g, a->vv, lc.depths, lc.grey); bool b_transient = createsTransientLHS(lc.g, b->vv, lc.depths, lc.grey); if (a_transient != b_transient) { return a_transient < b_transient; } } u64a score_a = scoreSet(a->lit); u64a score_b = scoreSet(b->lit); if (score_a != score_b) { return score_a > score_b; } /* vertices should only be in one candidate cut */ assert(a->vv == b->vv || a->vv.front() != b->vv.front()); return lc.g[a->vv.front()].index > lc.g[b->vv.front()].index; } private: const LitCollection &lc; }; static size_t shorter_than(const set &s, size_t limit) { size_t count = 0; for (const auto &lit : s) { if (lit.length() < limit) { count++; } } return count; } static u32 min_len(const set &s) { u32 rv = ~0U; for (const auto &lit : s) { rv = min(rv, (u32)lit.length()); } return rv; } static u32 max_len(const set &s) { u32 rv = 0; for (const auto &lit : s) { rv = max(rv, (u32)lit.length()); } return rv; } static u32 min_period(const set &s) { u32 rv = ~0U; for (const auto &lit : s) { rv = min(rv, (u32)minStringPeriod(lit)); } DEBUG_PRINTF("min period %u\n", rv); return rv; } static bool validateRoseLiteralSetQuality(const set &s, u64a score, u32 min_allowed_len, bool desperation, bool override_literal_quality_check) { if (!override_literal_quality_check && score >= NO_LITERAL_AT_EDGE_SCORE) { DEBUG_PRINTF("candidate is too bad %llu/%zu\n", score, s.size()); return false; } assert(!s.empty()); if (s.empty()) { DEBUG_PRINTF("candidate is too bad/something went wrong\n"); return false; } u32 s_min_len = min_len(s); u32 s_min_period = min_period(s); size_t short_count = shorter_than(s, 5); DEBUG_PRINTF("cand '%s': score %llu count=%zu min_len=%u min_period=%u" " short_count=%zu desp=%d\n", dumpString(*s.begin()).c_str(), score, s.size(), s_min_len, s_min_period, short_count, (int)desperation); bool ok = true; if (s.size() > 10 /* magic number is magic */ || s_min_len < min_allowed_len || (s_min_period <= 1 && !override_literal_quality_check && min_allowed_len != 1)) { ok = false; } if (!ok && desperation && s.size() <= 20 /* more magic numbers are magical */ && (s_min_len > 5 || (s_min_len > 2 && short_count <= 10)) && s_min_period > 1) { DEBUG_PRINTF("candidate is ok\n"); ok = true; } if (!ok && desperation && s.size() <= 50 /* more magic numbers are magical */ && s_min_len > 10 && s_min_period > 1) { DEBUG_PRINTF("candidate is ok\n"); ok = true; } if (!ok) { DEBUG_PRINTF("candidate is too bad\n"); return false; } return true; } static UNUSED void dumpRoseLiteralSet(const set &s) { for (UNUSED const auto &lit : s) { DEBUG_PRINTF(" lit: %s\n", dumpString(lit).c_str()); } } static void getSimpleRoseLiterals(const NGHolder &g, const set &a_dom, vector> *lits, u32 min_allowed_len, bool desperation, bool override_literal_quality_check) { map scores; map> lit_info; set s; for (auto v : a_dom) { s = getLiteralSet(g, v, true); /* RHS will take responsibility for any revisits to the target vertex */ if (s.empty()) { DEBUG_PRINTF("candidate is too bad\n"); continue; } DEBUG_PRINTF("|candidate raw literal set| = %zu\n", s.size()); dumpRoseLiteralSet(s); u64a score = compressAndScore(s); if (!validateRoseLiteralSetQuality(s, score, min_allowed_len, desperation, override_literal_quality_check)) { continue; } DEBUG_PRINTF("candidate is a candidate\n"); scores[v] = score; lit_info.insert(make_pair(v, ue2::make_unique(v, s))); } /* try to filter out cases where appending some characters produces worse * literals. Only bother to look back one byte, TODO make better */ for (auto u : a_dom) { if (out_degree(u, g) != 1 || !scores[u]) { continue; } NFAVertex v = *adjacent_vertices(u, g).first; if (contains(scores, v) && scores[v] >= scores[u]) { DEBUG_PRINTF("killing off v as score %llu >= %llu\n", scores[v], scores[u]); lit_info.erase(v); } } lits->reserve(lit_info.size()); for (auto &m : lit_info) { lits->push_back(move(m.second)); } DEBUG_PRINTF("%zu candidate literal sets\n", lits->size()); } static void getRegionRoseLiterals(const NGHolder &g, const ue2::unordered_map ®ion_map, const set &a_dom_raw, vector> *lits, u32 min_allowed_len, bool desperation, bool override_literal_quality_check) { /* This allows us to get more places to chop the graph as we are not limited to points where there is a single vertex to split. */ /* TODO: operate over 'proto-regions' which ignore back edges */ set mand, optional; map > exits; for (auto v : vertices_range(g)) { assert(contains(region_map, v)); const u32 region = region_map.at(v); if (is_any_start(v, g) || region == 0) { continue; } if (is_any_accept(v, g)) { continue; } if (isRegionExit(g, v, region_map)) { exits[region].push_back(v); } if (isRegionEntry(g, v, region_map)) { // Determine whether this region is mandatory or optional. We only // need to do this check for the first entry vertex we encounter // for this region. if (!contains(mand, region) && !contains(optional, region)) { if (isOptionalRegion(g, v, region_map)) { optional.insert(region); } else { mand.insert(region); } } } } for (const auto &m : exits) { if (0) { next_cand: continue; } const u32 region = m.first; const vector &vv = m.second; assert(!vv.empty()); if (!contains(mand, region)) { continue; } for (auto v : vv) { /* if an exit is in a_dom_raw, the region is already handled well * by getSimpleRoseLiterals */ if (contains(a_dom_raw, v)) { goto next_cand; } } /* the final region may not have a neat exit. validate that all exits * have an edge to each accept or none do */ bool edge_to_a = edge(vv[0], g.accept, g).second; bool edge_to_aeod = edge(vv[0], g.acceptEod, g).second; const auto &reports = g[vv[0]].reports; for (auto v : vv) { if (edge_to_a != edge(v, g.accept, g).second) { goto next_cand; } if (edge_to_aeod != edge(v, g.acceptEod, g).second) { goto next_cand; } if (g[v].reports != reports) { goto next_cand; } } DEBUG_PRINTF("inspecting region %u\n", region); set s; for (auto v : vv) { DEBUG_PRINTF(" exit vertex: %zu\n", g[v].index); /* Note: RHS can not be depended on to take all subsequent revisits * to this vertex */ set ss = getLiteralSet(g, v, false); if (ss.empty()) { DEBUG_PRINTF("candidate is too bad\n"); goto next_cand; } insert(&s, ss); } assert(!s.empty()); DEBUG_PRINTF("|candidate raw literal set| = %zu\n", s.size()); dumpRoseLiteralSet(s); u64a score = compressAndScore(s); DEBUG_PRINTF("|candidate literal set| = %zu\n", s.size()); dumpRoseLiteralSet(s); if (!validateRoseLiteralSetQuality(s, score, min_allowed_len, desperation, override_literal_quality_check)) { continue; } DEBUG_PRINTF("candidate is a candidate\n"); lits->push_back(ue2::make_unique(vv, s)); } } static void gatherBackEdges(const NGHolder &g, ue2::unordered_map> *out) { set backEdges; BackEdges> be(backEdges); depth_first_search(g, visitor(be).root_vertex(g.start)); for (const auto &e : backEdges) { (*out)[source(e, g)].push_back(target(e, g)); } } LitCollection::LitCollection(const NGHolder &g_in, const vector &depths_in, const ue2::unordered_map ®ion_map_in, const set &a_dom, const set &a_dom_raw, u32 min_len, bool desperation, const CompileContext &cc, bool override_literal_quality_check) : g(g_in), depths(depths_in), region_map(region_map_in), grey(cc.grey), seeking_transient(cc.streaming), seeking_anchored(true) { getSimpleRoseLiterals(g, a_dom, &lits, min_len, desperation, override_literal_quality_check); getRegionRoseLiterals(g, region_map, a_dom_raw, &lits, min_len, desperation, override_literal_quality_check); DEBUG_PRINTF("lit coll is looking for a%d t%d\n", (int)seeking_anchored, (int)seeking_transient); DEBUG_PRINTF("we have %zu candidate literal splits\n", lits.size()); sort(lits.begin(), lits.end(), LitComparator(*this)); gatherBackEdges(g, &back_edges); } void LitCollection::poisonLHS(const VertLitInfo &picked) { DEBUG_PRINTF("found anchored %d transient %d\n", (int)createsAnchoredLHS(g, picked.vv, depths, grey), (int)createsTransientLHS(g, picked.vv, depths, grey)); set curr; set next; insert(&curr, picked.vv); while (!curr.empty()) { insert(&poisoned, curr); next.clear(); for (auto v : curr) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (!is_special(u, g) && !contains(poisoned, u)) { next.insert(u); } } } curr.swap(next); } seeking_transient = false; seeking_anchored = false; /* reprioritise cuts now that the LHS is taken care off */ sort(lits.begin(), lits.end(), LitComparator(*this)); } static void flood_back(const NGHolder &g, u32 len, const set &initial, set *visited) { vector curr; vector next; insert(&curr, curr.end(), initial); insert(visited, initial); /* bfs: flood back len vertices */ for (u32 i = 1; i < len; i++) { next.clear(); DEBUG_PRINTF("poison %u/%u: curr %zu\n", i, len, curr.size()); for (auto v : curr) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (!contains(*visited, u)) { next.push_back(u); visited->insert(u); } } } next.swap(curr); } } /** * Add vertices near a picked literal to the poison set unless it looks * like they may still add value (ie they are on they other side of cycle). */ void LitCollection::poisonLitVerts(const VertLitInfo &picked) { DEBUG_PRINTF("poisoning vertices associated with picked literals\n"); u32 len = max_len(picked.lit); /* poison vertices behind */ set starters; insert(&starters, picked.vv); set visited; flood_back(g, len, starters, &visited); DEBUG_PRINTF("flood %zu vertices\n", visited.size()); /* inspect any back edges which are in the flooded subgraph; look for any * destination vertices which are not starters */ set anti; for (auto u : visited) { if (!contains(back_edges, u) || contains(starters, u)) { continue; } for (auto v : back_edges[u]) { if (contains(visited, v) && !contains(starters, v)) { anti.insert(v); } } } DEBUG_PRINTF("%zu cycle ends\n", visited.size()); /* remove any vertices which lie on the other side of a cycle from the * visited set */ set anti_pred; flood_back(g, len - 1, anti, &anti_pred); DEBUG_PRINTF("flood visited %zu vertices; anti %zu\n", visited.size(), anti_pred.size()); erase_all(&visited, anti_pred); DEBUG_PRINTF("filtered flood visited %zu vertices\n", visited.size()); insert(&poisoned, visited); insert(&poisoned, starters); /* complicated back loops can result in start vertices being removed from the visited set */ for (UNUSED auto v : picked.vv) { assert(contains(poisoned, v)); } /* TODO: poison vertices in front of us? */ } void LitCollection::poisonCandidates(const VertLitInfo &picked) { assert(!picked.lit.empty()); if (picked.lit.empty()) { return; } if ((seeking_anchored && createsAnchoredLHS(g, picked.vv, depths, grey)) || (seeking_transient && createsTransientLHS(g, picked.vv, depths, grey))) { /* We don't want to pick anything to the LHS of picked.v any more as we * have something good. We also don't want to provide any bonus for * remaining literals based on anchoredness/transientness of the lhs. */ poisonLHS(picked); } else { poisonLitVerts(picked); } } unique_ptr LitCollection::pickNext() { while (!lits.empty()) { if (0) { next_lit: continue; } for (auto v : lits.back()->vv) { if (contains(poisoned, v)) { DEBUG_PRINTF("skipping '%s' as overlapped\n", dumpString(*(lits.back()->lit.begin())).c_str()); lits.pop_back(); goto next_lit; } } unique_ptr rv = move(lits.back()); lits.pop_back(); poisonCandidates(*rv); DEBUG_PRINTF("best is '%s' %zu a%d t%d\n", dumpString(*(rv->lit.begin())).c_str(), g[rv->vv.front()].index, (int)createsAnchoredLHS(g, rv->vv, depths, grey), (int)createsTransientLHS(g, rv->vv, depths, grey)); return rv; } return nullptr; } } static bool can_match(const NGHolder &g, const ue2_literal &lit, bool overhang_ok) { set curr, next; curr.insert(g.accept); for (auto it = lit.rbegin(); it != lit.rend(); ++it) { next.clear(); for (auto v : curr) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == g.start) { if (overhang_ok) { DEBUG_PRINTF("bail\n"); return true; } else { continue; /* it is not possible for a lhs literal to * overhang the start */ } } const CharReach &cr = g[u].char_reach; if (!overlaps(*it, cr)) { DEBUG_PRINTF("skip\n"); continue; } next.insert(u); } } curr.swap(next); } return !curr.empty(); } u32 removeTrailingLiteralStates(NGHolder &g, const ue2_literal &lit, u32 max_delay, bool overhang_ok) { assert(isCorrectlyTopped(g)); if (max_delay == MO_INVALID_IDX) { max_delay--; } DEBUG_PRINTF("killing off '%s'\n", dumpString(lit).c_str()); set curr, next; curr.insert(g.accept); auto it = lit.rbegin(); for (u32 delay = max_delay; delay > 0 && it != lit.rend(); delay--, ++it) { next.clear(); for (auto v : curr) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == g.start) { if (overhang_ok) { DEBUG_PRINTF("bail\n"); goto bail; /* things got complicated */ } else { continue; /* it is not possible for a lhs literal to * overhang the start */ } } const CharReach &cr = g[u].char_reach; if (!overlaps(*it, cr)) { DEBUG_PRINTF("skip\n"); continue; } if (isSubsetOf(*it, cr)) { next.insert(u); } else { DEBUG_PRINTF("bail\n"); goto bail; /* things got complicated */ } } } curr.swap(next); } bail: if (curr.empty()) { /* This can happen when we have an edge representing a cross from two * sides of an alternation. This whole edge needs to be marked as * dead */ assert(0); /* should have been picked up by can match */ return MO_INVALID_IDX; } u32 delay = distance(lit.rbegin(), it); assert(delay <= max_delay); assert(delay <= lit.length()); DEBUG_PRINTF("managed delay %u (of max %u)\n", delay, max_delay); set pred; for (auto v : curr) { insert(&pred, inv_adjacent_vertices_range(v, g)); } clear_in_edges(g.accept, g); clearReports(g); for (auto v : pred) { NFAEdge e = add_edge(v, g.accept, g); g[v].reports.insert(0); if (is_triggered(g) && v == g.start) { g[e].tops.insert(DEFAULT_TOP); } } pruneUseless(g); assert(allMatchStatesHaveReports(g)); assert(isCorrectlyTopped(g)); DEBUG_PRINTF("graph has %zu vertices left\n", num_vertices(g)); return delay; } void restoreTrailingLiteralStates(NGHolder &g, const ue2_literal &lit, u32 delay, const vector &preds) { assert(delay <= lit.length()); assert(isCorrectlyTopped(g)); DEBUG_PRINTF("adding on '%s' %u\n", dumpString(lit).c_str(), delay); NFAVertex prev = g.accept; auto it = lit.rbegin(); while (delay--) { NFAVertex curr = add_vertex(g); assert(it != lit.rend()); g[curr].char_reach = *it; add_edge(curr, prev, g); ++it; prev = curr; } for (auto v : preds) { NFAEdge e = add_edge(v, prev, g); if (v == g.start && is_triggered(g)) { g[e].tops.insert(DEFAULT_TOP); } } // Every predecessor of accept must have a report. for (auto u : inv_adjacent_vertices_range(g.accept, g)) { g[u].reports.insert(0); } renumber_vertices(g); renumber_edges(g); assert(allMatchStatesHaveReports(g)); assert(isCorrectlyTopped(g)); } void restoreTrailingLiteralStates(NGHolder &g, const ue2_literal &lit, u32 delay) { vector preds; insert(&preds, preds.end(), inv_adjacent_vertices(g.accept, g)); clear_in_edges(g.accept, g); for (auto v : preds) { g[v].reports.clear(); /* clear report from old accepts */ } restoreTrailingLiteralStates(g, lit, delay, preds); } /* return false if we should get rid of the edge altogether */ static bool removeLiteralFromLHS(RoseInGraph &ig, const RoseInEdge &lhs, const CompileContext &cc) { unique_ptr h = cloneHolder(*ig[lhs].graph); NGHolder &g = *h; assert(ig[target(lhs, ig)].type == RIV_LITERAL); const ue2_literal &lit = ig[target(lhs, ig)].s; /* lhs should be connected to a start */ assert(ig[source(lhs, ig)].type == RIV_START || ig[source(lhs, ig)].type == RIV_ANCHORED_START); if (in_degree(g.acceptEod, g) != 1 /* edge from accept */) { assert(0); return true; } if (lit.empty()) { assert(0); return true; } const u32 max_delay = maxDelay(cc); // In streaming mode, we must limit the depth to the available history // UNLESS the given literal follows start or startDs and has nothing // before it that we will need to account for. In that case, we can // lean on FDR's support for long literals. if (literalIsWholeGraph(g, lit)) { assert(!ig[lhs].haig); assert(ig[lhs].minBound == 0); assert(ig[lhs].maxBound == ROSE_BOUND_INF); DEBUG_PRINTF("literal is the whole graph\n"); u32 delay = removeTrailingLiteralStates(g, lit, MO_INVALID_IDX, false); assert(delay == lit.length()); ig[lhs].graph = move(h); ig[lhs].graph_lag = delay; return true; } if (!can_match(g, lit, false)) { /* This is can happen if the literal arises from a large cyclic to/beyond the pivot. As the LHS graph only cares about the first reach of the pivot, this literal is junk */ DEBUG_PRINTF("bogus edge\n"); return false; } u32 delay = removeTrailingLiteralStates(g, lit, max_delay, false /* can't overhang start */); if (delay == MO_INVALID_IDX) { /* This is can happen if the literal arises from a large cyclic to/beyond the pivot. As the LHS graph only cares about the first reach of the pivot, this literal is junk */ DEBUG_PRINTF("bogus edge\n"); return false; } if (!delay) { return true; } DEBUG_PRINTF("setting delay %u on lhs %p\n", delay, h.get()); ig[lhs].graph = move(h); ig[lhs].graph_lag = delay; return true; } static void handleLhsCliche(RoseInGraph &ig, const RoseInEdge &lhs) { const NGHolder &h = *ig[lhs].graph; size_t s_od = out_degree(h.start, h); size_t sds_od = out_degree(h.startDs, h); assert(in_degree(h.acceptEod, h) == 1 /* edge from accept */); /* need to check if simple floating start */ if (edge(h.startDs, h.accept, h).second && sds_od == 2 && ((s_od == 2 && edge(h.start, h.accept, h).second) || s_od == 1)) { /* no need for graph */ ig[lhs].graph.reset(); ig[lhs].graph_lag = 0; DEBUG_PRINTF("lhs is floating start\n"); return; } /* need to check if a simple anchor */ /* start would have edges to sds and accept in this case */ if (edge(h.start, h.accept, h).second && s_od == 2 && sds_od == 1) { if (ig[source(lhs, ig)].type == RIV_ANCHORED_START) { // assert(ig[lhs].graph_lag == ig[target(lhs, ig)].s.length()); if (ig[lhs].graph_lag != ig[target(lhs, ig)].s.length()) { DEBUG_PRINTF("oddness\n"); return; } ig[lhs].graph.reset(); ig[lhs].graph_lag = 0; ig[lhs].maxBound = 0; DEBUG_PRINTF("lhs is anchored start\n"); } else { DEBUG_PRINTF("lhs rewiring start\n"); assert(ig[source(lhs, ig)].type == RIV_START); RoseInVertex t = target(lhs, ig); remove_edge(lhs, ig); RoseInVertex s2 = add_vertex(RoseInVertexProps::makeStart(true), ig); add_edge(s2, t, RoseInEdgeProps(0U, 0U), ig); } return; } } static void filterCandPivots(const NGHolder &g, const set &cand_raw, set *out) { for (auto u : cand_raw) { const CharReach &u_cr = g[u].char_reach; if (u_cr.count() > 40) { continue; /* too wide to be plausible */ } if (u_cr.count() > 2) { /* include u as a candidate as successor may have backed away from * expanding through it */ out->insert(u); continue; } NFAVertex v = getSoleDestVertex(g, u); if (v && in_degree(v, g) == 1 && out_degree(u, g) == 1) { const CharReach &v_cr = g[v].char_reach; if (v_cr.count() == 1 || v_cr.isCaselessChar()) { continue; /* v will always generate better literals */ } } out->insert(u); } } /* cand_raw is the candidate set before filtering points which are clearly * a bad idea. */ static void getCandidatePivots(const NGHolder &g, set *cand, set *cand_raw) { ue2::unordered_map dominators = findDominators(g); set accepts; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { if (is_special(v, g)) { continue; } accepts.insert(v); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (is_special(v, g)) { continue; } accepts.insert(v); } assert(!accepts.empty()); vector dom_trace; auto ait = accepts.begin(); assert(ait != accepts.end()); NFAVertex curr = *ait; while (curr && !is_special(curr, g)) { dom_trace.push_back(curr); curr = dominators[curr]; } reverse(dom_trace.begin(), dom_trace.end()); for (++ait; ait != accepts.end(); ++ait) { curr = *ait; vector dom_trace2; while (curr && !is_special(curr, g)) { dom_trace2.push_back(curr); curr = dominators[curr]; } reverse(dom_trace2.begin(), dom_trace2.end()); auto dti = dom_trace.begin(), dtie = dom_trace.end(); auto dtj = dom_trace2.begin(), dtje = dom_trace2.end(); while (dti != dtie && dtj != dtje && *dti == *dtj) { ++dti; ++dtj; } dom_trace.erase(dti, dtie); } cand_raw->insert(dom_trace.begin(), dom_trace.end()); filterCandPivots(g, *cand_raw, cand); } static void deanchorIfNeeded(NGHolder &g, bool *orig_anch) { DEBUG_PRINTF("hi\n"); if (proper_out_degree(g.startDs, g)) { return; } /* look for a non-special dot with a loop following start */ set succ_g; insert(&succ_g, adjacent_vertices(g.start, g)); succ_g.erase(g.startDs); for (auto v : adjacent_vertices_range(g.start, g)) { DEBUG_PRINTF("inspecting cand %zu || =%zu\n", g[v].index, g[v].char_reach.size()); if (v == g.startDs || !g[v].char_reach.all()) { continue; } set succ_v; insert(&succ_v, adjacent_vertices(v, g)); if (succ_v == succ_g) { DEBUG_PRINTF("found ^.*\n"); *orig_anch = true; for (auto succ : succ_g) { add_edge(g.startDs, succ, g); } clear_vertex(v, g); remove_vertex(v, g); renumber_vertices(g); return; } if (succ_g.size() == 1 && hasSelfLoop(v, g)) { DEBUG_PRINTF("found ^.+\n"); *orig_anch = true; add_edge(g.startDs, v, g); remove_edge(v, v, g); return; } } } static unique_ptr makeTrivialGraph(const NGHolder &h, vdest_map_t &v_dest_map, vsrc_map_t &v_src_map) { shared_ptr root_g = cloneHolder(h); bool orig_anch = isAnchored(*root_g); deanchorIfNeeded(*root_g, &orig_anch); DEBUG_PRINTF("orig_anch %d\n", (int)orig_anch); unique_ptr igp = ue2::make_unique(); RoseInVertex start = add_vertex(RoseInVertexProps::makeStart(orig_anch), *igp); RoseInVertex accept = add_vertex(RoseInVertexProps::makeAccept(set()), *igp); RoseInEdge e = add_edge(start, accept, RoseInEdgeProps(root_g, 0), *igp).first; for (auto v : vertices_range(*root_g)) { v_dest_map[v].emplace_back(e, v); v_src_map[e].push_back(v); } return igp; } static never_inline void updateVDestMap(const vector > &images, const ue2::unordered_map &lhs_map, const vector &l_e, const ue2::unordered_map &rhs_map, const vector &r_e, vdest_map_t &v_dest_map, vsrc_map_t &v_src_map) { RoseInEdge e = images.front().first; set edge_set; for (const auto &image : images) { edge_set.insert(image.first); } const vector &domain = v_src_map[e]; vector > temp; for (auto v : domain) { vdest_map_t::iterator it = v_dest_map.find(v); assert(it != v_dest_map.end()); temp.clear(); for (const auto &dest : it->second) { const RoseInEdge &old_e = dest.first; const NFAVertex old_dest = dest.second; if (old_e != e) { if (!contains(edge_set, old_e)) { temp.emplace_back(old_e, old_dest); } } else if (contains(lhs_map, old_dest)) { for (const auto &e2 : l_e) { temp.emplace_back(e2, lhs_map.at(old_dest)); } /* only allow v to be tracked on one side of the split */ } else if (contains(rhs_map, old_dest)) { for (const auto &e2 : r_e) { temp.emplace_back(e2, rhs_map.at(old_dest)); } } } NDEBUG_PRINTF("%zu images for vertex; prev %zu\n", temp.size(), it->second.size()); it->second.swap(temp); } } /** Returns the collection of vertices from the original graph which end up * having an image in the [lr]hs side of the graph split. */ static never_inline void fillDomain(const vdest_map_t &v_dest_map, const vsrc_map_t &v_src_map, RoseInEdge e, const ue2::unordered_map &split_map, vector *out) { const vector &presplit_domain = v_src_map.at(e); for (auto v : presplit_domain) { /* v is in the original graph, need to find its image on e's graph */ typedef vector > dests_t; const dests_t &dests = v_dest_map.at(v); for (const auto &dest : dests) { if (dest.first == e) { NFAVertex vv = dest.second; /* vv is v image on e's graph */ if (contains(split_map, vv)) { out->push_back(v); } } } } } static void getSourceVerts(RoseInGraph &ig, const vector > &images, vector *out) { set seen; for (const auto &image : images) { RoseInVertex s = source(image.first, ig); if (contains(seen, s)) { continue; } seen.insert(s); out->push_back(s); } } static void getDestVerts(RoseInGraph &ig, const vector > &images, vector *out) { set seen; for (const auto &image : images) { RoseInVertex t = target(image.first, ig); if (contains(seen, t)) { continue; } seen.insert(t); out->push_back(t); } } static void getSourceVerts(RoseInGraph &ig, const vector &edges, vector *out) { set seen; for (const auto &e : edges) { RoseInVertex s = source(e, ig); if (contains(seen, s)) { continue; } seen.insert(s); out->push_back(s); } } static void getDestVerts(RoseInGraph &ig, const vector &edges, vector *out) { set seen; for (const auto &e : edges) { RoseInVertex t = target(e, ig); if (contains(seen, t)) { continue; } seen.insert(t); out->push_back(t); } } static bool splitRoseEdge(RoseInGraph &ig, const VertLitInfo &split, vdest_map_t &v_dest_map, vsrc_map_t &v_src_map) { const vector &root_splitters = split.vv; /* vertices in the 'root' graph */ assert(!root_splitters.empty()); /* need copy as split rose edge will update orig map */ vector > images = v_dest_map[root_splitters[0]]; DEBUG_PRINTF("splitting %zu rose edge with %zu literals\n", images.size(), split.lit.size()); /* note: as we haven't removed literals yet the graphs on all edges that we * are going to split should be identical */ const auto &base_graph = ig[images.front().first].graph; vector splitters; /* vertices in the graph being split */ for (auto v : root_splitters) { if (!contains(v_dest_map, v)) { DEBUG_PRINTF("vertex to split on is no longer in the graph\n"); return false; } /* sanity check: verify all edges have the same underlying graph */ for (UNUSED const auto &m : v_dest_map[v]) { assert(base_graph == ig[m.first].graph); } assert(v_dest_map[v].size() == images.size()); splitters.push_back(v_dest_map[v].front().second); } /* note: the set of split edges should form a complete bipartite graph */ vector src_verts; vector dest_verts; getSourceVerts(ig, images, &src_verts); getDestVerts(ig, images, &dest_verts); assert(images.size() == src_verts.size() * dest_verts.size()); shared_ptr lhs = make_shared(); shared_ptr rhs = make_shared(); ue2::unordered_map lhs_map; ue2::unordered_map rhs_map; assert(base_graph); splitGraph(*base_graph, splitters, lhs.get(), &lhs_map, rhs.get(), &rhs_map); RoseInEdge first_e = images.front().first; /* all will be suffix or none */ bool suffix = ig[target(first_e, ig)].type == RIV_ACCEPT; set splitter_reports; for (auto v : splitters) { insert(&splitter_reports, (*base_graph)[v].reports); } bool do_accept = false; bool do_accept_eod = false; assert(rhs); if (isVacuous(*rhs) && suffix) { if (edge(rhs->start, rhs->accept, *rhs).second) { DEBUG_PRINTF("rhs has a cliche\n"); do_accept = true; remove_edge(rhs->start, rhs->accept, *rhs); } if (edge(rhs->start, rhs->acceptEod, *rhs).second) { DEBUG_PRINTF("rhs has an eod cliche\n"); do_accept_eod = true; remove_edge(rhs->start, rhs->acceptEod, *rhs); } } bool do_norm = out_degree(rhs->start, *rhs) != 1; /* check if we still have a graph left over */ vector lhs_domain; vector rhs_domain; fillDomain(v_dest_map, v_src_map, first_e, lhs_map, &lhs_domain); fillDomain(v_dest_map, v_src_map, first_e, rhs_map, &rhs_domain); vector l_e; vector r_e; for (const auto &lit : split.lit) { DEBUG_PRINTF("best is '%s'\n", escapeString(lit).c_str()); RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); /* work out delay later */ if (do_accept) { DEBUG_PRINTF("rhs has a cliche\n"); RoseInVertex tt = add_vertex(RoseInVertexProps::makeAccept( splitter_reports), ig); add_edge(v, tt, RoseInEdgeProps(0U, 0U), ig); } if (do_accept_eod) { DEBUG_PRINTF("rhs has an eod cliche\n"); RoseInVertex tt = add_vertex(RoseInVertexProps::makeAcceptEod( splitter_reports), ig); add_edge(v, tt, RoseInEdgeProps(0U, 0U), ig); } for (auto src_v : src_verts) { l_e.push_back(add_edge(src_v, v, RoseInEdgeProps(lhs, 0U), ig).first); v_src_map[l_e.back()] = lhs_domain; } if (do_norm) { for (auto dst_v : dest_verts) { /* work out delay later */ assert(out_degree(rhs->start, *rhs) > 1); r_e.push_back( add_edge(v, dst_v, RoseInEdgeProps(rhs, 0U), ig).first); v_src_map[r_e.back()] = rhs_domain; } } } updateVDestMap(images, lhs_map, l_e, rhs_map, r_e, v_dest_map, v_src_map); for (const auto &image : images) { /* remove old edge */ remove_edge(image.first, ig); v_src_map.erase(image.first); } return true; } static bool isStarCliche(const NGHolder &g) { DEBUG_PRINTF("checking graph with %zu vertices\n", num_vertices(g)); bool nonspecials_seen = false; for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } if (nonspecials_seen) { return false; } nonspecials_seen = true; if (!g[v].char_reach.all()) { return false; } if (!hasSelfLoop(v, g)) { return false; } if (!edge(v, g.accept, g).second) { return false; } } if (!nonspecials_seen) { return false; } if (!edge(g.start, g.accept, g).second) { return false; } return true; } static void processInfixes(RoseInGraph &ig, const CompileContext &cc) { /* we want to ensure that every prefix/infix graph is unique at this stage * as we have not done any analysis to check if they are safe to share */ vector dead; for (const auto &e : edges_range(ig)) { if (!ig[e].graph) { continue; } RoseInVertex u = source(e, ig), v = target(e, ig); // Infixes are edges between two literals. if (ig[u].type != RIV_LITERAL || ig[v].type != RIV_LITERAL) { continue; } if (ig[e].graph_lag) { continue; /* already looked at */ } DEBUG_PRINTF("looking at infix %p\n", ig[e].graph.get()); const ue2_literal &lit1 = ig[u].s; const ue2_literal &lit2 = ig[v].s; size_t overlap = maxOverlap(lit1, lit2, 0); const NGHolder &h = *ig[e].graph; DEBUG_PRINTF("infix rose between literals '%s' and '%s', overlap %zu," "size %zu\n", dumpString(lit1).c_str(), dumpString(lit2).c_str(), overlap, num_vertices(h)); if (!can_match(h, lit2, true)) { DEBUG_PRINTF("found bogus edge\n"); dead.push_back(e); continue; } unique_ptr h_new = cloneHolder(h); u32 delay = removeTrailingLiteralStates(*h_new, lit2, MO_INVALID_IDX); if (delay == MO_INVALID_IDX) { DEBUG_PRINTF("found bogus edge\n"); dead.push_back(e); continue; } // Delay can be set to at most lit2.length() - overlap, but we must // truncate to history available in streaming mode. u32 max_allowed_delay = lit2.length() - overlap; LIMIT_TO_AT_MOST(&max_allowed_delay, delay); if (cc.streaming) { LIMIT_TO_AT_MOST(&max_allowed_delay, cc.grey.maxHistoryAvailable); } if (delay != max_allowed_delay) { restoreTrailingLiteralStates(*h_new, lit2, delay); delay = removeTrailingLiteralStates(*h_new, lit2, max_allowed_delay); } if (isStarCliche(*h_new)) { DEBUG_PRINTF("is a X star!\n"); ig[e].graph.reset(); ig[e].graph_lag = 0; } else { ig[e].graph = move(h_new); ig[e].graph_lag = delay; DEBUG_PRINTF("delay increased to %u\n", delay); } } for (const auto &e : dead) { remove_edge(e, ig); } } static void poisonNetflowScores(RoseInGraph &ig, RoseInEdge lhs, vector *scores) { assert(ig[lhs].graph); NGHolder &h = *ig[lhs].graph; if (ig[target(lhs, ig)].type != RIV_LITERAL) { /* nothing to poison in outfixes */ assert(ig[target(lhs, ig)].type == RIV_ACCEPT); return; } set curr, next; insert(&curr, inv_adjacent_vertices(h.accept, h)); set poisoned; u32 len = ig[target(lhs, ig)].s.length(); assert(len); while (len) { next.clear(); for (auto v : curr) { insert(&poisoned, in_edges(v, h)); insert(&next, inv_adjacent_vertices(v, h)); } curr.swap(next); len--; } for (const auto &e : poisoned) { (*scores)[h[e].index] = NO_LITERAL_AT_EDGE_SCORE; } } #define MAX_NETFLOW_CUT_WIDTH 40 /* magic number is magic */ #define MAX_LEN_2_LITERALS_PER_CUT 3 static bool checkValidNetflowLits(NGHolder &h, const vector &scores, const map> &cut_lits, const Grey &grey) { DEBUG_PRINTF("cut width %zu\n", cut_lits.size()); if (cut_lits.size() > MAX_NETFLOW_CUT_WIDTH) { return false; } u32 len_2_count = 0; for (const auto &cut : cut_lits) { if (scores[h[cut.first].index] >= NO_LITERAL_AT_EDGE_SCORE) { DEBUG_PRINTF("cut uses a forbidden edge\n"); return false; } if (min_len(cut.second) < grey.minRoseNetflowLiteralLength) { DEBUG_PRINTF("cut uses a bad literal\n"); return false; } for (const auto &lit : cut.second) { if (lit.length() == 2) { len_2_count++; } } } if (len_2_count > MAX_LEN_2_LITERALS_PER_CUT) { return false; } return true; } static void splitEdgesByCut(RoseInGraph &ig, const vector &to_cut, const vector &cut, const map > &cut_lits) { assert(!to_cut.empty()); assert(ig[to_cut.front()].graph); NGHolder &h = *ig[to_cut.front()].graph; /* note: the set of split edges should form a complete bipartite graph */ vector src_verts; vector dest_verts; getSourceVerts(ig, to_cut, &src_verts); getDestVerts(ig, to_cut, &dest_verts); assert(to_cut.size() == src_verts.size() * dest_verts.size()); map, shared_ptr > done_rhs; /* iterate over cut for determinism */ for (const auto &e : cut) { NFAVertex prev_v = source(e, h); NFAVertex pivot = target(e, h); vector adj; insert(&adj, adj.end(), adjacent_vertices(pivot, h)); /* we can ignore presence of accept, accepteod in adj as it is best effort */ if (!contains(done_rhs, adj)) { ue2::unordered_map temp_map; shared_ptr new_rhs = make_shared(); splitRHS(h, adj, new_rhs.get(), &temp_map); remove_edge(new_rhs->start, new_rhs->accept, *new_rhs); remove_edge(new_rhs->start, new_rhs->acceptEod, *new_rhs); done_rhs.insert(make_pair(adj, new_rhs)); /* TODO need to update v_mapping (if we were doing more cuts) */ } DEBUG_PRINTF("splitting on pivot %zu\n", h[pivot].index); ue2::unordered_map temp_map; shared_ptr new_lhs = make_shared(); splitLHS(h, pivot, new_lhs.get(), &temp_map); /* want to cut of paths to pivot from things other than the pivot - * makes a more svelte graphy */ clear_in_edges(temp_map[pivot], *new_lhs); add_edge(temp_map[prev_v], temp_map[pivot], *new_lhs); pruneUseless(*new_lhs); const set &lits = cut_lits.at(e); for (const auto &lit : lits) { RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); if (edge(pivot, h.accept, h).second) { /* literal has a direct connection to accept */ assert(ig[dest_verts.front()].type == RIV_ACCEPT); const auto &reports = h[pivot].reports; RoseInVertex tt = add_vertex(RoseInVertexProps::makeAccept(reports), ig); add_edge(v, tt, RoseInEdgeProps(0U, 0U), ig); } if (edge(pivot, h.acceptEod, h).second) { /* literal has a direct connection to accept */ assert(ig[dest_verts.front()].type == RIV_ACCEPT); const auto &reports = h[pivot].reports; RoseInVertex tt = add_vertex( RoseInVertexProps::makeAcceptEod(reports), ig); add_edge(v, tt, RoseInEdgeProps(0U, 0U), ig); } assert(done_rhs[adj].get()); shared_ptr new_rhs = done_rhs[adj]; if (out_degree(new_rhs->start, *new_rhs) != 1) { for (auto dst_v : dest_verts) { add_edge(v, dst_v, RoseInEdgeProps(done_rhs[adj], 0), ig); } } for (auto src_v : src_verts) { add_edge(src_v, v, RoseInEdgeProps(new_lhs, 0), ig); } } } /* TODO need to update v_mapping (if we were doing more cuts) */ for (const auto &e : to_cut) { assert(ig[e].graph.get() == &h); remove_edge(e, ig); } } static bool doNetflowCut(RoseInGraph &ig, const vector &to_cut, const Grey &grey) { DEBUG_PRINTF("doing netflow cut\n"); /* TODO: we should really get literals/scores from the full graph as this * allows us to overlap the graph. Doesn't matter at the moment as we * are working on the LHS. */ NGHolder &h = *ig[to_cut.front()].graph; if (num_edges(h) > grey.maxRoseNetflowEdges) { /* We have a limit on this because scoring edges and running netflow * gets very slow for big graphs. */ DEBUG_PRINTF("too many edges, skipping netflow cut\n"); return false; } renumber_vertices(h); renumber_edges(h); /* Step 1: Get scores for all edges */ vector scores = scoreEdges(h); /* scores by edge_index */ /* Step 2: poison scores for edges covered by successor literal */ for (const auto &e : to_cut) { assert(&h == ig[e].graph.get()); poisonNetflowScores(ig, e, &scores); } /* Step 3: Find cutset based on scores */ vector cut = findMinCut(h, scores); /* Step 4: Get literals corresponding to cut edges */ map> cut_lits; for (const auto &e : cut) { set lits = getLiteralSet(h, e); compressAndScore(lits); cut_lits[e] = lits; } /* if literals are underlength bail or if it involves a forbidden edge*/ if (!checkValidNetflowLits(h, scores, cut_lits, grey)) { return false; } DEBUG_PRINTF("splitting\n"); /* Step 5: Split graph based on cuts */ splitEdgesByCut(ig, to_cut, cut, cut_lits); return true; } /** \brief Returns the number of intermediate vertices in the shortest path * between (from, to). */ static u32 min_dist_between(NFAVertex from, NFAVertex to, const NGHolder &g) { // Check for the trivial case: that way we don't have to set up the // containers below. if (edge(from, to, g).second) { return 0; } ue2::unordered_set visited; visited.insert(from); flat_set curr, next; curr.insert(from); assert(from != to); u32 d = 0; while (!curr.empty()) { next.clear(); for (auto v : curr) { for (auto w : adjacent_vertices_range(v, g)) { if (w == to) { return d; } if (visited.insert(w).second) { // first visit to *ai next.insert(w); } } } d++; curr.swap(next); } assert(0); return ROSE_BOUND_INF; } /** Literals which are completely enveloped by a successor are trouble because * hamsterwheel acceleration can skip past the start of the literal. */ static bool enveloped(const vector &cand_split_v, const set &cand_lit, const NGHolder &g, const RoseInVertexProps &succ) { if (succ.type != RIV_LITERAL) { return false; } /* TODO: handle multiple v more precisely: not all candidate v can start all * candidate literals */ for (auto v : cand_split_v) { u32 rhs_min_len = min_dist_between(v, g.accept, g); if (rhs_min_len + min_len(cand_lit) >= succ.s.length()) { return false; } } return true; /* we are in trouble */ } static bool enveloped(const VertLitInfo &cand_split, const RoseInGraph &ig, const vdest_map_t &v_dest_map) { for (auto v : cand_split.vv) { const auto &images = v_dest_map.at(v); for (const auto &image : images) { /* check that we aren't enveloped by the successor */ if (enveloped(vector(1, image.second), cand_split.lit, *ig[image.first].graph, ig[target(image.first, ig)])) { return true; } const RoseInVertexProps &pred = ig[source(image.first, ig)]; if (pred.type != RIV_LITERAL) { continue; } /* check we don't envelop the pred */ const NGHolder &g = *ig[image.first].graph; u32 lhs_min_len = min_dist_between(g.start, image.second, g); if (lhs_min_len + pred.s.length() < max_len(cand_split.lit)) { return true; } } } return false; } static bool attemptSplit(RoseInGraph &ig, vdest_map_t &v_dest_map, vsrc_map_t &v_src_map, const vector &v_e, LitCollection &lits) { NGHolder &h = *ig[v_e.front()].graph; unique_ptr split = lits.pickNext(); while (split) { for (const auto &e : v_e) { RoseInVertex t = target(e, ig); if (enveloped(split->vv, split->lit, h, ig[t])) { DEBUG_PRINTF("enveloped\n"); split = lits.pickNext(); goto next_split; } } break; next_split:; } if (!split) { return false; } for (auto v : split->vv) { if (edge(v, h.accept, h).second) { return false; } } DEBUG_PRINTF("saved by a bad literal\n"); splitRoseEdge(ig, *split, v_dest_map, v_src_map); return true; } static void appendLiteral(const ue2_literal &s, const CharReach &cr, vector *out) { for (size_t c = cr.find_first(); c != CharReach::npos; c = cr.find_next(c)) { bool nocase = ourisalpha(c) && cr.test(mytoupper(c)) && cr.test(mytolower(c)); if (nocase && (char)c == mytolower(c)) { continue; /* uppercase already handled us */ } out->push_back(s); out->back().push_back(c, nocase); } } static bool findAnchoredLiterals(const NGHolder &g, vector *out, vector *pivots_out) { DEBUG_PRINTF("trying for anchored\n"); #define MAX_ANCHORED_LITERALS 30 #define MAX_ANCHORED_LITERAL_LEN 30 /* TODO: this could be beefed up by going region-by-region but currently * that brings back bad memories of ng_rose. OR any AA region we can build * a dfa out of */ assert(!proper_out_degree(g.startDs, g)); vector lits; lits.push_back(ue2_literal()); set curr; insert(&curr, adjacent_vertices(g.start, g)); curr.erase(g.startDs); set old; if (contains(curr, g.accept) || curr.empty()) { DEBUG_PRINTF("surprise accept/voidness\n"); return false; } while (!curr.empty()) { set next_verts; insert(&next_verts, adjacent_vertices(*curr.begin(), g)); bool can_extend = !next_verts.empty() && !contains(next_verts, g.accept); CharReach cr; for (auto v : curr) { assert(!is_special(v, g)); if (can_extend) { /* next verts must agree */ set next_verts_local; insert(&next_verts_local, adjacent_vertices(v, g)); can_extend = next_verts_local == next_verts; } cr |= g[v].char_reach; } if (!can_extend) { goto bail; } /* extend literals */ assert(cr.any()); vector next_lits; for (const auto &lit : lits) { appendLiteral(lit, cr, &next_lits); if (next_lits.size() > MAX_ANCHORED_LITERALS) { goto bail; } } assert(!next_lits.empty()); old.swap(curr); if (next_lits[0].length() <= MAX_ANCHORED_LITERAL_LEN) { curr.swap(next_verts); } else { curr.clear(); } lits.swap(next_lits); } bail: assert(!lits.empty()); for (UNUSED const auto &lit : lits) { DEBUG_PRINTF("found anchored string: %s\n", dumpString(lit).c_str()); } insert(pivots_out, pivots_out->end(), old); out->swap(lits); return !out->empty() && !out->begin()->empty(); } static bool tryForAnchoredImprovement(RoseInGraph &ig, RoseInEdge e) { vector lits; vector pivots; if (!findAnchoredLiterals(*ig[e].graph, &lits, &pivots)) { DEBUG_PRINTF("unable to find literals\n"); return false; } DEBUG_PRINTF("found %zu literals to act as anchors\n", lits.size()); RoseInVertex s = source(e, ig); RoseInVertex t = target(e, ig); assert(!ig[e].graph_lag); shared_ptr lhs = make_shared(); shared_ptr rhs = make_shared(); ue2::unordered_map temp1; ue2::unordered_map temp2; splitGraph(*ig[e].graph, pivots, lhs.get(), &temp1, rhs.get(), &temp2); for (const auto &lit : lits) { RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); add_edge(s, v, RoseInEdgeProps(lhs, 0U), ig); add_edge(v, t, RoseInEdgeProps(rhs, 0U), ig); } remove_edge(e, ig); return true; } #define MAX_SINGLE_BYTE_ANCHORED_DIST 30 /* returns true if we should make another pass */ static bool lastChanceImproveLHS(RoseInGraph &ig, RoseInEdge lhs, const CompileContext &cc) { DEBUG_PRINTF("argh lhs is nasty\n"); assert(ig[lhs].graph); /* customise the lhs for this literal */ /* TODO better, don't recalc */ if (ig[target(lhs, ig)].type == RIV_LITERAL) { const NGHolder &h = *ig[lhs].graph; /* sanitise literal on lhs */ const ue2_literal &s = ig[target(lhs, ig)].s; if (!can_match(h, s, false)) { DEBUG_PRINTF("found bogus edge\n"); return false; } /* see if we can build some anchored literals out of this */ if (isAnchored(h) && tryForAnchoredImprovement(ig, lhs)) { return true; } unique_ptr cust = cloneHolder(h); u32 d = removeTrailingLiteralStates(*cust, s, MO_INVALID_IDX); if (d == MO_INVALID_IDX) { DEBUG_PRINTF("found bogus edge\n"); return false; } restoreTrailingLiteralStates(*cust, s, d); ig[lhs].graph = move(cust); } NGHolder &lhs_graph = *ig[lhs].graph; set cand; set cand_raw; getCandidatePivots(lhs_graph, &cand, &cand_raw); vdest_map_t v_dest_map; vsrc_map_t v_src_map; for (auto v : vertices_range(lhs_graph)) { v_dest_map[v].emplace_back(lhs, v); v_src_map[lhs].push_back(v); } vector depths; calcDepths(lhs_graph, depths); /* need to ensure regions are valid before we do lit discovery */ auto region_map = assignRegions(lhs_graph); vector to_cut(1, lhs); DEBUG_PRINTF("see if we can get a better lhs by another cut\n"); LitCollection lit1(lhs_graph, depths, region_map, cand, cand_raw, cc.grey.minRoseLiteralLength, true, cc); if (attemptSplit(ig, v_dest_map, v_src_map, to_cut, lit1)) { return true; } if (doNetflowCut(ig, to_cut, cc.grey)) { return true; } DEBUG_PRINTF("eek last chance try len 1 if it creates an anchored lhs\n"); { LitCollection lits(lhs_graph, depths, region_map, cand, cand_raw, 1, true, cc, true); unique_ptr split = lits.pickNext(); /* TODO fix edge to accept check */ while (split && (enveloped(split->vv, split->lit, lhs_graph, ig[target(lhs, ig)]) || edge(split->vv.front(), lhs_graph.accept, lhs_graph).second || !createsAnchoredLHS(lhs_graph, split->vv, depths, cc.grey, MAX_SINGLE_BYTE_ANCHORED_DIST))) { split = lits.pickNext(); } if (split) { DEBUG_PRINTF("saved by a really bad literal\n"); splitRoseEdge(ig, *split, v_dest_map, v_src_map); return true; } } return false; } /* returns false if nothing happened */ static bool lastChanceImproveLHS(RoseInGraph &ig, const vector &to_cut, const CompileContext &cc) { DEBUG_PRINTF("argh lhses are nasty\n"); NGHolder &lhs_graph = *ig[to_cut.front()].graph; set cand; set cand_raw; getCandidatePivots(lhs_graph, &cand, &cand_raw); vdest_map_t v_dest_map; vsrc_map_t v_src_map; for (auto v : vertices_range(lhs_graph)) { for (const auto &e : to_cut) { v_dest_map[v].emplace_back(e, v); v_src_map[e].push_back(v); } } vector depths; calcDepths(lhs_graph, depths); auto region_map = assignRegions(lhs_graph); DEBUG_PRINTF("see if we can get a better lhs by allowing another cut\n"); LitCollection lit1(lhs_graph, depths, region_map, cand, cand_raw, cc.grey.minRoseLiteralLength, true, cc); if (attemptSplit(ig, v_dest_map, v_src_map, to_cut, lit1)) { return true; } return doNetflowCut(ig, to_cut, cc.grey); } static bool improveLHS(RoseInGraph &ig, const vector &edges, const CompileContext &cc) { bool rv = false; vector src_verts; getSourceVerts(ig, edges, &src_verts); map> by_src; for (const auto &e : edges) { by_src[source(e, ig)].push_back(e); } for (auto v : src_verts) { const vector &local = by_src[v]; vector graphs; map > by_graph; for (const auto &e : local) { NGHolder *gp = ig[e].graph.get(); if (!contains(by_graph, gp)) { graphs.push_back(gp); } by_graph[gp].push_back(e); } for (auto h : graphs) { const vector &local2 = by_graph[h]; if (local2.size() == 1) { rv |= lastChanceImproveLHS(ig, local2.front(), cc); continue; } bool lrv = lastChanceImproveLHS(ig, local2, cc); if (lrv) { rv = true; } else { for (const auto &e2 : local2) { rv |= lastChanceImproveLHS(ig, e2, cc); } } } } return rv; } static void processLHS(RoseInGraph &ig, const CompileContext &cc) { bool redo; do { redo = false; vector to_improve; for (const auto &lhs : edges_range(ig)) { if (ig[source(lhs, ig)].type != RIV_START && ig[source(lhs, ig)].type != RIV_ANCHORED_START) { continue; } if (ig[target(lhs, ig)].type == RIV_LITERAL) { DEBUG_PRINTF("checking lhs->'%s'\n", ig[target(lhs, ig)].s.c_str()); } else { DEBUG_PRINTF("checking lhs->?\n"); } /* if check if lhs is nasty */ if (ig[target(lhs, ig)].type == RIV_ACCEPT) { to_improve.push_back(lhs); continue; } assert(ig[lhs].graph); const NGHolder *h = ig[lhs].graph.get(); vector depths; calcDepths(*h, depths); if (!isLHSTransient(*h, depths, cc.grey) && !literalIsWholeGraph(*h, ig[target(lhs, ig)].s) && !isLHSUsablyAnchored(*h, depths, cc.grey)) { to_improve.push_back(lhs); } } DEBUG_PRINTF("inspecting %zu lhs\n", to_improve.size()); if (to_improve.size() > 50) { DEBUG_PRINTF("too big\n"); break; } redo = improveLHS(ig, to_improve, cc); DEBUG_PRINTF("redo = %d\n", (int)redo); } while (redo); vector to_inspect; /* to prevent surprises caused by us * altering the graph while iterating */ for (const auto &e : edges_range(ig)) { if (ig[source(e, ig)].type == RIV_START || ig[source(e, ig)].type == RIV_ANCHORED_START) { to_inspect.push_back(e); } } for (const auto &lhs : to_inspect) { if (ig[target(lhs, ig)].type == RIV_LITERAL) { if (removeLiteralFromLHS(ig, lhs, cc)) { handleLhsCliche(ig, lhs); } else { /* telling us to delete the edge */ remove_edge(lhs, ig); } } } } static void tryNetflowCutForRHS(RoseInGraph &ig, const Grey &grey) { vector to_improve; for (const auto &rhs : edges_range(ig)) { if (ig[target(rhs, ig)].type != RIV_ACCEPT) { continue; } if (ig[source(rhs, ig)].type == RIV_LITERAL) { DEBUG_PRINTF("checking '%s'->rhs\n", ig[source(rhs, ig)].s.c_str()); } else { DEBUG_PRINTF("checking ?->rhs\n"); } if (!ig[rhs].graph) { continue; } DEBUG_PRINTF("%zu vertices\n", num_vertices(*ig[rhs].graph)); if (num_vertices(*ig[rhs].graph) < 512) { DEBUG_PRINTF("small\n"); continue; } /* if check if rhs is nasty */ to_improve.push_back(rhs); } DEBUG_PRINTF("inspecting %zu lhs\n", to_improve.size()); if (to_improve.size() > 50) { DEBUG_PRINTF("too big\n"); return; } for (const auto &e : to_improve) { vector to_cut(1, e); doNetflowCut(ig, to_cut, grey); } } /* just make the string nocase and get the graph to handle case mask, TODO. * This could be more nuanced but the effort would probably be better spent * just making rose less bad. */ static void makeNocaseWithPrefixMask(RoseInGraph &g, RoseInVertex v) { for (const auto &e : in_edges_range(v, g)) { const RoseInVertex u = source(e, g); if (!g[e].graph) { g[e].graph = make_shared(whatRoseIsThis(g, e)); g[e].graph_lag = g[v].s.length(); NGHolder &h = *g[e].graph; assert(!g[e].maxBound || g[e].maxBound == ROSE_BOUND_INF); if (g[u].type == RIV_START) { add_edge(h.startDs, h.accept, h); h[h.startDs].reports.insert(0); } else if (g[e].maxBound == ROSE_BOUND_INF) { add_edge(h.start, h.accept, h); NFAVertex ds = add_vertex(h); h[ds].char_reach = CharReach::dot(); NFAEdge e_start_to_ds = add_edge(h.start, ds, h); add_edge(ds, ds, h); add_edge(ds, h.accept, h); h[h.start].reports.insert(0); h[ds].reports.insert(0); if (g[u].type == RIV_LITERAL) { h[e_start_to_ds].tops.insert(DEFAULT_TOP); } } else { assert(g[u].type == RIV_ANCHORED_START); add_edge(h.start, h.accept, h); h[h.start].reports.insert(0); } } if (!g[e].graph_lag) { continue; } unique_ptr newg = cloneHolder(*g[e].graph); restoreTrailingLiteralStates(*newg, g[v].s, g[e].graph_lag); g[e].graph_lag = 0; g[e].graph = move(newg); } make_nocase(&g[v].s); } static unique_ptr makeGraphCopy(const NGHolder *g) { if (g) { return cloneHolder(*g); } else { return nullptr; } } static void explodeLiteral(RoseInGraph &g, RoseInVertex v, vector &exploded) { for (const auto &lit : exploded) { RoseInVertex v_new = add_vertex(g[v], g); g[v_new].s = lit; for (const auto &e : in_edges_range(v, g)) { RoseInEdge e2 = add_edge(source(e, g), v_new, g[e], g); // FIXME: are we safe to share graphs here? For now, make our very // own copy. g[e2].graph = makeGraphCopy(g[e].graph.get()); } for (const auto &e : out_edges_range(v, g)) { RoseInEdge e2 = add_edge(v_new, target(e, g), g[e], g); // FIXME: are we safe to share graphs here? For now, make our very // own copy. g[e2].graph = makeGraphCopy(g[e].graph.get()); } } clear_vertex(v, g); remove_vertex(v, g); } /* Sadly rose is hacky in terms of mixed case literals. TODO: remove when rose * becomes less bad */ static void handleLongMixedSensitivityLiterals(RoseInGraph &g) { const size_t maxExploded = 8; // only case-explode this far vector verts; for (auto v : vertices_range(g)) { if (g[v].type != RIV_LITERAL) { continue; } ue2_literal &s = g[v].s; if (!mixed_sensitivity(s)) { continue; } if (s.length() < MAX_MASK2_WIDTH) { DEBUG_PRINTF("mixed lit will be handled by benefits mask\n"); continue; } DEBUG_PRINTF("found mixed lit of len %zu\n", s.length()); verts.push_back(v); } for (auto v : verts) { vector exploded; case_iter cit = caseIterateBegin(g[v].s), cite = caseIterateEnd(); for (; cit != cite; ++cit) { exploded.emplace_back(*cit, false); if (exploded.size() > maxExploded) { goto dont_explode; } } DEBUG_PRINTF("exploding literal into %zu pieces\n", exploded.size()); explodeLiteral(g, v, exploded); continue; dont_explode: DEBUG_PRINTF("converting to nocase with prefix mask\n"); makeNocaseWithPrefixMask(g, v); } DEBUG_PRINTF("done!\n"); } static void dedupe(RoseInGraph &g) { /* We know that every prefix/infix is unique after the rose construction. * * If a vertex has out-going graphs with the same rewind and they are equal * we can dedupe the graph. * * After this, we may share graphs on out-edges of a vertex. */ map, vector>> buckets; for (auto v : vertices_range(g)) { buckets.clear(); for (const auto &e : out_edges_range(v, g)) { if (!g[e].graph || g[target(e, g)].type != RIV_LITERAL) { continue; } auto k = make_pair(g[e].graph_lag, hash_holder(*g[e].graph)); auto &bucket = buckets[k]; for (const auto &h : bucket) { if (is_equal(*g[e].graph, 0U, *h, 0U)) { g[e].graph = h; goto next_edge; } } bucket.push_back(g[e].graph); next_edge:; } } } static bool pureReport(NFAVertex v, const NGHolder &g) { for (auto w : adjacent_vertices_range(v, g)) { if (w != g.accept && w != g.acceptEod) { return false; } } return true; } static bool pureReport(const vector &vv, const NGHolder &g) { for (auto v : vv) { if (!pureReport(v, g)) { return false; } } return true; } /* ensures that a vertex is followed by a start construct AND the cyclic states * has a reasonably wide reach */ static bool followedByStar(NFAVertex v, const NGHolder &g) { set succ; insert(&succ, adjacent_vertices(v, g)); set asucc; for (auto w : adjacent_vertices_range(v, g)) { if (g[w].char_reach.count() < N_CHARS - MAX_ESCAPE_CHARS) { continue; /* state is too narrow to be considered as a sane star cyclic */ } asucc.clear(); insert(&asucc, adjacent_vertices(w, g)); if (asucc == succ) { return true; } } return false; } static bool followedByStar(const vector &vv, const NGHolder &g) { for (auto v : vv) { if (!followedByStar(v, g)) { return false; } } return true; } static bool isEodPrefixCandidate(const NGHolder &g) { if (in_degree(g.accept, g)) { DEBUG_PRINTF("graph isn't eod anchored\n"); return false; } // TODO: handle more than one report. if (all_reports(g).size() != 1) { return false; } return true; } static bool isEodWithPrefix(const RoseInGraph &g) { if (num_vertices(g) != 2) { return false; } for (const auto &e : edges_range(g)) { RoseInVertex u = source(e, g), v = target(e, g); DEBUG_PRINTF("edge from %d -> %d\n", g[u].type, g[v].type); if (g[u].type != RIV_START && g[u].type != RIV_ANCHORED_START) { DEBUG_PRINTF("source not start, type=%d\n", g[u].type); return false; } if (g[v].type != RIV_ACCEPT && g[v].type != RIV_ACCEPT_EOD) { DEBUG_PRINTF("target not accept, type=%d\n", g[v].type); return false; } // Haigs not handled. if (g[e].haig) { DEBUG_PRINTF("edge has haig\n"); return false; } if (!g[e].graph) { DEBUG_PRINTF("no graph on edge\n"); return false; } if (!isEodPrefixCandidate(*g[e].graph)) { DEBUG_PRINTF("graph is not eod prefix candidate\n"); return false; } } return true; } static void processEodPrefixes(RoseInGraph &g) { // Find edges to accept with EOD-anchored graphs that we can move over to // acceptEod. vector acc_edges; for (const auto &e : edges_range(g)) { if (g[target(e, g)].type != RIV_ACCEPT) { continue; } if (g[e].haig || !g[e].graph) { continue; } if (!isEodPrefixCandidate(*g[e].graph)) { continue; } // TODO: handle cases with multiple out-edges. if (out_degree(source(e, g), g) > 1) { continue; } acc_edges.push_back(e); } set accepts; for (const RoseInEdge &e : acc_edges) { RoseInVertex u = source(e, g), v = target(e, g); assert(g[e].graph); assert(g[v].type == RIV_ACCEPT); assert(all_reports(*g[e].graph).size() == 1); // Move this edge from accept to acceptEod and give it the right reports // from the graph on the edge. const set reports = all_reports(*g[e].graph); RoseInVertex w = add_vertex( RoseInVertexProps::makeAcceptEod(reports), g); add_edge(u, w, g[e], g); remove_edge(e, g); accepts.insert(v); } for (auto v : accepts) { if (!in_degree(v, g)) { remove_vertex(v, g); } } } /** Run some reduction passes on the graphs on our edges. */ static void reduceGraphs(RoseInGraph &g, const CompileContext &cc) { for (const auto &e : edges_range(g)) { if (!g[e].graph) { continue; } NGHolder &h = *g[e].graph; assert(h.kind == whatRoseIsThis(g, e)); DEBUG_PRINTF("before, graph %p has %zu vertices, %zu edges\n", &h, num_vertices(h), num_edges(h)); pruneUseless(h); reduceGraphEquivalences(h, cc); removeRedundancy(h, SOM_NONE); /* rose doesn't track som */ DEBUG_PRINTF("after, graph %p has %zu vertices, %zu edges\n", &h, num_vertices(h), num_edges(h)); // It's possible that one of our graphs may have reduced to a dot-star // cliche, i.e. it contains a startDs->accept edge. If so, we can // remove it from the edge and just use edge bounds to represent it. if (edge(h.startDs, h.accept, h).second) { DEBUG_PRINTF("graph reduces to dot-star, deleting\n"); g[e].graph.reset(); g[e].graph_lag = 0; g[e].minBound = 0; g[e].maxBound = ROSE_BOUND_INF; } } } static unique_ptr buildRose(const NGHolder &h, bool desperation, const CompileContext &cc) { /* Need to pick a pivot point which splits the graph in two with starts on * one side and accepts on the other. Thus the pivot needs to dominate all * the accept vertices */ /* maps a vertex in h to one of its images in the rose graph */ vdest_map_t v_dest_map; vsrc_map_t v_src_map; /* create trivial rose graph */ unique_ptr igp = makeTrivialGraph(h, v_dest_map, v_src_map); RoseInGraph &ig = *igp; /* root graph is the graph on the only edge in our new RoseInGraph */ assert(num_edges(ig) == 1); shared_ptr root_g = ig[*edges(ig).first].graph; assert(root_g); /* find the literals */ set cand; set cand_raw; getCandidatePivots(*root_g, &cand, &cand_raw); DEBUG_PRINTF("|cand| = %zu\n", cand.size()); vector depths; calcDepths(*root_g, depths); auto region_map = assignRegions(*root_g); LitCollection lits(*root_g, depths, region_map, cand, cand_raw, cc.grey.minRoseLiteralLength, desperation, cc); for (u32 i = 0; i < cc.grey.roseDesiredSplit; ++i) { DEBUG_PRINTF("attempting split %u (desired %u)\n", i, cc.grey.roseDesiredSplit); unique_ptr split = lits.pickNext(); /* need to check we aren't creating any enveloping literals */ while (split && enveloped(*split, ig, v_dest_map)) { DEBUG_PRINTF("bad cand; getting next split\n"); split = lits.pickNext(); } if (!split) { DEBUG_PRINTF("no more lits :(\n"); break; } splitRoseEdge(ig, *split, v_dest_map, v_src_map); } /* try for more split literals if they are followed by .* or accept */ for (;;) { DEBUG_PRINTF("attempting bonus split\n"); unique_ptr split = lits.pickNext(); /* need to check we aren't creating any enveloping literals */ while (split && (enveloped(*split, ig, v_dest_map) || (!pureReport(split->vv, *root_g) && !followedByStar(split->vv, *root_g)))) { DEBUG_PRINTF("bad cand; getting next split\n"); split = lits.pickNext(); } if (!split) { DEBUG_PRINTF("no more lits :(\n"); break; } DEBUG_PRINTF("got bonus split\n"); splitRoseEdge(ig, *split, v_dest_map, v_src_map); } processLHS(ig, cc); if (num_vertices(ig) <= 2) { // At present, we don't accept all outfixes. // However, we do handle the specific case of a rose that precedes an // acceptEod, which we will support as a prefix to a special EOD event // "literal". if (!isEodWithPrefix(ig)) { igp.reset(); return igp; } } processEodPrefixes(ig); processInfixes(ig, cc); handleLongMixedSensitivityLiterals(ig); dedupe(ig); pruneUseless(ig); reduceGraphs(ig, cc); dumpPreRoseGraph(ig, cc.grey); renumber_vertices(ig); calcVertexOffsets(ig); return igp; } static void desperationImprove(RoseInGraph &ig, const CompileContext &cc) { DEBUG_PRINTF("rose said no; can we do better?\n"); /* infixes are tricky as we have to worry about delays, enveloping * literals, etc */ tryNetflowCutForRHS(ig, cc.grey); processInfixes(ig, cc); handleLongMixedSensitivityLiterals(ig); dedupe(ig); pruneUseless(ig); renumber_vertices(ig); calcVertexOffsets(ig); } bool splitOffRose(RoseBuild &rose, const NGHolder &h, bool prefilter, const CompileContext &cc) { if (!cc.grey.allowRose) { return false; } // We should have at least one edge into accept or acceptEod! assert(in_degree(h.accept, h) || in_degree(h.acceptEod, h) > 1); unique_ptr igp = buildRose(h, false, cc); if (igp && rose.addRose(*igp, prefilter)) { goto ok; } igp = buildRose(h, true, cc); if (igp) { if (rose.addRose(*igp, prefilter)) { goto ok; } desperationImprove(*igp, cc); if (rose.addRose(*igp, prefilter)) { goto ok; } } DEBUG_PRINTF("rose build failed\n"); return false; ok: DEBUG_PRINTF("rose build ok\n"); return true; } bool finalChanceRose(RoseBuild &rose, const NGHolder &h, bool prefilter, const CompileContext &cc) { DEBUG_PRINTF("final chance rose\n"); if (!cc.grey.allowRose) { return false; } assert(h.kind == NFA_OUTFIX); ue2_literal lit; bool anch = false; shared_ptr rhs = make_shared(); if (!splitOffLeadingLiteral(h, &lit, &*rhs)) { DEBUG_PRINTF("no floating literal\n"); anch = true; if (!splitOffAnchoredLeadingLiteral(h, &lit, &*rhs)) { DEBUG_PRINTF("no anchored literal\n"); return false; } } if (lit.length() < cc.grey.minRoseLiteralLength || minStringPeriod(lit) < 2 ) { DEBUG_PRINTF("lit too weak\n"); return false; } assert(lit.length() <= MAX_MASK2_WIDTH || !mixed_sensitivity(lit)); RoseInGraph ig; RoseInVertex s = add_vertex(RoseInVertexProps::makeStart(anch), ig); RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); add_edge(s, v, RoseInEdgeProps(0, anch ? 0 : ROSE_BOUND_INF), ig); ue2_literal lit2; if (getTrailingLiteral(h, &lit2) && lit2.length() >= cc.grey.minRoseLiteralLength && minStringPeriod(lit2) >= 2) { /* TODO: handle delay */ size_t overlap = maxOverlap(lit, lit2, 0); u32 delay2 = lit2.length() - overlap; delay2 = min(delay2, maxDelay(cc)); delay2 = removeTrailingLiteralStates(*rhs, lit2, delay2); rhs->kind = NFA_INFIX; assert(delay2 <= lit2.length()); RoseInVertex w = add_vertex(RoseInVertexProps::makeLiteral(lit2), ig); add_edge(v, w, RoseInEdgeProps(rhs, delay2), ig); NFAVertex reporter = getSoleSourceVertex(h, h.accept); assert(reporter); const auto &reports = h[reporter].reports; RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(reports), ig); add_edge(w, a, RoseInEdgeProps(0U, 0U), ig); } else { RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(set()), ig); add_edge(v, a, RoseInEdgeProps(rhs, 0U), ig); } renumber_vertices(ig); calcVertexOffsets(ig); return rose.addRose(ig, prefilter, true /* final chance */); } bool checkRose(const ReportManager &rm, const NGHolder &h, bool prefilter, const CompileContext &cc) { if (!cc.grey.allowRose) { return false; } // We should have at least one edge into accept or acceptEod! assert(in_degree(h.accept, h) || in_degree(h.acceptEod, h) > 1); unique_ptr igp; // First pass. igp = buildRose(h, false, cc); if (igp && roseCheckRose(*igp, prefilter, rm, cc)) { return true; } // Second ("desperation") pass. igp = buildRose(h, true, cc); if (igp) { if (roseCheckRose(*igp, prefilter, rm, cc)) { return true; } desperationImprove(*igp, cc); if (roseCheckRose(*igp, prefilter, rm, cc)) { return true; } } return false; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_haig.cpp0000644000175000017500000006163413055426554020766 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Build code for Haig SOM DFA. */ #include "ng_haig.h" #include "grey.h" #include "nfa/goughcompile.h" #include "ng_holder.h" #include "ng_mcclellan_internal.h" #include "ng_som_util.h" #include "ng_squash.h" #include "util/bitfield.h" #include "util/container.h" #include "util/determinise.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/ue2_containers.h" #include #include #include #include #include #include using namespace std; using boost::dynamic_bitset; namespace ue2 { #define NFA_STATE_LIMIT 256 #define HAIG_MAX_NFA_STATE 600 #define HAIG_MAX_LIVE_SOM_SLOTS 32 namespace { struct haig_too_wide { }; template static void populateInit(const NGHolder &g, const flat_set &unused, stateset *init, stateset *initDS, vector *v_by_index) { DEBUG_PRINTF("graph kind: %u\n", (int)g.kind); for (auto v : vertices_range(g)) { if (contains(unused, v)) { continue; } u32 v_index = g[v].index; if (is_any_start(v, g)) { init->set(v_index); if (hasSelfLoop(v, g) || is_triggered(g)) { DEBUG_PRINTF("setting %u\n", v_index); initDS->set(v_index); } } assert(v_index < init->size()); } v_by_index->clear(); v_by_index->resize(num_vertices(g), NGHolder::null_vertex()); for (auto v : vertices_range(g)) { u32 v_index = g[v].index; assert((*v_by_index)[v_index] == NGHolder::null_vertex()); (*v_by_index)[v_index] = v; } } template void populateAccepts(const NGHolder &g, StateSet *accept, StateSet *acceptEod) { for (auto v : inv_adjacent_vertices_range(g.accept, g)) { accept->set(g[v].index); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (v == g.accept) { continue; } acceptEod->set(g[v].index); } } template class Automaton_Base { public: using StateSet = typename Automaton_Traits::StateSet; using StateMap = typename Automaton_Traits::StateMap; protected: Automaton_Base(const NGHolder &graph_in, som_type som, const vector> &triggers, bool unordered_som) : graph(graph_in), numStates(num_vertices(graph)), unused(getRedundantStarts(graph_in)), init(Automaton_Traits::init_states(numStates)), initDS(Automaton_Traits::init_states(numStates)), squash(Automaton_Traits::init_states(numStates)), accept(Automaton_Traits::init_states(numStates)), acceptEod(Automaton_Traits::init_states(numStates)), toppable(Automaton_Traits::init_states(numStates)), dead(Automaton_Traits::init_states(numStates)) { calculateAlphabet(graph, alpha, unalpha, &alphasize); assert(alphasize <= ALPHABET_SIZE); populateInit(graph, unused, &init, &initDS, &v_by_index); populateAccepts(graph, &accept, &acceptEod); start_anchored = DEAD_STATE + 1; if (initDS == init) { start_floating = start_anchored; } else if (initDS.any()) { start_floating = start_anchored + 1; } else { start_floating = DEAD_STATE; } cr_by_index = populateCR(graph, v_by_index, alpha); if (!unordered_som) { for (const auto &sq : findSquashers(graph, som)) { NFAVertex v = sq.first; u32 vert_id = graph[v].index; squash.set(vert_id); squash_mask[vert_id] = shrinkStateSet(sq.second); } } if (is_triggered(graph)) { dynamic_bitset<> temp(numStates); markToppableStarts(graph, unused, false, triggers, &temp); toppable = Automaton_Traits::copy_states(temp, numStates); } } private: // Convert an NFAStateSet (as used by the squash code) into a StateSet. StateSet shrinkStateSet(const NFAStateSet &in) const { StateSet out = Automaton_Traits::init_states(numStates); for (size_t i = in.find_first(); i != in.npos && i < out.size(); i = in.find_next(i)) { out.set(i); } return out; } void reports_i(const StateSet &in, bool eod, flat_set &rv) { StateSet acc = in & (eod ? acceptEod : accept); for (size_t i = acc.find_first(); i != StateSet::npos; i = acc.find_next(i)) { NFAVertex v = v_by_index[i]; DEBUG_PRINTF("marking report\n"); const auto &my_reports = graph[v].reports; rv.insert(my_reports.begin(), my_reports.end()); } } public: void transition(const StateSet &in, StateSet *next) { transition_graph(*this, v_by_index, in, next); } const vector initial() { vector rv = {init}; if (start_floating != DEAD_STATE && start_floating != start_anchored) { rv.push_back(initDS); } return rv; } void reports(const StateSet &in, flat_set &rv) { reports_i(in, false, rv); } void reportsEod(const StateSet &in, flat_set &rv) { reports_i(in, true, rv); } static bool canPrune(const flat_set &) { return false; } const NGHolder &graph; const u32 numStates; const flat_set unused; array alpha; array unalpha; u16 alphasize; set done_a; set done_b; u16 start_anchored; u16 start_floating; vector v_by_index; vector cr_by_index; /* pre alpha'ed */ StateSet init; StateSet initDS; StateSet squash; /* states which allow us to mask out other states */ StateSet accept; StateSet acceptEod; StateSet toppable; /* states which are allowed to be on when a top arrives, * triggered dfas only */ map squash_mask; StateSet dead; }; struct Big_Traits { using StateSet = dynamic_bitset<>; using StateMap = map; static StateSet init_states(u32 num) { return StateSet(num); } static StateSet copy_states(const dynamic_bitset<> &in, UNUSED u32 num) { assert(in.size() == num); return in; } }; class Automaton_Big : public Automaton_Base { public: Automaton_Big(const NGHolder &graph_in, som_type som, const vector> &triggers, bool unordered_som) : Automaton_Base(graph_in, som, triggers, unordered_som) {} }; struct Graph_Traits { using StateSet = bitfield; using StateMap = ue2::unordered_map; static StateSet init_states(UNUSED u32 num) { assert(num <= NFA_STATE_LIMIT); return StateSet(); } static StateSet copy_states(const dynamic_bitset<> &in, u32 num) { StateSet out = init_states(num); for (size_t i = in.find_first(); i != in.npos && i < out.size(); i = in.find_next(i)) { out.set(i); } return out; } }; class Automaton_Graph : public Automaton_Base { public: Automaton_Graph(const NGHolder &graph_in, som_type som, const vector> &triggers, bool unordered_som) : Automaton_Base(graph_in, som, triggers, unordered_som) {} }; class Automaton_Haig_Merge { public: typedef vector StateSet; typedef ue2::unordered_map StateMap; explicit Automaton_Haig_Merge(const vector &in) : nfas(in.begin(), in.end()), dead(in.size()) { calculateAlphabet(); populateAsFs(); } void populateAsFs(void) { bool fs_same = true; bool fs_dead = true; as.resize(nfas.size()); fs.resize(nfas.size()); for (u32 i = 0; i < nfas.size(); i++) { as[i] = nfas[i]->start_anchored; fs[i] = nfas[i]->start_floating; if (fs[i]) { fs_dead = false; } if (as[i] != fs[i]) { fs_same = false; } } start_anchored = DEAD_STATE + 1; if (fs_same) { start_floating = start_anchored; } else if (fs_dead) { start_floating = DEAD_STATE; } else { start_floating = start_anchored + 1; } } void calculateAlphabet(void) { DEBUG_PRINTF("calculating alphabet\n"); vector esets(1, CharReach::dot()); for (const auto &haig : nfas) { DEBUG_PRINTF("...next dfa alphabet\n"); assert(haig); const auto &alpha_remap = haig->alpha_remap; for (size_t i = 0; i < esets.size(); i++) { assert(esets[i].any()); if (esets[i].count() == 1) { DEBUG_PRINTF("skipping singleton eq set\n"); continue; } CharReach t; u8 leader_s = alpha_remap[esets[i].find_first()]; DEBUG_PRINTF("checking eq set, leader %02hhx \n", leader_s); for (size_t s = esets[i].find_first(); s != CharReach::npos; s = esets[i].find_next(s)) { if (alpha_remap[s] != leader_s) { t.set(s); } } if (t.any() && t != esets[i]) { esets[i] &= ~t; esets.push_back(t); } } } alphasize = buildAlphabetFromEquivSets(esets, alpha, unalpha); } void transition(const StateSet &in, StateSet *next) { u16 t[ALPHABET_SIZE]; for (u32 i = 0; i < alphasize; i++) { next[i].resize(nfas.size()); } for (u32 j = 0; j < nfas.size(); j++) { getFullTransitionFromState(*nfas[j], in[j], t); for (u32 i = 0; i < alphasize; i++) { next[i][j]= t[unalpha[i]]; } } } const vector initial() { vector rv(1, as); if (start_floating != DEAD_STATE && start_floating != start_anchored) { rv.push_back(fs); } return rv; } private: void reports_i(const StateSet &in, flat_set dstate::*r_set, flat_set &r) { for (u32 i = 0; i < nfas.size(); i++) { const auto &rs = nfas[i]->states[in[i]].*r_set; insert(&r, rs); } } public: void reports(const StateSet &in, flat_set &rv) { reports_i(in, &dstate::reports, rv); } void reportsEod(const StateSet &in, flat_set &rv) { reports_i(in, &dstate::reports_eod, rv); } static bool canPrune(const flat_set &) { return false; } private: vector nfas; vector as; vector fs; public: array alpha; array unalpha; u16 alphasize; StateSet dead; u16 start_anchored; u16 start_floating; }; } enum bslm_mode { ONLY_EXISTING, INCLUDE_INVALID }; static bool is_any_start_inc_virtual(NFAVertex v, const NGHolder &g) { return is_virtual_start(v, g) || is_any_start(v, g); } static s32 getSlotID(const NGHolder &g, UNUSED const flat_set &unused, NFAVertex v) { if (is_triggered(g) && v == g.start) { assert(!contains(unused, v)); } else if (is_any_start_inc_virtual(v, g)) { return CREATE_NEW_SOM; } return g[v].index; } template static void haig_do_preds(const NGHolder &g, const stateset &nfa_states, const vector &state_mapping, som_tran_info &preds) { for (size_t i = nfa_states.find_first(); i != stateset::npos; i = nfa_states.find_next(i)) { NFAVertex v = state_mapping[i]; s32 slot_id = g[v].index; DEBUG_PRINTF("d vertex %zu\n", g[v].index); vector &out_map = preds[slot_id]; for (auto u : inv_adjacent_vertices_range(v, g)) { out_map.push_back(g[u].index); } sort(out_map.begin(), out_map.end()); assert(!out_map.empty() || v == g.start); } } template static void haig_do_report(const NGHolder &g, const flat_set &unused, NFAVertex accept_v, const stateset &source_nfa_states, const vector &state_mapping, set &out) { for (size_t i = source_nfa_states.find_first(); i != stateset::npos; i = source_nfa_states.find_next(i)) { NFAVertex v = state_mapping[i]; if (!edge(v, accept_v, g).second) { continue; } for (ReportID report_id : g[v].reports) { out.insert(som_report(report_id, getSlotID(g, unused, v))); } } } static void haig_note_starts(const NGHolder &g, map *out) { if (is_triggered(g)) { return; } DEBUG_PRINTF("seeing who creates new som values\n"); vector depths = getDistancesFromSOM(g); for (auto v : vertices_range(g)) { if (is_any_start_inc_virtual(v, g)) { DEBUG_PRINTF("%zu creates new som value\n", g[v].index); out->emplace(g[v].index, 0U); continue; } if (is_any_accept(v, g)) { continue; } const DepthMinMax &d = depths[g[v].index]; if (d.min == d.max && d.min.is_finite()) { DEBUG_PRINTF("%zu is fixed at %u\n", g[v].index, (u32)d.min); out->emplace(g[v].index, d.min); } } } template static bool doHaig(const NGHolder &g, som_type som, const vector> &triggers, bool unordered_som, raw_som_dfa *rdfa) { u32 state_limit = HAIG_FINAL_DFA_STATE_LIMIT; /* haig never backs down from a fight */ typedef typename Auto::StateSet StateSet; vector nfa_state_map; Auto n(g, som, triggers, unordered_som); try { if (determinise(n, rdfa->states, state_limit, &nfa_state_map)) { DEBUG_PRINTF("state limit exceeded\n"); return false; } } catch (haig_too_wide &) { DEBUG_PRINTF("too many live som states\n"); return false; } rdfa->start_anchored = n.start_anchored; rdfa->start_floating = n.start_floating; rdfa->alpha_size = n.alphasize; rdfa->alpha_remap = n.alpha; rdfa->state_som.reserve(rdfa->states.size()); for (u32 i = 0; i < rdfa->states.size(); i++) { rdfa->state_som.push_back(dstate_som()); const StateSet &source_states = nfa_state_map[i]; if (source_states.count() > HAIG_MAX_LIVE_SOM_SLOTS) { DEBUG_PRINTF("too many live states\n"); return false; } DEBUG_PRINTF("generating som info for %u\n", i); haig_do_preds(g, source_states, n.v_by_index, rdfa->state_som.back().preds); haig_do_report(g, n.unused, g.accept, source_states, n.v_by_index, rdfa->state_som.back().reports); haig_do_report(g, n.unused, g.acceptEod, source_states, n.v_by_index, rdfa->state_som.back().reports_eod); } haig_note_starts(g, &rdfa->new_som_nfa_states); return true; } unique_ptr attemptToBuildHaig(const NGHolder &g, som_type som, u32 somPrecision, const vector> &triggers, const Grey &grey, bool unordered_som) { assert(is_triggered(g) != triggers.empty()); assert(!unordered_som || is_triggered(g)); if (!grey.allowGough) { /* must be at least one engine capable of handling raw som dfas */ return nullptr; } DEBUG_PRINTF("attempting to build haig \n"); assert(allMatchStatesHaveReports(g)); assert(hasCorrectlyNumberedVertices(g)); u32 numStates = num_vertices(g); if (numStates > HAIG_MAX_NFA_STATE) { DEBUG_PRINTF("giving up... looks too big\n"); return nullptr; } auto rdfa = ue2::make_unique(g.kind, unordered_som, NODE_START, somPrecision); DEBUG_PRINTF("determinising nfa with %u vertices\n", numStates); bool rv; if (numStates <= NFA_STATE_LIMIT) { /* fast path */ rv = doHaig(g, som, triggers, unordered_som, rdfa.get()); } else { /* not the fast path */ rv = doHaig(g, som, triggers, unordered_som, rdfa.get()); } if (!rv) { return nullptr; } DEBUG_PRINTF("determinised, building impl dfa (a,f) = (%hu,%hu)\n", rdfa->start_anchored, rdfa->start_floating); assert(rdfa->kind == g.kind); return rdfa; } static void haig_merge_do_preds(const vector &dfas, const vector &per_dfa_adj, const vector &source_nfa_states, som_tran_info &som_tran) { for (u32 d = 0; d < dfas.size(); ++d) { u32 adj = per_dfa_adj[d]; const som_tran_info &som_tran_d = dfas[d]->state_som[source_nfa_states[d]].preds; for (som_tran_info::const_iterator it = som_tran_d.begin(); it != som_tran_d.end(); ++it) { assert(it->first != CREATE_NEW_SOM); u32 dest_slot = it->first < N_SPECIALS ? it->first : it->first + adj; vector &out = som_tran[dest_slot]; if (!out.empty()) { /* stylised specials already done; it does not matter who builds the preds */ assert(dest_slot < N_SPECIALS); continue; } for (vector::const_iterator jt = it->second.begin(); jt != it->second.end(); ++jt) { if (*jt < N_SPECIALS || *jt == CREATE_NEW_SOM) { out.push_back(*jt); } else { out.push_back(*jt + adj); } } } } } static void haig_merge_note_starts(const vector &dfas, const vector &per_dfa_adj, map *out) { for (u32 d = 0; d < dfas.size(); ++d) { u32 adj = per_dfa_adj[d]; const map &new_soms = dfas[d]->new_som_nfa_states; for (map::const_iterator it = new_soms.begin(); it != new_soms.end(); ++it) { if (it->first < N_SPECIALS) { assert(!it->second); out->emplace(it->first, 0U); } else { assert(d + 1 >= per_dfa_adj.size() || it->first + adj < per_dfa_adj[d + 1]); out->emplace(it->first + adj, it->second); } } } } static never_inline void haig_merge_do_report(const vector &dfas, const vector &per_dfa_adj, const vector &source_nfa_states, bool eod, set &out) { for (u32 d = 0; d < dfas.size(); ++d) { u32 adj = per_dfa_adj[d]; const set &reps = eod ? dfas[d]->state_som[source_nfa_states[d]].reports_eod : dfas[d]->state_som[source_nfa_states[d]].reports; for (set::const_iterator it = reps.begin(); it != reps.end(); ++it) { u32 slot = it->slot; if (slot != CREATE_NEW_SOM && slot >= N_SPECIALS) { slot += adj; } out.insert(som_report(it->report, slot)); } } } static u32 total_slots_used(const raw_som_dfa &rdfa) { u32 rv = 0; for (vector::const_iterator it = rdfa.state_som.begin(); it != rdfa.state_som.end(); ++it) { for (som_tran_info::const_iterator jt = it->preds.begin(); jt != it->preds.end(); ++jt) { assert(jt->first != CREATE_NEW_SOM); ENSURE_AT_LEAST(&rv, jt->first + 1); } } const map &new_soms = rdfa.new_som_nfa_states; for (map::const_iterator it = new_soms.begin(); it != new_soms.end(); ++it) { ENSURE_AT_LEAST(&rv, it->first + 1); } return rv; } unique_ptr attemptToMergeHaig(const vector &dfas, u32 limit) { assert(!dfas.empty()); Automaton_Haig_Merge n(dfas); DEBUG_PRINTF("merging %zu dfas\n", dfas.size()); bool unordered_som = false; for (const auto &haig : dfas) { assert(haig); assert(haig->kind == dfas.front()->kind); unordered_som |= haig->unordered_som_triggers; if (haig->states.size() > limit) { DEBUG_PRINTF("too many states!\n"); return nullptr; } } typedef Automaton_Haig_Merge::StateSet StateSet; vector nfa_state_map; auto rdfa = ue2::make_unique(dfas[0]->kind, unordered_som, NODE_START, dfas[0]->stream_som_loc_width); int rv = determinise(n, rdfa->states, limit, &nfa_state_map); if (rv) { DEBUG_PRINTF("%d:state limit (%u) exceeded\n", rv, limit); return nullptr; /* over state limit */ } rdfa->start_anchored = n.start_anchored; rdfa->start_floating = n.start_floating; rdfa->alpha_size = n.alphasize; rdfa->alpha_remap = n.alpha; vector per_dfa_adj; u32 curr_adj = 0; for (const auto &haig : dfas) { per_dfa_adj.push_back(curr_adj); curr_adj += total_slots_used(*haig); if (curr_adj < per_dfa_adj.back()) { /* overflowed our som slot count */ return nullptr; } } rdfa->state_som.reserve(rdfa->states.size()); for (u32 i = 0; i < rdfa->states.size(); i++) { rdfa->state_som.push_back(dstate_som()); const vector &source_nfa_states = nfa_state_map[i]; DEBUG_PRINTF("finishing state %u\n", i); haig_merge_do_preds(dfas, per_dfa_adj, source_nfa_states, rdfa->state_som.back().preds); if (rdfa->state_som.back().preds.size() > HAIG_MAX_LIVE_SOM_SLOTS) { DEBUG_PRINTF("som slot limit exceeded (%zu)\n", rdfa->state_som.back().preds.size()); return nullptr; } haig_merge_do_report(dfas, per_dfa_adj, source_nfa_states, false /* not eod */, rdfa->state_som.back().reports); haig_merge_do_report(dfas, per_dfa_adj, source_nfa_states, true /* eod */, rdfa->state_som.back().reports_eod); } haig_merge_note_starts(dfas, per_dfa_adj, &rdfa->new_som_nfa_states); DEBUG_PRINTF("merged, building impl dfa (a,f) = (%hu,%hu)\n", rdfa->start_anchored, rdfa->start_floating); return rdfa; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_dominators.h0000644000175000017500000000400413055426554021666 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Calculate dominator and post-dominator trees. * * A small wrapper around the BGL's lengauer_tarjan_dominator_tree algorithm. */ #ifndef NG_DOMINATORS_H #define NG_DOMINATORS_H #include "ng_holder.h" #include "util/ue2_containers.h" namespace ue2 { class NGHolder; ue2::unordered_map findDominators(const NGHolder &g); ue2::unordered_map findPostDominators(const NGHolder &g); } // namespace ue2 #endif // NG_DOMINATORS_H hyperscan-4.4.1/src/nfagraph/ng_repeat.h0000644000175000017500000001307613055426554021000 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Bounded repeat analysis. */ #ifndef NG_REPEAT_H #define NG_REPEAT_H #include "ng_holder.h" #include "ue2common.h" #include "nfa/repeat_internal.h" #include "util/depth.h" #include "util/ue2_containers.h" #include #include namespace ue2 { class NGHolder; class ReportManager; struct Grey; /** * \brief Everything you need to know about a bounded repeat that we have * transformed. */ struct BoundedRepeatData { BoundedRepeatData(enum RepeatType type_in, const depth &a, const depth &z, u32 minPeriod_in, NFAVertex cyc, NFAVertex pos, const std::vector &tug_in) : type(type_in), repeatMin(a), repeatMax(z), minPeriod(minPeriod_in), cyclic(cyc), pos_trigger(pos), tug_triggers(tug_in) {} BoundedRepeatData() = delete; // no default construction allowed. enum RepeatType type; //!< selected type based on bounds and structure depth repeatMin; //!< minimum repeat bound depth repeatMax; //!< maximum repeat bound u32 minPeriod; //!< min trigger period NFAVertex cyclic; //!< cyclic vertex representing repeat in graph NFAVertex pos_trigger; //!< positive trigger vertex std::vector tug_triggers; //!< list of tug trigger vertices }; /** * \brief Run the bounded repeat analysis and transform the graph where * bounded repeats are found. * * \param h * Graph to operate on. * \param rm * ReportManager, or nullptr if the graph's reports are internal (e.g. for * Rose use). * \param fixed_depth_tops * Map of top to possible trigger depth. * \param triggers * Map of top to the vector of triggers (i.e. preceding literals/masks) * \param repeats * Repeat info is filled in for caller here. * \param streaming * True if we're in streaming mode. * \param simple_model_selection * Don't perform complex (and slow) model selection analysis, e.g. * determining whether the repeat is sole entry. * \param grey * Grey box object. * \param reformed_start_ds * If supplied, this will be set to true if the graph was optimised for a * leading first repeat, resulting in the output graph having no self-loop * on startDs. */ void analyseRepeats(NGHolder &h, const ReportManager *rm, const std::map &fixed_depth_tops, const std::map>> &triggers, std::vector *repeats, bool streaming, bool simple_model_selection, const Grey &grey, bool *reformed_start_ds = nullptr); /** * \brief Information on repeats in a holder, returned from \ref findRepeats. */ struct GraphRepeatInfo { depth repeatMin; /**< minimum bound */ depth repeatMax; /**< effective max bound */ std::vector vertices; /**< vertices involved in repeat */ }; /** * \brief Provides information on repeats in the graph. */ void findRepeats(const NGHolder &h, u32 minRepeatVertices, std::vector *repeats_out); struct PureRepeat { CharReach reach; DepthMinMax bounds; ue2::flat_set reports; bool operator==(const PureRepeat &a) const { return reach == a.reach && bounds == a.bounds && reports == a.reports; } bool operator!=(const PureRepeat &a) const { return !(*this == a); } bool operator<(const PureRepeat &a) const { if (reach != a.reach) { return reach < a.reach; } if (bounds != a.bounds) { return bounds < a.bounds; } return reports < a.reports; } }; /** * \brief Returns true and fills the given PureRepeat structure if the graph is * wholly a repeat over a single character class. * * For example, something like: * * /^[a-z]{10,20}/ * * - Note: graph must not use SDS or EOD. * - Note: \p PureRepeat::bounds::max is set to infinity if there is no upper * bound on the repeat. */ bool isPureRepeat(const NGHolder &h, PureRepeat &r); } // namespace ue2 #endif // NG_REPEAT_H hyperscan-4.4.1/src/nfagraph/ng_misc_opt.cpp0000644000175000017500000005545413055426554021676 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Miscellaneous optimisations. * * We sometimes see patterns of the form: * * /^.*<[^<]*foobaz/s * * This is bad for Rose as the escapes from the cyclic state are the same as * the trigger. However, we can transform this into: * * /^.*<.*foobaz/s * * ... as the first dot star can eat all but the last '<'. * * Slightly more formally: * * Given a cyclic state v with character reachability v_cr and proper preds * {p1 .. pn} with character reachability {p1_cr .. pn_cr}. * * let v_cr' = union(intersection(p1_cr .. pn_cr), v_cr) * * v_cr can be replaced with v_cr' without changing the behaviour of the system * if: * * for any given proper pred pi: if pi is set in the nfa then after consuming * any symbol in v_cr', pi will still be set in the nfa and every successor of * v is a successor of pi. * * The easiest way for this condition to be satisfied is for each proper pred * pi to have all its preds all have an edge to a pred of pi with a character * reachability containing v_cr'. There are, however, other ways to establish * the condition holds. * * Note: a similar transformation can be applied in reverse, details left as an * exercise for the interested reader. */ #include "ng_misc_opt.h" #include "ng_holder.h" #include "ng_prune.h" #include "ng_util.h" #include "util/charreach.h" #include "util/container.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include "ue2common.h" #include #include #include #include #include using namespace std; using boost::make_filtered_graph; namespace ue2 { static void findCandidates(NGHolder &g, const vector &ordering, vector *cand) { for (auto it = ordering.rbegin(), ite = ordering.rend(); it != ite; ++it) { NFAVertex v = *it; if (is_special(v, g) || !hasSelfLoop(v, g) || g[v].char_reach.all()) { continue; } // For `v' to be a candidate, its predecessors must all have the same // successor set as `v'. auto succ_v = succs(v, g); flat_set succ_u; for (auto u : inv_adjacent_vertices_range(v, g)) { succ_u.clear(); succ(g, u, &succ_u); if (succ_v != succ_u) { goto next_cand; } } DEBUG_PRINTF("vertex %zu is a candidate\n", g[v].index); cand->push_back(v); next_cand:; } } static void findCandidates_rev(NGHolder &g, const vector &ordering, vector *cand) { for (auto it = ordering.begin(), ite = ordering.end(); it != ite; ++it) { NFAVertex v = *it; if (is_special(v, g) || !hasSelfLoop(v, g) || g[v].char_reach.all()) { continue; } // For `v' to be a candidate, its predecessors must all have the same // successor set as `v'. auto pred_v = preds(v, g); flat_set pred_u; for (auto u : adjacent_vertices_range(v, g)) { pred_u.clear(); pred(g, u, &pred_u); if (pred_v != pred_u) { goto next_cand; } } DEBUG_PRINTF("vertex %zu is a candidate\n", g[v].index); cand->push_back(v); next_cand:; } } /** Find the intersection of the reachability of the predecessors of \p v. */ static void predCRIntersection(const NGHolder &g, NFAVertex v, CharReach &add) { add.setall(); for (auto u : inv_adjacent_vertices_range(v, g)) { if (u != v) { add &= g[u].char_reach; } } } /** Find the intersection of the reachability of the successors of \p v. */ static void succCRIntersection(const NGHolder &g, NFAVertex v, CharReach &add) { add.setall(); for (auto u : adjacent_vertices_range(v, g)) { if (u != v) { add &= g[u].char_reach; } } } /** The sustain set is used to show that once vertex p is on it stays on given * the alphabet new_cr. Every vertex pp in the sustain set has the following * properties: * -# an edge to p * -# enough edges to vertices in the sustain set to ensure that a vertex in * the sustain set will be on after consuming a character. */ static set findSustainSet(const NGHolder &g, NFAVertex p, bool ignore_starts, const CharReach &new_cr) { auto cand = preds>(p, g); if (ignore_starts) { cand.erase(g.startDs); } /* remove elements from cand until the sustain set property holds */ bool changed; do { DEBUG_PRINTF("|cand| %zu\n", cand.size()); changed = false; set::const_iterator it = cand.begin(); while (it != cand.end()) { NFAVertex u = *it; ++it; CharReach sus_cr; for (auto v : adjacent_vertices_range(u, g)) { if (contains(cand, v)) { sus_cr |= g[v].char_reach; } } if (!new_cr.isSubsetOf(sus_cr)) { cand.erase(u); changed = true; } } } while (changed); /* Note: it may be possible to find a (larger) sustain set for a smaller * new_cr */ return cand; } /** Finds the reverse version of the sustain set.. whatever that means. */ static set findSustainSet_rev(const NGHolder &g, NFAVertex p, const CharReach &new_cr) { auto cand = succs>(p, g); /* remove elements from cand until the sustain set property holds */ bool changed; do { changed = false; set::const_iterator it = cand.begin(); while (it != cand.end()) { NFAVertex u = *it; ++it; CharReach sus_cr; for (auto v : inv_adjacent_vertices_range(u, g)) { if (contains(cand, v)) { sus_cr |= g[v].char_reach; } } if (!new_cr.isSubsetOf(sus_cr)) { cand.erase(u); changed = true; } } } while (changed); /* Note: it may be possible to find a (larger) sustain set for a smaller * new_cr */ return cand; } static bool enlargeCyclicVertex(NGHolder &g, som_type som, NFAVertex v) { DEBUG_PRINTF("considering vertex %zu\n", g[v].index); const CharReach &v_cr = g[v].char_reach; CharReach add; predCRIntersection(g, v, add); add |= v_cr; if (add == v_cr) { DEBUG_PRINTF("no benefit\n"); return false; } DEBUG_PRINTF("cr of width %zu up for grabs\n", add.count() - v_cr.count()); for (auto p : inv_adjacent_vertices_range(v, g)) { if (p == v) { continue; } DEBUG_PRINTF("looking at pred %zu\n", g[p].index); bool ignore_sds = som; /* if we are tracking som, entries into a state from sds are significant. */ set sustain = findSustainSet(g, p, ignore_sds, add); DEBUG_PRINTF("sustain set is %zu\n", sustain.size()); if (sustain.empty()) { DEBUG_PRINTF("yawn\n"); } for (auto pp : inv_adjacent_vertices_range(p, g)) { /* we need to ensure that whenever pp sets p, that a member of the sustain set is set. Note: p's cr may be not be a subset of new_cr */ CharReach sustain_cr; for (auto pv : adjacent_vertices_range(pp, g)) { if (contains(sustain, pv)) { sustain_cr |= g[pv].char_reach; } } if (!g[p].char_reach.isSubsetOf(sustain_cr)) { DEBUG_PRINTF("unable to establish that preds are forced on\n"); return false; } } } /* the cr can be increased */ g[v].char_reach = add; DEBUG_PRINTF("vertex %zu was widened\n", g[v].index); return true; } static bool enlargeCyclicVertex_rev(NGHolder &g, NFAVertex v) { DEBUG_PRINTF("considering vertex %zu\n", g[v].index); const CharReach &v_cr = g[v].char_reach; CharReach add; succCRIntersection(g, v, add); add |= v_cr; if (add == v_cr) { DEBUG_PRINTF("no benefit\n"); return false; } DEBUG_PRINTF("cr of width %zu up for grabs\n", add.count() - v_cr.count()); for (auto p : adjacent_vertices_range(v, g)) { if (p == v) { continue; } DEBUG_PRINTF("looking at succ %zu\n", g[p].index); set sustain = findSustainSet_rev(g, p, add); DEBUG_PRINTF("sustain set is %zu\n", sustain.size()); if (sustain.empty()) { DEBUG_PRINTF("yawn\n"); } for (auto pp : adjacent_vertices_range(p, g)) { /* we need to ensure something - see fwd ver */ CharReach sustain_cr; for (auto pv : inv_adjacent_vertices_range(pp, g)) { if (contains(sustain, pv)) { sustain_cr |= g[pv].char_reach; } } if (!g[p].char_reach.isSubsetOf(sustain_cr)) { DEBUG_PRINTF("unable to establish that succs are thingy\n"); return false; } } } /* the cr can be increased */ g[v].char_reach = add; DEBUG_PRINTF("vertex %zu was widened\n", g[v].index); return true; } static bool enlargeCyclicCR(NGHolder &g, som_type som, const vector &ordering) { DEBUG_PRINTF("hello\n"); vector candidates; findCandidates(g, ordering, &candidates); bool rv = false; for (auto v : candidates) { rv |= enlargeCyclicVertex(g, som, v); } return rv; } static bool enlargeCyclicCR_rev(NGHolder &g, const vector &ordering) { DEBUG_PRINTF("olleh\n"); vector candidates; findCandidates_rev(g, ordering, &candidates); bool rv = false; for (auto v : candidates) { rv |= enlargeCyclicVertex_rev(g, v); } return rv; } bool improveGraph(NGHolder &g, som_type som) { /* use a topo ordering so that we can get chains of cyclic states * done in one sweep */ const vector ordering = getTopoOrdering(g); return enlargeCyclicCR(g, som, ordering) | enlargeCyclicCR_rev(g, ordering); } /** finds a smaller reachability for a state by the reverse transformation of * enlargeCyclicCR. */ CharReach reduced_cr(NFAVertex v, const NGHolder &g, const map &br_cyclic) { DEBUG_PRINTF("find minimal cr for %zu\n", g[v].index); CharReach v_cr = g[v].char_reach; if (proper_in_degree(v, g) != 1) { return v_cr; } NFAVertex pred = getSoleSourceVertex(g, v); assert(pred); /* require pred to be fed by one vertex OR (start + startDS) */ NFAVertex predpred; size_t idp = in_degree(pred, g); if (hasSelfLoop(pred, g)) { return v_cr; /* not cliche */ } else if (idp == 1) { predpred = getSoleSourceVertex(g, pred); } else if (idp == 2 && edge(g.start, pred, g).second && edge(g.startDs, pred, g).second) { predpred = g.startDs; } else { return v_cr; /* not cliche */ } assert(predpred); /* require predpred to be cyclic and its cr to be a superset of pred and v */ if (!hasSelfLoop(predpred, g)) { return v_cr; /* not cliche */ } if (contains(br_cyclic, predpred) && !br_cyclic.at(predpred).unbounded()) { return v_cr; /* fake cyclic */ } const CharReach &p_cr = g[pred].char_reach; const CharReach &pp_cr = g[predpred].char_reach; if (!v_cr.isSubsetOf(pp_cr) || !p_cr.isSubsetOf(pp_cr)) { return v_cr; /* not cliche */ } DEBUG_PRINTF("confirming [x]* prop\n"); /* we require all of v succs to be succ of p */ set v_succ; insert(&v_succ, adjacent_vertices(v, g)); set p_succ; insert(&p_succ, adjacent_vertices(pred, g)); if (!is_subset_of(v_succ, p_succ)) { DEBUG_PRINTF("fail\n"); return v_cr; /* not cliche */ } if (contains(v_succ, g.accept) || contains(v_succ, g.acceptEod)) { /* need to check that reports of v are a subset of p's */ if (!is_subset_of(g[v].reports, g[pred].reports)) { DEBUG_PRINTF("fail - reports not subset\n"); return v_cr; /* not cliche */ } } DEBUG_PRINTF("woot success\n"); v_cr &= ~p_cr; return v_cr; } vector reduced_cr(const NGHolder &g, const map &br_cyclic) { assert(hasCorrectlyNumberedVertices(g)); vector refined_cr(num_vertices(g), CharReach()); for (auto v : vertices_range(g)) { u32 v_idx = g[v].index; refined_cr[v_idx] = reduced_cr(v, g, br_cyclic); } return refined_cr; } static bool anyOutSpecial(NFAVertex v, const NGHolder &g) { for (auto w : adjacent_vertices_range(v, g)) { if (is_special(w, g) && w != v) { return true; } } return false; } bool mergeCyclicDotStars(NGHolder &g) { set verticesToRemove; set edgesToRemove; // avoid graphs where startDs is not a free spirit if (out_degree(g.startDs, g) > 1) { return false; } // check if any of the connected vertices are dots for (auto v : adjacent_vertices_range(g.start, g)) { if (is_special(v, g)) { continue; } const CharReach &cr = g[v].char_reach; // if this is a cyclic dot if (cr.all() && edge(v, v, g).second) { // prevent insane graphs if (anyOutSpecial(v, g)) { continue; } // we don't know if we're going to remove this vertex yet vector deadEdges; // check if all adjacent vertices have edges from start for (const auto &e : out_edges_range(v, g)) { NFAVertex t = target(e, g); // skip self if (t == v) { continue; } // skip vertices that don't have edges from start if (!edge(g.start, t, g).second) { continue; } // add an edge from startDs to this vertex add_edge_if_not_present(g.startDs, t, g); // mark this edge for removal deadEdges.push_back(e); } // if the number of edges to be removed equals out degree, vertex // needs to be removed; else, only remove the edges if (deadEdges.size() == proper_out_degree(v, g)) { verticesToRemove.insert(v); } else { edgesToRemove.insert(deadEdges.begin(), deadEdges.end()); } } } if (verticesToRemove.empty() && edgesToRemove.empty()) { return false; } DEBUG_PRINTF("removing %zu edges and %zu vertices\n", edgesToRemove.size(), verticesToRemove.size()); remove_edges(edgesToRemove, g); remove_vertices(verticesToRemove, g); /* some predecessors to the cyclic vertices may no longer be useful (no out * edges), so we can remove them */ pruneUseless(g); return true; } /** * Returns the set of vertices that cannot be on if v is not on. */ static flat_set findDependentVertices(const NGHolder &g, NFAVertex v) { auto v_pred = preds(v, g); flat_set may_be_on; /* We need to exclude any vertex that may be reached on a path which is * incompatible with the vertex v being on. */ /* A vertex u is bad if: * 1) its reach may be incompatible with v (not a subset) * 2) it if there is an edge from a bad vertex b and there is either not an * edge v->u or not an edge b->v. * Note: 2) means v is never bad as it has a selfloop * * Can do this with a DFS from all the initial bad states with a conditional * check down edges. Alternately can just filter these edges out of the * graph first. */ flat_set no_explore; for (NFAVertex t : adjacent_vertices_range(v, g)) { for (NFAEdge e : in_edges_range(t, g)) { NFAVertex s = source(e, g); if (edge(s, v, g).second) { no_explore.insert(e); } } } auto filtered_g = make_filtered_graph(g, make_bad_edge_filter(&no_explore)); vector color_raw(num_vertices(g)); auto color = make_iterator_property_map(color_raw.begin(), get(vertex_index, g)); flat_set bad; for (NFAVertex b : vertices_range(g)) { if (b != g.start && g[b].char_reach.isSubsetOf(g[v].char_reach)) { continue; } boost::depth_first_visit(filtered_g, b, make_vertex_recorder(bad), color); } flat_set rv; for (NFAVertex u : vertices_range(g)) { if (!contains(bad, u)) { DEBUG_PRINTF("%zu is good\n", g[u].index); rv.insert(u); } } return rv; } static bool willBeEnabledConcurrently(NFAVertex main_cyclic, NFAVertex v, const NGHolder &g) { return is_subset_of(preds(main_cyclic, g), preds(v, g)); } static bool sometimesEnabledConcurrently(NFAVertex main_cyclic, NFAVertex v, const NGHolder &g) { return has_intersection(preds(main_cyclic, g), preds(v, g)); } static bool pruneUsingSuccessors(NGHolder &g, NFAVertex u, som_type som) { if (som && (is_virtual_start(u, g) || u == g.startDs)) { return false; } bool changed = false; DEBUG_PRINTF("using cyclic %zu as base\n", g[u].index); auto children = findDependentVertices(g, u); vector u_succs; for (NFAVertex v : adjacent_vertices_range(u, g)) { if (som && is_virtual_start(v, g)) { /* as v is virtual start, its som has been reset so can not override * existing in progress matches. */ continue; } u_succs.push_back(v); } stable_sort(u_succs.begin(), u_succs.end(), [&](NFAVertex a, NFAVertex b) { return g[a].char_reach.count() > g[b].char_reach.count(); }); for (NFAVertex v : u_succs) { DEBUG_PRINTF(" using %zu as killer\n", g[v].index); /* Need to distinguish between vertices that are switched on after the * cyclic vs vertices that are switched on concurrently with the cyclic * if (subject to a suitable reach) */ bool v_peer_of_cyclic = willBeEnabledConcurrently(u, v, g); set dead; for (NFAVertex s : adjacent_vertices_range(v, g)) { DEBUG_PRINTF(" looking at preds of %zu\n", g[s].index); for (NFAEdge e : in_edges_range(s, g)) { NFAVertex p = source(e, g); if (!contains(children, p) || p == v || p == u || p == g.accept) { DEBUG_PRINTF("%zu not a cand\n", g[p].index); continue; } if (is_any_accept(s, g) && g[p].reports != g[v].reports) { DEBUG_PRINTF("%zu bad reports\n", g[p].index); continue; } /* the out-edges of a vertex that may be enabled on the same * byte as the cyclic can only be killed by the out-edges of a * peer vertex which will be enabled with the cyclic (a non-peer * may not be switched on until another byte is processed). */ if (!v_peer_of_cyclic && sometimesEnabledConcurrently(u, p, g)) { DEBUG_PRINTF("%zu can only be squashed by a proper peer\n", g[p].index); continue; } if (g[p].char_reach.isSubsetOf(g[v].char_reach)) { dead.insert(e); changed = true; DEBUG_PRINTF("removing edge %zu->%zu\n", g[p].index, g[s].index); } else if (is_subset_of(succs(p, g), succs(u, g))) { if (is_match_vertex(p, g) && !is_subset_of(g[p].reports, g[v].reports)) { continue; } DEBUG_PRINTF("updating reach on %zu\n", g[p].index); changed |= (g[p].char_reach & g[v].char_reach).any(); g[p].char_reach &= ~g[v].char_reach; } } } remove_edges(dead, g); } DEBUG_PRINTF("changed %d\n", (int)changed); return changed; } bool prunePathsRedundantWithSuccessorOfCyclics(NGHolder &g, som_type som) { /* TODO: the reverse form of this is also possible */ bool changed = false; for (NFAVertex v : vertices_range(g)) { if (hasSelfLoop(v, g) && g[v].char_reach.all()) { changed |= pruneUsingSuccessors(g, v, som); } } if (changed) { pruneUseless(g); clearReports(g); } return changed; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_violet.cpp0000644000175000017500000024436413055426554021363 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "ng_violet.h" #include "grey.h" #include "ng_depth.h" #include "ng_dominators.h" #include "ng_dump.h" #include "ng_equivalence.h" #include "ng_holder.h" #include "ng_is_equal.h" #include "ng_literal_analysis.h" #include "ng_netflow.h" #include "ng_prune.h" #include "ng_redundancy.h" #include "ng_region.h" #include "ng_reports.h" #include "ng_rose.h" #include "ng_split.h" #include "ng_util.h" #include "ng_width.h" #include "rose/rose_build.h" #include "rose/rose_build_util.h" #include "rose/rose_in_dump.h" #include "rose/rose_in_graph.h" #include "rose/rose_in_util.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/target_info.h" #include "util/ue2string.h" #include "util/ue2_containers.h" #include #include #include #include #include #define STAGE_DEBUG_PRINTF DEBUG_PRINTF using namespace std; using boost::adaptors::map_values; namespace ue2 { /* createsAnchoredLHS() is conservative as the depths take into account * back edges that come from beyond the split point and would be missing after * the graph is split. */ static bool createsAnchoredLHS(const NGHolder &g, const vector &vv, const vector &depths, const Grey &grey, depth max_depth = depth::infinity()) { max_depth = min(max_depth, depth(grey.maxAnchoredRegion)); for (auto v : vv) { /* avoid issues of self loops blowing out depths: * look at preds, add 1 */ for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; } u32 idx = g[u].index; assert(idx < depths.size()); if (maxDistFromStartOfData(depths.at(idx)) >= max_depth) { return false; } } } return true; } /* createsTransientLHS() is conservative as the depths take into account * back edges that come from beyond the split point and would be missing after * the graph is split. */ static bool createsTransientLHS(const NGHolder &g, const vector &vv, const vector &depths, const Grey &grey) { const depth max_depth(grey.maxHistoryAvailable); for (auto v : vv) { /* avoid issues of self loops blowing out depths: * look at preds, add 1 */ for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; } u32 idx = g[u].index; assert(idx < depths.size()); if (maxDistFromInit(depths.at(idx)) >= max_depth) { return false; } } } return true; } namespace { /** * Information on a cut: vertices and literals. */ struct VertLitInfo { VertLitInfo() {} VertLitInfo(NFAVertex v, const set &litlit, bool c_anch, bool c_tran = false) : vv(vector(1, v)), lit(litlit), creates_anchored(c_anch), creates_transient(c_tran) {} VertLitInfo(const vector &vv_in, const set &lit_in, bool c_anch) : vv(vv_in), lit(lit_in), creates_anchored(c_anch) {} vector vv; set lit; bool creates_anchored = false; bool creates_transient = false; }; /** * \brief Comparator class for sorting LitCollection::lits. * * This is separated out from LitCollection itself as passing LitCollection to * std::sort() would incur a (potentially expensive) copy. */ class LitComparator { public: LitComparator(const NGHolder &g_in, bool sa, bool st) : g(g_in), seeking_anchored(sa), seeking_transient(st) {} bool operator()(const unique_ptr &a, const unique_ptr &b) const { assert(a && b); if (seeking_anchored) { if (a->creates_anchored != b->creates_anchored) { return a->creates_anchored < b->creates_anchored; } } if (seeking_transient) { if (a->creates_transient != b->creates_transient) { return a->creates_transient < b->creates_transient; } } u64a score_a = scoreSet(a->lit); u64a score_b = scoreSet(b->lit); if (score_a != score_b) { return score_a > score_b; } /* vertices should only be in one candidate cut */ assert(a->vv == b->vv || a->vv.front() != b->vv.front()); return g[a->vv.front()].index > g[b->vv.front()].index; } private: const NGHolder &g; /**< graph on which cuts are found */ bool seeking_anchored; bool seeking_transient; }; } static size_t shorter_than(const set &s, size_t limit) { size_t count = 0; for (const auto &lit : s) { if (lit.length() < limit) { count++; } } return count; } static u32 min_len(const set &s) { u32 rv = ~0U; for (const auto &lit : s) { rv = min(rv, (u32)lit.length()); } return rv; } static u32 min_period(const set &s) { u32 rv = ~0U; for (const auto &lit : s) { rv = min(rv, (u32)minStringPeriod(lit)); } DEBUG_PRINTF("min period %u\n", rv); return rv; } #define MIN_ANCHORED_LEN 2 static bool validateRoseLiteralSetQuality(const set &s, u64a score, bool anchored, u32 min_allowed_floating_len, bool desperation) { u32 min_allowed_len = anchored ? MIN_ANCHORED_LEN : min_allowed_floating_len; assert(none_of(begin(s), end(s), bad_mixed_sensitivity)); if (score >= NO_LITERAL_AT_EDGE_SCORE) { DEBUG_PRINTF("candidate is too bad %llu/%zu\n", score, s.size()); return false; } assert(!s.empty()); if (s.empty()) { DEBUG_PRINTF("candidate is too bad/something went wrong\n"); return false; } u32 s_min_len = min_len(s); u32 s_min_period = min_period(s); size_t short_count = shorter_than(s, 5); DEBUG_PRINTF("cand '%s': score %llu count=%zu min_len=%u min_period=%u" " short_count=%zu desp=%d\n", dumpString(*s.begin()).c_str(), score, s.size(), s_min_len, s_min_period, short_count, (int)desperation); bool ok = true; if (s.size() > 10 /* magic number is magic */ || s_min_len < min_allowed_len || (s_min_period <= 1 && min_allowed_len != 1)) { ok = false; } if (!ok && desperation && s.size() <= 20 /* more magic numbers are magical */ && (s_min_len > 5 || (s_min_len > 2 && short_count <= 10)) && s_min_period > 1) { DEBUG_PRINTF("candidate is ok\n"); ok = true; } if (!ok && desperation && s.size() <= 50 /* more magic numbers are magical */ && s_min_len > 10 && s_min_period > 1) { DEBUG_PRINTF("candidate is ok\n"); ok = true; } if (!ok) { DEBUG_PRINTF("candidate is too shitty\n"); return false; } return true; } static UNUSED void dumpRoseLiteralSet(const set &s) { for (UNUSED const auto &lit : s) { DEBUG_PRINTF(" lit: %s\n", dumpString(lit).c_str()); } } static void getSimpleRoseLiterals(const NGHolder &g, bool seeking_anchored, const vector *depths, const set &a_dom, vector> *lits, u32 min_allowed_len, bool desperation, const CompileContext &cc) { assert(depths || !seeking_anchored); map scores; map> lit_info; set s; for (auto v : a_dom) { s = getLiteralSet(g, v, true); /* RHS will take responsibility for any revisits to the target vertex */ if (s.empty()) { DEBUG_PRINTF("candidate is too shitty\n"); continue; } DEBUG_PRINTF("|candidate raw literal set| = %zu\n", s.size()); dumpRoseLiteralSet(s); u64a score = sanitizeAndCompressAndScore(s); bool anchored = false; if (seeking_anchored) { anchored = createsAnchoredLHS(g, {v}, *depths, cc.grey); } if (!validateRoseLiteralSetQuality(s, score, anchored, min_allowed_len, desperation)) { continue; } DEBUG_PRINTF("candidate is a candidate\n"); scores[v] = score; lit_info[v] = make_unique(v, s, anchored); } /* try to filter out cases where appending some characters produces worse * literals. Only bother to look back one byte, TODO make better */ for (auto u : a_dom) { if (out_degree(u, g) != 1 || !scores[u]) { continue; } NFAVertex v = *adjacent_vertices(u, g).first; if (contains(scores, v) && scores[v] >= scores[u]) { DEBUG_PRINTF("killing off v as score %llu >= %llu\n", scores[v], scores[u]); lit_info.erase(v); } } lits->reserve(lit_info.size()); for (auto &m : lit_info) { lits->push_back(move(m.second)); } DEBUG_PRINTF("%zu candidate literal sets\n", lits->size()); } static void getRegionRoseLiterals(const NGHolder &g, bool seeking_anchored, const vector *depths, const set &bad, const set *allowed, vector> *lits, u32 min_allowed_len, bool desperation, const CompileContext &cc) { /* This allows us to get more places to split the graph as we are not limited to points where there is a single vertex to split at. */ assert(depths || !seeking_anchored); /* TODO: operate over 'proto-regions' which ignore back edges */ auto regions = assignRegions(g); set mand, optional; map > exits; for (auto v : vertices_range(g)) { u32 region = regions[v]; if (is_any_start(v, g) || region == 0) { continue; } if (is_any_accept(v, g)) { continue; } if (!generates_callbacks(g) && is_match_vertex(v, g)) { /* we cannot leave a completely vacuous infix */ continue; } if (isRegionExit(g, v, regions)) { exits[region].push_back(v); } if (isRegionEntry(g, v, regions)) { // Determine whether this region is mandatory or optional. We only // need to do this check for the first entry vertex we encounter // for this region. if (!contains(mand, region) && !contains(optional, region)) { if (isOptionalRegion(g, v, regions)) { optional.insert(region); } else { mand.insert(region); } } } } for (const auto &m : exits) { if (false) { next_cand: continue; } const u32 region = m.first; const vector &vv = m.second; assert(!vv.empty()); if (!contains(mand, region)) { continue; } for (auto v : vv) { /* if an exit is in bad, the region is already handled well * by getSimpleRoseLiterals or is otherwise bad */ if (contains(bad, v)) { goto next_cand; } /* if we are only allowed to consider some vertices, v must be in the list; */ if (allowed && !contains(*allowed, v)) { goto next_cand; } } /* the final region may not have a neat exit. validate that all exits * have an edge to each accept or none do */ bool edge_to_a = edge(vv[0], g.accept, g).second; bool edge_to_aeod = edge(vv[0], g.acceptEod, g).second; const auto &reports = g[vv[0]].reports; for (auto v : vv) { if (edge_to_a != edge(v, g.accept, g).second) { goto next_cand; } if (edge_to_aeod != edge(v, g.acceptEod, g).second) { goto next_cand; } if (g[v].reports != reports) { goto next_cand; } } DEBUG_PRINTF("inspecting region %u\n", region); set s; for (auto v : vv) { DEBUG_PRINTF(" exit vertex: %zu\n", g[v].index); /* Note: RHS can not be depended on to take all subsequent revisits * to this vertex */ set ss = getLiteralSet(g, v, false); if (ss.empty()) { DEBUG_PRINTF("candidate is too shitty\n"); goto next_cand; } insert(&s, ss); } assert(!s.empty()); DEBUG_PRINTF("|candidate raw literal set| = %zu\n", s.size()); dumpRoseLiteralSet(s); u64a score = sanitizeAndCompressAndScore(s); DEBUG_PRINTF("|candidate literal set| = %zu\n", s.size()); dumpRoseLiteralSet(s); bool anchored = false; if (seeking_anchored) { anchored = createsAnchoredLHS(g, vv, *depths, cc.grey); } if (!validateRoseLiteralSetQuality(s, score, anchored, min_allowed_len, desperation)) { goto next_cand; } DEBUG_PRINTF("candidate is a candidate\n"); lits->push_back(make_unique(vv, s, anchored)); } } static void filterCandPivots(const NGHolder &g, const set &cand_raw, set *out) { for (auto u : cand_raw) { const CharReach &u_cr = g[u].char_reach; if (u_cr.count() > 40) { continue; /* too wide to be plausible */ } if (u_cr.count() > 2) { /* include u as a candidate as successor may have backed away from * expanding through it */ out->insert(u); continue; } NFAVertex v = getSoleDestVertex(g, u); if (v && in_degree(v, g) == 1 && out_degree(u, g) == 1) { const CharReach &v_cr = g[v].char_reach; if (v_cr.count() == 1 || v_cr.isCaselessChar()) { continue; /* v will always generate better literals */ } } out->insert(u); } } /* cand_raw is the candidate set before filtering points which are clearly * a bad idea. */ static void getCandidatePivots(const NGHolder &g, set *cand, set *cand_raw) { ue2::unordered_map dominators = findDominators(g); set accepts; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { if (is_special(v, g)) { continue; } accepts.insert(v); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (is_special(v, g)) { continue; } accepts.insert(v); } assert(!accepts.empty()); vector dom_trace; auto ait = accepts.begin(); assert(ait != accepts.end()); NFAVertex curr = *ait; while (curr && !is_special(curr, g)) { dom_trace.push_back(curr); curr = dominators[curr]; } reverse(dom_trace.begin(), dom_trace.end()); for (++ait; ait != accepts.end(); ++ait) { curr = *ait; vector dom_trace2; while (curr && !is_special(curr, g)) { dom_trace2.push_back(curr); curr = dominators[curr]; } reverse(dom_trace2.begin(), dom_trace2.end()); auto dti = dom_trace.begin(), dtie = dom_trace.end(); auto dtj = dom_trace2.begin(), dtje = dom_trace2.end(); while (dti != dtie && dtj != dtje && *dti == *dtj) { ++dti; ++dtj; } dom_trace.erase(dti, dtie); } cand_raw->insert(dom_trace.begin(), dom_trace.end()); filterCandPivots(g, *cand_raw, cand); } static unique_ptr findBestSplit(const NGHolder &g, const vector *depths, bool for_prefix, u32 min_len, const set *allowed_cand, const set *disallowed_cand, const CompileContext &cc) { assert(!for_prefix || depths); /* look for a single simple split point */ set cand; set cand_raw; getCandidatePivots(g, &cand, &cand_raw); if (allowed_cand) { set cand2; set cand2_raw; set_intersection(allowed_cand->begin(), allowed_cand->end(), cand.begin(), cand.end(), inserter(cand2, cand2.begin())); set_intersection(allowed_cand->begin(), allowed_cand->end(), cand_raw.begin(), cand_raw.end(), inserter(cand2_raw, cand2_raw.begin())); cand = std::move(cand2); cand_raw = std::move(cand2_raw); } if (disallowed_cand) { DEBUG_PRINTF("%zu disallowed candidates\n", disallowed_cand->size()); DEBUG_PRINTF("|old cand| = %zu\n", cand.size()); erase_all(&cand, *disallowed_cand); insert(&cand_raw, *disallowed_cand); } if (!generates_callbacks(g)) { /* not output exposed so must leave some RHS */ for (NFAVertex v : inv_adjacent_vertices_range(g.accept, g)) { cand.erase(v); cand_raw.erase(v); } for (NFAVertex v : inv_adjacent_vertices_range(g.acceptEod, g)) { cand.erase(v); cand_raw.erase(v); } } DEBUG_PRINTF("|cand| = %zu\n", cand.size()); bool seeking_anchored = for_prefix; bool seeking_transient = for_prefix; //cc.streaming; /* TODO: revisit when backstop goes away */ bool desperation = for_prefix && cc.streaming; vector> lits; /**< sorted list of potential cuts */ getSimpleRoseLiterals(g, seeking_anchored, depths, cand, &lits, min_len, desperation, cc); getRegionRoseLiterals(g, seeking_anchored, depths, cand_raw, allowed_cand, &lits, min_len, desperation, cc); if (lits.empty()) { DEBUG_PRINTF("no literals found\n"); return nullptr; } if (seeking_transient) { for (auto &a : lits) { a->creates_transient = createsTransientLHS(g, a->vv, *depths, cc.grey); } } auto cmp = LitComparator(g, seeking_anchored, seeking_transient); unique_ptr best = move(lits.back()); lits.pop_back(); while (!lits.empty()) { if (cmp(best, lits.back())) { best = move(lits.back()); } lits.pop_back(); } DEBUG_PRINTF("best is '%s' %zu a%d t%d\n", dumpString(*best->lit.begin()).c_str(), g[best->vv.front()].index, depths ? (int)createsAnchoredLHS(g, best->vv, *depths, cc.grey) : 0, depths ? (int)createsTransientLHS(g, best->vv, *depths, cc.grey) : 0); return best; } static void poisonFromSuccessor(const NGHolder &h, const ue2_literal &succ, bool overhang_ok, flat_set &bad) { DEBUG_PRINTF("poisoning holder of size %zu, succ len %zu\n", num_vertices(h), succ.length()); map > curr; for (const auto &e : in_edges_range(h.accept, h)) { curr[source(e, h)].insert(e); } map > next; for (auto it = succ.rbegin(); it != succ.rend(); ++it) { for (const auto &path : curr) { NFAVertex u = path.first; const auto &path_set = path.second; if (u == h.start && overhang_ok) { DEBUG_PRINTF("poisoning early %zu [overhang]\n", path_set.size()); insert(&bad, path_set); continue; } if (overlaps(h[u].char_reach, *it)) { for (const auto &e : in_edges_range(u, h)) { auto &new_path_set = next[source(e, h)]; insert(&new_path_set, path_set); new_path_set.insert(e); } } } DEBUG_PRINTF("succ char matches at %zu paths\n", next.size()); assert(overhang_ok || !curr.empty()); swap(curr, next); next.clear(); } assert(overhang_ok || !curr.empty()); for (const auto &path : curr) { insert(&bad, path.second); DEBUG_PRINTF("poisoning %zu vertices\n", path.second.size()); } } static void poisonForGoodPrefix(const NGHolder &h, const vector &depths, flat_set &bad, const Grey &grey) { for (const auto &v : vertices_range(h)) { if (!createsAnchoredLHS(h, {v}, depths, grey) && !createsTransientLHS(h, {v}, depths, grey)) { insert(&bad, in_edges_range(v, h)); } } } static flat_set poisonEdges(const NGHolder &h, const vector *depths, const RoseInGraph &vg, const vector &ee, bool for_prefix, const Grey &grey) { DEBUG_PRINTF("poisoning edges %zu successor edges\n", ee.size()); /* poison edges covered by successor literal */ set > succs; for (const RoseInEdge &ve : ee) { if (vg[target(ve, vg)].type != RIV_LITERAL) { /* nothing to poison in suffixes/outfixes */ assert(vg[target(ve, vg)].type == RIV_ACCEPT); continue; } succs.insert({vg[target(ve, vg)].s, vg[source(ve, vg)].type == RIV_LITERAL}); } DEBUG_PRINTF("poisoning edges %zu successor literals\n", succs.size()); flat_set bad; for (const auto &p : succs) { poisonFromSuccessor(h, p.first, p.second, bad); } /* poison edges which don't significantly improve a prefix */ if (for_prefix) { poisonForGoodPrefix(h, *depths, bad, grey); } return bad; } static set poisonVertices(const NGHolder &h, const RoseInGraph &vg, const vector &ee, const Grey &grey) { flat_set bad_edges = poisonEdges(h, nullptr, vg, ee, false, grey); set bad_vertices; for (const NFAEdge &e : bad_edges) { bad_vertices.insert(target(e, h)); DEBUG_PRINTF("bad: %zu->%zu\n", h[source(e, h)].index, h[target(e, h)].index); } return bad_vertices; } static unique_ptr findBestNormalSplit(const NGHolder &g, const RoseInGraph &vg, const vector &ee, const CompileContext &cc) { assert(g.kind == NFA_OUTFIX || g.kind == NFA_INFIX || g.kind == NFA_SUFFIX); set bad_vertices = poisonVertices(g, vg, ee, cc.grey); return findBestSplit(g, nullptr, false, cc.grey.minRoseLiteralLength, nullptr, &bad_vertices, cc); } static unique_ptr findSimplePrefixSplit(const NGHolder &g, const CompileContext &cc) { DEBUG_PRINTF("looking for simple prefix split\n"); bool anchored = !proper_out_degree(g.startDs, g); NFAVertex u = anchored ? g.start : g.startDs; if (out_degree(u, g) != 2) { /* startDs + succ */ return nullptr; } NFAVertex v = NGHolder::null_vertex(); for (NFAVertex t : adjacent_vertices_range(u, g)) { if (t != g.startDs) { assert(!v); v = t; } } assert(v); if (!anchored) { if (out_degree(g.start, g) > 2) { return nullptr; } if (out_degree(g.start, g) == 2 && !edge(g.start, v, g).second) { return nullptr; } } NFAVertex best_v = NGHolder::null_vertex(); ue2_literal best_lit; u32 limit = cc.grey.maxHistoryAvailable; if (anchored) { LIMIT_TO_AT_MOST(&limit, cc.grey.maxAnchoredRegion); } ue2_literal curr_lit; for (u32 i = 0; i < limit; i++) { const auto &v_cr = g[v].char_reach; if (v_cr.count() == 1 || v_cr.isCaselessChar()) { curr_lit.push_back(v_cr.find_first(), v_cr.isCaselessChar()); } else { curr_lit.clear(); } if (curr_lit.length() > best_lit.length()) { best_lit = curr_lit; best_v = v; } if (out_degree(v, g) != 1) { break; } v = *adjacent_vertices(v, g).first; } if (best_lit.length() < cc.grey.minRoseLiteralLength) { return nullptr; } set best_lit_set({best_lit}); if (bad_mixed_sensitivity(best_lit)) { sanitizeAndCompressAndScore(best_lit_set); } return ue2::make_unique(best_v, best_lit_set, anchored, true); } static unique_ptr findBestPrefixSplit(const NGHolder &g, const vector &depths, const RoseInGraph &vg, const vector &ee, const CompileContext &cc) { assert(g.kind == NFA_PREFIX); set bad_vertices = poisonVertices(g, vg, ee, cc.grey); auto rv = findBestSplit(g, &depths, true, cc.grey.minRoseLiteralLength, nullptr, &bad_vertices, cc); /* large back edges may prevent us identifying anchored or transient cases * properly - use a simple walk instead */ if (!rv || !(rv->creates_transient || rv->creates_anchored)) { auto rv2 = findSimplePrefixSplit(g, cc); if (rv2) { return rv2; } } return rv; } static unique_ptr findBestCleanSplit(const NGHolder &g, const CompileContext &cc) { assert(g.kind != NFA_PREFIX); set cleanSplits; for (NFAVertex v : vertices_range(g)) { if (!g[v].char_reach.all() || !edge(v, v, g).second) { continue; } insert(&cleanSplits, inv_adjacent_vertices(v, g)); cleanSplits.erase(v); } cleanSplits.erase(g.start); if (cleanSplits.empty()) { return nullptr; } return findBestSplit(g, nullptr, false, cc.grey.violetEarlyCleanLiteralLen, &cleanSplits, nullptr, cc); } static bool can_match(const NGHolder &g, const ue2_literal &lit, bool overhang_ok) { set curr, next; curr.insert(g.accept); for (auto it = lit.rbegin(); it != lit.rend(); ++it) { next.clear(); for (auto v : curr) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == g.start) { if (overhang_ok) { DEBUG_PRINTF("bail\n"); return true; } else { continue; /* it is not possible for a lhs literal to * overhang the start */ } } const CharReach &cr = g[u].char_reach; if (!overlaps(*it, cr)) { continue; } next.insert(u); } } curr.swap(next); } return !curr.empty(); } static bool splitRoseEdge(const NGHolder &base_graph, RoseInGraph &vg, const vector &ee, const VertLitInfo &split) { const vector &splitters = split.vv; assert(!splitters.empty()); shared_ptr lhs = make_shared(); shared_ptr rhs = make_shared(); ue2::unordered_map lhs_map; ue2::unordered_map rhs_map; splitGraph(base_graph, splitters, lhs.get(), &lhs_map, rhs.get(), &rhs_map); DEBUG_PRINTF("split %s:%zu into %s:%zu + %s:%zu\n", to_string(base_graph.kind).c_str(), num_vertices(base_graph), to_string(lhs->kind).c_str(), num_vertices(*lhs), to_string(rhs->kind).c_str(), num_vertices(*rhs)); bool suffix = vg[target(ee.front(), vg)].type == RIV_ACCEPT; if (is_triggered(base_graph)) { /* if we are already guarded, check if the split reduces the size of * the problem before continuing with the split */ if (num_vertices(*lhs) >= num_vertices(base_graph) && !(suffix && isVacuous(*rhs))) { DEBUG_PRINTF("split's lhs is no smaller\n"); return false; } if (num_vertices(*rhs) >= num_vertices(base_graph)) { DEBUG_PRINTF("split's rhs is no smaller\n"); return false; } } bool do_accept = false; bool do_accept_eod = false; assert(rhs); if (isVacuous(*rhs) && suffix) { if (edge(rhs->start, rhs->accept, *rhs).second) { DEBUG_PRINTF("rhs has a cliche\n"); do_accept = true; remove_edge(rhs->start, rhs->accept, *rhs); } if (edge(rhs->start, rhs->acceptEod, *rhs).second) { DEBUG_PRINTF("rhs has an eod cliche\n"); do_accept_eod = true; remove_edge(rhs->start, rhs->acceptEod, *rhs); } renumber_edges(*rhs); } /* check if we still have a useful graph left over */ bool do_norm = out_degree(rhs->start, *rhs) != 1; set splitter_reports; for (auto v : splitters) { insert(&splitter_reports, base_graph[v].reports); } /* find the targets of each source vertex; note the use of vectors to * preserve deterministic ordering */ vector sources; map> images; for (const RoseInEdge &e : ee) { RoseInVertex src = source(e, vg); RoseInVertex dest = target(e, vg); if (!contains(images, src)) { sources.push_back(src); } images[src].push_back(dest); remove_edge(e, vg); } map, vector> verts_by_image; for (const auto &u : sources) { const auto &image = images[u]; if (contains(verts_by_image, image)) { for (RoseInVertex v : verts_by_image[image]) { add_edge(u, v, RoseInEdgeProps(lhs, 0U), vg); } continue; } for (const auto &lit : split.lit) { assert(!bad_mixed_sensitivity(lit)); /* don't allow overhang in can_match() as literals should * correspond to the edge graph being split; overhanging the graph * would indicate a false path.*/ if (!can_match(*lhs, lit, false)) { DEBUG_PRINTF("'%s' did not match lhs\n", escapeString(lit).c_str()); continue; } DEBUG_PRINTF("best is '%s'\n", escapeString(lit).c_str()); auto v = add_vertex(RoseInVertexProps::makeLiteral(lit), vg); add_edge(u, v, RoseInEdgeProps(lhs, 0U), vg); /* work out delay later */ if (do_accept) { DEBUG_PRINTF("rhs has a cliche\n"); auto tt = add_vertex(RoseInVertexProps::makeAccept( splitter_reports), vg); add_edge(v, tt, RoseInEdgeProps(0U, 0U), vg); } if (do_accept_eod) { DEBUG_PRINTF("rhs has an eod cliche\n"); auto tt = add_vertex(RoseInVertexProps::makeAcceptEod( splitter_reports), vg); add_edge(v, tt, RoseInEdgeProps(0U, 0U), vg); } if (do_norm) { assert(out_degree(rhs->start, *rhs) > 1); for (RoseInVertex dest : image) { add_edge(v, dest, RoseInEdgeProps(rhs, 0U), vg); } } verts_by_image[image].push_back(v); } } assert(hasCorrectlyNumberedVertices(*rhs)); assert(hasCorrectlyNumberedEdges(*rhs)); assert(isCorrectlyTopped(*rhs)); assert(hasCorrectlyNumberedVertices(*lhs)); assert(hasCorrectlyNumberedEdges(*lhs)); assert(isCorrectlyTopped(*lhs)); return true; } #define MAX_NETFLOW_CUT_WIDTH 40 /* magic number is magic */ #define MAX_LEN_2_LITERALS_PER_CUT 3 static bool checkValidNetflowLits(NGHolder &h, const vector &scores, const map> &cut_lits, u32 min_allowed_length) { DEBUG_PRINTF("cut width %zu; min allowed %u\n", cut_lits.size(), min_allowed_length); if (cut_lits.size() > MAX_NETFLOW_CUT_WIDTH) { return false; } u32 len_2_count = 0; for (const auto &cut : cut_lits) { if (scores[h[cut.first].index] >= NO_LITERAL_AT_EDGE_SCORE) { DEBUG_PRINTF("cut uses a forbidden edge\n"); return false; } if (min_len(cut.second) < min_allowed_length) { DEBUG_PRINTF("cut uses a bad literal\n"); return false; } for (const auto &lit : cut.second) { if (lit.length() == 2) { len_2_count++; } } } if (len_2_count > MAX_LEN_2_LITERALS_PER_CUT) { return false; } return true; } static void splitEdgesByCut(NGHolder &h, RoseInGraph &vg, const vector &to_cut, const vector &cut, const map> &cut_lits) { DEBUG_PRINTF("splitting %s:\n", to_string(h.kind).c_str()); /* create literal vertices and connect preds */ unordered_set done_sources; map>> verts_by_source; for (const RoseInEdge &ve : to_cut) { assert(&h == &*vg[ve].graph); RoseInVertex src = source(ve, vg); if (!done_sources.insert(src).second) { continue; /* already processed */ } /* iterate over cut for determinism */ for (const auto &e : cut) { NFAVertex prev_v = source(e, h); NFAVertex pivot = target(e, h); DEBUG_PRINTF("splitting on pivot %zu\n", h[pivot].index); ue2::unordered_map temp_map; shared_ptr new_lhs = make_shared(); splitLHS(h, pivot, new_lhs.get(), &temp_map); /* want to cut off paths to pivot from things other than the pivot - * makes a more svelte graphy */ clear_in_edges(temp_map[pivot], *new_lhs); NFAEdge pivot_edge = add_edge(temp_map[prev_v], temp_map[pivot], *new_lhs); if (is_triggered(h) && prev_v == h.start) { (*new_lhs)[pivot_edge].tops.insert(DEFAULT_TOP); } pruneUseless(*new_lhs, false); renumber_vertices(*new_lhs); renumber_edges(*new_lhs); DEBUG_PRINTF(" into lhs %s\n", to_string(new_lhs->kind).c_str()); assert(hasCorrectlyNumberedVertices(*new_lhs)); assert(hasCorrectlyNumberedEdges(*new_lhs)); assert(isCorrectlyTopped(*new_lhs)); const set &lits = cut_lits.at(e); for (const auto &lit : lits) { if (!can_match(*new_lhs, lit, is_triggered(h))) { continue; } RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), vg); /* if this is a prefix/infix an edge directly to accept should * represent a false path as we have poisoned vertices covered * by the literals. */ if (generates_callbacks(h)) { if (edge(pivot, h.accept, h).second) { DEBUG_PRINTF("adding acceptEod\n"); /* literal has a direct connection to accept */ const flat_set &reports = h[pivot].reports; auto tt = add_vertex( RoseInVertexProps::makeAccept(reports), vg); add_edge(v, tt, RoseInEdgeProps(0U, 0U), vg); } if (edge(pivot, h.acceptEod, h).second) { assert(generates_callbacks(h)); DEBUG_PRINTF("adding acceptEod\n"); /* literal has a direct connection to accept */ const flat_set &reports = h[pivot].reports; auto tt = add_vertex( RoseInVertexProps::makeAcceptEod(reports), vg); add_edge(v, tt, RoseInEdgeProps(0U, 0U), vg); } } add_edge(src, v, RoseInEdgeProps(new_lhs, 0), vg); verts_by_source[src].push_back({v, pivot}); } } } /* wire the literal vertices up to successors */ map, shared_ptr > done_rhs; for (const RoseInEdge &ve : to_cut) { RoseInVertex src = source(ve, vg); RoseInVertex dest = target(ve, vg); /* iterate over cut for determinism */ for (const auto &elem : verts_by_source[src]) { NFAVertex pivot = elem.second; RoseInVertex v = elem.first; vector adj; insert(&adj, adj.end(), adjacent_vertices(pivot, h)); /* we can ignore presence of accept, accepteod in adj as it is best effort */ if (!contains(done_rhs, adj)) { ue2::unordered_map temp_map; shared_ptr new_rhs = make_shared(); splitRHS(h, adj, new_rhs.get(), &temp_map); remove_edge(new_rhs->start, new_rhs->accept, *new_rhs); remove_edge(new_rhs->start, new_rhs->acceptEod, *new_rhs); renumber_edges(*new_rhs); DEBUG_PRINTF(" into rhs %s\n", to_string(new_rhs->kind).c_str()); done_rhs.emplace(adj, new_rhs); assert(isCorrectlyTopped(*new_rhs)); } assert(done_rhs[adj].get()); shared_ptr new_rhs = done_rhs[adj]; assert(hasCorrectlyNumberedVertices(*new_rhs)); assert(hasCorrectlyNumberedEdges(*new_rhs)); assert(isCorrectlyTopped(*new_rhs)); if (vg[dest].type == RIV_LITERAL && !can_match(*new_rhs, vg[dest].s, true)) { continue; } if (out_degree(new_rhs->start, *new_rhs) != 1) { add_edge(v, dest, RoseInEdgeProps(new_rhs, 0), vg); } } remove_edge(ve, vg); } } static bool doNetflowCut(NGHolder &h, const vector *depths, RoseInGraph &vg, const vector &ee, bool for_prefix, const Grey &grey, u32 min_allowed_length = 0U) { ENSURE_AT_LEAST(&min_allowed_length, grey.minRoseNetflowLiteralLength); DEBUG_PRINTF("doing netflow cut\n"); /* TODO: we should really get literals/scores from the full graph as this * allows us to overlap with previous cuts. */ assert(!ee.empty()); assert(&h == &*vg[ee.front()].graph); assert(!for_prefix || depths); if (num_edges(h) > grey.maxRoseNetflowEdges) { /* We have a limit on this because scoring edges and running netflow * gets very slow for big graphs. */ DEBUG_PRINTF("too many edges, skipping netflow cut\n"); return false; } assert(hasCorrectlyNumberedVertices(h)); assert(hasCorrectlyNumberedEdges(h)); auto known_bad = poisonEdges(h, depths, vg, ee, for_prefix, grey); /* Step 1: Get scores for all edges */ vector scores = scoreEdges(h, known_bad); /* scores by edge_index */ /* Step 2: Find cutset based on scores */ vector cut = findMinCut(h, scores); /* Step 3: Get literals corresponding to cut edges */ map> cut_lits; for (const auto &e : cut) { set lits = getLiteralSet(h, e); sanitizeAndCompressAndScore(lits); cut_lits[e] = lits; } /* if literals are underlength bail or if it involves a forbidden edge*/ if (!checkValidNetflowLits(h, scores, cut_lits, min_allowed_length)) { return false; } DEBUG_PRINTF("splitting\n"); /* Step 4: Split graph based on cuts */ splitEdgesByCut(h, vg, ee, cut, cut_lits); return true; } static bool deanchorIfNeeded(NGHolder &g) { DEBUG_PRINTF("hi\n"); if (proper_out_degree(g.startDs, g)) { return false; } /* look for a non-special dot with a loop following start */ set succ_g; insert(&succ_g, adjacent_vertices(g.start, g)); succ_g.erase(g.startDs); for (auto v : adjacent_vertices_range(g.start, g)) { DEBUG_PRINTF("inspecting cand %zu || = %zu\n", g[v].index, g[v].char_reach.count()); if (v == g.startDs || !g[v].char_reach.all()) { continue; } set succ_v; insert(&succ_v, adjacent_vertices(v, g)); if (succ_v == succ_g) { DEBUG_PRINTF("found ^.*\n"); for (auto succ : adjacent_vertices_range(g.start, g)) { if (succ == g.startDs) { continue; } add_edge(g.startDs, succ, g); } clear_vertex(v, g); remove_vertex(v, g); renumber_vertices(g); return true; } if (succ_g.size() == 1 && hasSelfLoop(v, g)) { DEBUG_PRINTF("found ^.+\n"); add_edge(g.startDs, v, g); remove_edge(v, v, g); return true; } } return false; } static RoseInGraph populateTrivialGraph(const NGHolder &h) { RoseInGraph g; shared_ptr root_g = cloneHolder(h); bool orig_anch = isAnchored(*root_g); orig_anch |= deanchorIfNeeded(*root_g); DEBUG_PRINTF("orig_anch %d\n", (int)orig_anch); auto start = add_vertex(RoseInVertexProps::makeStart(orig_anch), g); auto accept = add_vertex(RoseInVertexProps::makeAccept(set()), g); add_edge(start, accept, RoseInEdgeProps(root_g, 0), g); return g; } static void avoidOutfixes(RoseInGraph &vg, const CompileContext &cc) { STAGE_DEBUG_PRINTF("AVOIDING OUTFIX\n"); if (num_vertices(vg) > 2) { /* must be at least one literal aside from start and accept */ return; } RoseInEdge e = *edges(vg).first; NGHolder &h = *vg[e].graph; assert(isCorrectlyTopped(h)); renumber_vertices(h); renumber_edges(h); unique_ptr split = findBestNormalSplit(h, vg, {e}, cc); if (split && splitRoseEdge(h, vg, {e}, *split)) { DEBUG_PRINTF("split on simple literal\n"); } else { doNetflowCut(h, nullptr, vg, {e}, false, cc.grey); } } static void removeRedundantPrefixes(RoseInGraph &g) { STAGE_DEBUG_PRINTF("REMOVING REDUNDANT PREFIXES\n"); for (const RoseInEdge &e : edges_range(g)) { RoseInVertex s = source(e, g); RoseInVertex t = target(e, g); if (g[s].type != RIV_START || g[t].type != RIV_LITERAL) { continue; } if (!g[e].graph) { continue; } assert(!g[t].delay); const ue2_literal &lit = g[t].s; if (!literalIsWholeGraph(*g[e].graph, lit)) { DEBUG_PRINTF("not whole graph\n"); continue; } if (!isFloating(*g[e].graph)) { DEBUG_PRINTF("not floating\n"); continue; } g[e].graph.reset(); } } static u32 maxDelay(const CompileContext &cc) { if (!cc.streaming) { return MO_INVALID_IDX; } return cc.grey.maxHistoryAvailable; } static void removeRedundantLiteralsFromPrefixes(RoseInGraph &g, const CompileContext &cc) { STAGE_DEBUG_PRINTF("REMOVING LITERALS FROM PREFIXES\n"); vector to_anchor; for (const RoseInEdge &e : edges_range(g)) { RoseInVertex s = source(e, g); RoseInVertex t = target(e, g); if (g[s].type != RIV_START && g[s].type != RIV_ANCHORED_START) { continue; } if (g[t].type != RIV_LITERAL) { continue; } if (!g[e].graph) { continue; } assert(!g[t].delay); const ue2_literal &lit = g[t].s; DEBUG_PRINTF("removing states for literal: %s\n", dumpString(lit).c_str()); unique_ptr h = cloneHolder(*g[e].graph); const u32 max_delay = maxDelay(cc); u32 delay = removeTrailingLiteralStates(*h, lit, max_delay, false /* can't overhang start */); DEBUG_PRINTF("got delay %u (max allowed %u)\n", delay, max_delay); if (edge(h->startDs, h->accept, *h).second) { /* we should have delay == lit.length(), but in really complex * cases we may fail to identify that we can remove the whole * graph. Regardless, the fact that sds is wired to accept means the * graph serves no purpose. */ DEBUG_PRINTF("whole graph\n"); g[e].graph.reset(); continue; } if (delay == lit.length() && edge(h->start, h->accept, *h).second && num_vertices(*h) == N_SPECIALS) { to_anchor.push_back(e); continue; } /* if we got here we should still have an interesting graph */ assert(delay == max_delay || num_vertices(*h) > N_SPECIALS); if (delay && delay != MO_INVALID_IDX) { DEBUG_PRINTF("setting delay %u on lhs %p\n", delay, h.get()); g[e].graph = move(h); g[e].graph_lag = delay; } } if (!to_anchor.empty()) { RoseInVertex anch = add_vertex(RoseInVertexProps::makeStart(true), g); for (RoseInEdge e : to_anchor) { DEBUG_PRINTF("rehoming to anchor\n"); RoseInVertex v = target(e, g); add_edge(anch, v, g); remove_edge(e, g); } } } static bool isStarCliche(const NGHolder &g) { DEBUG_PRINTF("checking graph with %zu vertices\n", num_vertices(g)); bool nonspecials_seen = false; for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } if (nonspecials_seen) { return false; } nonspecials_seen = true; if (!g[v].char_reach.all()) { return false; } if (!hasSelfLoop(v, g)) { return false; } if (!edge(v, g.accept, g).second) { return false; } } if (!nonspecials_seen) { return false; } if (!edge(g.start, g.accept, g).second) { return false; } return true; } static void removeRedundantLiteralsFromInfix(const NGHolder &h, RoseInGraph &ig, const vector &ee, const CompileContext &cc) { /* TODO: This could be better by not creating a separate graph for each * successor literal. This would require using distinct report ids and also * taking into account overlap of successor literals. */ set preds; for (const RoseInEdge &e : ee) { RoseInVertex u = source(e, ig); assert(ig[u].type == RIV_LITERAL); assert(!ig[e].graph_lag); assert(!ig[u].delay); preds.insert(ig[u].s); } set succs; for (const RoseInEdge &e : ee) { RoseInVertex v = target(e, ig); assert(ig[v].type == RIV_LITERAL); assert(!ig[v].delay); succs.insert(ig[v].s); } map, u32> > graphs; /* + delay */ for (const ue2_literal &right : succs) { size_t max_overlap = 0; for (const ue2_literal &left : preds) { size_t overlap = maxOverlap(left, right, 0); ENSURE_AT_LEAST(&max_overlap, overlap); } u32 max_allowed_delay = right.length() - max_overlap; if (cc.streaming) { LIMIT_TO_AT_MOST(&max_allowed_delay, cc.grey.maxHistoryAvailable); } if (!max_allowed_delay) { continue; } shared_ptr h_new = cloneHolder(h); u32 delay = removeTrailingLiteralStates(*h_new, right, max_allowed_delay); if (delay == MO_INVALID_IDX) { /* successor literal could not match infix -> ignore false path */ assert(0); continue; } assert(isCorrectlyTopped(*h_new)); graphs[right] = make_pair(h_new, delay); } for (const RoseInEdge &e : ee) { RoseInVertex v = target(e, ig); const ue2_literal &succ = ig[v].s; if (!contains(graphs, succ)) { continue; } ig[e].graph = graphs[succ].first; ig[e].graph_lag = graphs[succ].second; if (isStarCliche(*ig[e].graph)) { DEBUG_PRINTF("is a X star!\n"); ig[e].graph.reset(); ig[e].graph_lag = 0; } } } static void removeRedundantLiteralsFromInfixes(RoseInGraph &g, const CompileContext &cc) { vector seen_order; map> infixes; for (const RoseInEdge &e : edges_range(g)) { RoseInVertex s = source(e, g); RoseInVertex t = target(e, g); if (g[s].type != RIV_LITERAL || g[t].type != RIV_LITERAL) { continue; } if (!g[e].graph) { continue; } assert(!g[t].delay); NGHolder *h = g[e].graph.get(); if (!contains(infixes, h)) { seen_order.push_back(h); } infixes[h].push_back(e); } for (NGHolder *h : seen_order) { removeRedundantLiteralsFromInfix(*h, g, infixes[h], cc); } } static void removeRedundantLiterals(RoseInGraph &g, const CompileContext &cc) { removeRedundantLiteralsFromPrefixes(g, cc); removeRedundantLiteralsFromInfixes(g, cc); } static RoseInVertex getStart(RoseInGraph &vg) { for (RoseInVertex v : vertices_range(vg)) { if (vg[v].type == RIV_START || vg[v].type == RIV_ANCHORED_START) { return v; } } assert(0); return RoseInGraph::null_vertex(); } /** * Finds the initial accept vertex created to which suffix/outfixes are * attached. */ static RoseInVertex getPrimaryAccept(RoseInGraph &vg) { for (RoseInVertex v : vertices_range(vg)) { if (vg[v].type == RIV_ACCEPT && vg[v].reports.empty()) { return v; } } assert(0); return RoseInGraph::null_vertex(); } static bool willBeTransient(const depth &max_depth, const CompileContext &cc) { if (!cc.streaming) { return max_depth <= depth(ROSE_BLOCK_TRANSIENT_MAX_WIDTH); } else { return max_depth <= depth(cc.grey.maxHistoryAvailable + 1); } } static bool willBeAnchoredTable(const depth &max_depth, const Grey &grey) { return max_depth <= depth(grey.maxAnchoredRegion); } static unique_ptr make_chain(u32 count) { assert(count); auto rv = make_unique(NFA_INFIX); NGHolder &h = *rv; NFAVertex u = h.start; for (u32 i = 0; i < count; i++) { NFAVertex v = add_vertex(h); h[v].char_reach = CharReach::dot(); add_edge(u, v, h); u = v; } h[u].reports.insert(0); add_edge(u, h.accept, h); setTops(h); return rv; } #define SHORT_TRIGGER_LEN 16 static bool makeTransientFromLongLiteral(NGHolder &h, RoseInGraph &vg, const vector &ee, const CompileContext &cc) { /* check max width and literal lengths to see if possible */ size_t min_lit = (size_t)~0ULL; for (const RoseInEdge &e : ee) { RoseInVertex v = target(e, vg); LIMIT_TO_AT_MOST(&min_lit, vg[v].s.length()); } if (min_lit <= SHORT_TRIGGER_LEN || min_lit >= UINT_MAX) { return false; } depth max_width = findMaxWidth(h); u32 delta = min_lit - SHORT_TRIGGER_LEN; if (!willBeTransient(max_width - depth(delta), cc) && !willBeAnchoredTable(max_width - depth(delta), cc.grey)) { return false; } DEBUG_PRINTF("candidate for splitting long literal (len %zu)\n", min_lit); DEBUG_PRINTF("delta = %u\n", delta); /* try split */ map > graphs; for (const RoseInEdge &e : ee) { RoseInVertex v = target(e, vg); shared_ptr h_new = cloneHolder(h); u32 delay = removeTrailingLiteralStates(*h_new, vg[v].s, delta); DEBUG_PRINTF("delay %u\n", delay); if (delay != delta) { DEBUG_PRINTF("unable to trim literal\n"); return false; } if (in_degree(v, vg) != 1) { DEBUG_PRINTF("complicated\n"); return false; } DEBUG_PRINTF("new mw = %u\n", (u32)findMaxWidth(*h_new)); assert(willBeTransient(findMaxWidth(*h_new), cc) || willBeAnchoredTable(findMaxWidth(*h_new), cc.grey)); assert(isCorrectlyTopped(*h_new)); graphs[v] = h_new; } /* add .{repeats} from prefixes to long literals */ for (const RoseInEdge &e : ee) { RoseInVertex s = source(e, vg); RoseInVertex t = target(e, vg); remove_edge(e, vg); const ue2_literal &orig_lit = vg[t].s; ue2_literal lit(orig_lit.begin(), orig_lit.end() - delta); ue2_literal lit2(orig_lit.end() - delta, orig_lit.end()); assert(lit.length() + delta == orig_lit.length()); vg[t].s = lit2; RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), vg); add_edge(s, v, RoseInEdgeProps(graphs[t], 0), vg); add_edge(v, t, RoseInEdgeProps(make_chain(delta), 0), vg); } DEBUG_PRINTF("success\n"); /* TODO: alter split point to avoid pathological splits */ return true; } static bool improvePrefix(NGHolder &h, RoseInGraph &vg, const vector &ee, const CompileContext &cc) { DEBUG_PRINTF("trying to improve prefix %p, %zu verts\n", &h, num_vertices(h)); assert(isCorrectlyTopped(h)); renumber_vertices(h); renumber_edges(h); vector depths; calcDepths(h, depths); /* If the reason the prefix is not transient is due to a very long literal * following, we can make it transient by restricting ourselves to using * just the head of the literal. */ if (makeTransientFromLongLiteral(h, vg, ee, cc)) { return true; } unique_ptr split = findBestPrefixSplit(h, depths, vg, ee, cc); if (split && (split->creates_transient || split->creates_anchored) && splitRoseEdge(h, vg, ee, *split)) { DEBUG_PRINTF("split on simple literal\n"); return true; } /* large back edges may prevent us identifing anchored or transient cases * properly - use a simple walk instead */ if (doNetflowCut(h, &depths, vg, ee, true, cc.grey)) { return true; } if (split && splitRoseEdge(h, vg, ee, *split)) { /* use the simple split even though it doesn't create a transient * prefix */ DEBUG_PRINTF("split on simple literal\n"); return true; } /* look for netflow cuts which don't produce good prefixes */ if (doNetflowCut(h, &depths, vg, ee, false, cc.grey)) { return true; } if (ee.size() > 1) { DEBUG_PRINTF("split the prefix apart based on succ literals\n"); unordered_map, vector >, NGHolderHasher, NGHolderEqual> trimmed; for (const auto &e : ee) { shared_ptr hh = cloneHolder(h); auto succ_lit = vg[target(e, vg)].s; assert(isCorrectlyTopped(*hh)); u32 delay = removeTrailingLiteralStates(*hh, succ_lit, succ_lit.length(), false /* can't overhang start */); if (!delay) { DEBUG_PRINTF("could not remove any literal, skip over\n"); continue; } assert(isCorrectlyTopped(*hh)); trimmed[hh].emplace_back(e, delay); } if (trimmed.size() == 1) { return false; } /* shift the contents to a vector so we can modify the graphs without * violating the map's invariants. */ vector, vector > > > trimmed_vec(trimmed.begin(), trimmed.end()); trimmed.clear(); for (auto &elem : trimmed_vec) { shared_ptr &hp = elem.first; NGHolder &eh = *hp; vector base_states; insert(&base_states, base_states.end(), inv_adjacent_vertices(eh.accept, eh)); clear_in_edges(eh.accept, eh); for (auto v : base_states) { eh[v].reports.clear(); /* clear report from old accepts */ } for (const auto &edge_delay : elem.second) { const RoseInEdge &e = edge_delay.first; u32 delay = edge_delay.second; auto succ_lit = vg[target(e, vg)].s; vg[e].graph = hp; assert(delay <= succ_lit.length()); restoreTrailingLiteralStates(*vg[e].graph, succ_lit, delay, base_states); } } return true; } return false; } #define MAX_FIND_BETTER_PREFIX_GEN 4 #define MAX_FIND_BETTER_PREFIX_COUNT 100 static void findBetterPrefixes(RoseInGraph &vg, const CompileContext &cc) { STAGE_DEBUG_PRINTF("FIND BETTER PREFIXES\n"); RoseInVertex start = getStart(vg); bool changed; u32 gen = 0; do { DEBUG_PRINTF("gen %u\n", gen); changed = false; vector seen_order; map > prefixes; /* find prefixes */ for (const RoseInEdge &e : out_edges_range(start, vg)) { /* outfixes shouldn't have made it this far */ assert(vg[target(e, vg)].type == RIV_LITERAL); if (vg[e].graph) { NGHolder *h = vg[e].graph.get(); if (!contains(prefixes, h)) { seen_order.push_back(h); } prefixes[h].push_back(e); } } if (prefixes.size() > MAX_FIND_BETTER_PREFIX_COUNT) { break; } /* look for bad prefixes and try to split */ for (NGHolder *h : seen_order) { depth max_width = findMaxWidth(*h); if (willBeTransient(max_width, cc) || willBeAnchoredTable(max_width, cc.grey)) { continue; } changed = improvePrefix(*h, vg, prefixes[h], cc); } } while (changed && gen++ < MAX_FIND_BETTER_PREFIX_GEN); } #define STRONG_LITERAL_LENGTH 20 #define MAX_EXTRACT_STRONG_LITERAL_GRAPHS 10 static bool extractStrongLiteral(NGHolder &h, RoseInGraph &vg, const vector &ee, const CompileContext &cc) { DEBUG_PRINTF("looking for string literal\n"); unique_ptr split = findBestNormalSplit(h, vg, ee, cc); if (split && min_len(split->lit) >= STRONG_LITERAL_LENGTH) { DEBUG_PRINTF("splitting simple literal\n"); return splitRoseEdge(h, vg, ee, *split); } return false; } static void extractStrongLiterals(RoseInGraph &vg, const CompileContext &cc) { if (!cc.grey.violetExtractStrongLiterals) { return; } STAGE_DEBUG_PRINTF("EXTRACT STRONG LITERALS\n"); set stuck; bool changed; do { changed = false; vector seen_order; map > edges_by_graph; for (const RoseInEdge &ve : edges_range(vg)) { if (vg[source(ve, vg)].type != RIV_LITERAL) { continue; } if (vg[ve].graph) { if (!contains(edges_by_graph, vg[ve].graph.get())) { seen_order.push_back(vg[ve].graph.get()); } edges_by_graph[vg[ve].graph.get()].push_back(ve); } } if (edges_by_graph.size() > MAX_EXTRACT_STRONG_LITERAL_GRAPHS) { DEBUG_PRINTF("too many graphs, stopping\n"); return; } for (NGHolder *g : seen_order) { if (contains(stuck, g)) { DEBUG_PRINTF("already known to be bad\n"); continue; } bool rv = extractStrongLiteral(*g, vg, edges_by_graph[g], cc); if (rv) { changed = true; } else { stuck.insert(g); } } } while (changed); } #define INFIX_STRONG_GUARD_LEN 8 #define INFIX_MIN_SPLIT_LITERAL_LEN 12 static bool improveInfix(NGHolder &h, RoseInGraph &vg, const vector &ee, const CompileContext &cc) { unique_ptr split = findBestNormalSplit(h, vg, ee, cc); if (split && min_len(split->lit) >= INFIX_MIN_SPLIT_LITERAL_LEN && splitRoseEdge(h, vg, ee, *split)) { DEBUG_PRINTF("splitting simple literal\n"); return true; } DEBUG_PRINTF("trying for a netflow cut\n"); /* look for netflow cuts which don't produce good prefixes */ bool rv = doNetflowCut(h, nullptr, vg, ee, false, cc.grey, 8); DEBUG_PRINTF("did netfow cut? = %d\n", (int)rv); return rv; } /** * Infixes which are weakly guarded can, in effect, act like prefixes as they * will often be live. We should try to split these infixes further if they * contain strong literals so that we are at least running smaller weak infixes * which can hopeful be accelerated/miracled. */ static void improveWeakInfixes(RoseInGraph &vg, const CompileContext &cc) { if (!cc.grey.violetAvoidWeakInfixes) { return; } STAGE_DEBUG_PRINTF("IMPROVE WEAK INFIXES\n"); RoseInVertex start = getStart(vg); set weak; vector ordered_weak; for (RoseInVertex vv : adjacent_vertices_range(start, vg)) { /* outfixes shouldn't have made it this far */ assert(vg[vv].type == RIV_LITERAL); if (vg[vv].s.length() >= INFIX_STRONG_GUARD_LEN) { continue; } for (const RoseInEdge &e : out_edges_range(vv, vg)) { if (vg[target(e, vg)].type != RIV_LITERAL || !vg[e].graph) { continue; } NGHolder *h = vg[e].graph.get(); DEBUG_PRINTF("'%s' guards %p\n", dumpString(vg[vv].s).c_str(), h); if (!contains(weak, h)) { weak.insert(h); ordered_weak.push_back(h); } } } map > weak_edges; for (const RoseInEdge &ve : edges_range(vg)) { if (contains(weak, vg[ve].graph.get())) { weak_edges[vg[ve].graph.get()].push_back(ve); } } for (NGHolder *h : ordered_weak) { improveInfix(*h, vg, weak_edges[h], cc); } } static void splitEdgesForSuffix(const NGHolder &base_graph, RoseInGraph &vg, const vector &ee, const VertLitInfo &split, bool eod, const flat_set &reports) { const vector &splitters = split.vv; assert(!splitters.empty()); shared_ptr lhs = make_shared(); unordered_map v_map; cloneHolder(*lhs, base_graph, &v_map); lhs->kind = NFA_INFIX; clear_in_edges(lhs->accept, *lhs); clear_in_edges(lhs->acceptEod, *lhs); add_edge(lhs->accept, lhs->acceptEod, *lhs); clearReports(*lhs); for (NFAVertex v : splitters) { NFAEdge e = add_edge(v_map[v], lhs->accept, *lhs); if (v == base_graph.start) { (*lhs)[e].tops.insert(DEFAULT_TOP); } (*lhs)[v_map[v]].reports.insert(0); } pruneUseless(*lhs); assert(isCorrectlyTopped(*lhs)); /* create literal vertices and connect preds */ for (const auto &lit : split.lit) { if (!can_match(*lhs, lit, is_triggered(*lhs))) { continue; } DEBUG_PRINTF("best is '%s'\n", escapeString(lit).c_str()); RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), vg); RoseInVertex tt; if (eod) { DEBUG_PRINTF("doing eod\n"); tt = add_vertex(RoseInVertexProps::makeAcceptEod(reports), vg); } else { DEBUG_PRINTF("doing non-eod\n"); tt = add_vertex(RoseInVertexProps::makeAccept(reports), vg); } add_edge(v, tt, RoseInEdgeProps(0U, 0U), vg); for (const RoseInEdge &e : ee) { RoseInVertex u = source(e, vg); assert(!edge(u, v, vg).second); add_edge(u, v, RoseInEdgeProps(lhs, 0U), vg); } } } #define MIN_SUFFIX_LEN 6 static bool replaceSuffixWithInfix(const NGHolder &h, RoseInGraph &vg, const vector &suffix_edges, const CompileContext &cc) { DEBUG_PRINTF("inspecting suffix : %p on %zu edges\n", &h, suffix_edges.size()); /* * We would, in general, rather not have output exposed engines because * once they are triggered, they must be run while infixes only have to run * if the successor literal is seen. Matches from output exposed engines * also have to be placed in a priority queue and interleaved with matches * from other sources. * * Note: * - if the LHS is extremely unlikely we may be better off leaving * a suffix unguarded. * * - limited width suffixes may be less bad as they won't be continuously * active, we may want to have (a) stronger controls on if we want to pick * a trailing literal in these cases and/or (b) look also for literals * near accept as well as right on accept * * TODO: improve heuristics, splitting logic. */ /* we may do multiple splits corresponding to different report behaviour */ set seen; map >, VertLitInfo> by_reports; /* eod, rep */ for (NFAVertex v : inv_adjacent_vertices_range(h.accept, h)) { set ss = getLiteralSet(h, v, false); if (ss.empty()) { DEBUG_PRINTF("candidate is too shitty\n"); return false; } VertLitInfo &vli = by_reports[make_pair(false, h[v].reports)]; insert(&vli.lit, ss); vli.vv.push_back(v); seen.insert(v); } seen.insert(h.accept); for (NFAVertex v : inv_adjacent_vertices_range(h.acceptEod, h)) { if (contains(seen, v)) { continue; } set ss = getLiteralSet(h, v, false); if (ss.empty()) { DEBUG_PRINTF("candidate is too shitty\n"); return false; } VertLitInfo &vli = by_reports[make_pair(true, h[v].reports)]; insert(&vli.lit, ss); vli.vv.push_back(v); } assert(!by_reports.empty()); /* TODO: how strong a min len do we want here ? */ u32 min_len = cc.grey.minRoseLiteralLength; ENSURE_AT_LEAST(&min_len, MIN_SUFFIX_LEN); for (auto &vli : by_reports | map_values) { u64a score = sanitizeAndCompressAndScore(vli.lit); if (vli.lit.empty() || !validateRoseLiteralSetQuality(vli.lit, score, false, min_len, false)) { return false; } } for (const auto &info : by_reports) { DEBUG_PRINTF("splitting on simple literals\n"); splitEdgesForSuffix(h, vg, suffix_edges, info.second, info.first.first /* eod */, info.first.second /* reports */); } for (const RoseInEdge &e : suffix_edges) { remove_edge(e, vg); } return true; } static void avoidSuffixes(RoseInGraph &vg, const CompileContext &cc) { if (!cc.grey.violetAvoidSuffixes) { return; } STAGE_DEBUG_PRINTF("AVOID SUFFIXES\n"); RoseInVertex accept = getPrimaryAccept(vg); map > suffixes; vector ordered_suffixes; /* find suffixes */ for (const RoseInEdge &e : in_edges_range(accept, vg)) { /* outfixes shouldn't have made it this far */ assert(vg[source(e, vg)].type == RIV_LITERAL); assert(vg[e].graph); /* non suffix paths should be wired to other accepts */ const NGHolder *h = vg[e].graph.get(); if (!contains(suffixes, h)) { ordered_suffixes.push_back(h); } suffixes[h].push_back(e); } /* look at suffixes and try to split */ for (const NGHolder *h : ordered_suffixes) { replaceSuffixWithInfix(*h, vg, suffixes[h], cc); } } static bool leadingDotStartLiteral(const NGHolder &h, VertLitInfo *out) { if (out_degree(h.start, h) != 3) { return false; } NFAVertex v = NGHolder::null_vertex(); NFAVertex ds = NGHolder::null_vertex(); for (NFAVertex a : adjacent_vertices_range(h.start, h)) { if (a == h.startDs) { continue; } if (h[a].char_reach.all()) { ds = a; if (out_degree(ds, h) != 2 || !edge(ds, ds, h).second) { return false; } } else { v = a; } } if (!v || !ds || !edge(ds, v, h).second) { return false; } if (h[v].char_reach.count() != 1 && !h[v].char_reach.isCaselessChar()) { return false; } ue2_literal lit; lit.push_back(h[v].char_reach.find_first(), h[v].char_reach.isCaselessChar()); while (out_degree(v, h) == 1) { NFAVertex vv = *adjacent_vertices(v, h).first; if (h[vv].char_reach.count() != 1 && !h[vv].char_reach.isCaselessChar()) { break; } v = vv; lit.push_back(h[v].char_reach.find_first(), h[v].char_reach.isCaselessChar()); } if (is_match_vertex(v, h) && h.kind != NFA_SUFFIX) { /* we have rediscovered the post-infix literal */ return false; } if (bad_mixed_sensitivity(lit)) { make_nocase(&lit); } DEBUG_PRINTF("%zu found %s\n", h[v].index, dumpString(lit).c_str()); out->vv = {v}; out->lit = {lit}; return true; } static bool lookForDoubleCut(const NGHolder &h, const vector &ee, RoseInGraph &vg, const Grey &grey) { VertLitInfo info; if (!leadingDotStartLiteral(h, &info) || min_len(info.lit) < grey.violetDoubleCutLiteralLen) { return false; } DEBUG_PRINTF("performing split\n"); return splitRoseEdge(h, vg, ee, {info}); } static void lookForDoubleCut(RoseInGraph &vg, const CompileContext &cc) { if (!cc.grey.violetDoubleCut) { return; } map > right_edges; vector ordered_graphs; for (const RoseInEdge &ve : edges_range(vg)) { if (vg[ve].graph && vg[source(ve, vg)].type == RIV_LITERAL) { const NGHolder *h = vg[ve].graph.get(); if (!contains(right_edges, h)) { ordered_graphs.push_back(h); } right_edges[h].push_back(ve); } } for (const NGHolder *h : ordered_graphs) { lookForDoubleCut(*h, right_edges[h], vg, cc.grey); } } static pair findLiteralBefore(const NGHolder &h, NFAVertex v) { ue2_literal lit; if (h[v].char_reach.count() != 1 && !h[v].char_reach.isCaselessChar()) { return {v, std::move(lit) }; } lit.push_back(h[v].char_reach.find_first(), h[v].char_reach.isCaselessChar()); while (in_degree(v, h) == 1) { NFAVertex vv = *inv_adjacent_vertices(v, h).first; if (h[vv].char_reach.count() != 1 && !h[vv].char_reach.isCaselessChar()) { break; } lit.push_back(h[vv].char_reach.find_first(), h[vv].char_reach.isCaselessChar()); v = vv; } return {v, std::move(lit) }; } static bool lookForDotStarPred(NFAVertex v, const NGHolder &h, NFAVertex *u, NFAVertex *ds) { *u = NGHolder::null_vertex(); *ds = NGHolder::null_vertex(); for (NFAVertex a : inv_adjacent_vertices_range(v, h)) { if (h[a].char_reach.all()) { if (!edge(a, a, h).second) { return false; } if (*ds) { return false; } *ds = a; } else { if (*u) { return false; } *u = a; } } if (!*u || !*ds) { return false; } return true; } static bool trailingDotStarLiteral(const NGHolder &h, VertLitInfo *out) { /* Note: there is no delay yet - so the final literal is the already * discovered successor literal - we are in fact interested in the literal * before it. */ if (in_degree(h.accept, h) != 1) { return false; } if (in_degree(h.acceptEod, h) != 1) { assert(0); return false; } NFAVertex v = findLiteralBefore(h, *inv_adjacent_vertices(h.accept, h).first).first; NFAVertex u; NFAVertex ds; if (!lookForDotStarPred(v, h, &u, &ds)) { return false; } v = u; auto rv = findLiteralBefore(h, v); if (!lookForDotStarPred(v, h, &u, &ds)) { return false; } ue2_literal lit = reverse_literal(rv.second); DEBUG_PRINTF("%zu found %s\n", h[v].index, dumpString(lit).c_str()); if (bad_mixed_sensitivity(lit)) { make_nocase(&lit); } out->vv = {v}; out->lit = {lit}; return true; } static bool lookForTrailingLiteralDotStar(const NGHolder &h, const vector &ee, RoseInGraph &vg, const Grey &grey) { VertLitInfo info; if (!trailingDotStarLiteral(h, &info) || min_len(info.lit) < grey.violetDoubleCutLiteralLen) { return false; } DEBUG_PRINTF("performing split\n"); return splitRoseEdge(h, vg, ee, info); } /* In streaming mode, active engines have to be caught up at stream boundaries * and have to be stored in stream state, so we prefer to decompose patterns * in to literals with no state between them if possible. */ static void decomposeLiteralChains(RoseInGraph &vg, const CompileContext &cc) { if (!cc.grey.violetLiteralChains) { return; } bool changed; do { changed = false; map > right_edges; vector ordered_graphs; for (const RoseInEdge &ve : edges_range(vg)) { if (vg[ve].graph && vg[source(ve, vg)].type == RIV_LITERAL) { const NGHolder *h = vg[ve].graph.get(); if (!contains(right_edges, h)) { ordered_graphs.push_back(h); } right_edges[h].push_back(ve); } } for (const NGHolder *h : ordered_graphs) { const vector &ee = right_edges[h]; bool rv = lookForDoubleCut(*h, ee, vg, cc.grey); if (!rv && h->kind != NFA_SUFFIX) { rv = lookForTrailingLiteralDotStar(*h, ee, vg, cc.grey); } changed |= rv; } } while (changed); } static bool lookForCleanSplit(const NGHolder &h, const vector &ee, RoseInGraph &vg, const CompileContext &cc) { unique_ptr split = findBestCleanSplit(h, cc); if (split) { return splitRoseEdge(h, vg, {ee}, *split); } return false; } #define MAX_DESIRED_CLEAN_SPLIT_DEPTH 4 static void lookForCleanEarlySplits(RoseInGraph &vg, const CompileContext &cc) { u32 gen = 0; vector prev = {getStart(vg)}; while (gen < MAX_DESIRED_CLEAN_SPLIT_DEPTH) { /* collect vertices in edge order for determinism */ vector curr; set curr_seen; for (RoseInVertex u : prev) { for (auto v : adjacent_vertices_range(u, vg)) { if (curr_seen.insert(v).second) { curr.push_back(v); } } } map> rightfixes; vector ordered_graphs; for (RoseInVertex v : curr) { for (const RoseInEdge &e : out_edges_range(v, vg)) { if (vg[e].graph) { NGHolder *h = vg[e].graph.get(); if (!contains(rightfixes, h)) { ordered_graphs.push_back(h); } rightfixes[h].push_back(e); } } } for (const NGHolder *h : ordered_graphs) { lookForCleanSplit(*h, rightfixes[h], vg, cc); } prev = curr; gen++; } } static void rehomeEodSuffixes(RoseInGraph &vg) { // Find edges to accept with EOD-anchored graphs that we can move over to // acceptEod. vector acc_edges; for (const auto &e : edges_range(vg)) { if (vg[target(e, vg)].type != RIV_ACCEPT) { continue; } if (vg[e].haig || !vg[e].graph) { continue; } const NGHolder &h = *vg[e].graph; if (in_degree(h.accept, h)) { DEBUG_PRINTF("graph isn't eod anchored\n"); continue; } acc_edges.push_back(e); } for (const RoseInEdge &e : acc_edges) { // Move this edge from accept to acceptEod RoseInVertex w = add_vertex(RoseInVertexProps::makeAcceptEod(), vg); add_edge(source(e, vg), w, vg[e], vg); remove_edge(e, vg); } /* old accept vertices will be tidied up by final pruneUseless() call */ } bool doViolet(RoseBuild &rose, const NGHolder &h, bool prefilter, const CompileContext &cc) { assert(!can_never_match(h)); if (!cc.grey.allowViolet) { return false; } DEBUG_PRINTF("hello world\n"); RoseInGraph vg = populateTrivialGraph(h); /* Step 1: avoid outfixes as we always have to run them. */ avoidOutfixes(vg, cc); if (num_vertices(vg) <= 2) { /* only have an outfix; leave for ng_rose for now */ return false; } removeRedundantPrefixes(vg); dumpPreRoseGraph(vg, cc.grey, "pre_prefix_rose.dot"); /* Step 2: avoid non-transient prefixes (esp in streaming mode) */ findBetterPrefixes(vg, cc); dumpPreRoseGraph(vg, cc.grey, "post_prefix_rose.dot"); extractStrongLiterals(vg, cc); dumpPreRoseGraph(vg, cc.grey, "post_extract_rose.dot"); improveWeakInfixes(vg, cc); dumpPreRoseGraph(vg, cc.grey, "post_infix_rose.dot"); /* Step 3: avoid output exposed engines if there is a strong trailing literal) */ avoidSuffixes(vg, cc); /* Step 4: look for infixes/suffixes with leading .*literals * This can reduce the amount of work a heavily picked literal has to do and * reduce the amount of state used as .* is handled internally to rose. */ lookForDoubleCut(vg, cc); if (cc.streaming) { lookForCleanEarlySplits(vg, cc); decomposeLiteralChains(vg, cc); } /* Step 5: avoid unimplementable, or overly large engines if possible */ /* TODO: later - ng_rose is currently acting as a backstop */ /* Step 6: send to rose */ rehomeEodSuffixes(vg); removeRedundantLiterals(vg, cc); pruneUseless(vg); dumpPreRoseGraph(vg, cc.grey); renumber_vertices(vg); calcVertexOffsets(vg); bool rv = rose.addRose(vg, prefilter); DEBUG_PRINTF("violet: %s\n", rv ? "success" : "fail"); return rv; } } hyperscan-4.4.1/src/nfagraph/ng_som_add_redundancy.cpp0000644000175000017500000001440513055426554023672 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Add redundancy to graph to assist in SOM analysis. * * Currently patterns of the form: * * /(GET|POST).*foo/ * * baffle our SOM analysis as the T's get merged into one by our graph * reductions and they lose the fixed depth property. One way to solve this is * to tell the T vertex to go fork itself before we do the main SOM pass. * * Overall plan: * * 1. build a topo ordering * 2. walk vertices in topo order * 3. fix up vertices where possible * 4. go home * * Vertex fix up plan: * * 1. consider depth of vertex * - if vertex is at fixed depth continue to next vertex * - if vertex can be at an unbounded depth continue to next vertex * - if vertex has a pred which is not a fixed depth continue to next vertex * 2. group preds by their depth * 3. for each group: * - create a clone of the vertex (vertex props and out edges) * - create edges from each vertex in the group to the clone * - work out the depth for the clone * 4. blow away original vertex * * Originally in UE-1862. */ #include "ng_som_add_redundancy.h" #include "ng_dump.h" #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/depth.h" #include "util/graph.h" #include "util/graph_range.h" using namespace std; namespace ue2 { /** \brief Hard limit on the maximum number of new vertices to create. */ static const size_t MAX_NEW_VERTICES = 32; static const DepthMinMax &getDepth(NFAVertex v, const NGHolder &g, const vector &depths) { return depths.at(g[v].index); } static bool hasFloatingPred(NFAVertex v, const NGHolder &g, const vector &depths) { for (auto u : inv_adjacent_vertices_range(v, g)) { const DepthMinMax &d = getDepth(u, g, depths); if (d.min != d.max) { return true; } } return false; } static bool forkVertex(NFAVertex v, NGHolder &g, vector &depths, set &dead, size_t *numNewVertices) { map> predGroups; for (const auto &e : in_edges_range(v, g)) { const DepthMinMax &d = getDepth(source(e, g), g, depths); assert(d.min == d.max); predGroups[d.min].push_back(e); } DEBUG_PRINTF("forking vertex with %zu pred groups\n", predGroups.size()); if (*numNewVertices + predGroups.size() > MAX_NEW_VERTICES) { return false; } *numNewVertices += predGroups.size(); for (auto &group : predGroups) { const depth &predDepth = group.first; const vector &preds = group.second; // Clone v for this depth with all its associated out-edges. u32 clone_idx = depths.size(); // next index to be used NFAVertex clone = add_vertex(g[v], g); depth clone_depth = predDepth + 1; g[clone].index = clone_idx; depths.push_back(DepthMinMax(clone_depth, clone_depth)); DEBUG_PRINTF("cloned vertex %u with depth %s\n", clone_idx, clone_depth.str().c_str()); // Add copies of the out-edges from v. for (const auto &e : out_edges_range(v, g)) { add_edge(clone, target(e, g), g[e], g); } // Add in-edges from preds in this group. for (const auto &e : preds) { add_edge(source(e, g), clone, g[e], g); } } clear_vertex(v, g); dead.insert(v); return true; } bool addSomRedundancy(NGHolder &g, vector &depths) { DEBUG_PRINTF("entry\n"); const vector ordering = getTopoOrdering(g); set dead; size_t numNewVertices = 0; for (auto it = ordering.rbegin(), ite = ordering.rend(); it != ite; ++it) { NFAVertex v = *it; if (is_special(v, g)) { continue; } if (!in_degree(v, g)) { continue; // unreachable, probably killed } const DepthMinMax &d = getDepth(v, g, depths); DEBUG_PRINTF("vertex %zu has depths %s\n", g[v].index, d.str().c_str()); if (d.min == d.max) { DEBUG_PRINTF("fixed depth\n"); continue; } if (d.max.is_unreachable()) { DEBUG_PRINTF("unbounded depth\n"); continue; } if (hasFloatingPred(v, g, depths)) { DEBUG_PRINTF("has floating pred\n"); continue; } if (!forkVertex(v, g, depths, dead, &numNewVertices)) { DEBUG_PRINTF("new vertex limit reached\n"); break; } } assert(numNewVertices <= MAX_NEW_VERTICES); if (dead.empty()) { return false; // no changes made to the graph } remove_vertices(dead, g); return true; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_cyclic_redundancy.cpp0000644000175000017500000001775513055426554023545 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Cyclic Path Redundancy pass. Removes redundant vertices on paths * leading to a cyclic repeat. * * This is a graph reduction pass intended to remove vertices that are * redundant because they lead solely to a cyclic vertex with a superset of * their character reachability. For example, in this pattern: * * /(abc|def|abcghi).*0123/s * * The vertices for 'ghi' can be removed due to the presence of the dot-star * repeat. * * Algorithm: * * for each cyclic vertex V: * for each proper predecessor U of V: * let S be the set of successors of U that are successors of V * (including V itself) * for each successor W of U not in S: * perform a DFS forward from W, stopping exploration when a vertex * in S is encountered; * if a vertex with reach not in reach(V) or an accept is encountered: * fail and continue to the next W. * else: * remove (U, W) * * NOTE: the following code is templated not just for fun, but so that we can * run this analysis both forward and in reverse over the graph. */ #include "ng_cyclic_redundancy.h" #include "ng_holder.h" #include "ng_prune.h" #include "ng_util.h" #include "util/container.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include #include using namespace std; using boost::reverse_graph; namespace ue2 { namespace { // Terminator function for depth first traversal, tells us not to explore // beyond vertices in set S. template class VertexInSet { public: explicit VertexInSet(const flat_set &s) : verts(s) {} bool operator()(const Vertex &v, const Graph&) const { return contains(verts, v); } private: const flat_set &verts; }; struct SearchFailed {}; // Visitor for depth first traversal, throws an error if we encounter a vertex // with bad reach or a report. class SearchVisitor : public boost::default_dfs_visitor { public: explicit SearchVisitor(const CharReach &r) : cr(r) {} template void discover_vertex(const Vertex &v, const Graph &g) const { DEBUG_PRINTF("vertex %zu\n", g[v].index); if (is_special(v, g)) { DEBUG_PRINTF("start or accept\n"); throw SearchFailed(); } if (g[v].assert_flags) { DEBUG_PRINTF("assert flags\n"); throw SearchFailed(); } const CharReach &vcr = g[v].char_reach; if (vcr != (vcr & cr)) { DEBUG_PRINTF("bad reach\n"); throw SearchFailed(); } } private: const CharReach &cr; }; } // namespace template static bool searchForward(const Graph &g, const CharReach &reach, const flat_set &s, typename Graph::vertex_descriptor w) { map colours; try { depth_first_visit(g, w, SearchVisitor(reach), make_assoc_property_map(colours), VertexInSet(s)); } catch (SearchFailed&) { return false; } return true; } static NFAEdge to_raw(const NFAEdge &e, const NGHolder &) { return e; } static NFAEdge to_raw(const reverse_graph::edge_descriptor &e, const reverse_graph &g) { return get(boost::edge_underlying, g, e); } /* returns true if we did stuff */ template static bool removeCyclicPathRedundancy(Graph &g, typename Graph::vertex_descriptor v, NGHolder &raw) { bool did_stuff = false; const CharReach &reach = g[v].char_reach; typedef typename Graph::vertex_descriptor vertex_descriptor; // precalc successors of v. flat_set succ_v; insert(&succ_v, adjacent_vertices(v, g)); flat_set s; for (const auto &e : in_edges_range(v, g)) { vertex_descriptor u = source(e, g); if (u == v) { continue; } if (is_any_accept(u, g)) { continue; } DEBUG_PRINTF("- checking u %zu\n", g[u].index); // let s be intersection(succ(u), succ(v)) s.clear(); for (auto b : adjacent_vertices_range(u, g)) { if (contains(succ_v, b)) { s.insert(b); } } for (const auto &e_u : make_vector_from(out_edges(u, g))) { vertex_descriptor w = target(e_u, g); if (is_special(w, g) || contains(s, w)) { continue; } const CharReach &w_reach = g[w].char_reach; if (!w_reach.isSubsetOf(reach)) { continue; } DEBUG_PRINTF(" - checking w %zu\n", g[w].index); if (!searchForward(g, reach, s, w)) { continue; } DEBUG_PRINTF("removing edge (%zu,%zu)\n", g[u].index, g[w].index); /* we are currently iterating over the in-edges of v, so it would be unwise to remove edges to v. However, */ assert(w != v); /* as v is in s */ remove_edge(to_raw(e_u, g), raw); did_stuff = true; } } return did_stuff; } template static bool cyclicPathRedundancyPass(Graph &g, NGHolder &raw) { bool did_stuff = false; for (auto v : vertices_range(g)) { if (is_special(v, g) || !edge(v, v, g).second) { continue; } DEBUG_PRINTF("examining cyclic vertex %zu\n", g[v].index); did_stuff |= removeCyclicPathRedundancy(g, v, raw); } return did_stuff; } bool removeCyclicPathRedundancy(NGHolder &g) { // Forward pass. bool f_changed = cyclicPathRedundancyPass(g, g); if (f_changed) { DEBUG_PRINTF("edges removed by forward pass\n"); pruneUseless(g); } // Reverse pass. DEBUG_PRINTF("REVERSE PASS\n"); typedef reverse_graph RevGraph; RevGraph revg(g); bool r_changed = cyclicPathRedundancyPass(revg, g); if (r_changed) { DEBUG_PRINTF("edges removed by reverse pass\n"); pruneUseless(g); } return f_changed || r_changed; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_redundancy.h0000644000175000017500000000417213055426554021651 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief NFA graph reductions. */ #ifndef NG_REDUNDANCY_H #define NG_REDUNDANCY_H #include "som/som.h" namespace ue2 { class NGHolder; struct CompileContext; /** Attempt to make the NFA graph \p g smaller by performing a number of local * transformations. */ bool removeRedundancy(NGHolder &g, som_type som); /** UE-524: remove edges into nodes that are dominated by cyclic nodes with * reachability that is a superset of all paths feeding into that edge. Returns * true if any edges/vertices were removed. */ bool removeCyclicDominated(NGHolder &g, som_type som); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_limex_accel.cpp0000644000175000017500000007366613055426554022333 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA acceleration analysis code. */ #include "ng_limex_accel.h" #include "ng_holder.h" #include "ng_misc_opt.h" #include "ng_util.h" #include "ue2common.h" #include "nfa/accel.h" #include "nfa/multiaccel_compilehelper.h" #include "util/bitutils.h" // for CASE_CLEAR #include "util/charreach.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/target_info.h" #include #include using namespace std; namespace ue2 { #define WIDE_FRIEND_MIN 200 static void findAccelFriendGeneration(const NGHolder &g, const CharReach &cr, const flat_set &cands, const flat_set &preds, flat_set *next_cands, flat_set *next_preds, flat_set *friends) { for (auto v : cands) { if (contains(preds, v)) { continue; } const CharReach &acr = g[v].char_reach; DEBUG_PRINTF("checking %zu\n", g[v].index); if (acr.count() < WIDE_FRIEND_MIN || !acr.isSubsetOf(cr)) { DEBUG_PRINTF("bad reach %zu\n", acr.count()); continue; } for (auto u : inv_adjacent_vertices_range(v, g)) { if (!contains(preds, u)) { DEBUG_PRINTF("bad pred\n"); goto next_cand; } } next_preds->insert(v); insert(next_cands, adjacent_vertices(v, g)); DEBUG_PRINTF("%zu is a friend indeed\n", g[v].index); friends->insert(v); next_cand:; } } void findAccelFriends(const NGHolder &g, NFAVertex v, const map &br_cyclic, u32 offset, flat_set *friends) { /* A friend of an accel state is a successor state which can only be on when * the accel is on. This requires that it has a subset of the accel state's * preds and a charreach which is a subset of the accel state. * * A friend can be safely ignored when accelerating provided there is * sufficient back-off. A friend is useful if it has a wide reach. */ /* BR cyclic states which may go stale cannot have friends as they may * suddenly turn off leading their so-called friends stranded and alone. * TODO: restrict to only stale going BR cyclics */ if (contains(br_cyclic, v) && !br_cyclic.at(v).unbounded()) { return; } u32 friend_depth = offset + 1; flat_set preds; insert(&preds, inv_adjacent_vertices(v, g)); const CharReach &cr = g[v].char_reach; flat_set cands; insert(&cands, adjacent_vertices(v, g)); flat_set next_preds; flat_set next_cands; for (u32 i = 0; i < friend_depth; i++) { findAccelFriendGeneration(g, cr, cands, preds, &next_cands, &next_preds, friends); preds.insert(next_preds.begin(), next_preds.end()); next_preds.clear(); cands.swap(next_cands); next_cands.clear(); } } static void findPaths(const NGHolder &g, NFAVertex v, const vector &refined_cr, vector > *paths, const flat_set &forbidden, u32 depth) { static const u32 MAGIC_TOO_WIDE_NUMBER = 16; if (!depth) { paths->push_back(vector()); return; } if (v == g.accept || v == g.acceptEod) { paths->push_back(vector()); if (!generates_callbacks(g) || v == g.acceptEod) { paths->back().push_back(CharReach()); /* red tape options */ } return; } /* for the escape 'literals' we want to use the minimal cr so we * can be more selective */ const CharReach &cr = refined_cr[g[v].index]; if (out_degree(v, g) >= MAGIC_TOO_WIDE_NUMBER || hasSelfLoop(v, g)) { /* give up on pushing past this point */ paths->push_back(vector()); vector &p = paths->back(); p.push_back(cr); return; } for (auto w : adjacent_vertices_range(v, g)) { if (contains(forbidden, w)) { /* path has looped back to one of the active+boring acceleration * states. We can ignore this path if we have sufficient back- * off. */ paths->push_back(vector()); paths->back().push_back(CharReach()); continue; } u32 new_depth = depth - 1; vector > curr; do { curr.clear(); findPaths(g, w, refined_cr, &curr, forbidden, new_depth); } while (new_depth-- && curr.size() >= MAGIC_TOO_WIDE_NUMBER); for (vector >::iterator it = curr.begin(); it != curr.end(); ++it) { paths->push_back(vector()); vector &p = paths->back(); p.swap(*it); p.push_back(cr); } } } struct SAccelScheme { SAccelScheme(const CharReach &cr_in, u32 offset_in) : cr(cr_in), offset(offset_in) { assert(offset <= MAX_ACCEL_DEPTH); } SAccelScheme() {} bool operator<(const SAccelScheme &b) const { const SAccelScheme &a = *this; const size_t a_count = cr.count(), b_count = b.cr.count(); if (a_count != b_count) { return a_count < b_count; } /* TODO: give bonus if one is a 'caseless' character */ ORDER_CHECK(offset); ORDER_CHECK(cr); return false; } CharReach cr = CharReach::dot(); u32 offset = MAX_ACCEL_DEPTH + 1; }; static void findBest(vector >::const_iterator pb, vector >::const_iterator pe, const SAccelScheme &curr, SAccelScheme *best) { assert(curr.offset <= MAX_ACCEL_DEPTH); DEBUG_PRINTF("paths left %zu\n", pe - pb); if (pb == pe) { if (curr < *best) { DEBUG_PRINTF("new best\n"); *best = curr; } *best = curr; return; } DEBUG_PRINTF("p len %zu\n", pb->end() - pb->begin()); vector priority_path; priority_path.reserve(pb->size()); u32 i = 0; for (vector::const_iterator p = pb->begin(); p != pb->end(); ++p, i++) { SAccelScheme as(*p | curr.cr, MAX(i, curr.offset)); if (*best < as) { DEBUG_PRINTF("worse\n"); continue; } priority_path.push_back(move(as)); } sort(priority_path.begin(), priority_path.end()); for (auto it = priority_path.begin(); it != priority_path.end(); ++it) { auto jt = next(it); for (; jt != priority_path.end(); ++jt) { if (!it->cr.isSubsetOf(jt->cr)) { break; } } priority_path.erase(next(it), jt); DEBUG_PRINTF("||%zu\n", it->cr.count()); } DEBUG_PRINTF("---\n"); for (vector::const_iterator it = priority_path.begin(); it != priority_path.end(); ++it) { DEBUG_PRINTF("%u:|| = %zu; p remaining len %zu\n", i, it->cr.count(), priority_path.end() - it); SAccelScheme in = move(*it); if (*best < in) { DEBUG_PRINTF("worse\n"); continue; } findBest(pb + 1, pe, in, best); if (curr.cr == best->cr) { return; /* could only get better by offset */ } } } struct DAccelScheme { DAccelScheme(const CharReach &cr_in, u32 offset_in) : double_cr(cr_in), double_offset(offset_in) { assert(double_offset <= MAX_ACCEL_DEPTH); } bool operator<(const DAccelScheme &b) const { const DAccelScheme &a = *this; size_t a_dcount = a.double_cr.count(); size_t b_dcount = b.double_cr.count(); assert(!a.double_byte.empty() || a_dcount || a.double_offset); assert(!b.double_byte.empty() || b_dcount || b.double_offset); if (a_dcount != b_dcount) { return a_dcount < b_dcount; } if (!a_dcount) { bool cd_a = buildDvermMask(a.double_byte); bool cd_b = buildDvermMask(b.double_byte); if (cd_a != cd_b) { return cd_a > cd_b; } } ORDER_CHECK(double_byte.size()); ORDER_CHECK(double_offset); /* TODO: give bonus if one is a 'caseless' character */ ORDER_CHECK(double_byte); ORDER_CHECK(double_cr); return false; } ue2::flat_set > double_byte; CharReach double_cr; u32 double_offset = 0; }; static DAccelScheme make_double_accel(DAccelScheme as, CharReach cr_1, const CharReach &cr_2_in, u32 offset_in) { cr_1 &= ~as.double_cr; CharReach cr_2 = cr_2_in & ~as.double_cr; u32 offset = offset_in; if (cr_1.none()) { DEBUG_PRINTF("empty first element\n"); ENSURE_AT_LEAST(&as.double_offset, offset); return as; } if (cr_2_in != cr_2 || cr_2.none()) { offset = offset_in + 1; } size_t two_count = cr_1.count() * cr_2.count(); DEBUG_PRINTF("will generate raw %zu pairs\n", two_count); if (!two_count) { DEBUG_PRINTF("empty element\n"); ENSURE_AT_LEAST(&as.double_offset, offset); return as; } if (two_count > DOUBLE_SHUFTI_LIMIT) { if (cr_2.count() < cr_1.count()) { as.double_cr |= cr_2; offset = offset_in + 1; } else { as.double_cr |= cr_1; } } else { for (auto i = cr_1.find_first(); i != CharReach::npos; i = cr_1.find_next(i)) { for (auto j = cr_2.find_first(); j != CharReach::npos; j = cr_2.find_next(j)) { as.double_byte.emplace(i, j); } } } ENSURE_AT_LEAST(&as.double_offset, offset); DEBUG_PRINTF("construct da %zu pairs, %zu singles, offset %u\n", as.double_byte.size(), as.double_cr.count(), as.double_offset); return as; } static void findDoubleBest(vector >::const_iterator pb, vector >::const_iterator pe, const DAccelScheme &curr, DAccelScheme *best) { assert(curr.double_offset <= MAX_ACCEL_DEPTH); DEBUG_PRINTF("paths left %zu\n", pe - pb); DEBUG_PRINTF("current base: %zu pairs, %zu singles, offset %u\n", curr.double_byte.size(), curr.double_cr.count(), curr.double_offset); if (pb == pe) { if (curr < *best) { *best = curr; DEBUG_PRINTF("new best: %zu pairs, %zu singles, offset %u\n", best->double_byte.size(), best->double_cr.count(), best->double_offset); } return; } DEBUG_PRINTF("p len %zu\n", pb->end() - pb->begin()); vector priority_path; priority_path.reserve(pb->size()); u32 i = 0; for (vector::const_iterator p = pb->begin(); p != pb->end() && next(p) != pb->end(); ++p, i++) { DAccelScheme as = make_double_accel(curr, *p, *next(p), i); if (*best < as) { DEBUG_PRINTF("worse\n"); continue; } priority_path.push_back(move(as)); } sort(priority_path.begin(), priority_path.end()); DEBUG_PRINTF("%zu candidates for this path\n", priority_path.size()); DEBUG_PRINTF("input best: %zu pairs, %zu singles, offset %u\n", best->double_byte.size(), best->double_cr.count(), best->double_offset); for (vector::const_iterator it = priority_path.begin(); it != priority_path.end(); ++it) { DAccelScheme in = move(*it); DEBUG_PRINTF("in: %zu pairs, %zu singles, offset %u\n", in.double_byte.size(), in.double_cr.count(), in.double_offset); if (*best < in) { DEBUG_PRINTF("worse\n"); continue; } findDoubleBest(pb + 1, pe, in, best); } } #ifdef DEBUG static void dumpPaths(const vector > &paths) { for (vector >::const_iterator p = paths.begin(); p != paths.end(); ++p) { DEBUG_PRINTF("path: ["); for (vector::const_iterator it = p->begin(); it != p->end(); ++it) { printf(" ["); describeClass(stdout, *it, 20, CC_OUT_TEXT); printf("]"); } printf(" ]\n"); } } #endif static void blowoutPathsLessStrictSegment(vector > &paths) { /* paths segments which are a superset of an earlier segment should never be * picked as an acceleration segment -> to improve processing just replace * with dot */ for (auto &p : paths) { for (auto it = p.begin(); it != p.end(); ++it) { for (auto jt = next(it); jt != p.end(); ++jt) { if (it->isSubsetOf(*jt)) { *jt = CharReach::dot(); } } } } } static void unifyPathsLastSegment(vector > &paths) { /* try to unify paths which only differ in the last segment */ for (vector >::iterator p = paths.begin(); p != paths.end() && p + 1 != paths.end();) { vector &a = *p; vector &b = *(p + 1); if (a.size() != b.size()) { ++p; continue; } u32 i = 0; for (; i < a.size() - 1; i++) { if (a[i] != b[i]) { break; } } if (i == a.size() - 1) { /* we can unify these paths */ a[i] |= b[i]; paths.erase(p + 1); } else { ++p; } } } static void improvePaths(vector > &paths) { #ifdef DEBUG DEBUG_PRINTF("orig paths\n"); dumpPaths(paths); #endif blowoutPathsLessStrictSegment(paths); sort(paths.begin(), paths.end()); unifyPathsLastSegment(paths); #ifdef DEBUG DEBUG_PRINTF("opt paths\n"); dumpPaths(paths); #endif } #define MAX_DOUBLE_ACCEL_PATHS 10 static DAccelScheme findBestDoubleAccelScheme(vector > paths, const CharReach &terminating) { DEBUG_PRINTF("looking for double accel, %zu terminating symbols\n", terminating.count()); unifyPathsLastSegment(paths); #ifdef DEBUG DEBUG_PRINTF("paths:\n"); dumpPaths(paths); #endif /* if there are too many paths, shorten the paths to reduce the number of * distinct paths we have to consider */ while (paths.size() > MAX_DOUBLE_ACCEL_PATHS) { for (auto &p : paths) { if (p.empty()) { return DAccelScheme(terminating, 0U); } p.pop_back(); } unifyPathsLastSegment(paths); } if (paths.empty()) { return DAccelScheme(terminating, 0U); } DAccelScheme curr(terminating, 0U); DAccelScheme best(CharReach::dot(), 0U); findDoubleBest(paths.begin(), paths.end(), curr, &best); DEBUG_PRINTF("da %zu pairs, %zu singles\n", best.double_byte.size(), best.double_cr.count()); return best; } #define MAX_EXPLORE_PATHS 40 AccelScheme findBestAccelScheme(vector > paths, const CharReach &terminating, bool look_for_double_byte) { AccelScheme rv; if (look_for_double_byte) { DAccelScheme da = findBestDoubleAccelScheme(paths, terminating); if (da.double_byte.size() <= DOUBLE_SHUFTI_LIMIT) { rv.double_byte = move(da.double_byte); rv.double_cr = move(da.double_cr); rv.double_offset = da.double_offset; } } improvePaths(paths); DEBUG_PRINTF("we have %zu paths\n", paths.size()); if (paths.size() > MAX_EXPLORE_PATHS) { return rv; /* too many paths to explore */ } /* if we were smart we would do something netflowy on the paths to find the * best cut. But we aren't, so we will just brute force it. */ SAccelScheme curr(terminating, 0U); SAccelScheme best; findBest(paths.begin(), paths.end(), curr, &best); /* find best is a bit lazy in terms of minimising the offset, see if we can * make it better. need to find the min max offset that we need.*/ u32 offset = 0; for (vector >::iterator p = paths.begin(); p != paths.end(); ++p) { u32 i = 0; for (vector::iterator it = p->begin(); it != p->end(); ++it, i++) { if (it->isSubsetOf(best.cr)) { break; } } offset = MAX(offset, i); } assert(offset <= best.offset); best.offset = offset; rv.offset = best.offset; rv.cr = best.cr; if (rv.cr.count() < rv.double_cr.count()) { rv.double_byte.clear(); } return rv; } AccelScheme nfaFindAccel(const NGHolder &g, const vector &verts, const vector &refined_cr, const map &br_cyclic, bool allow_wide, bool look_for_double_byte) { CharReach terminating; for (auto v : verts) { if (!hasSelfLoop(v, g)) { DEBUG_PRINTF("no self loop\n"); return AccelScheme(); /* invalid scheme */ } // check that this state is reachable on most characters terminating |= ~g[v].char_reach; } DEBUG_PRINTF("set vertex has %zu stop chars\n", terminating.count()); size_t limit = allow_wide ? ACCEL_MAX_FLOATING_STOP_CHAR : ACCEL_MAX_STOP_CHAR; if (terminating.count() > limit) { return AccelScheme(); /* invalid scheme */ } vector > paths; flat_set ignore_vert_set(verts.begin(), verts.end()); /* Note: we can not in general (TODO: ignore when possible) ignore entries * into the bounded repeat cyclic states as that is when the magic happens */ for (map::const_iterator it = br_cyclic.begin(); it != br_cyclic.end(); ++it) { /* TODO: can allow if repeatMin <= 1 ? */ ignore_vert_set.erase(it->first); } for (auto v : verts) { for (auto w : adjacent_vertices_range(v, g)) { if (w != v) { findPaths(g, w, refined_cr, &paths, ignore_vert_set, MAX_ACCEL_DEPTH); } } } /* paths built wrong: reverse them */ for (vector >::iterator it = paths.begin(); it != paths.end(); ++it) { reverse(it->begin(), it->end()); } return findBestAccelScheme(std::move(paths), terminating, look_for_double_byte); } NFAVertex get_sds_or_proxy(const NGHolder &g) { DEBUG_PRINTF("looking for sds proxy\n"); if (proper_out_degree(g.startDs, g)) { return g.startDs; } NFAVertex v = NGHolder::null_vertex(); for (auto w : adjacent_vertices_range(g.start, g)) { if (w != g.startDs) { if (!v) { v = w; } else { return g.startDs; } } } if (!v) { return g.startDs; } while (true) { if (hasSelfLoop(v, g)) { DEBUG_PRINTF("woot %zu\n", g[v].index); return v; } if (out_degree(v, g) != 1) { break; } NFAVertex u = getSoleDestVertex(g, v); if (!g[u].char_reach.all()) { break; } v = u; } return g.startDs; } static NFAVertex find_next(const NFAVertex v, const NGHolder &g) { NFAVertex res = NGHolder::null_vertex(); for (NFAVertex u : adjacent_vertices_range(v, g)) { if (u != v) { res = u; break; } } return res; } /** \brief Check if vertex \a v is a multi accelerable state (for a limex NFA). */ MultibyteAccelInfo nfaCheckMultiAccel(const NGHolder &g, const vector &states, const CompileContext &cc) { // For a set of states to be accelerable, we basically have to have only // one state to accelerate. if (states.size() != 1) { DEBUG_PRINTF("can't accelerate multiple states\n"); return MultibyteAccelInfo(); } // Get our base vertex NFAVertex v = states[0]; // We need the base vertex to be a self-looping dotall leading to exactly // one vertex. if (!hasSelfLoop(v, g)) { DEBUG_PRINTF("base vertex has self-loop\n"); return MultibyteAccelInfo(); } if (!g[v].char_reach.all()) { DEBUG_PRINTF("can't accelerate anything but dot\n"); return MultibyteAccelInfo(); } if (proper_out_degree(v, g) != 1) { DEBUG_PRINTF("can't accelerate states with multiple successors\n"); return MultibyteAccelInfo(); } // find our start vertex NFAVertex cur = find_next(v, g); if (cur == NGHolder::null_vertex()) { DEBUG_PRINTF("invalid start vertex\n"); return MultibyteAccelInfo(); } bool has_offset = false; u32 offset = 0; CharReach cr = g[cur].char_reach; // if we start with a dot, we have an offset, so defer figuring out the // real CharReach for this accel scheme if (cr == CharReach::dot()) { has_offset = true; offset = 1; } // figure out our offset while (has_offset) { // vertices have to have no self loops if (hasSelfLoop(cur, g)) { DEBUG_PRINTF("can't have self-loops\n"); return MultibyteAccelInfo(); } // we have to have exactly 1 successor to have this acceleration scheme if (out_degree(cur, g) != 1) { DEBUG_PRINTF("can't have multiple successors\n"); return MultibyteAccelInfo(); } cur = *adjacent_vertices(cur, g).first; // if we met a special vertex, bail out if (is_special(cur, g)) { DEBUG_PRINTF("can't have special vertices\n"); return MultibyteAccelInfo(); } // now, get the real char reach if (g[cur].char_reach != CharReach::dot()) { cr = g[cur].char_reach; has_offset = false; } else { offset++; } } // now, fire up the compilation machinery target_t ti = cc.target_info; unsigned max_len = ti.has_avx2() ? MULTIACCEL_MAX_LEN_AVX2 : MULTIACCEL_MAX_LEN_SSE; MultiaccelCompileHelper mac(cr, offset, max_len); while (mac.canAdvance()) { // vertices have to have no self loops if (hasSelfLoop(cur, g)) { break; } // we have to have exactly 1 successor to have this acceleration scheme if (out_degree(cur, g) != 1) { break; } cur = *adjacent_vertices(cur, g).first; // if we met a special vertex, bail out if (is_special(cur, g)) { break; } mac.advance(g[cur].char_reach); } MultibyteAccelInfo mai = mac.getBestScheme(); #ifdef DEBUG DEBUG_PRINTF("Multibyte acceleration scheme: type: %u offset: %u lengths: %u,%u\n", mai.type, mai.offset, mai.len1, mai.len2); for (size_t c = mai.cr.find_first(); c != CharReach::npos; c = mai.cr.find_next(c)) { DEBUG_PRINTF("multibyte accel char: %zu\n", c); } #endif return mai; } /** \brief Check if vertex \a v is an accelerable state (for a limex NFA). */ bool nfaCheckAccel(const NGHolder &g, NFAVertex v, const vector &refined_cr, const map &br_cyclic, AccelScheme *as, bool allow_wide) { // For a state to be accelerable, our current criterion is that it be a // large character class with a self-loop and narrow set of possible other // successors (i.e. no special successors, union of successor reachability // is small). if (!hasSelfLoop(v, g)) { return false; } // check that this state is reachable on most characters /* we want to use the maximal reach here (in the graph) */ CharReach terminating = g[v].char_reach; terminating.flip(); DEBUG_PRINTF("vertex %zu is cyclic and has %zu stop chars%s\n", g[v].index, terminating.count(), allow_wide ? " (w)" : ""); size_t limit = allow_wide ? ACCEL_MAX_FLOATING_STOP_CHAR : ACCEL_MAX_STOP_CHAR; if (terminating.count() > limit) { DEBUG_PRINTF("too leaky\n"); return false; } flat_set curr, next; insert(&curr, adjacent_vertices(v, g)); curr.erase(v); // erase self-loop // We consider offsets of zero through three; this is fairly arbitrary at // present and could probably be increased (FIXME) /* WARNING: would/could do horrible things to compile time */ bool stop = false; vector depthReach(MAX_ACCEL_DEPTH); unsigned int depth; for (depth = 0; !stop && depth < MAX_ACCEL_DEPTH; depth++) { CharReach &cr = depthReach[depth]; for (auto t : curr) { if (is_special(t, g)) { // We've bumped into the edge of the graph, so we should stop // searching. // Exception: iff our cyclic state is not a dot, than we can // safely accelerate towards an EOD accept. /* Exception: nfas that don't generate callbacks so accepts are * fine too */ if (t == g.accept && !generates_callbacks(g)) { stop = true; // don't search beyond this depth continue; } else if (t == g.accept) { goto depth_done; } assert(t == g.acceptEod); stop = true; // don't search beyond this depth } else { // Non-special vertex insert(&next, adjacent_vertices(t, g)); /* for the escape 'literals' we want to use the minimal cr so we * can be more selective */ cr |= refined_cr[g[t].index]; } } cr |= terminating; DEBUG_PRINTF("depth %u has unioned reach %zu\n", depth, cr.count()); curr.swap(next); next.clear(); } depth_done: if (depth == 0) { return false; } DEBUG_PRINTF("selecting from depth 0..%u\n", depth); /* Look for the most awesome acceleration evar */ for (unsigned int i = 0; i < depth; i++) { if (depthReach[i].none()) { DEBUG_PRINTF("red tape acceleration engine depth %u\n", i); *as = AccelScheme(); as->offset = i; as->cr = CharReach(); return true; } } // First, loop over our depths and see if we have a suitable 2-byte // caseful vermicelli option: this is the (second) fastest accel we have if (depth > 1) { for (unsigned int i = 0; i < (depth - 1); i++) { const CharReach &cra = depthReach[i]; const CharReach &crb = depthReach[i + 1]; if ((cra.count() == 1 && crb.count() == 1) || (cra.count() == 2 && crb.count() == 2 && cra.isBit5Insensitive() && crb.isBit5Insensitive())) { DEBUG_PRINTF("two-byte vermicelli, depth %u\n", i); *as = AccelScheme(); as->offset = i; return true; } } } // Second option: a two-byte shufti (i.e. less than eight 2-byte // literals) if (depth > 1) { for (unsigned int i = 0; i < (depth - 1); i++) { if (depthReach[i].count() * depthReach[i+1].count() <= DOUBLE_SHUFTI_LIMIT) { DEBUG_PRINTF("two-byte shufti, depth %u\n", i); *as = AccelScheme(); as->offset = i; return true; } } } // Look for offset accel schemes verm/shufti; vector verts(1, v); *as = nfaFindAccel(g, verts, refined_cr, br_cyclic, allow_wide, true); DEBUG_PRINTF("as width %zu\n", as->cr.count()); return as->cr.count() <= ACCEL_MAX_STOP_CHAR || allow_wide; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_uncalc_components.h0000644000175000017500000000513713055426554023231 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA graph merging ("uncalc") */ #ifndef NG_UNCALC_COMPONENTS_H #define NG_UNCALC_COMPONENTS_H #include #include namespace ue2 { struct CompileContext; struct Grey; class NGHolder; class ReportManager; /** * \brief Returns the common prefix length for a pair of graphs. * * The CPL is calculated based the topological ordering given by the state * indices for each graph. */ u32 commonPrefixLength(const NGHolder &ga, const NGHolder &gb); /** * \brief Merge the group of graphs in \p cluster where possible. * * The (from, to) mapping of merged graphs is returned. */ std::map mergeNfaCluster(const std::vector &cluster, const ReportManager *rm, const CompileContext &cc); /** * \brief Merge graph \p ga into graph \p gb. * * Returns false on failure. On success, \p gb is reduced via \ref * reduceImplementableGraph and renumbered. */ bool mergeNfaPair(const NGHolder &ga, NGHolder &gb, const ReportManager *rm, const CompileContext &cc); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_vacuous.cpp0000644000175000017500000001102313055426554021526 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Build code for vacuous graphs. */ #include "ng_vacuous.h" #include "grey.h" #include "ng.h" #include "ng_util.h" using namespace std; namespace ue2 { static ReportID getInternalId(ReportManager &rm, const NGWrapper &graph) { Report ir = rm.getBasicInternalReport(graph); // Apply any extended params. if (graph.min_offset || graph.max_offset != MAX_OFFSET) { ir.minOffset = graph.min_offset; ir.maxOffset = graph.max_offset; } assert(!graph.min_length); // should be handled elsewhere. return rm.getInternalId(ir); } static void makeFirehose(BoundaryReports &boundary, ReportManager &rm, NGWrapper &g) { const ReportID r = getInternalId(rm, g); boundary.report_at_0_eod.insert(r); boundary.report_at_0.insert(r); // Replace the graph with a '.+'. clear_graph(g); clearReports(g); remove_edge(g.start, g.accept, g); remove_edge(g.start, g.acceptEod, g); remove_edge(g.startDs, g.accept, g); remove_edge(g.startDs, g.acceptEod, g); NFAVertex v = add_vertex(g); g[v].char_reach.setall(); g[v].reports.insert(r); add_edge(v, v, g); add_edge(g.start, v, g); add_edge(g.startDs, v, g); add_edge(v, g.accept, g); } static void makeAnchoredAcceptor(BoundaryReports &boundary, ReportManager &rm, NGWrapper &g) { boundary.report_at_0.insert(getInternalId(rm, g)); remove_edge(g.start, g.accept, g); remove_edge(g.start, g.acceptEod, g); g[g.start].reports.clear(); } static void makeEndAnchoredAcceptor(BoundaryReports &boundary, ReportManager &rm, NGWrapper &g) { boundary.report_at_eod.insert(getInternalId(rm, g)); remove_edge(g.startDs, g.acceptEod, g); remove_edge(g.start, g.acceptEod, g); g[g.start].reports.clear(); g[g.startDs].reports.clear(); } static void makeNothingAcceptor(BoundaryReports &boundary, ReportManager &rm, NGWrapper &g) { boundary.report_at_0_eod.insert(getInternalId(rm, g)); remove_edge(g.start, g.acceptEod, g); g[g.start].reports.clear(); } bool splitOffVacuous(BoundaryReports &boundary, ReportManager &rm, NGWrapper &g) { if (edge(g.startDs, g.accept, g).second) { // e.g. '.*'; match "between" every byte DEBUG_PRINTF("graph is firehose\n"); makeFirehose(boundary, rm, g); return true; } bool work_done = false; if (edge(g.start, g.accept, g).second) { DEBUG_PRINTF("creating anchored acceptor\n"); makeAnchoredAcceptor(boundary, rm, g); work_done = true; } if (edge(g.startDs, g.acceptEod, g).second) { DEBUG_PRINTF("creating end-anchored acceptor\n"); makeEndAnchoredAcceptor(boundary, rm, g); work_done = true; } if (edge(g.start, g.acceptEod, g).second) { DEBUG_PRINTF("creating nothing acceptor\n"); makeNothingAcceptor(boundary, rm, g); work_done = true; } return work_done; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_rose.h0000644000175000017500000000624413055426554020467 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose construction from NGHolder. */ #ifndef NG_ROSE_H #define NG_ROSE_H #include "ng_holder.h" #include "ue2common.h" #include namespace ue2 { class NGHolder; class ReportManager; class RoseBuild; struct CompileContext; struct ue2_literal; /** \brief Attempt to consume the entire pattern in graph \a h with Rose. * Returns true if successful. */ bool splitOffRose(RoseBuild &rose, const NGHolder &h, bool prefilter, const CompileContext &cc); /** \brief Attempt to consume the entire pattern in graph \a h with Rose. * This is the last attempt to handle a pattern before we resort to an outfix. * Returns true if successful. */ bool finalChanceRose(RoseBuild &rose, const NGHolder &h, bool prefilter, const CompileContext &cc); /** \brief True if the pattern in \a h is consumable by Rose. This function * may be conservative (return false even if supported) for efficiency. */ bool checkRose(const ReportManager &rm, const NGHolder &h, bool prefilter, const CompileContext &cc); /** \brief Returns the delay or MO_INVALID_IDX if the graph cannot match with * the trailing literal. */ u32 removeTrailingLiteralStates(NGHolder &g, const ue2_literal &lit, u32 max_delay, bool overhang_ok = true); void restoreTrailingLiteralStates(NGHolder &g, const ue2_literal &lit, u32 delay); void restoreTrailingLiteralStates(NGHolder &g, const ue2_literal &lit, u32 delay, const std::vector &preds); } // namespace ue2 #endif // NG_ROSE_H hyperscan-4.4.1/src/nfagraph/ng_vacuous.h0000644000175000017500000000362313055426554021202 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Build code for vacuous graphs. */ #ifndef NG_VACUOUS_H #define NG_VACUOUS_H namespace ue2 { struct BoundaryReports; class NGWrapper; class ReportManager; // Returns true if a "vacuous" reporter was created. bool splitOffVacuous(BoundaryReports &boundary, ReportManager &rm, NGWrapper &graph); } // namespace ue2 #endif // NG_VACUOUS_H hyperscan-4.4.1/src/nfagraph/ng_region_redundancy.h0000644000175000017500000000364113055426554023214 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Region Redundancy optimisation pass. * * Identifies and removes entire regions that are adjacent to a cyclic state * with a superset of their character reachability. */ #ifndef NG_REGION_REDUNDANCY_H #define NG_REGION_REDUNDANCY_H #include "som/som.h" namespace ue2 { class NGHolder; void removeRegionRedundancy(NGHolder &g, som_type som); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_prune.cpp0000644000175000017500000003317613055426554021207 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Functions for pruning unreachable vertices or reports from the graph. */ #include "ng_prune.h" #include "ng_dominators.h" #include "ng_holder.h" #include "ng_reports.h" #include "ng_util.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/report_manager.h" #include #include #include #include using namespace std; using boost::default_color_type; using boost::reverse_graph; namespace ue2 { /** Remove any vertices that can't be reached by traversing the graph in * reverse from acceptEod. */ void pruneUnreachable(NGHolder &g) { deque dead; if (in_degree(g.acceptEod, g) == 1 && !in_degree(g.accept, g) && edge(g.accept, g.acceptEod, g).second) { // Trivial case: there are no in-edges to our accepts (other than // accept->acceptEod), so all non-specials are unreachable. for (auto v : vertices_range(g)) { if (!is_special(v, g)) { dead.push_back(v); } } } else { // Walk a reverse graph from acceptEod with Boost's depth_first_visit // call. typedef reverse_graph RevNFAGraph; RevNFAGraph revg(g); map colours; depth_first_visit(revg, g.acceptEod, make_dfs_visitor(boost::null_visitor()), make_assoc_property_map(colours)); DEBUG_PRINTF("color map has %zu entries after DFV\n", colours.size()); // All non-special vertices that aren't in the colour map (because they // weren't reached) can be removed. for (auto v : vertices_range(revg)) { if (is_special(v, revg)) { continue; } if (!contains(colours, v)) { dead.push_back(v); } } } if (dead.empty()) { DEBUG_PRINTF("no unreachable vertices\n"); return; } remove_vertices(dead, g, false); DEBUG_PRINTF("removed %zu unreachable vertices\n", dead.size()); } template static bool pruneForwardUseless(NGHolder &h, const nfag_t &g, typename nfag_t::vertex_descriptor s, vector &vertexColor) { // Begin with all vertices set to white, as DFV only marks visited // vertices. fill(vertexColor.begin(), vertexColor.end(), boost::white_color); auto index_map = get(&NFAGraphVertexProps::index, g); depth_first_visit(g, s, make_dfs_visitor(boost::null_visitor()), make_iterator_property_map(vertexColor.begin(), index_map)); vector dead; // All non-special vertices that are still white can be removed. for (auto v : vertices_range(g)) { u32 idx = g[v].index; if (!is_special(v, g) && vertexColor[idx] == boost::white_color) { DEBUG_PRINTF("vertex %zu is unreachable from %zu\n", g[v].index, g[s].index); dead.push_back(NFAVertex(v)); } } if (dead.empty()) { return false; } DEBUG_PRINTF("removing %zu vertices\n", dead.size()); remove_vertices(dead, h, false); return true; } /** Remove any vertices which can't be reached by traversing the graph forward * from start or in reverse from acceptEod. If \p renumber is false, no * vertex/edge renumbering is done. */ void pruneUseless(NGHolder &g, bool renumber) { DEBUG_PRINTF("pruning useless vertices\n"); assert(hasCorrectlyNumberedVertices(g)); vector vertexColor(num_vertices(g)); bool work_done = pruneForwardUseless(g, g, g.start, vertexColor); work_done |= pruneForwardUseless(g, reverse_graph(g), g.acceptEod, vertexColor); if (!work_done) { return; } if (renumber) { renumber_edges(g); renumber_vertices(g); } } /** This code removes any vertices which do not accept any symbols. Any * vertices which no longer lie on a path from a start to an accept are also * pruned. */ void pruneEmptyVertices(NGHolder &g) { DEBUG_PRINTF("pruning empty vertices\n"); vector dead; for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } const CharReach &cr = g[v].char_reach; if (cr.none()) { DEBUG_PRINTF("empty: %zu\n", g[v].index); dead.push_back(v); } } if (dead.empty()) { return; } remove_vertices(dead, g); pruneUseless(g); } /** Remove any edges from vertices that generate accepts (for Highlander * graphs). */ void pruneHighlanderAccepts(NGHolder &g, const ReportManager &rm) { // Safety check: all reports must be simple exhaustible reports, or this is // not safe. This optimisation should be called early enough that no // internal reports have been added. for (auto report_id : all_reports(g)) { const Report &ir = rm.getReport(report_id); if (ir.ekey == INVALID_EKEY || ir.hasBounds() || !isExternalReport(ir)) { DEBUG_PRINTF("report %u is not external highlander with " "no bounds\n", report_id); return; } } vector dead; for (auto u : inv_adjacent_vertices_range(g.accept, g)) { if (is_special(u, g)) { continue; } // We can prune any out-edges that aren't accepts for (const auto &e : out_edges_range(u, g)) { if (!is_any_accept(target(e, g), g)) { dead.push_back(e); } } } if (dead.empty()) { return; } DEBUG_PRINTF("found %zu removable edges due to single match\n", dead.size()); remove_edges(dead, g); pruneUseless(g); } static bool isDominatedByReporter(const NGHolder &g, const ue2::unordered_map &dom, NFAVertex v, ReportID report_id) { for (auto it = dom.find(v); it != end(dom); it = dom.find(v)) { NFAVertex u = it->second; // Note: reporters with edges only to acceptEod are not considered to // dominate. if (edge(u, g.accept, g).second && contains(g[u].reports, report_id)) { DEBUG_PRINTF("%zu is dominated by %zu, and both report %u\n", g[v].index, g[u].index, report_id); return true; } v = u; } return false; } /** * True if the vertex has (a) a self-loop, (b) only out-edges to accept and * itself and (c) only simple exhaustible reports. */ static bool hasOnlySelfLoopAndExhaustibleAccepts(const NGHolder &g, const ReportManager &rm, NFAVertex v) { if (!edge(v, v, g).second) { return false; } for (auto w : adjacent_vertices_range(v, g)) { if (w != v && w != g.accept) { return false; } } for (const auto &report_id : g[v].reports) { if (!isSimpleExhaustible(rm.getReport(report_id))) { return false; } } return true; } void pruneHighlanderDominated(NGHolder &g, const ReportManager &rm) { vector reporters; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { for (const auto &report_id : g[v].reports) { const Report &r = rm.getReport(report_id); if (isSimpleExhaustible(r)) { reporters.push_back(v); break; } } } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { for (const auto &report_id : g[v].reports) { const Report &r = rm.getReport(report_id); if (isSimpleExhaustible(r)) { reporters.push_back(v); break; } } } if (reporters.empty()) { return; } sort(begin(reporters), end(reporters)); reporters.erase(unique(begin(reporters), end(reporters)), end(reporters)); DEBUG_PRINTF("%zu vertices have simple exhaustible reports\n", reporters.size()); const auto &dom = findDominators(g); bool modified = false; // If a reporter vertex is dominated by another with the same report, we // can remove that report; if all reports are removed, we can remove the // vertex entirely. for (const auto v : reporters) { const auto reports = g[v].reports; // copy, as we're going to mutate for (const auto &report_id : reports) { if (!isSimpleExhaustible(rm.getReport(report_id))) { continue; } if (isDominatedByReporter(g, dom, v, report_id)) { DEBUG_PRINTF("removed dominated report %u from vertex %zu\n", report_id, g[v].index); g[v].reports.erase(report_id); } } if (g[v].reports.empty()) { DEBUG_PRINTF("removed edges to accepts from %zu, no reports left\n", g[v].index); remove_edge(v, g.accept, g); remove_edge(v, g.acceptEod, g); modified = true; } } // If a reporter vertex has a self-loop, but otherwise only leads to accept // (note: NOT acceptEod) and has simple exhaustible reports, we can delete // the self-loop. for (const auto v : reporters) { if (hasOnlySelfLoopAndExhaustibleAccepts(g, rm, v)) { remove_edge(v, v, g); modified = true; DEBUG_PRINTF("removed self-loop on %zu\n", g[v].index); } } if (!modified) { return; } pruneUseless(g); // We may have only removed self-loops, in which case pruneUseless wouldn't // renumber, so we do edge renumbering explicitly here. renumber_edges(g); } /** Removes the given Report ID from vertices connected to accept, and then * prunes useless vertices that have had their report sets reduced to empty. */ void pruneReport(NGHolder &g, ReportID report) { set dead; for (const auto &e : in_edges_range(g.accept, g)) { NFAVertex u = source(e, g); auto &reports = g[u].reports; if (contains(reports, report)) { reports.erase(report); if (reports.empty()) { dead.insert(e); } } } for (const auto &e : in_edges_range(g.acceptEod, g)) { NFAVertex u = source(e, g); if (u == g.accept) { continue; } auto &reports = g[u].reports; if (contains(reports, report)) { reports.erase(report); if (reports.empty()) { dead.insert(e); } } } if (dead.empty()) { return; } remove_edges(dead, g); pruneUnreachable(g); renumber_vertices(g); renumber_edges(g); } /** Removes all Report IDs bar the given one from vertices connected to accept, * and then prunes useless vertices that have had their report sets reduced to * empty. */ void pruneAllOtherReports(NGHolder &g, ReportID report) { set dead; for (const auto &e : in_edges_range(g.accept, g)) { NFAVertex u = source(e, g); auto &reports = g[u].reports; if (contains(reports, report)) { reports.clear(); reports.insert(report); } else { reports.clear(); dead.insert(e); } } for (const auto &e : in_edges_range(g.acceptEod, g)) { NFAVertex u = source(e, g); if (u == g.accept) { continue; } auto &reports = g[u].reports; if (contains(reports, report)) { reports.clear(); reports.insert(report); } else { reports.clear(); dead.insert(e); } } if (dead.empty()) { return; } remove_edges(dead, g); pruneUnreachable(g); renumber_vertices(g); renumber_edges(g); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_som.cpp0000644000175000017500000031441513055426554020652 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief SOM ("Start of Match") analysis. */ #include "ng.h" #include "ng_dump.h" #include "ng_equivalence.h" #include "ng_execute.h" #include "ng_haig.h" #include "ng_limex.h" #include "ng_literal_analysis.h" #include "ng_prune.h" #include "ng_redundancy.h" #include "ng_region.h" #include "ng_reports.h" #include "ng_rose.h" #include "ng_som.h" #include "ng_som_add_redundancy.h" #include "ng_som_util.h" #include "ng_split.h" #include "ng_util.h" #include "ng_width.h" #include "grey.h" #include "ue2common.h" #include "nfa/goughcompile.h" #include "nfa/nfa_internal.h" // for MO_INVALID_IDX #include "parser/position.h" #include "som/som.h" #include "rose/rose_build.h" #include "rose/rose_in_util.h" #include "util/alloc.h" #include "util/compare.h" #include "util/compile_error.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/make_unique.h" #include #include #include using namespace std; namespace ue2 { static const size_t MAX_SOM_PLANS = 10; static const size_t MAX_SOMBE_CHAIN_VERTICES = 4000; #define MAX_REV_NFA_PREFIX 80 namespace { struct som_plan { som_plan(const shared_ptr &p, const CharReach &e, bool i, u32 parent_in) : prefix(p), escapes(e), is_reset(i), no_implement(false), parent(parent_in) { } shared_ptr prefix; CharReach escapes; bool is_reset; bool no_implement; u32 parent; // index of parent plan in the vector. // Reporters: a list of vertices in the graph that must be have their // reports updated at implementation time to report this plan's // som_loc_out. vector reporters; // Similar, but these report the som_loc_in. vector reporters_in; }; } static bool regionCanEstablishSom(const NGHolder &g, const ue2::unordered_map ®ions, const u32 region, const vector &r_exits, const vector &depths) { if (region == regions.at(g.accept) || region == regions.at(g.acceptEod)) { DEBUG_PRINTF("accept in region\n"); return false; } DEBUG_PRINTF("region %u\n", region); for (UNUSED auto v : r_exits) { DEBUG_PRINTF(" exit %zu\n", g[v].index); } /* simple if each region exit is at fixed distance from SOM. Note SOM does not include virtual starts */ for (auto v : r_exits) { assert(regions.at(v) == region); const DepthMinMax &d = depths.at(g[v].index); if (d.min != d.max) { DEBUG_PRINTF("failing %zu as %s != %s\n", g[v].index, d.min.str().c_str(), d.max.str().c_str()); return false; } } DEBUG_PRINTF("region %u/%zu is good\n", regions.at(r_exits[0]), g[r_exits[0]].index); return true; } namespace { struct region_info { region_info() : optional(false), dag(false) {} vector enters; vector exits; vector full; bool optional; /* skip edges around region */ bool dag; /* completely acyclic */ }; } static void buildRegionMapping(const NGHolder &g, const ue2::unordered_map ®ions, map &info, bool include_region_0 = false) { for (auto v : vertices_range(g)) { u32 region = regions.at(v); if (!include_region_0 && (is_any_start(v, g) || region == 0)) { continue; } assert(!region || !is_any_start(v, g)); if (is_any_accept(v, g)) { continue; } if (isRegionEntry(g, v, regions)) { info[region].enters.push_back(v); } if (isRegionExit(g, v, regions)) { info[region].exits.push_back(v); } info[region].full.push_back(v); } for (auto &m : info) { if (!m.second.enters.empty() && isOptionalRegion(g, m.second.enters.front(), regions)) { m.second.optional = true; } m.second.dag = true; /* will be cleared for cyclic regions later */ } set be; BackEdges > backEdgeVisitor(be); boost::depth_first_search(g, visitor(backEdgeVisitor).root_vertex(g.start)); for (const auto &e : be) { NFAVertex u = source(e, g); NFAVertex v = target(e, g); if (is_special(u, g) || is_special(v, g)) { assert(is_special(u, g) && is_special(v, g)); continue; } u32 r = regions.at(v); assert(regions.at(u) == r); info[r].dag = false; } if (include_region_0) { info[0].dag = false; } #ifdef DEBUG for (const auto &m : info) { u32 r = m.first; const region_info &r_i = m.second; DEBUG_PRINTF("region %u:%s%s\n", r, r_i.dag ? " (dag)" : "", r_i.optional ? " (optional)" : ""); DEBUG_PRINTF(" enters:"); for (u32 i = 0; i < r_i.enters.size(); i++) { printf(" %zu", g[r_i.enters[i]].index); } printf("\n"); DEBUG_PRINTF(" exits:"); for (u32 i = 0; i < r_i.exits.size(); i++) { printf(" %zu", g[r_i.exits[i]].index); } printf("\n"); DEBUG_PRINTF(" all:"); for (u32 i = 0; i < r_i.full.size(); i++) { printf(" %zu", g[r_i.full[i]].index); } printf("\n"); } #endif } static bool validateXSL(const NGHolder &g, const ue2::unordered_map ®ions, const u32 region, const CharReach &escapes, u32 *bad_region) { /* need to check that the escapes escape all of the graph past region */ u32 first_bad_region = ~0U; for (auto v : vertices_range(g)) { u32 v_region = regions.at(v); if (!is_special(v, g) && v_region > region && (escapes & g[v].char_reach).any()) { DEBUG_PRINTF("problem with escapes for %zu\n", g[v].index); first_bad_region = MIN(first_bad_region, v_region); } } if (first_bad_region != ~0U) { *bad_region = first_bad_region; return false; } return true; } static bool validateEXSL(const NGHolder &g, const ue2::unordered_map ®ions, const u32 region, const CharReach &escapes, const NGHolder &prefix, u32 *bad_region) { /* EXSL: To be a valid EXSL with escapes e, we require that all states * go dead after /[e][^e]*{subsequent prefix match}/. */ /* TODO: this is overly conservative as it allow partial matches from the * prefix to be considered even when the tail has processed some [^e] */ u32 first_bad_region = ~0U; const vector escapes_vec(1, escapes); const vector notescapes_vec(1, ~escapes); ue2::flat_set states; /* turn on all states past the prefix */ DEBUG_PRINTF("region %u is cutover\n", region); for (auto v : vertices_range(g)) { if (!is_special(v, g) && regions.at(v) > region) { states.insert(v); } } /* process the escapes */ states = execute_graph(g, escapes_vec, states); /* flood with any number of not escapes */ ue2::flat_set prev_states; while (prev_states != states) { prev_states = states; states = execute_graph(g, notescapes_vec, states); insert(&states, prev_states); } /* find input starts to use for when we are running the prefix through as * when the escape character arrives we may be in matching the prefix * already */ ue2::flat_set prefix_start_states; for (auto v : vertices_range(prefix)) { if (v != prefix.accept && v != prefix.acceptEod /* and as we have already made it past the prefix once */ && v != prefix.start) { prefix_start_states.insert(v); } } prefix_start_states = execute_graph(prefix, escapes_vec, prefix_start_states); assert(contains(prefix_start_states, prefix.startDs)); /* see what happens after we feed it the prefix */ states = execute_graph(g, prefix, prefix_start_states, states); for (auto v : states) { assert(v != g.accept && v != g.acceptEod); /* no cr -> should never be * on */ DEBUG_PRINTF("state still active\n"); first_bad_region = MIN(first_bad_region, regions.at(v)); } if (first_bad_region != ~0U) { *bad_region = first_bad_region; return false; } return true; } static bool isPossibleLock(const NGHolder &g, map::const_iterator region, const map &info, CharReach *escapes_out) { /* TODO: we could also check for self-loops on curr region */ /* TODO: some straw-walking logic. lowish priority has we know there can * only be optional regions between us and the cyclic */ assert(region != info.end()); map::const_iterator next_region = region; ++next_region; if (next_region == info.end()) { assert(0); /* odd */ return false; } const region_info &next_info = next_region->second; if (next_info.enters.empty()) { assert(0); /* odd */ return false; } if (next_info.full.size() == 1 && !next_info.dag) { *escapes_out = ~g[next_info.full.front()].char_reach; return true; } return false; } static unique_ptr makePrefix(const NGHolder &g, const ue2::unordered_map ®ions, const region_info &curr, const region_info &next, bool renumber = true) { const vector &curr_exits = curr.exits; const vector &next_enters = next.enters; assert(!next_enters.empty()); assert(!curr_exits.empty()); unique_ptr prefix_ptr = ue2::make_unique(); NGHolder &prefix = *prefix_ptr; deque lhs_verts; insert(&lhs_verts, lhs_verts.end(), vertices(g)); ue2::unordered_map lhs_map; // g -> prefix fillHolder(&prefix, g, lhs_verts, &lhs_map); prefix.kind = NFA_OUTFIX; // We need a reverse mapping to track regions. ue2::unordered_map rev_map; // prefix -> g for (const auto &e : lhs_map) { rev_map.emplace(e.second, e.first); } clear_in_edges(prefix.accept, prefix); clear_in_edges(prefix.acceptEod, prefix); add_edge(prefix.accept, prefix.acceptEod, prefix); assert(!next_enters.empty()); assert(next_enters.front() != NGHolder::null_vertex()); u32 dead_region = regions.at(next_enters.front()); DEBUG_PRINTF("curr_region %u, dead_region %u\n", regions.at(curr_exits.front()), dead_region); for (auto v : inv_adjacent_vertices_range(next_enters.front(), g)) { if (regions.at(v) >= dead_region) { continue; } /* add edge to new accepts */ NFAVertex p_v = lhs_map[v]; add_edge(p_v, prefix.accept, prefix); } assert(in_degree(prefix.accept, prefix) != 0); /* prune everything past the picked region */ vector to_clear; assert(contains(lhs_map, curr_exits.front())); NFAVertex p_u = lhs_map[curr_exits.front()]; DEBUG_PRINTF("p_u: %zu\n", prefix[p_u].index); for (auto p_v : adjacent_vertices_range(p_u, prefix)) { auto v = rev_map.at(p_v); if (p_v == prefix.accept || regions.at(v) < dead_region) { continue; } to_clear.push_back(p_v); } for (auto v : to_clear) { DEBUG_PRINTF("clearing in_edges on %zu\n", prefix[v].index); clear_in_edges(v, prefix); } pruneUseless(prefix, renumber /* sometimes we want no renumber to keep depth map valid */); assert(num_vertices(prefix) > N_SPECIALS); return prefix_ptr; } static void replaceTempSomSlot(ReportManager &rm, NGHolder &g, u32 real_slot) { const u32 temp_slot = UINT32_MAX; /* update the som slot on the prefix report */ for (auto v : inv_adjacent_vertices_range(g.accept, g)) { auto &reports = g[v].reports; assert(reports.size() == 1); Report ir = rm.getReport(*reports.begin()); if (ir.onmatch != temp_slot) { continue; } ir.onmatch = real_slot; ReportID rep = rm.getInternalId(ir); assert(reports.size() == 1); reports.clear(); reports.insert(rep); } } static void setPrefixReports(ReportManager &rm, NGHolder &g, ReportType ir_type, u32 som_loc, const vector &depths, bool prefix_by_rev) { Report ir = makeCallback(0U, 0); ir.type = ir_type; ir.onmatch = som_loc; /* add report for storing in som location on new accepts */ for (auto v : inv_adjacent_vertices_range(g.accept, g)) { if (prefix_by_rev) { ir.somDistance = MO_INVALID_IDX; /* will be populated properly * later */ } else { const DepthMinMax &d = depths.at(g[v].index); assert(d.min == d.max); ir.somDistance = d.max; } ReportID rep = rm.getInternalId(ir); auto &reports = g[v].reports; reports.clear(); reports.insert(rep); } } static void updatePrefixReports(ReportManager &rm, NGHolder &g, ReportType ir_type) { /* update the som action on the prefix report */ for (auto v : inv_adjacent_vertices_range(g.accept, g)) { auto &reports = g[v].reports; assert(reports.size() == 1); Report ir = rm.getReport(*reports.begin()); ir.type = ir_type; ReportID rep = rm.getInternalId(ir); assert(reports.size() == 1); reports.clear(); reports.insert(rep); } } static void updatePrefixReportsRevNFA(ReportManager &rm, NGHolder &g, u32 rev_comp_id) { /* update the action on the prefix report, to refer to a reverse nfa, * report type is also adjusted. */ for (auto v : inv_adjacent_vertices_range(g.accept, g)) { auto &reports = g[v].reports; assert(reports.size() == 1); Report ir = rm.getReport(*reports.begin()); switch (ir.type) { case INTERNAL_SOM_LOC_SET: ir.type = INTERNAL_SOM_LOC_SET_SOM_REV_NFA; break; case INTERNAL_SOM_LOC_SET_IF_UNSET: ir.type = INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET; break; case INTERNAL_SOM_LOC_SET_IF_WRITABLE: ir.type = INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE; break; default: assert(0); break; } ir.revNfaIndex = rev_comp_id; ReportID rep = rm.getInternalId(ir); assert(reports.size() == 1); reports.clear(); reports.insert(rep); } } static void setMidfixReports(ReportManager &rm, const som_plan &item, const u32 som_slot_in, const u32 som_slot_out) { assert(item.prefix); NGHolder &g = *item.prefix; Report ir = makeCallback(0U, 0); ir.type = item.is_reset ? INTERNAL_SOM_LOC_COPY : INTERNAL_SOM_LOC_COPY_IF_WRITABLE; ir.onmatch = som_slot_out; ir.somDistance = som_slot_in; ReportID rep = rm.getInternalId(ir); /* add report for storing in som location on new accepts */ for (auto v : inv_adjacent_vertices_range(g.accept, g)) { auto &reports = g[v].reports; reports.clear(); reports.insert(rep); } } static bool finalRegion(const NGHolder &g, const ue2::unordered_map ®ions, NFAVertex v) { u32 region = regions.at(v); for (auto w : adjacent_vertices_range(v, g)) { if (w != g.accept && w != g.acceptEod && regions.at(w) != region) { return false; } } return true; } static void replaceExternalReportsWithSomRep(ReportManager &rm, NGHolder &g, NFAVertex v, ReportType ir_type, u64a param) { assert(!g[v].reports.empty()); flat_set r_new; for (const ReportID &report_id : g[v].reports) { Report ir = rm.getReport(report_id); if (ir.type != EXTERNAL_CALLBACK) { /* we must have already done whatever magic we needed to do to this * report */ r_new.insert(report_id); continue; } ir.type = ir_type; ir.somDistance = param; ReportID rep = rm.getInternalId(ir); DEBUG_PRINTF("vertex %zu, replacing report %u with %u (type %u)\n", g[v].index, report_id, rep, ir_type); r_new.insert(rep); } g[v].reports = r_new; } /* updates the reports on all vertices leading to the sink */ static void makeSomRelReports(ReportManager &rm, NGHolder &g, NFAVertex sink, const vector &depths) { for (auto v : inv_adjacent_vertices_range(sink, g)) { if (v == g.accept) { continue; } const DepthMinMax &d = depths.at(g[v].index); assert(d.min == d.max); replaceExternalReportsWithSomRep(rm, g, v, EXTERNAL_CALLBACK_SOM_REL, d.min); } } /* updates the reports on all the provided vertices */ static void makeSomRelReports(ReportManager &rm, NGHolder &g, const vector &to_update, const vector &depths) { for (auto v : to_update) { const DepthMinMax &d = depths.at(g[v].index); assert(d.min == d.max); replaceExternalReportsWithSomRep(rm, g, v, EXTERNAL_CALLBACK_SOM_REL, d.min); } } static void makeSomAbsReports(ReportManager &rm, NGHolder &g, NFAVertex sink) { for (auto v : inv_adjacent_vertices_range(sink, g)) { if (v == g.accept) { continue; } replaceExternalReportsWithSomRep(rm, g, v, EXTERNAL_CALLBACK_SOM_ABS, 0); } } static void updateReportToUseRecordedSom(ReportManager &rm, NGHolder &g, u32 som_loc) { for (auto v : inv_adjacent_vertices_range(g.accept, g)) { replaceExternalReportsWithSomRep(rm, g, v, EXTERNAL_CALLBACK_SOM_STORED, som_loc); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (v == g.accept) { continue; } replaceExternalReportsWithSomRep(rm, g, v, EXTERNAL_CALLBACK_SOM_STORED, som_loc); } } static void updateReportToUseRecordedSom(ReportManager &rm, NGHolder &g, const vector &to_update, u32 som_loc) { for (auto v : to_update) { replaceExternalReportsWithSomRep(rm, g, v, EXTERNAL_CALLBACK_SOM_STORED, som_loc); } } static bool createEscaper(NG &ng, const NGHolder &prefix, const CharReach &escapes, u32 som_loc) { ReportManager &rm = ng.rm; /* escaper = /prefix[^escapes]*[escapes]/ */ DEBUG_PRINTF("creating escaper for %u\n", som_loc); NGHolder h; cloneHolder(h, prefix); assert(h.kind == NFA_OUTFIX); NFAVertex u = add_vertex(h); h[u].char_reach = ~escapes; NFAVertex v = add_vertex(h); h[v].char_reach = escapes; for (auto w : inv_adjacent_vertices_range(h.accept, h)) { add_edge(w, u, h); add_edge(w, v, h); h[w].reports.clear(); } clear_in_edges(h.accept, h); add_edge(u, v, h); add_edge(u, u, h); add_edge(v, h.accept, h); Report ir = makeCallback(0U, 0); ir.type = INTERNAL_SOM_LOC_MAKE_WRITABLE; ir.onmatch = som_loc; h[v].reports.insert(rm.getInternalId(ir)); return ng.addHolder(h); } static void fillHolderForLockCheck(NGHolder *out, const NGHolder &g, const map &info, map::const_iterator picked) { /* NOTE: This is appropriate for firstMatchIsFirst */ DEBUG_PRINTF("prepping for lock check\n"); NGHolder &midfix = *out; map v_map; v_map[g.start] = midfix.start; v_map[g.startDs] = midfix.startDs; /* include the lock region */ assert(picked != info.end()); auto graph_last = next(picked); assert(!graph_last->second.dag); assert(graph_last->second.full.size() == 1); for (auto jt = graph_last; ; --jt) { DEBUG_PRINTF("adding r %u to midfix\n", jt->first); /* add all vertices in region, create mapping */ for (auto v : jt->second.full) { DEBUG_PRINTF("adding v %zu to midfix\n", g[v].index); if (contains(v_map, v)) { continue; } /* treat all virtual starts as happening anywhere, so that the * virtual start is not counted as part of the SoM */ if (is_virtual_start(v, g)) { v_map[v] = midfix.startDs; continue; } NFAVertex vnew = add_vertex(g[v], midfix); v_map[v] = vnew; } /* add edges leaving region verts based on mapping */ for (auto v : jt->second.full) { NFAVertex u = v_map[v]; for (auto w : adjacent_vertices_range(v, g)) { if (w == g.accept || w == g.acceptEod) { add_edge_if_not_present(u, midfix.accept, midfix); continue; } if (!contains(v_map, w)) { add_edge_if_not_present(u, midfix.accept, midfix); } else { add_edge_if_not_present(u, v_map[w], midfix); } } } if (jt == info.begin()) { break; } } /* add edges from startds to the enters of all the initial optional * regions and the first mandatory region. */ for (auto jt = info.begin(); ; ++jt) { for (auto enter : jt->second.enters) { assert(contains(v_map, enter)); NFAVertex v = v_map[enter]; add_edge_if_not_present(midfix.startDs, v, midfix); } if (!jt->second.optional) { break; } if (jt == graph_last) { /* all regions are optional - add a direct edge to accept */ add_edge_if_not_present(midfix.startDs, midfix.accept, midfix); break; } } assert(in_degree(midfix.accept, midfix)); renumber_vertices(midfix); } static void fillRoughMidfix(NGHolder *out, const NGHolder &g, const ue2::unordered_map ®ions, const map &info, map::const_iterator picked) { /* as we are not the first prefix, we are probably not acyclic. We need to * generate an acyclic holder to acts a fake prefix to sentClearsTail. * This will result in a more conservative estimate. */ /* NOTE: This is not appropriate for firstMatchIsFirst */ NGHolder &midfix = *out; add_edge(midfix.startDs, midfix.accept, midfix); map v_map; map::const_iterator jt = picked; for (; jt->second.dag; --jt) { DEBUG_PRINTF("adding r %u to midfix\n", jt->first); if (!jt->second.optional) { clear_out_edges(midfix.startDs, midfix); add_edge(midfix.startDs, midfix.startDs, midfix); } /* add all vertices in region, create mapping */ for (auto v : jt->second.full) { DEBUG_PRINTF("adding v %zu to midfix\n", g[v].index); NFAVertex vnew = add_vertex(g[v], midfix); v_map[v] = vnew; } /* add edges leaving region verts based on mapping */ for (auto v : jt->second.full) { NFAVertex u = v_map[v]; for (auto w : adjacent_vertices_range(v, g)) { if (w == g.accept || w == g.acceptEod) { continue; } if (!contains(v_map, w)) { add_edge_if_not_present(u, midfix.accept, midfix); } else { add_edge_if_not_present(u, v_map[w], midfix); } } } /* add edges from startds to enters */ for (auto enter : jt->second.enters) { assert(contains(v_map, enter)); NFAVertex v = v_map[enter]; add_edge(midfix.startDs, v, midfix); } if (jt == info.begin()) { break; } } /* we can include the exits of the regions leading in */ if (!jt->second.dag) { u32 first_early_region = jt->first; clear_out_edges(midfix.startDs, midfix); add_edge(midfix.startDs, midfix.startDs, midfix); do { for (auto v : jt->second.exits) { DEBUG_PRINTF("adding v %zu to midfix\n", g[v].index); NFAVertex vnew = add_vertex(g[v], midfix); v_map[v] = vnew; /* add edges from startds to new vertices */ add_edge(midfix.startDs, vnew, midfix); } /* add edges leaving region verts based on mapping */ for (auto v : jt->second.exits) { NFAVertex u = v_map[v]; for (auto w : adjacent_vertices_range(v, g)) { if (w == g.accept || w == g.acceptEod || regions.at(w) <= first_early_region) { continue; } if (!contains(v_map, w)) { add_edge_if_not_present(u, midfix.accept, midfix); } else { add_edge_if_not_present(u, v_map[w], midfix); } } } } while (jt->second.optional && jt != info.begin() && (jt--)->first); if (jt->second.optional) { assert(!jt->second.exits.empty()); NFAVertex v = v_map[jt->second.exits.front()]; for (auto w : adjacent_vertices_range(v, midfix)) { add_edge(midfix.startDs, w, midfix); } } } } static bool beginsWithDotStar(const NGHolder &g) { bool hasDot = false; // We can ignore the successors of start, as matches that begin there will // necessarily have a SOM of 0. set succ; insert(&succ, adjacent_vertices(g.startDs, g)); succ.erase(g.startDs); for (auto v : succ) { // We want 'dot' states that aren't virtual starts. if (g[v].char_reach.all() && !g[v].assert_flags) { hasDot = true; set dotsucc; insert(&dotsucc, adjacent_vertices(v, g)); if (dotsucc != succ) { DEBUG_PRINTF("failed dot-star succ check\n"); return false; } } } if (hasDot) { DEBUG_PRINTF("begins with dot-star\n"); } return hasDot; } static bool buildMidfix(NG &ng, const som_plan &item, const u32 som_slot_in, const u32 som_slot_out) { assert(item.prefix); assert(hasCorrectlyNumberedVertices(*item.prefix)); /* setup escaper for second som_location if required */ if (item.escapes.any()) { if (!createEscaper(ng, *item.prefix, item.escapes, som_slot_out)) { return false; } } /* ensure we copy som from prev loc */ setMidfixReports(ng.rm, item, som_slot_in, som_slot_out); /* add second prefix/1st midfix */ if (!ng.addHolder(*item.prefix)) { DEBUG_PRINTF("---addHolder failed---\n"); return false; } return true; } static bool isMandRegionBetween(map::const_iterator a, map::const_iterator b) { while (b != a) { if (!b->second.optional) { return true; } --b; } return false; } // Attempts to advance the current plan. Returns true if we advance to the end // (woot!); updates picked, plan and bad_region. static bool advancePlan(const NGHolder &g, const ue2::unordered_map ®ions, const NGHolder &prefix, bool stuck, map::const_iterator &picked, const map::const_iterator furthest, const map::const_iterator furthest_lock, const CharReach &next_escapes, som_plan &plan, u32 *bad_region) { u32 bad_region_r = 0; u32 bad_region_x = 0; u32 bad_region_e = 0; DEBUG_PRINTF("curr %u\n", picked->first); if (sentClearsTail(g, regions, prefix, furthest->first, &bad_region_r)) { plan.is_reset = true; picked = furthest; DEBUG_PRINTF("Prefix clears tail, woot!\n"); return true; } else { DEBUG_PRINTF("Reset failed, first bad region %u\n", bad_region_r); } if (stuck) { u32 to_region = furthest_lock->first; if (validateXSL(g, regions, to_region, next_escapes, &bad_region_x)) { DEBUG_PRINTF("XSL\n"); picked = furthest_lock; plan.escapes = next_escapes; return true; } else { DEBUG_PRINTF("XSL failed, first bad region %u\n", bad_region_x); } if (validateEXSL(g, regions, to_region, next_escapes, prefix, &bad_region_e)) { DEBUG_PRINTF("EXSL\n"); picked = furthest_lock; plan.escapes = next_escapes; return true; } else { DEBUG_PRINTF("EXSL failed, first bad region %u\n", bad_region_e); } } else { DEBUG_PRINTF("!stuck, skipped XSL and EXSL\n"); } assert(!plan.is_reset); *bad_region = max(bad_region_x, bad_region_e); if (bad_region_r >= *bad_region) { *bad_region = bad_region_r; plan.is_reset = true; plan.escapes.clear(); picked = furthest; } else { picked = furthest_lock; plan.escapes = next_escapes; } DEBUG_PRINTF("first bad region now %u\n", *bad_region); return false; } static bool addPlan(vector &plan, u32 parent) { DEBUG_PRINTF("adding plan %zu with parent %u\n", plan.size(), parent); if (plan.size() >= MAX_SOM_PLANS) { DEBUG_PRINTF("too many plans!\n"); return false; } plan.emplace_back(nullptr, CharReach(), false, parent); return true; } // Fetches all preds of {accept, acceptEod} for this graph. static void addReporterVertices(const NGHolder &g, vector &reporters) { set tmp; insert(&tmp, inv_adjacent_vertices(g.accept, g)); insert(&tmp, inv_adjacent_vertices(g.acceptEod, g)); tmp.erase(g.accept); #ifdef DEBUG DEBUG_PRINTF("add reporters:"); for (UNUSED auto v : tmp) { printf(" %zu", g[v].index); } printf("\n"); #endif reporters.insert(reporters.end(), tmp.begin(), tmp.end()); } // Fetches all preds of {accept, acceptEod} in this region. static void addReporterVertices(const region_info &r, const NGHolder &g, vector &reporters) { for (auto v : r.exits) { if (edge(v, g.accept, g).second || edge(v, g.acceptEod, g).second) { DEBUG_PRINTF("add reporter %zu\n", g[v].index); reporters.push_back(v); } } } // Fetches the mappings of all preds of {accept, acceptEod} in this region. static void addMappedReporterVertices(const region_info &r, const NGHolder &g, const ue2::unordered_map &mapping, vector &reporters) { for (auto v : r.exits) { if (edge(v, g.accept, g).second || edge(v, g.acceptEod, g).second) { DEBUG_PRINTF("adding v=%zu\n", g[v].index); ue2::unordered_map::const_iterator it = mapping.find(v); assert(it != mapping.end()); reporters.push_back(it->second); } } } // Clone a version of the graph, but only including the in-edges of `enter' // from earlier regions. static void cloneGraphWithOneEntry(NGHolder &out, const NGHolder &g, const ue2::unordered_map ®ions, NFAVertex entry, const vector &enters, ue2::unordered_map &orig_to_copy) { orig_to_copy.clear(); cloneHolder(out, g, &orig_to_copy); assert(contains(orig_to_copy, entry)); const u32 region = regions.at(entry); for (auto v : enters) { if (v == entry) { continue; } assert(contains(orig_to_copy, v)); for (auto u : inv_adjacent_vertices_range(v, g)) { if (regions.at(u) < region) { assert(edge(orig_to_copy[u], orig_to_copy[v], out).second); remove_edge(orig_to_copy[u], orig_to_copy[v], out); } } } pruneUseless(out); } static void expandGraph(NGHolder &g, ue2::unordered_map ®ions, vector &enters) { assert(!enters.empty()); const u32 split_region = regions.at(enters.front()); vector new_enters; // Gather the list of vertices in the split region and subsequent regions. vector tail_vertices; for (auto v : vertices_range(g)) { if (is_special(v, g) || regions.at(v) < split_region) { continue; } tail_vertices.push_back(v); } for (auto enter : enters) { DEBUG_PRINTF("processing enter %zu\n", g[enter].index); map orig_to_copy; // Make a copy of all of the tail vertices, storing region info along // the way. for (auto v : tail_vertices) { auto v2 = clone_vertex(g, v); orig_to_copy[v] = v2; regions[v2] = regions.at(v); } // Wire up the edges: edges from previous regions come from the // original vertices, while edges internal to and beyond the split // region go to the copies. for (const auto &m : orig_to_copy) { NFAVertex v = m.first, v2 = m.second; for (const auto &e : out_edges_range(v, g)) { NFAVertex t = target(e, g); u32 t_region = regions.at(t); if (t_region >= split_region && !is_special(t, g)) { assert(contains(orig_to_copy, t)); t = orig_to_copy[t]; } add_edge_if_not_present(v2, t, g[e], g); } for (const auto &e : in_edges_range(v, g)) { NFAVertex u = source(e, g); if (regions.at(u) >= split_region && !is_special(u, g)) { assert(contains(orig_to_copy, u)); u = orig_to_copy[u]; } add_edge_if_not_present(u, v2, g[e], g); } } // Clear the in-edges from earlier regions of the OTHER enters for this // copy of the split region. for (auto v : enters) { if (v == enter) { continue; } remove_in_edge_if(orig_to_copy[v], [&](const NFAEdge &e) { NFAVertex u = source(e, g); return regions.at(u) < split_region; }, g); } new_enters.push_back(orig_to_copy[enter]); } // Remove the original set of tail vertices. remove_vertices(tail_vertices, g); pruneUseless(g); regions = assignRegions(g); enters.swap(new_enters); } static bool doTreePlanningIntl(NGHolder &g, const ue2::unordered_map ®ions, const map &info, map::const_iterator picked, u32 bad_region, u32 parent_plan, const ue2::unordered_map ©_to_orig, vector &plan, const Grey &grey) { assert(picked != info.end()); DEBUG_PRINTF("picked=%u\n", picked->first); DEBUG_PRINTF("parent is %u\n", parent_plan); map::const_iterator furthest; bool to_end = false; while (!to_end) { DEBUG_PRINTF("picked is %u\n", picked->first); DEBUG_PRINTF("first bad region now %u\n", bad_region); furthest = info.find(bad_region); /* first bad */ if (furthest == info.end()) { DEBUG_PRINTF("no partition\n"); return false; } --furthest; /* last region we can establish som for */ if (furthest->first <= picked->first) { DEBUG_PRINTF("failed to make any progress\n"); return false; } map::const_iterator furthest_lock = furthest; CharReach next_escapes; bool lock_found; /* The last possible lock in the range that we examine should be the * best. If the previous plan is a lock, this follow as any early lock * must have a reach that is a subset of the last plan's lock. If the * last plan is a resetting plan ..., ?is this true? */ do { lock_found = isPossibleLock(g, furthest_lock, info, &next_escapes); } while (!lock_found && (--furthest_lock)->first > picked->first); DEBUG_PRINTF("lock possible? %d\n", (int)lock_found); if (lock_found && !isMandRegionBetween(picked, furthest_lock)) { lock_found = false; } if (!isMandRegionBetween(picked, furthest)) { return false; } /* There is no certainty that the som at a reset location will always * go forward */ if (plan[parent_plan].is_reset && lock_found) { NGHolder midfix; DEBUG_PRINTF("checking if midfix is suitable for lock\n"); fillHolderForLockCheck(&midfix, g, info, furthest_lock); if (!firstMatchIsFirst(midfix)) { DEBUG_PRINTF("not stuck\n"); lock_found = false; } } if (!addPlan(plan, parent_plan)) { return false; } to_end = false; if (lock_found && next_escapes.none()) { picked = furthest_lock; to_end = true; } if (!to_end) { NGHolder conservative_midfix; /* for use in reset, exsl analysis */ fillRoughMidfix(&conservative_midfix, g, regions, info, furthest); dumpHolder(conservative_midfix, 15, "som_pathmidfix", grey); u32 old_bad_region = bad_region; to_end = advancePlan(g, regions, conservative_midfix, lock_found, picked, furthest, furthest_lock, next_escapes, plan.back(), &bad_region); if (!to_end && bad_region <= old_bad_region) { /* we failed to progress */ DEBUG_PRINTF("failed to make any progress\n"); return false; } } /* handle direct edge to accepts from region */ if (edge(furthest->second.exits.front(), g.accept, g).second || edge(furthest->second.exits.front(), g.acceptEod, g).second) { map::const_iterator it = furthest; do { addMappedReporterVertices(it->second, g, copy_to_orig, plan.back().reporters_in); } while (it != info.begin() && it->second.optional && (it--)->first); } /* create second prefix */ plan.back().prefix = makePrefix(g, regions, furthest->second, next(furthest)->second); parent_plan = plan.size() - 1; } // The last region contributes reporters. If it's optional, the regions // before it do as well. map::const_reverse_iterator it = info.rbegin(); do { DEBUG_PRINTF("add mapped reporters for region %u\n", it->first); addMappedReporterVertices(it->second, g, copy_to_orig, plan.back().reporters); } while (it->second.optional && it != info.rend() && (++it)->first > furthest->first); return true; } static bool doTreePlanning(NGHolder &g, map::const_iterator presplit, map::const_iterator picked, vector &plan, const Grey &grey) { DEBUG_PRINTF("picked is %u\n", picked->first); DEBUG_PRINTF("presplit is %u\n", presplit->first); map::const_iterator splitter = next(presplit); vector enters = splitter->second.enters; // mutable copy DEBUG_PRINTF("problem region has %zu entry vertices\n", enters.size()); if (enters.size() <= 1) { // TODO: Splitting a region with one entry won't get us anywhere, but // it shouldn't create buggy analyses either. See UE-1892. DEBUG_PRINTF("nothing to split\n"); return false; } if (plan.size() + enters.size() > MAX_SOM_PLANS) { DEBUG_PRINTF("splitting this tree would hit the plan limit.\n"); return false; } assert(!plan.empty()); const u32 parent_plan = plan.size() - 1; // Make a copy of the graph, with the subgraph under each enter vertex // duplicated without the edges into the other enter vertices. // NOTE WELL: this will invalidate 'info' from the split point, but it's // OK... we don't use it after this. auto g_regions = assignRegions(g); expandGraph(g, g_regions, enters); dumpHolder(g, g_regions, 14, "som_expandedtree", grey); for (auto v : enters) { DEBUG_PRINTF("enter %zu\n", g[v].index); // For this entry vertex, construct a version of the graph without the // other entries in this region (g_path), and calculate its depths and // regions. NGHolder g_path; ue2::unordered_map orig_to_copy; cloneGraphWithOneEntry(g_path, g, g_regions, v, enters, orig_to_copy); auto regions = assignRegions(g_path); dumpHolder(g_path, regions, 14, "som_treepath", grey); map path_info; buildRegionMapping(g_path, regions, path_info); // Translate 'picked' to the corresponding region iterator over the // g_path graph. we can't trust the numbering, so we use a vertex // instead. NFAVertex picked_v = picked->second.enters.front(); assert(contains(orig_to_copy, picked_v)); u32 picked_region = regions.at(orig_to_copy[picked_v]); map::const_iterator path_pick = path_info.find(picked_region); if (path_pick == path_info.end()) { assert(0); // odd return false; } // Similarly, find our bad_region. assert(contains(orig_to_copy, v)); u32 bad_region = regions.at(orig_to_copy[v]); // It's possible that the region may have grown to include its // successors, in which case we (currently) run screaming. Just // checking the size should be sufficient here. if (picked->second.full.size() != path_pick->second.full.size()) { DEBUG_PRINTF("picked region has grown, bailing\n"); return false; } // Construct reverse mapping from vertices in g_path to g. ue2::unordered_map copy_to_orig; for (const auto &m : orig_to_copy) { copy_to_orig.insert(make_pair(m.second, m.first)); } bool to_end = doTreePlanningIntl(g_path, regions, path_info, path_pick, bad_region, parent_plan, copy_to_orig, plan, grey); if (!to_end) { return false; } } return true; } enum dsp_behaviour { ALLOW_MODIFY_HOLDER, DISALLOW_MODIFY_HOLDER /* say no to tree planning */ }; static bool doSomPlanning(NGHolder &g, bool stuck_in, const ue2::unordered_map ®ions, const map &info, map::const_iterator picked, vector &plan, const Grey &grey, dsp_behaviour behaviour = ALLOW_MODIFY_HOLDER) { DEBUG_PRINTF("in picked is %u\n", picked->first); /* Need to verify how far the lock covers */ u32 bad_region; NGHolder *ap_pref = plan.back().prefix.get(); NGHolder ap_temp; if (hasBigCycles(*ap_pref)) { fillRoughMidfix(&ap_temp, g, regions, info, picked); ap_pref = &ap_temp; } bool to_end = advancePlan(g, regions, *ap_pref, stuck_in, picked, picked, picked, plan.back().escapes, plan.back(), &bad_region); if (to_end) { DEBUG_PRINTF("advanced through the whole graph in one go!\n"); addReporterVertices(g, plan.back().reporters); return true; } map::const_iterator prev_furthest = picked; map::const_iterator furthest; furthest = info.find(bad_region); /* first bad */ if (furthest == info.begin() || furthest == info.end()) { DEBUG_PRINTF("no partition\n"); return false; } --furthest; /* last region we can establish som for */ if (furthest->first <= picked->first) { do_tree: /* unable to establish SoM past the last picked region */ if (behaviour == DISALLOW_MODIFY_HOLDER) { /* tree planning mutates the graph */ return false; } DEBUG_PRINTF("failed to make any progress\n"); assert(!plan.empty()); if (plan.size() == 1) { DEBUG_PRINTF("not handling initial alternations yet\n"); return false; } plan.pop_back(); return doTreePlanning(g, furthest, prev_furthest, plan, grey); } furthest = picked; while (!to_end) { prev_furthest = furthest; DEBUG_PRINTF("prev further is %u\n", prev_furthest->first); DEBUG_PRINTF("first bad region now %u\n", bad_region); furthest = info.find(bad_region); /* first bad */ if (furthest == info.begin() || furthest == info.end()) { DEBUG_PRINTF("no partition\n"); return false; } --furthest; /* last region we can establish som for */ map::const_iterator furthest_lock = furthest; CharReach next_escapes; bool stuck; do { stuck = isPossibleLock(g, furthest_lock, info, &next_escapes); } while (!stuck && (--furthest_lock)->first > prev_furthest->first); DEBUG_PRINTF("lock possible? %d\n", (int)stuck); DEBUG_PRINTF("furthest_lock=%u\n", furthest_lock->first); if (stuck && !isMandRegionBetween(prev_furthest, furthest_lock)) { stuck = false; } if (!isMandRegionBetween(prev_furthest, furthest)) { DEBUG_PRINTF("no mand region between %u and %u\n", prev_furthest->first, furthest->first); return false; } /* There is no certainty that the som at a reset location will always * go forward */ if (plan.back().is_reset && stuck) { NGHolder midfix; fillHolderForLockCheck(&midfix, g, info, furthest_lock); DEBUG_PRINTF("checking if midfix is suitable for lock\n"); if (!firstMatchIsFirst(midfix)) { DEBUG_PRINTF("not stuck\n"); stuck = false; } } assert(!plan.empty()); if (!addPlan(plan, plan.size() - 1)) { return false; } to_end = false; if (stuck && next_escapes.none()) { picked = furthest_lock; to_end = true; } if (!to_end) { NGHolder conservative_midfix; /* for use in reset, exsl analysis */ fillRoughMidfix(&conservative_midfix, g, regions, info, furthest); u32 old_bad_region = bad_region; to_end = advancePlan(g, regions, conservative_midfix, stuck, picked, furthest, furthest_lock, next_escapes, plan.back(), &bad_region); if (!to_end && bad_region <= old_bad_region) { /* we failed to progress */ goto do_tree; } } /* handle direct edge to accepts from region */ if (edge(furthest->second.exits.front(), g.accept, g).second || edge(furthest->second.exits.front(), g.acceptEod, g).second) { map::const_iterator it = furthest; do { DEBUG_PRINTF("direct edge to accept from region %u\n", it->first); addReporterVertices(it->second, g, plan.back().reporters_in); } while (it != info.begin() && it->second.optional && (it--)->first); } /* create second prefix */ plan.back().prefix = makePrefix(g, regions, furthest->second, next(furthest)->second); } DEBUG_PRINTF("(final) picked is %u\n", picked->first); // The last region contributes reporters. If it's optional, the regions // before it do as well. map::const_reverse_iterator it = info.rbegin(); do { DEBUG_PRINTF("region %u contributes reporters to last plan\n", it->first); addReporterVertices(it->second, g, plan.back().reporters); } while (it->second.optional && it != info.rend() && (++it)->first > furthest->first); DEBUG_PRINTF("done!\n"); return true; } static void dumpSomPlan(UNUSED const NGHolder &g, UNUSED const som_plan &p, UNUSED size_t num) { #if defined(DEBUG) || defined(DUMP_PLANS) DEBUG_PRINTF("plan %zu: prefix=%p, escapes=%s, is_reset=%d, " "parent=%u\n", num, p.prefix.get(), describeClass(p.escapes, 20, CC_OUT_TEXT).c_str(), p.is_reset, p.parent); printf(" reporters:"); for (auto v : p.reporters) { printf(" %zu", g[v].index); } printf("\n"); printf(" reporters_in:"); for (auto v : p.reporters_in) { printf(" %zu", g[v].index); } printf("\n"); #endif } /** * Note: if we fail to build a midfix/ng.addHolder, we throw a pattern too * large exception as (1) if previous ng modification have been applied (other * midfixes have been applied), ng will be an undefined state on return and (2) * if the head of a pattern cannot be implemented we are generally unable to * implement the full pattern. */ static void implementSomPlan(NG &ng, const NGWrapper &w, u32 comp_id, NGHolder &g, vector &plan, const u32 first_som_slot) { ReportManager &rm = ng.rm; SomSlotManager &ssm = ng.ssm; DEBUG_PRINTF("%zu plans\n", plan.size()); assert(plan.size() <= MAX_SOM_PLANS); assert(!plan.empty()); vector som_slots(plan.size()); som_slots[0] = first_som_slot; // Root plan, which already has a SOM slot assigned (first_som_slot). dumpSomPlan(g, plan.front(), 0); dumpSomSubComponent(*plan.front().prefix, "04_som", w.expressionIndex, comp_id, 0, ng.cc.grey); assert(plan.front().prefix); if (plan.front().escapes.any() && !plan.front().is_reset) { /* setup escaper for first som location */ if (!createEscaper(ng, *plan.front().prefix, plan.front().escapes, first_som_slot)) { throw CompileError(w.expressionIndex, "Pattern is too large."); } } assert(plan.front().reporters_in.empty()); updateReportToUseRecordedSom(rm, g, plan.front().reporters, first_som_slot); // Tree of plans, encoded in a vector. vector::const_iterator it = plan.begin(); for (++it; it != plan.end(); ++it) { const u32 plan_num = it - plan.begin(); dumpSomPlan(g, *it, plan_num); dumpSomSubComponent(*it->prefix, "04_som", w.expressionIndex, comp_id, plan_num, ng.cc.grey); assert(it->parent < plan_num); u32 som_slot_in = som_slots[it->parent]; u32 som_slot_out = ssm.getSomSlot(*it->prefix, it->escapes, it->is_reset, som_slot_in); som_slots[plan_num] = som_slot_out; assert(!it->no_implement); if (!buildMidfix(ng, *it, som_slot_in, som_slot_out)) { throw CompileError(w.expressionIndex, "Pattern is too large."); } updateReportToUseRecordedSom(rm, g, it->reporters_in, som_slot_in); updateReportToUseRecordedSom(rm, g, it->reporters, som_slot_out); } /* create prefix to set the som_loc */ if (!plan.front().no_implement) { renumber_vertices(*plan.front().prefix); assert(plan.front().prefix->kind == NFA_OUTFIX); if (!ng.addHolder(*plan.front().prefix)) { throw CompileError(w.expressionIndex, "Pattern is too large."); } } } static void anchorStarts(NGHolder &g) { vector dead; for (const auto &e : out_edges_range(g.startDs, g)) { NFAVertex v = target(e, g); if (v == g.startDs) { continue; } add_edge_if_not_present(g.start, v, g[e], g); dead.push_back(e); } remove_edges(dead, g); } static void setZeroReports(NGHolder &g) { set acceptors; insert(&acceptors, inv_adjacent_vertices(g.accept, g)); insert(&acceptors, inv_adjacent_vertices(g.acceptEod, g)); acceptors.erase(g.accept); for (auto v : vertices_range(g)) { auto &reports = g[v].reports; reports.clear(); if (!contains(acceptors, v)) { continue; } // We use the report ID to store the offset adjustment used for virtual // starts. if (g[v].assert_flags & POS_FLAG_VIRTUAL_START) { reports.insert(1); } else { reports.insert(0); } } } /* updates the reports on all vertices leading to the sink */ static void makeSomRevNfaReports(ReportManager &rm, NGHolder &g, NFAVertex sink, const ReportID report, const u32 comp_id) { // Construct replacement report. Report ir = rm.getReport(report); ir.type = EXTERNAL_CALLBACK_SOM_REV_NFA; ir.revNfaIndex = comp_id; ReportID new_report = rm.getInternalId(ir); for (auto v : inv_adjacent_vertices_range(sink, g)) { if (v == g.accept) { continue; } auto &r = g[v].reports; if (contains(r, report)) { r.erase(report); r.insert(new_report); } } } static void clearProperInEdges(NGHolder &g, const NFAVertex sink) { vector dead; for (const auto &e : in_edges_range(sink, g)) { if (source(e, g) == g.accept) { continue; } dead.push_back(e); } if (dead.empty()) { return; } remove_edges(dead, g); pruneUseless(g, false); } namespace { struct SomRevNfa { SomRevNfa(NFAVertex s, ReportID r, aligned_unique_ptr n) : sink(s), report(r), nfa(move(n)) {} SomRevNfa(SomRevNfa&& s) // MSVC2013 needs this for emplace : sink(s.sink), report(s.report), nfa(move(s.nfa)) {} NFAVertex sink; ReportID report; aligned_unique_ptr nfa; }; } static aligned_unique_ptr makeBareSomRevNfa(const NGHolder &g, const CompileContext &cc) { // Create a reversed anchored version of this NFA which fires a zero report // ID on accept. NGHolder g_rev; reverseHolder(g, g_rev); anchorStarts(g_rev); setZeroReports(g_rev); // Prep for actual construction. renumber_vertices(g_rev); g_rev.kind = NFA_REV_PREFIX; reduceGraphEquivalences(g_rev, cc); removeRedundancy(g_rev, SOM_NONE); DEBUG_PRINTF("building a rev NFA with %zu vertices\n", num_vertices(g_rev)); aligned_unique_ptr nfa = constructReversedNFA(g_rev, cc); if (!nfa) { return nfa; } // Set some useful properties. depth maxWidth = findMaxWidth(g); if (maxWidth.is_finite()) { nfa->maxWidth = (u32)maxWidth; } else { nfa->maxWidth = 0; } depth minWidth = findMinWidth(g); nfa->minWidth = (u32)minWidth; return nfa; } static bool makeSomRevNfa(vector &som_nfas, const NGHolder &g, const ReportID report, const NFAVertex sink, const CompileContext &cc) { // Clone the graph with ONLY the given report vertices on the given sink. NGHolder g2; cloneHolder(g2, g); clearProperInEdges(g2, sink == g.accept ? g2.acceptEod : g2.accept); pruneAllOtherReports(g2, report); if (in_degree(g2.accept, g2) == 0 && in_degree(g2.acceptEod, g2) == 1) { DEBUG_PRINTF("no work to do for this sink\n"); return true; } renumber_vertices(g2); // for findMinWidth, findMaxWidth. aligned_unique_ptr nfa = makeBareSomRevNfa(g2, cc); if (!nfa) { DEBUG_PRINTF("couldn't build rev nfa\n"); return false; } som_nfas.emplace_back(sink, report, move(nfa)); return true; } static bool doSomRevNfa(NG &ng, NGHolder &g, const CompileContext &cc) { ReportManager &rm = ng.rm; // FIXME might want to work on a graph without extra redundancy? depth maxWidth = findMaxWidth(g); DEBUG_PRINTF("maxWidth=%s\n", maxWidth.str().c_str()); if (maxWidth > depth(ng.maxSomRevHistoryAvailable)) { DEBUG_PRINTF("too wide\n"); return false; } set reports = all_reports(g); DEBUG_PRINTF("%zu reports\n", reports.size()); // We distinguish between reports and accept/acceptEod sinks in order to // correctly handle cases which do different things on eod/normal accepts. // Later, it might be more elegant to do this with a single NFA and // multi-tops. vector som_nfas; for (auto report : reports) { if (!makeSomRevNfa(som_nfas, g, report, g.accept, cc)) { return false; } if (!makeSomRevNfa(som_nfas, g, report, g.acceptEod, cc)) { return false; } } for (auto &som_nfa : som_nfas) { assert(som_nfa.nfa); // Transfer ownership of the NFA to the SOM slot manager. u32 comp_id = ng.ssm.addRevNfa(move(som_nfa.nfa), maxWidth); // Replace this report on 'g' with a SOM_REV_NFA report pointing at our // new component. makeSomRevNfaReports(rm, g, som_nfa.sink, som_nfa.report, comp_id); } if (ng.cc.streaming) { assert(ng.ssm.somHistoryRequired() <= max(cc.grey.maxHistoryAvailable, ng.maxSomRevHistoryAvailable)); } return true; } static u32 doSomRevNfaPrefix(NG &ng, const NGWrapper &w, NGHolder &g, const CompileContext &cc) { depth maxWidth = findMaxWidth(g); assert(maxWidth <= depth(ng.maxSomRevHistoryAvailable)); assert(all_reports(g).size() == 1); auto nfa = makeBareSomRevNfa(g, cc); if (!nfa) { throw CompileError(w.expressionIndex, "Pattern is too large."); } if (ng.cc.streaming) { assert(ng.ssm.somHistoryRequired() <= max(cc.grey.maxHistoryAvailable, ng.maxSomRevHistoryAvailable)); } return ng.ssm.addRevNfa(move(nfa), maxWidth); } static bool is_literable(const NGHolder &g, NFAVertex v) { const CharReach &cr = g[v].char_reach; return cr.count() == 1 || cr.isCaselessChar(); } static void append(ue2_literal &s, const CharReach &cr) { assert(cr.count() == 1 || cr.isCaselessChar()); s.push_back(cr.find_first(), cr.isCaselessChar()); } static map::const_iterator findLaterLiteral(const NGHolder &g, const map &info, map::const_iterator lower_bound, ue2_literal &s_out, const Grey &grey) { #define MIN_LITERAL_LENGTH 3 s_out.clear(); bool past_lower = false; ue2_literal s; map::const_iterator it; for (it = info.begin(); it != info.end(); ++it) { if (it == lower_bound) { past_lower = true; } if (!it->second.optional && it->second.dag && it->second.full.size() == 1 && is_literable(g, it->second.full.front())) { append(s, g[it->second.full.front()].char_reach); if (s.length() >= grey.maxHistoryAvailable && past_lower) { goto exit; } } else { if (past_lower && it != lower_bound && s.length() >= MIN_LITERAL_LENGTH) { --it; goto exit; } s.clear(); } } if (past_lower && it != lower_bound && s.length() >= MIN_LITERAL_LENGTH) { --it; s_out = s; return it; } exit: if (s.length() > grey.maxHistoryAvailable) { ue2_literal::const_iterator jt = s.end() - grey.maxHistoryAvailable; for (; jt != s.end(); ++jt) { s_out.push_back(*jt); } } else { s_out = s; } return it; } static bool attemptToBuildChainAfterSombe(SomSlotManager &ssm, NGHolder &g, const ue2::unordered_map ®ions, const map &info, map::const_iterator picked, const Grey &grey, vector *plan) { DEBUG_PRINTF("trying to chain from %u\n", picked->first); const u32 numSomLocsBefore = ssm.numSomSlots(); /* for rollback */ shared_ptr prefix = makePrefix(g, regions, picked->second, next(picked)->second); // Quick check to stop us from trying this on huge graphs, which causes us // to spend forever in ng_execute looking at cases that will most like // fail. See UE-2078. size_t prefix_size = num_vertices(*prefix); size_t total_size = num_vertices(g); assert(total_size >= prefix_size); if (total_size - prefix_size > MAX_SOMBE_CHAIN_VERTICES) { DEBUG_PRINTF("suffix has %zu vertices, fail\n", total_size - prefix_size); return false; } clearReports(*prefix); for (auto u : inv_adjacent_vertices_range(prefix->accept, *prefix)) { (*prefix)[u].reports.insert(0); } dumpHolder(*prefix, 0, "full_haiglit_prefix", grey); CharReach escapes; bool stuck = isPossibleLock(g, picked, info, &escapes); if (stuck) { NGHolder gg; fillHolderForLockCheck(&gg, g, info, picked); stuck = firstMatchIsFirst(gg); } DEBUG_PRINTF("stuck = %d\n", (int)stuck); // Note: no-one should ever pay attention to the root plan's som_loc_in. plan->emplace_back(prefix, escapes, false, 0); plan->back().no_implement = true; dumpHolder(*plan->back().prefix, 22, "som_prefix", grey); /* don't allow tree planning to mutate the graph */ if (!doSomPlanning(g, stuck, regions, info, picked, *plan, grey, DISALLOW_MODIFY_HOLDER)) { // Rollback SOM locations. ssm.rollbackSomTo(numSomLocsBefore); DEBUG_PRINTF("fail to chain\n"); return false; } return true; } static void setReportOnHaigPrefix(RoseBuild &rose, NGHolder &h) { ReportID haig_report_id = rose.getNewNfaReport(); DEBUG_PRINTF("setting report id of %u\n", haig_report_id); clearReports(h); for (auto u : inv_adjacent_vertices_range(h.accept, h)) { h[u].reports.clear(); h[u].reports.insert(haig_report_id); } } static bool tryHaig(RoseBuild &rose, NGHolder &g, const ue2::unordered_map ®ions, som_type som, u32 somPrecision, map::const_iterator picked, shared_ptr *haig, shared_ptr *haig_prefix, const Grey &grey) { DEBUG_PRINTF("trying to build a haig\n"); shared_ptr prefix = makePrefix(g, regions, picked->second, next(picked)->second); prefix->kind = NFA_PREFIX; setReportOnHaigPrefix(rose, *prefix); dumpHolder(*prefix, 0, "haig_prefix", grey); vector > triggers; /* empty for prefix */ *haig = attemptToBuildHaig(*prefix, som, somPrecision, triggers, grey); if (!*haig) { DEBUG_PRINTF("failed to haig\n"); return false; } *haig_prefix = prefix; return true; } static void roseAddHaigLiteral(RoseBuild &tb, const shared_ptr &prefix, const shared_ptr &haig, const ue2_literal &lit, const set &reports) { assert(prefix && haig); DEBUG_PRINTF("trying to build a sombe from %s\n", dumpString(lit).c_str()); RoseInGraph ig; RoseInVertex s = add_vertex(RoseInVertexProps::makeStart(false), ig); RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); add_edge(s, v, RoseInEdgeProps(prefix, haig, lit.length()), ig); assert(!reports.empty()); RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(reports), ig); add_edge(v, a, RoseInEdgeProps(0U, 0U), ig); calcVertexOffsets(ig); UNUSED bool rv = tb.addSombeRose(ig); assert(rv); // TODO: recover from addRose failure } static sombe_rv doHaigLitSom(NG &ng, NGHolder &g, const NGWrapper &w, u32 comp_id, som_type som, const ue2::unordered_map ®ions, const map &info, map::const_iterator lower_bound) { DEBUG_PRINTF("entry\n"); assert(g.kind == NFA_OUTFIX); const CompileContext &cc = ng.cc; ReportManager &rm = ng.rm; SomSlotManager &ssm = ng.ssm; if (!cc.grey.allowHaigLit) { return SOMBE_FAIL; } const u32 numSomLocsBefore = ssm.numSomSlots(); /* for rollback */ u32 som_loc = ssm.getPrivateSomSlot(); if (!checkRose(rm, g, false, cc) && !isImplementableNFA(g, &rm, cc)) { // This is an optimisation: if we can't build a Haig from a portion of // the graph, then we won't be able to manage it as an outfix either // when we fall back. throw CompileError(w.expressionIndex, "Pattern is too large."); } while (1) { DEBUG_PRINTF("lower bound is %u\n", lower_bound->first); ue2_literal s; map::const_iterator lit = findLaterLiteral(g, info, lower_bound, s, cc.grey); if (lit == info.end()) { DEBUG_PRINTF("failed to find literal\n"); ssm.rollbackSomTo(numSomLocsBefore); return SOMBE_FAIL; } DEBUG_PRINTF("test literal: %s [r=%u]\n", dumpString(s).c_str(), lit->first); if (s.length() > MAX_MASK2_WIDTH && mixed_sensitivity(s)) { DEBUG_PRINTF("long & mixed-sensitivity, Rose can't handle this\n"); lower_bound = lit; ++lower_bound; continue; } shared_ptr haig; shared_ptr haig_prefix; map::const_iterator haig_reg = lit; if (edge(lit->second.exits.front(), g.acceptEod, g).second) { /* TODO: handle */ ssm.rollbackSomTo(numSomLocsBefore); return SOMBE_FAIL; } advance(haig_reg, -(s32)s.length()); if (!haig_reg->first && haig_reg->second.full.size() == 2) { /* just starts */ /* TODO: make below assertion true, reset checks could be stronger * (12356) */ /* assert(!attemptToBuildChainAfterSombe(ng, g, info, lit, cc.grey, &plan)); */ lower_bound = lit; ++lower_bound; continue; /* somebody else should have been able to chain */ } bool ok = true; set rep; if (next(lit) != info.end()) { /* non terminal literal */ /* TODO: handle edges to accept ? */ vector plan; if (edge(lit->second.exits.front(), g.accept, g).second) { insert(&rep, g[lit->second.exits.front()].reports); remove_edge(lit->second.exits.front(), g.accept, g); g[lit->second.exits.front()].reports.clear(); /* Note: we can mess with the graph as this is the last literal * we will find and on failure the graph will be thrown away */ } ok = attemptToBuildChainAfterSombe(ssm, g, regions, info, lit, cc.grey, &plan); ok = ok && tryHaig(*ng.rose, g, regions, som, ssm.somPrecision(), haig_reg, &haig, &haig_prefix, cc.grey); if (!ok) { DEBUG_PRINTF(":( going to next attempt\n"); goto next_try; } implementSomPlan(ng, w, comp_id, g, plan, som_loc); Report ir = makeCallback(0U, 0); assert(!plan.empty()); if (plan.front().is_reset) { ir.type = INTERNAL_SOM_LOC_SET_FROM; } else { ir.type = INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE; } ir.onmatch = som_loc; rep.insert(rm.getInternalId(ir)); } else { /* terminal literal */ ok = tryHaig(*ng.rose, g, regions, som, ssm.somPrecision(), haig_reg, &haig, &haig_prefix, cc.grey); /* find report */ insert(&rep, g[lit->second.exits.front()].reports); /* TODO: som_loc is unused */ } if (ok) { roseAddHaigLiteral(*ng.rose, haig_prefix, haig, s, rep); if (next(lit) != info.end()) { return SOMBE_HANDLED_INTERNAL; } else { ssm.rollbackSomTo(numSomLocsBefore); return SOMBE_HANDLED_ALL; } } next_try: lower_bound = lit; ++lower_bound; } assert(0); return SOMBE_FAIL; } static bool leadingLiterals(const NGHolder &g, set *lits, set *terminals) { /* TODO: smarter (topo) */ #define MAX_LEADING_LITERALS 20 set s_succ; insert(&s_succ, adjacent_vertices(g.start, g)); set sds_succ; insert(&sds_succ, adjacent_vertices(g.startDs, g)); if (!is_subset_of(s_succ, sds_succ)) { DEBUG_PRINTF("not floating\n"); return false; } sds_succ.erase(g.startDs); map > curr; curr[g.startDs].push_back(ue2_literal()); map > seen; map > next; bool did_expansion = true; while (did_expansion) { did_expansion = false; u32 count = 0; assert(!curr.empty()); for (const auto &m : curr) { const NFAVertex u = m.first; const vector &base = m.second; DEBUG_PRINTF("expanding from %zu\n", g[u].index); for (auto v : adjacent_vertices_range(u, g)) { if (v == g.startDs) { continue; } if (contains(seen[u], v)) { DEBUG_PRINTF("loop\n"); goto skip_to_next_terminal; } if (is_any_accept(v, g) || is_match_vertex(v, g)) { DEBUG_PRINTF("match\n"); goto skip_to_next_terminal; } if (g[v].char_reach.count() > 2 * MAX_LEADING_LITERALS) { DEBUG_PRINTF("wide\n"); goto skip_to_next_terminal; } } for (auto v : adjacent_vertices_range(u, g)) { assert(!contains(seen[u], v)); if (v == g.startDs) { continue; } insert(&seen[v], seen[u]); seen[v].insert(v); CharReach cr = g[v].char_reach; vector &out = next[v]; DEBUG_PRINTF("expanding to %zu (|| = %zu)\n", g[v].index, cr.count()); for (size_t c = cr.find_first(); c != CharReach::npos; c = cr.find_next(c)) { bool nocase = ourisalpha(c) && cr.test(mytoupper(c)) && cr.test(mytolower(c)); if (nocase && (char)c == mytolower(c)) { continue; /* uppercase already handled us */ } for (const auto &lit : base) { if (count >= MAX_LEADING_LITERALS) { DEBUG_PRINTF("count %u\n", count); goto exit; } did_expansion = true; out.push_back(lit); out.back().push_back(c, nocase); count++; if (out.back().length() > MAX_MASK2_WIDTH && mixed_sensitivity(out.back())) { goto exit; } } } } if (0) { skip_to_next_terminal: insert(&next[u], next[u].end(), base); count += base.size(); if (count > MAX_LEADING_LITERALS) { DEBUG_PRINTF("count %u\n", count); goto exit; } } } curr.swap(next); next.clear(); }; exit:; for (const auto &m : curr) { NFAVertex t = m.first; if (t == g.startDs) { assert(curr.size() == 1); return false; } assert(!is_special(t, g)); terminals->insert(t); insert(lits, m.second); } assert(lits->size() <= MAX_LEADING_LITERALS); return !lits->empty(); } static bool splitOffLeadingLiterals(const NGHolder &g, set *lit_out, NGHolder *rhs) { DEBUG_PRINTF("looking for a leading literals\n"); set terms; if (!leadingLiterals(g, lit_out, &terms)) { return false; } for (UNUSED const auto &lit : *lit_out) { DEBUG_PRINTF("literal is '%s' (len %zu)\n", dumpString(lit).c_str(), lit.length()); } /* need to validate that it is a clean split */ assert(!terms.empty()); set adj_term1; insert(&adj_term1, adjacent_vertices(*terms.begin(), g)); for (auto v : terms) { DEBUG_PRINTF("term %zu\n", g[v].index); set temp; insert(&temp, adjacent_vertices(v, g)); if (temp != adj_term1) { DEBUG_PRINTF("bad split\n"); return false; } } ue2::unordered_map rhs_map; vector pivots; insert(&pivots, pivots.end(), adj_term1); splitRHS(g, pivots, rhs, &rhs_map); assert(is_triggered(*rhs)); return true; } static void findBestLiteral(const NGHolder &g, const ue2::unordered_map ®ions, ue2_literal *lit_out, NFAVertex *v, const CompileContext &cc) { map info; buildRegionMapping(g, regions, info, false); ue2_literal best; NFAVertex best_v = NGHolder::null_vertex(); map::const_iterator lit = info.begin(); while (1) { ue2_literal s; lit = findLaterLiteral(g, info, lit, s, cc.grey); if (lit == info.end()) { break; } DEBUG_PRINTF("test literal: %s [r=%u]\n", dumpString(s).c_str(), lit->first); if (s.length() > MAX_MASK2_WIDTH && mixed_sensitivity(s)) { DEBUG_PRINTF("long & mixed-sensitivity, Rose can't handle this\n"); ++lit; continue; } if (s.length() > best.length()) { best = s; assert(!lit->second.exits.empty()); best_v = lit->second.exits[0]; } ++lit; } lit_out->swap(best); *v = best_v; } static bool splitOffBestLiteral(const NGHolder &g, const ue2::unordered_map ®ions, ue2_literal *lit_out, NGHolder *lhs, NGHolder *rhs, const CompileContext &cc) { NFAVertex v = NGHolder::null_vertex(); findBestLiteral(g, regions, lit_out, &v, cc); if (lit_out->empty()) { return false; } DEBUG_PRINTF("literal is '%s'\n", dumpString(*lit_out).c_str()); ue2::unordered_map lhs_map; ue2::unordered_map rhs_map; splitGraph(g, v, lhs, &lhs_map, rhs, &rhs_map); DEBUG_PRINTF("v = %zu\n", g[v].index); return true; } /** * Replace the given graph's EXTERNAL_CALLBACK reports with * EXTERNAL_CALLBACK_SOM_PASS reports. */ void makeReportsSomPass(ReportManager &rm, NGHolder &g) { for (const auto &v : vertices_range(g)) { const auto &reports = g[v].reports; if (reports.empty()) { continue; } flat_set new_reports; for (const ReportID &id : reports) { const Report &report = rm.getReport(id); if (report.type != EXTERNAL_CALLBACK) { new_reports.insert(id); continue; } Report report2 = report; report2.type = EXTERNAL_CALLBACK_SOM_PASS; new_reports.insert(rm.getInternalId(report2)); } g[v].reports = new_reports; } } static bool doLitHaigSom(NG &ng, NGHolder &g, som_type som) { ue2_literal lit; shared_ptr rhs = make_shared(); if (!ng.cc.grey.allowLitHaig) { return false; } dumpHolder(g, 90, "lithaig_full", ng.cc.grey); if (!splitOffLeadingLiteral(g, &lit, &*rhs)) { DEBUG_PRINTF("no literal\n"); return false; } if (lit.length() < ng.cc.grey.minRoseLiteralLength) { DEBUG_PRINTF("lit too short\n"); return false; } assert(lit.length() <= MAX_MASK2_WIDTH || !mixed_sensitivity(lit)); makeReportsSomPass(ng.rm, *rhs); dumpHolder(*rhs, 91, "lithaig_rhs", ng.cc.grey); vector > triggers; triggers.push_back(as_cr_seq(lit)); assert(rhs->kind == NFA_SUFFIX); shared_ptr haig = attemptToBuildHaig(*rhs, som, ng.ssm.somPrecision(), triggers, ng.cc.grey, false /* lit implies adv som */); if (!haig) { DEBUG_PRINTF("failed to haig\n"); return false; } DEBUG_PRINTF("haig %p\n", haig.get()); RoseInGraph ig; RoseInVertex s = add_vertex(RoseInVertexProps::makeStart(false), ig); RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); add_edge(s, v, RoseInEdgeProps(0, ROSE_BOUND_INF), ig); RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(set()), ig); add_edge(v, a, RoseInEdgeProps(haig), ig); calcVertexOffsets(ig); return ng.rose->addSombeRose(ig); } static bool doHaigLitHaigSom(NG &ng, NGHolder &g, const ue2::unordered_map ®ions, som_type som) { if (!ng.cc.grey.allowLitHaig) { return false; } // In streaming mode, we can only delay up to our max available history. const u32 max_delay = ng.cc.streaming ? ng.cc.grey.maxHistoryAvailable : MO_INVALID_IDX; ue2_literal lit; shared_ptr rhs = make_shared(); shared_ptr lhs = make_shared(); if (!splitOffBestLiteral(g, regions, &lit, &*lhs, &*rhs, ng.cc)) { return false; } DEBUG_PRINTF("split off best lit '%s' (len=%zu)\n", dumpString(lit).c_str(), lit.length()); if (lit.length() < ng.cc.grey.minRoseLiteralLength) { DEBUG_PRINTF("lit too short\n"); return false; } assert(lit.length() <= MAX_MASK2_WIDTH || !mixed_sensitivity(lit)); if (edge(rhs->start, rhs->acceptEod, *rhs).second) { return false; /* TODO: handle */ } makeReportsSomPass(ng.rm, *rhs); dumpHolder(*lhs, 92, "haiglithaig_lhs", ng.cc.grey); dumpHolder(*rhs, 93, "haiglithaig_rhs", ng.cc.grey); u32 delay = removeTrailingLiteralStates(*lhs, lit, max_delay); RoseInGraph ig; RoseInVertex s = add_vertex(RoseInVertexProps::makeStart(false), ig); RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); bool lhs_all_vac = true; NGHolder::adjacency_iterator ai, ae; for (tie(ai, ae) = adjacent_vertices(lhs->startDs, *lhs); ai != ae && lhs_all_vac; ++ai) { if (!is_special(*ai, *lhs)) { lhs_all_vac = false; } } for (tie(ai, ae) = adjacent_vertices(lhs->start, *lhs); ai != ae && lhs_all_vac; ++ai) { if (!is_special(*ai, *lhs)) { lhs_all_vac = false; } } if (lhs_all_vac) { /* lhs is completely vacuous --> no prefix needed */ add_edge(s, v, RoseInEdgeProps(0, ROSE_BOUND_INF), ig); } else { assert(delay == lit.length()); setReportOnHaigPrefix(*ng.rose, *lhs); vector > prefix_triggers; /* empty for prefix */ assert(lhs->kind == NFA_PREFIX); shared_ptr l_haig = attemptToBuildHaig(*lhs, som, ng.ssm.somPrecision(), prefix_triggers, ng.cc.grey); if (!l_haig) { DEBUG_PRINTF("failed to haig\n"); return false; } DEBUG_PRINTF("lhs haig %p\n", l_haig.get()); add_edge(s, v, RoseInEdgeProps(lhs, l_haig, delay), ig); } if (!edge(rhs->start, rhs->accept, *rhs).second) { assert(rhs->kind == NFA_SUFFIX); vector > triggers; triggers.push_back(as_cr_seq(lit)); ue2_literal lit2; if (getTrailingLiteral(g, &lit2) && lit2.length() >= ng.cc.grey.minRoseLiteralLength && minStringPeriod(lit2) >= 2) { /* TODO: handle delay */ size_t overlap = maxOverlap(lit, lit2, 0); u32 delay2 = min((size_t)max_delay, lit2.length() - overlap); delay2 = removeTrailingLiteralStates(*rhs, lit2, delay2); rhs->kind = NFA_INFIX; assert(delay2 <= lit2.length()); setReportOnHaigPrefix(*ng.rose, *rhs); shared_ptr m_haig = attemptToBuildHaig(*rhs, som, ng.ssm.somPrecision(), triggers, ng.cc.grey, true); DEBUG_PRINTF("mhs haig %p\n", m_haig.get()); if (!m_haig) { DEBUG_PRINTF("failed to haig\n"); return false; } RoseInVertex w = add_vertex(RoseInVertexProps::makeLiteral(lit2), ig); add_edge(v, w, RoseInEdgeProps(rhs, m_haig, delay2), ig); NFAVertex reporter = getSoleSourceVertex(g, g.accept); assert(reporter); const auto &reports = g[reporter].reports; RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(reports), ig); add_edge(w, a, RoseInEdgeProps(0U, 0U), ig); } else { /* TODO: analysis to see if som is in fact always increasing */ shared_ptr r_haig = attemptToBuildHaig(*rhs, som, ng.ssm.somPrecision(), triggers, ng.cc.grey, true); DEBUG_PRINTF("rhs haig %p\n", r_haig.get()); if (!r_haig) { DEBUG_PRINTF("failed to haig\n"); return false; } RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(set()), ig); add_edge(v, a, RoseInEdgeProps(r_haig), ig); } } else { DEBUG_PRINTF("has start->accept edge\n"); if (in_degree(g.acceptEod, g) > 1) { DEBUG_PRINTF("also has a path to EOD\n"); return false; } NFAVertex reporter = getSoleSourceVertex(g, g.accept); if (!reporter) { return false; /* TODO: later */ } const auto &reports = g[reporter].reports; assert(!reports.empty()); RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(reports), ig); add_edge(v, a, RoseInEdgeProps(0U, 0U), ig); } calcVertexOffsets(ig); return ng.rose->addSombeRose(ig); } static bool doMultiLitHaigSom(NG &ng, NGHolder &g, som_type som) { set lits; shared_ptr rhs = make_shared(); if (!ng.cc.grey.allowLitHaig) { return false; } dumpHolder(g, 90, "lithaig_full", ng.cc.grey); if (!splitOffLeadingLiterals(g, &lits, &*rhs)) { DEBUG_PRINTF("no literal\n"); return false; } makeReportsSomPass(ng.rm, *rhs); dumpHolder(*rhs, 91, "lithaig_rhs", ng.cc.grey); vector> triggers; for (const auto &lit : lits) { if (lit.length() < ng.cc.grey.minRoseLiteralLength) { DEBUG_PRINTF("lit too short\n"); return false; } assert(lit.length() <= MAX_MASK2_WIDTH || !mixed_sensitivity(lit)); triggers.push_back(as_cr_seq(lit)); } bool unordered_som_triggers = true; /* TODO: check overlaps to ensure that * we can promise ordering */ assert(rhs->kind == NFA_SUFFIX); shared_ptr haig = attemptToBuildHaig(*rhs, som, ng.ssm.somPrecision(), triggers, ng.cc.grey, unordered_som_triggers); if (!haig) { DEBUG_PRINTF("failed to haig\n"); return false; } DEBUG_PRINTF("haig %p\n", haig.get()); RoseInGraph ig; RoseInVertex s = add_vertex(RoseInVertexProps::makeStart(false), ig); RoseInVertex a = add_vertex(RoseInVertexProps::makeAccept(set()), ig); for (const auto &lit : lits) { RoseInVertex v = add_vertex(RoseInVertexProps::makeLiteral(lit), ig); add_edge(s, v, RoseInEdgeProps(0, ROSE_BOUND_INF), ig); add_edge(v, a, RoseInEdgeProps(haig), ig); } calcVertexOffsets(ig); return ng.rose->addSombeRose(ig); } static bool trySombe(NG &ng, NGHolder &g, som_type som) { if (doLitHaigSom(ng, g, som)) { return true; } auto regions = assignRegions(g); if (doHaigLitHaigSom(ng, g, regions, som)) { return true; } if (doMultiLitHaigSom(ng, g, som)) { return true; } return false; } static map::const_iterator pickInitialSomCut(const NGHolder &g, const ue2::unordered_map ®ions, const map &info, const vector &depths) { map::const_iterator picked = info.end(); for (map::const_iterator it = info.begin(); it != info.end(); ++it) { if (it->second.exits.empty()) { assert(it == info.begin()); continue; } if (!regionCanEstablishSom(g, regions, it->first, it->second.exits, depths)) { /* last region is as far as we can go */ DEBUG_PRINTF("region %u is beyond the fixed region\n", it->first); break; } picked = it; } return picked; } static map::const_iterator tryForLaterRevNfaCut(const NGHolder &g, const ue2::unordered_map ®ions, const map &info, const vector &depths, const map::const_iterator &orig, const CompileContext &cc) { DEBUG_PRINTF("trying for later rev nfa cut\n"); assert(orig != info.end()); vector::const_iterator> cands; map::const_iterator it = orig; ++it; for (; it != info.end(); ++it) { /* for simplicity */ if (it->second.exits.size() != 1 || it->second.optional) { continue; } NFAVertex v = *it->second.exits.begin(); if (edge(v, g.accept, g).second || edge(v, g.acceptEod, g).second) { continue; /* for simplicity would require external som nfa reports * as well. */ } const depth &max_depth = depths[g[v].index].max; if (max_depth > depth(cc.grey.somMaxRevNfaLength - 1)) { /* virtual starts */ continue; } if (max_depth > depth(MAX_REV_NFA_PREFIX)) { /* probably not a good idea, anyway */ continue; } cands.push_back(it); } while (!cands.empty()) { map::const_iterator rv = cands.back(); cands.pop_back(); NFAVertex v = *rv->second.exits.begin(); set lits = getLiteralSet(g, v); compressAndScore(lits); if (lits.empty()) { next_region: continue; } for (const auto &lit : lits) { if (lit.length() <= 3 || minStringPeriod(lit) < 2) { goto next_region; } } if (rv->second.enters.empty() || find(rv->second.full.begin(), rv->second.full.end(), g.startDs) != rv->second.full.end()) { continue; } if (!isMandRegionBetween(info.begin(), rv) && info.begin()->second.optional) { continue; } /* check to see if it is a reasonable size */ auto prefix = makePrefix(g, regions, rv->second, next(rv)->second, false); NGHolder g_rev; reverseHolder(*prefix, g_rev); anchorStarts(g_rev); renumber_vertices(g_rev); g_rev.kind = NFA_REV_PREFIX; reduceGraphEquivalences(g_rev, cc); removeRedundancy(g_rev, SOM_NONE); if (num_vertices(g_rev) > 128) { /* too big */ continue; } return rv; } return info.end(); } static unique_ptr makePrefixForChain(NGHolder &g, const ue2::unordered_map ®ions, const map &info, const map::const_iterator &picked, vector *depths, bool prefix_by_rev, ReportManager &rm) { DEBUG_PRINTF("making prefix for chain attempt\n"); auto prefix = makePrefix(g, regions, picked->second, next(picked)->second, false); /* For the root SOM plan, we use a temporary SOM slot to start with so that * we don't have to do any complicated rollback operations if the call to * doSomPlanning() below fails. The temporary SOM slot is replaced with a * real one afterwards. */ const u32 temp_som_loc = UINT32_MAX; setPrefixReports(rm, *prefix, INTERNAL_SOM_LOC_SET_IF_WRITABLE, temp_som_loc, *depths, prefix_by_rev); /* handle direct edge to accepts from region */ if (edge(picked->second.exits.front(), g.accept, g).second || edge(picked->second.exits.front(), g.acceptEod, g).second) { map::const_iterator it = picked; do { makeSomRelReports(rm, g, it->second.exits, *depths); } while (it != info.begin() && it->second.optional && (it--)->first); } depths->clear(); /* renumbering invalidates depths */ renumber_vertices(*prefix); DEBUG_PRINTF("done\n"); return prefix; } sombe_rv doSom(NG &ng, NGHolder &g, const NGWrapper &w, u32 comp_id, som_type som) { assert(som); DEBUG_PRINTF("som hello\n"); ReportManager &rm = ng.rm; SomSlotManager &ssm = ng.ssm; const CompileContext &cc = ng.cc; // Special case: if g is completely anchored or begins with a dot-star, we // know that we have an absolute SOM of zero all the time. if (!proper_out_degree(g.startDs, g) || beginsWithDotStar(g)) { makeSomAbsReports(rm, g, g.accept); makeSomAbsReports(rm, g, g.acceptEod); return SOMBE_HANDLED_INTERNAL; } if (!cc.grey.allowSomChain) { return SOMBE_FAIL; } // A pristine copy of the input graph, which must be restored to in paths // that return false. Also used as the forward graph for som rev nfa // construction. NGHolder g_pristine; cloneHolder(g_pristine, g); vector depths = getDistancesFromSOM(g); // try a redundancy pass. if (addSomRedundancy(g, depths)) { depths = getDistancesFromSOM(g); // recalc } auto regions = assignRegions(g); dumpHolder(g, regions, 11, "som_explode", cc.grey); map info; buildRegionMapping(g, regions, info); map::const_iterator picked = pickInitialSomCut(g, regions, info, depths); DEBUG_PRINTF("picked %u\n", picked->first); if (picked == info.end() || picked->second.exits.empty()) { DEBUG_PRINTF("no regions/no progress possible\n"); clear_graph(g); cloneHolder(g, g_pristine); if (doSomRevNfa(ng, g, cc)) { return SOMBE_HANDLED_INTERNAL; } else { return SOMBE_FAIL; } } if (finalRegion(g, regions, picked->second.exits[0])) { makeSomRelReports(rm, g, g.accept, depths); makeSomRelReports(rm, g, g.acceptEod, depths); return SOMBE_HANDLED_INTERNAL; } if (doSomRevNfa(ng, g_pristine, cc)) { clear_graph(g); cloneHolder(g, g_pristine); return SOMBE_HANDLED_INTERNAL; } bool prefix_by_rev = false; map::const_iterator picked_old = picked; map::const_iterator rev_pick = tryForLaterRevNfaCut(g, regions, info, depths, picked, cc); if (rev_pick != info.end()) { DEBUG_PRINTF("found later rev prefix cut point\n"); assert(rev_pick != picked); picked = rev_pick; prefix_by_rev = true; } else { /* sanity checks for picked region, these checks have already been done * if we are using a prefix reverse nfa. */ if (picked->second.enters.empty() || find(picked->second.full.begin(), picked->second.full.end(), g.startDs) != picked->second.full.end()) { clear_graph(g); cloneHolder(g, g_pristine); return SOMBE_FAIL; } if (!isMandRegionBetween(info.begin(), picked) && info.begin()->second.optional) { clear_graph(g); cloneHolder(g, g_pristine); return SOMBE_FAIL; } } DEBUG_PRINTF("region %u is the final\n", picked->first); shared_ptr prefix = makePrefixForChain( g, regions, info, picked, &depths, prefix_by_rev, rm); /* note depths cleared as we have renumbered */ CharReach escapes; bool stuck = isPossibleLock(g, picked, info, &escapes); if (stuck) { DEBUG_PRINTF("investigating potential lock\n"); NGHolder gg; fillHolderForLockCheck(&gg, g, info, picked); stuck = firstMatchIsFirst(gg); } if (stuck && escapes.none()) { /* leads directly to .* --> woot */ DEBUG_PRINTF("initial slot is full lock\n"); u32 som_loc = ssm.getSomSlot(*prefix, escapes, false, SomSlotManager::NO_PARENT); replaceTempSomSlot(rm, *prefix, som_loc); /* update all reports on g to report the som_loc's som */ updateReportToUseRecordedSom(rm, g, som_loc); /* create prefix to set the som_loc */ updatePrefixReports(rm, *prefix, INTERNAL_SOM_LOC_SET_IF_UNSET); if (prefix_by_rev) { u32 rev_comp_id = doSomRevNfaPrefix(ng, w, *prefix, cc); updatePrefixReportsRevNFA(rm, *prefix, rev_comp_id); } renumber_vertices(*prefix); if (!ng.addHolder(*prefix)) { DEBUG_PRINTF("failed to add holder\n"); clear_graph(g); cloneHolder(g, g_pristine); return SOMBE_FAIL; } DEBUG_PRINTF("ok found initial lock\n"); return SOMBE_HANDLED_INTERNAL; } vector plan; retry: // Note: no-one should ever pay attention to the root plan's parent. plan.push_back(som_plan(prefix, escapes, false, 0)); dumpHolder(*plan.back().prefix, 12, "som_prefix", cc.grey); if (!prefix_by_rev) { if (!doSomPlanning(g, stuck, regions, info, picked, plan, cc.grey)) { DEBUG_PRINTF("failed\n"); clear_graph(g); cloneHolder(g, g_pristine); return SOMBE_FAIL; } } else { DEBUG_PRINTF("trying for som plan\n"); if (!doSomPlanning(g, stuck, regions, info, picked, plan, cc.grey, DISALLOW_MODIFY_HOLDER)) { /* Note: the larger prefixes generated by reverse nfas may not * advance as fair as the original prefix - so we should retry * with a smaller prefix. */ prefix_by_rev = false; stuck = false; /* if we reached a lock, then prefix_by_rev would not * have advanced. */ picked = picked_old; plan.clear(); depths = getDistancesFromSOM(g); /* due to renumbering, need to * regenerate */ prefix = makePrefixForChain(g, regions, info, picked, &depths, prefix_by_rev, rm); escapes.clear(); DEBUG_PRINTF("retrying\n"); goto retry; } } DEBUG_PRINTF("som planning ok\n"); /* if the initial prefix is weak is if sombe approaches are better */ if (findMinWidth(*prefix) <= depth(2)) { DEBUG_PRINTF("weak prefix... seeing if sombe can help out\n"); NGHolder g2; cloneHolder(g2, g_pristine); if (trySombe(ng, g2, som)) { return SOMBE_HANDLED_ALL; } } /* From this point we know that we are going to succeed or die horribly with * a pattern too large. Anything done past this point can be considered * committed to the compile. */ regions = assignRegions(g); // Update as g may have changed. DEBUG_PRINTF("-- get slot for initial plan\n"); u32 som_loc; if (plan[0].is_reset) { som_loc = ssm.getInitialResetSomSlot(*prefix, g, regions, picked->first, &plan[0].no_implement); } else { som_loc = ssm.getSomSlot(*prefix, escapes, false, SomSlotManager::NO_PARENT); } replaceTempSomSlot(rm, *prefix, som_loc); if (plan.front().is_reset) { updatePrefixReports(rm, *prefix, INTERNAL_SOM_LOC_SET); } if (prefix_by_rev && !plan.front().no_implement) { u32 rev_comp_id = doSomRevNfaPrefix(ng, w, *prefix, cc); updatePrefixReportsRevNFA(rm, *prefix, rev_comp_id); } implementSomPlan(ng, w, comp_id, g, plan, som_loc); DEBUG_PRINTF("success\n"); return SOMBE_HANDLED_INTERNAL; } sombe_rv doSomWithHaig(NG &ng, NGHolder &g, const NGWrapper &w, u32 comp_id, som_type som) { assert(som); DEBUG_PRINTF("som+haig hello\n"); // A pristine copy of the input graph, which must be restored to in paths // that return false. Also used as the forward graph for som rev nfa // construction. NGHolder g_pristine; cloneHolder(g_pristine, g); if (trySombe(ng, g, som)) { return SOMBE_HANDLED_ALL; } if (!ng.cc.grey.allowHaigLit || !ng.cc.grey.allowSomChain) { return SOMBE_FAIL; } // know that we have an absolute SOM of zero all the time. assert(edge(g.startDs, g.startDs, g).second); vector depths = getDistancesFromSOM(g); // try a redundancy pass. if (addSomRedundancy(g, depths)) { depths = getDistancesFromSOM(g); } auto regions = assignRegions(g); dumpHolder(g, regions, 21, "som_explode", ng.cc.grey); map info; buildRegionMapping(g, regions, info, true); sombe_rv rv = doHaigLitSom(ng, g, w, comp_id, som, regions, info, info.begin()); if (rv == SOMBE_FAIL) { clear_graph(g); cloneHolder(g, g_pristine); } return rv; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_haig.h0000644000175000017500000000470013055426554020422 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Build code for Haig SOM DFA. */ #ifndef NG_HAIG_H #define NG_HAIG_H #include "ue2common.h" #include "som/som.h" #include #include namespace ue2 { class CharReach; class NGHolder; struct Grey; struct raw_som_dfa; #define HAIG_FINAL_DFA_STATE_LIMIT 16383 #define HAIG_HARD_DFA_STATE_LIMIT 8192 /* unordered_som_triggers being true indicates that a live haig may be subjected * to later tops arriving with earlier soms (without the haig going dead in * between) */ std::unique_ptr attemptToBuildHaig(const NGHolder &g, som_type som, u32 somPrecision, const std::vector> &triggers, const Grey &grey, bool unordered_som_triggers = false); std::unique_ptr attemptToMergeHaig(const std::vector &dfas, u32 limit = HAIG_HARD_DFA_STATE_LIMIT); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_violet.h0000644000175000017500000000373613055426554021024 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ /** \file * \brief Violet method of rose construction from NGHolder. */ #ifndef NG_VIOLET_H #define NG_VIOLET_H #include "ue2common.h" namespace ue2 { class NGHolder; class RoseBuild; struct CompileContext; /** \brief Attempt to consume the entire pattern in graph \a h with Rose. * Returns true if successful. */ bool doViolet(RoseBuild &rose, const NGHolder &h, bool prefilter, const CompileContext &cc); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_extparam.h0000644000175000017500000000360613055426554021337 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Propagate extended parameters to vertex reports and reduce graph if * possible. */ #ifndef NG_EXTPARAM_H #define NG_EXTPARAM_H namespace ue2 { struct CompileContext; class NGWrapper; class ReportManager; void handleExtendedParams(ReportManager &rm, NGWrapper &g, const CompileContext &cc); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_cyclic_redundancy.h0000644000175000017500000000347013055426554023177 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Cyclic Path Redundancy pass. Removes redundant vertices on paths * leading to a cyclic repeat. */ #ifndef NG_CYCLIC_REDUNDANCY_H #define NG_CYCLIC_REDUNDANCY_H namespace ue2 { class NGHolder; bool removeCyclicPathRedundancy(NGHolder &g); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_equivalence.h0000644000175000017500000000364213055426554022017 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Equivalence class graph reduction pass. */ #ifndef NG_EQUIVALENCE_H_ #define NG_EQUIVALENCE_H_ namespace ue2 { class NGHolder; struct CompileContext; /** Attempt to make the NFA graph \p g smaller by performing a number of local * transformations. */ bool reduceGraphEquivalences(NGHolder &g, const CompileContext &cc); } // namespace ue2 #endif /* NG_EQUIVALENCE_H_ */ hyperscan-4.4.1/src/nfagraph/ng_util.cpp0000644000175000017500000005235013055426554021026 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Miscellaneous NFA graph utilities. */ #include "ng_util.h" #include "grey.h" #include "ng_depth.h" // for NFAVertexDepth #include "ng_dump.h" #include "ue2common.h" #include "nfa/limex_limits.h" // for NFA_MAX_TOP_MASKS. #include "parser/position.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/order_check.h" #include "util/ue2string.h" #include "util/report_manager.h" #include #include #include #include #include using namespace std; using boost::default_color_type; using boost::make_filtered_graph; using boost::make_assoc_property_map; namespace ue2 { depth maxDistFromInit(const NFAVertexDepth &vd) { if (vd.fromStart.max.is_unreachable()) { return vd.fromStartDotStar.max; } else if (vd.fromStartDotStar.max.is_unreachable()) { return vd.fromStart.max; } else { return max(vd.fromStartDotStar.max, vd.fromStart.max); } } depth maxDistFromStartOfData(const NFAVertexDepth &vd) { if (vd.fromStartDotStar.max.is_reachable()) { /* the irrepressible nature of floating literals cannot be contained */ return depth::infinity(); } else { return vd.fromStart.max; } } NFAVertex getSoleDestVertex(const NGHolder &g, NFAVertex a) { assert(a != NGHolder::null_vertex()); NGHolder::out_edge_iterator ii, iie; tie(ii, iie) = out_edges(a, g); if (ii == iie) { return NGHolder::null_vertex(); } NFAVertex b = target(*ii, g); if (a == b) { ++ii; if (ii == iie) { return NGHolder::null_vertex(); } b = target(*ii, g); if (++ii != iie) { return NGHolder::null_vertex(); } } else if (++ii != iie && (target(*ii, g) != a || ++ii != iie)) { return NGHolder::null_vertex(); } assert(a != b); return b; } NFAVertex getSoleSourceVertex(const NGHolder &g, NFAVertex a) { assert(a != NGHolder::null_vertex()); u32 idegree = in_degree(a, g); if (idegree != 1 && !(idegree == 2 && hasSelfLoop(a, g))) { return NGHolder::null_vertex(); } NGHolder::in_edge_iterator ii, iie; tie(ii, iie) = in_edges(a, g); if (ii == iie) { return NGHolder::null_vertex(); } NFAVertex b = source(*ii, g); if (a == b) { ++ii; if (ii == iie) { return NGHolder::null_vertex(); } b = source(*ii, g); } assert(a != b); return b; } NFAVertex clone_vertex(NGHolder &g, NFAVertex v) { NFAVertex clone = add_vertex(g); u32 idx = g[clone].index; g[clone] = g[v]; g[clone].index = idx; return clone; } void clone_out_edges(NGHolder &g, NFAVertex source, NFAVertex dest) { for (const auto &e : out_edges_range(source, g)) { NFAVertex t = target(e, g); if (edge(dest, t, g).second) { continue; } NFAEdge clone = add_edge(dest, t, g); u32 idx = g[clone].index; g[clone] = g[e]; g[clone].index = idx; } } void clone_in_edges(NGHolder &g, NFAVertex s, NFAVertex dest) { for (const auto &e : in_edges_range(s, g)) { NFAVertex ss = source(e, g); assert(!edge(ss, dest, g).second); NFAEdge clone = add_edge(ss, dest, g); u32 idx = g[clone].index; g[clone] = g[e]; g[clone].index = idx; } } bool onlyOneTop(const NGHolder &g) { return getTops(g).size() == 1; } namespace { struct CycleFound {}; struct DetectCycles : public boost::default_dfs_visitor { explicit DetectCycles(const NGHolder &g) : startDs(g.startDs) {} void back_edge(const NFAEdge &e, const NGHolder &g) const { NFAVertex u = source(e, g), v = target(e, g); // We ignore the startDs self-loop. if (u == startDs && v == startDs) { return; } // Any other back-edge indicates a cycle. DEBUG_PRINTF("back edge %zu->%zu found\n", g[u].index, g[v].index); throw CycleFound(); } private: const NFAVertex startDs; }; } // namespace bool isVacuous(const NGHolder &h) { return edge(h.start, h.accept, h).second || edge(h.start, h.acceptEod, h).second || edge(h.startDs, h.accept, h).second || edge(h.startDs, h.acceptEod, h).second; } bool isAnchored(const NGHolder &g) { for (auto v : adjacent_vertices_range(g.startDs, g)) { if (v != g.startDs) { return false; } } return true; } bool isFloating(const NGHolder &g) { for (auto v : adjacent_vertices_range(g.start, g)) { if (v != g.startDs && !edge(g.startDs, v, g).second) { return false; } } return true; } bool isAcyclic(const NGHolder &g) { try { boost::depth_first_search(g, visitor(DetectCycles(g)) .root_vertex(g.start)); } catch (const CycleFound &) { return false; } return true; } /** True if the graph has a cycle reachable from the given source vertex. */ bool hasReachableCycle(const NGHolder &g, NFAVertex src) { assert(hasCorrectlyNumberedVertices(g)); vector colors(num_vertices(g)); try { // Use depth_first_visit, rather than depth_first_search, so that we // only search from src. auto index_map = get(vertex_index, g); boost::depth_first_visit(g, src, DetectCycles(g), make_iterator_property_map(colors.begin(), index_map)); } catch (const CycleFound &) { return true; } return false; } bool hasBigCycles(const NGHolder &g) { assert(hasCorrectlyNumberedVertices(g)); set dead; BackEdges> backEdgeVisitor(dead); boost::depth_first_search(g, visitor(backEdgeVisitor).root_vertex(g.start)); for (const auto &e : dead) { if (source(e, g) != target(e, g)) { return true; } } return false; } bool can_never_match(const NGHolder &g) { assert(edge(g.accept, g.acceptEod, g).second); if (in_degree(g.accept, g) == 0 && in_degree(g.acceptEod, g) == 1) { DEBUG_PRINTF("no paths into accept\n"); return true; } return false; } bool can_match_at_eod(const NGHolder &h) { if (in_degree(h.acceptEod, h) > 1) { DEBUG_PRINTF("more than one edge to acceptEod\n"); return true; } for (auto e : in_edges_range(h.accept, h)) { if (h[e].assert_flags) { DEBUG_PRINTF("edge to accept has assert flags %d\n", h[e].assert_flags); return true; } } return false; } bool can_only_match_at_eod(const NGHolder &g) { NGHolder::in_edge_iterator ie, ee; tie(ie, ee) = in_edges(g.accept, g); return ie == ee; } bool matches_everywhere(const NGHolder &h) { NFAEdge e = edge(h.startDs, h.accept, h); return e && !h[e].assert_flags; } bool is_virtual_start(NFAVertex v, const NGHolder &g) { return g[v].assert_flags & POS_FLAG_VIRTUAL_START; } static void reorderSpecials(const NGHolder &g, vector &topoOrder) { // Start is last element of reverse topo ordering. auto it = find(topoOrder.begin(), topoOrder.end(), g.start); if (it != topoOrder.end() - 1) { DEBUG_PRINTF("repositioning start\n"); assert(it != topoOrder.end()); topoOrder.erase(it); topoOrder.insert(topoOrder.end(), g.start); } // StartDs is second-to-last element of reverse topo ordering. it = find(topoOrder.begin(), topoOrder.end(), g.startDs); if (it != topoOrder.end() - 2) { DEBUG_PRINTF("repositioning start ds\n"); assert(it != topoOrder.end()); topoOrder.erase(it); topoOrder.insert(topoOrder.end() - 1, g.startDs); } // AcceptEOD is first element of reverse topo ordering. it = find(topoOrder.begin(), topoOrder.end(), g.acceptEod); if (it != topoOrder.begin()) { DEBUG_PRINTF("repositioning accept\n"); assert(it != topoOrder.end()); topoOrder.erase(it); topoOrder.insert(topoOrder.begin(), g.acceptEod); } // Accept is second element of reverse topo ordering, if it's connected. it = find(topoOrder.begin(), topoOrder.end(), g.accept); if (it != topoOrder.begin() + 1) { DEBUG_PRINTF("repositioning accept\n"); assert(it != topoOrder.end()); topoOrder.erase(it); if (in_degree(g.accept, g) != 0) { topoOrder.insert(topoOrder.begin() + 1, g.accept); } } } vector getTopoOrdering(const NGHolder &g) { assert(hasCorrectlyNumberedVertices(g)); // Use the same colour map for both DFS and topological_sort below: avoids // having to reallocate it, etc. const size_t num_verts = num_vertices(g); vector colour(num_verts); using EdgeSet = ue2::unordered_set; EdgeSet backEdges; BackEdges be(backEdges); auto index_map = get(vertex_index, g); depth_first_search(g, visitor(be).root_vertex(g.start) .color_map(make_iterator_property_map( colour.begin(), index_map))); auto acyclic_g = make_filtered_graph(g, make_bad_edge_filter(&backEdges)); vector ordering; ordering.reserve(num_verts); topological_sort(acyclic_g, back_inserter(ordering), color_map(make_iterator_property_map(colour.begin(), index_map))); reorderSpecials(g, ordering); return ordering; } static void mustBeSetBefore_int(NFAVertex u, const NGHolder &g, vector &vertexColor) { set s; insert(&s, adjacent_vertices(u, g)); set dead; // Edges leading to u or u's successors. for (auto v : inv_adjacent_vertices_range(u, g)) { for (const auto &e : out_edges_range(v, g)) { NFAVertex t = target(e, g); if (t == u || contains(s, t)) { dead.insert(e); } } } auto prefix = make_filtered_graph(g, make_bad_edge_filter(&dead)); depth_first_visit( prefix, g.start, make_dfs_visitor(boost::null_visitor()), make_iterator_property_map(vertexColor.begin(), get(vertex_index, g))); } bool mustBeSetBefore(NFAVertex u, NFAVertex v, const NGHolder &g, mbsb_cache &cache) { assert(&cache.g == &g); auto key = make_pair(g[u].index, g[v].index); DEBUG_PRINTF("cache checking (%zu)\n", cache.cache.size()); if (contains(cache.cache, key)) { DEBUG_PRINTF("cache hit\n"); return cache.cache[key]; } vector vertexColor(num_vertices(g)); mustBeSetBefore_int(u, g, vertexColor); for (auto vi : vertices_range(g)) { auto key2 = make_pair(g[u].index, g[vi].index); DEBUG_PRINTF("adding %zu %zu\n", key2.first, key2.second); assert(!contains(cache.cache, key2)); bool value = vertexColor[g[vi].index] == boost::white_color; cache.cache[key2] = value; assert(contains(cache.cache, key2)); } DEBUG_PRINTF("cache miss %zu %zu (%zu)\n", key.first, key.second, cache.cache.size()); return cache.cache[key]; } void appendLiteral(NGHolder &h, const ue2_literal &s) { DEBUG_PRINTF("adding '%s' to graph\n", dumpString(s).c_str()); vector tail; assert(in_degree(h.acceptEod, h) == 1); for (auto v : inv_adjacent_vertices_range(h.accept, h)) { tail.push_back(v); } assert(!tail.empty()); for (auto v : tail) { remove_edge(v, h.accept, h); } for (const auto &c : s) { NFAVertex v = add_vertex(h); h[v].char_reach = c; for (auto u : tail) { add_edge(u, v, h); } tail.clear(); tail.push_back(v); } for (auto v : tail) { add_edge(v, h.accept, h); } } ue2::flat_set getTops(const NGHolder &h) { ue2::flat_set tops; for (const auto &e : out_edges_range(h.start, h)) { insert(&tops, h[e].tops); } return tops; } void setTops(NGHolder &h, u32 top) { for (const auto &e : out_edges_range(h.start, h)) { assert(h[e].tops.empty()); if (target(e, h) == h.startDs) { continue; } h[e].tops.insert(top); } } void clearReports(NGHolder &g) { DEBUG_PRINTF("clearing reports without an accept edge\n"); ue2::unordered_set allow; insert(&allow, inv_adjacent_vertices(g.accept, g)); insert(&allow, inv_adjacent_vertices(g.acceptEod, g)); allow.erase(g.accept); // due to stylised edge. for (auto v : vertices_range(g)) { if (contains(allow, v)) { continue; } g[v].reports.clear(); } } void duplicateReport(NGHolder &g, ReportID r_old, ReportID r_new) { for (auto v : vertices_range(g)) { auto &reports = g[v].reports; if (contains(reports, r_old)) { reports.insert(r_new); } } } static void fillHolderOutEdges(NGHolder &out, const NGHolder &in, const ue2::unordered_map &v_map, NFAVertex u) { NFAVertex u_new = v_map.at(u); for (auto e : out_edges_range(u, in)) { NFAVertex v = target(e, in); if (is_special(u, in) && is_special(v, in)) { continue; } auto it = v_map.find(v); if (it == v_map.end()) { continue; } NFAVertex v_new = it->second; assert(!edge(u_new, v_new, out).second); add_edge(u_new, v_new, in[e], out); } } void fillHolder(NGHolder *outp, const NGHolder &in, const deque &vv, ue2::unordered_map *v_map_out) { NGHolder &out = *outp; ue2::unordered_map &v_map = *v_map_out; out.kind = in.kind; for (auto v : vv) { if (is_special(v, in)) { continue; } v_map[v] = add_vertex(in[v], out); } for (u32 i = 0; i < N_SPECIALS; i++) { v_map[in.getSpecialVertex(i)] = out.getSpecialVertex(i); } DEBUG_PRINTF("copied %zu vertices to NG graph\n", v_map.size()); fillHolderOutEdges(out, in, v_map, in.start); fillHolderOutEdges(out, in, v_map, in.startDs); for (auto u : vv) { if (is_special(u, in)) { continue; } fillHolderOutEdges(out, in, v_map, u); } renumber_edges(out); renumber_vertices(out); } void cloneHolder(NGHolder &out, const NGHolder &in) { assert(hasCorrectlyNumberedVertices(in)); assert(hasCorrectlyNumberedVertices(out)); out.kind = in.kind; // Note: depending on the state of the input graph, some stylized edges // (e.g. start->startDs) may not exist. This must be propagated to the // output graph as well. /* remove the existing special edges */ clear_vertex(out.startDs, out); clear_vertex(out.accept, out); renumber_edges(out); vector out_mapping(num_vertices(in)); out_mapping[NODE_START] = out.start; out_mapping[NODE_START_DOTSTAR] = out.startDs; out_mapping[NODE_ACCEPT] = out.accept; out_mapping[NODE_ACCEPT_EOD] = out.acceptEod; for (auto v : vertices_range(in)) { u32 i = in[v].index; /* special vertices are already in the out graph */ if (i >= N_SPECIALS) { assert(!out_mapping[i]); out_mapping[i] = add_vertex(in[v], out); } out[out_mapping[i]] = in[v]; } for (auto e : edges_range(in)) { u32 si = in[source(e, in)].index; u32 ti = in[target(e, in)].index; DEBUG_PRINTF("adding edge %u->%u\n", si, ti); NFAVertex s = out_mapping[si]; NFAVertex t = out_mapping[ti]; NFAEdge e2 = add_edge(s, t, out); out[e2] = in[e]; } // Safety checks. assert(num_vertices(in) == num_vertices(out)); assert(num_edges(in) == num_edges(out)); assert(hasCorrectlyNumberedVertices(out)); } void cloneHolder(NGHolder &out, const NGHolder &in, ue2::unordered_map *mapping) { cloneHolder(out, in); vector out_verts(num_vertices(in)); for (auto v : vertices_range(out)) { out_verts[out[v].index] = v; } mapping->clear(); for (auto v : vertices_range(in)) { (*mapping)[v] = out_verts[in[v].index]; assert((*mapping)[v]); } } unique_ptr cloneHolder(const NGHolder &in) { unique_ptr h = ue2::make_unique(); cloneHolder(*h, in); return h; } void reverseHolder(const NGHolder &g_in, NGHolder &g) { // Make the BGL do the grunt work. ue2::unordered_map vertexMap; boost::transpose_graph(g_in, g, orig_to_copy(boost::make_assoc_property_map(vertexMap))); // The transpose_graph operation will have created extra copies of our // specials. We have to rewire their neighbours to the 'real' specials and // delete them. NFAVertex start = vertexMap[g_in.acceptEod]; NFAVertex startDs = vertexMap[g_in.accept]; NFAVertex accept = vertexMap[g_in.startDs]; NFAVertex acceptEod = vertexMap[g_in.start]; // Successors of starts. for (const auto &e : out_edges_range(start, g)) { NFAVertex v = target(e, g); add_edge(g.start, v, g[e], g); } for (const auto &e : out_edges_range(startDs, g)) { NFAVertex v = target(e, g); add_edge(g.startDs, v, g[e], g); } // Predecessors of accepts. for (const auto &e : in_edges_range(accept, g)) { NFAVertex u = source(e, g); add_edge(u, g.accept, g[e], g); } for (const auto &e : in_edges_range(acceptEod, g)) { NFAVertex u = source(e, g); add_edge(u, g.acceptEod, g[e], g); } // Remove our impostors. clear_vertex(start, g); remove_vertex(start, g); clear_vertex(startDs, g); remove_vertex(startDs, g); clear_vertex(accept, g); remove_vertex(accept, g); clear_vertex(acceptEod, g); remove_vertex(acceptEod, g); // Renumber so that g's properties (number of vertices, edges) are // accurate. renumber_vertices(g); renumber_edges(g); assert(num_vertices(g) == num_vertices(g_in)); assert(num_edges(g) == num_edges(g_in)); } #ifndef NDEBUG bool allMatchStatesHaveReports(const NGHolder &g) { unordered_set reporters; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { if (g[v].reports.empty()) { DEBUG_PRINTF("vertex %zu has no reports!\n", g[v].index); return false; } reporters.insert(v); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (v == g.accept) { continue; // stylised edge } if (g[v].reports.empty()) { DEBUG_PRINTF("vertex %zu has no reports!\n", g[v].index); return false; } reporters.insert(v); } for (auto v : vertices_range(g)) { if (!contains(reporters, v) && !g[v].reports.empty()) { DEBUG_PRINTF("vertex %zu is not a match state, but has reports!\n", g[v].index); return false; } } return true; } bool isCorrectlyTopped(const NGHolder &g) { if (is_triggered(g)) { for (const auto &e : out_edges_range(g.start, g)) { if (g[e].tops.empty() != (target(e, g) == g.startDs)) { return false; } } } else { for (const auto &e : out_edges_range(g.start, g)) { if (!g[e].tops.empty()) { return false; } } } return true; } #endif // NDEBUG } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_util.h0000644000175000017500000002372713055426554020501 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Miscellaneous NFA graph utilities. */ #ifndef NG_UTIL_H #define NG_UTIL_H #include #include #include // for default_dfs_visitor #include "ng_holder.h" #include "ue2common.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/ue2_containers.h" namespace ue2 { struct Grey; struct NFAVertexDepth; struct ue2_literal; class depth; class ReportManager; depth maxDistFromInit(const NFAVertexDepth &d); depth maxDistFromStartOfData(const NFAVertexDepth &d); /** True if the given vertex is a dot (reachable on any character). */ template static really_inline bool is_dot(NFAVertex v, const GraphT &g) { return g[v].char_reach.all(); } /** adds successors of v to s */ template static really_inline void succ(const NGHolder &g, NFAVertex v, U *s) { auto rv = adjacent_vertices(v, g); s->insert(rv.first, rv.second); } template> ContTemp succs(NFAVertex u, const NGHolder &g) { ContTemp rv; succ(g, u, &rv); return rv; } /** adds predecessors of v to s */ template static really_inline void pred(const NGHolder &g, NFAVertex v, U *p) { auto rv = inv_adjacent_vertices(v, g); p->insert(rv.first, rv.second); } template> ContTemp preds(NFAVertex u, const NGHolder &g) { ContTemp rv; pred(g, u, &rv); return rv; } /** returns a vertex with an out edge from v and is not v. * v must have exactly one out-edge excluding self-loops. * will return NGHolder::null_vertex() if the preconditions don't hold. */ NFAVertex getSoleDestVertex(const NGHolder &g, NFAVertex v); /** Like getSoleDestVertex but for in-edges */ NFAVertex getSoleSourceVertex(const NGHolder &g, NFAVertex v); /** \brief edge filtered graph. * * This will give you a view over the graph that has none of the edges from * the provided set included. * * If this is provided with the back edges of the graph, this will result in an * acyclic subgraph view. This is useful for topological_sort and other * algorithms that require a DAG. */ template struct bad_edge_filter { bad_edge_filter() {} explicit bad_edge_filter(const EdgeSet *bad_e) : bad_edges(bad_e) {} bool operator()(const typename EdgeSet::value_type &e) const { return !contains(*bad_edges, e); /* keep edges not in the bad set */ } const EdgeSet *bad_edges = nullptr; }; template bad_edge_filter make_bad_edge_filter(const EdgeSet *e) { return bad_edge_filter(e); } /** Visitor that records back edges */ template class BackEdges : public boost::default_dfs_visitor { public: explicit BackEdges(BackEdgeSet &edges) : backEdges(edges) {} template void back_edge(const EdgeT &e, const GraphT &) { backEdges.insert(e); // Remove this back edge only } BackEdgeSet &backEdges; }; /** Returns true if the vertex is either of the real starts (NODE_START, * NODE_START_DOTSTAR). */ template static really_inline bool is_any_start(typename GraphT::vertex_descriptor v, const GraphT &g) { u32 i = g[v].index; return i == NODE_START || i == NODE_START_DOTSTAR; } bool is_virtual_start(NFAVertex v, const NGHolder &g); template bool is_any_accept(typename GraphT::vertex_descriptor v, const GraphT &g) { u32 i = g[v].index; return i == NODE_ACCEPT || i == NODE_ACCEPT_EOD; } /** returns true iff v has an edge to accept or acceptEod */ template bool is_match_vertex(typename GraphT::vertex_descriptor v, const GraphT &g) { return edge(v, g.accept, g).second || edge(v, g.acceptEod, g).second; } /** Generate a reverse topological ordering for a back-edge filtered version of * our graph (as it must be a DAG and correctly numbered). * * Note: we ensure that we produce a topo ordering that begins with acceptEod * and accept (if present) and ends with startDs followed by start. */ std::vector getTopoOrdering(const NGHolder &g); bool onlyOneTop(const NGHolder &g); /** Return the set of the tops on the given graph. */ flat_set getTops(const NGHolder &h); /** Initialise the tops on h to the provide top. Assumes that h is triggered and * no tops have been set on h. */ void setTops(NGHolder &h, u32 top = DEFAULT_TOP); /** adds a vertex to g with all the same vertex properties as \p v (aside from * index) */ NFAVertex clone_vertex(NGHolder &g, NFAVertex v); /** * \brief Copies all out-edges from source to target. * * Edge properties (aside from index) are preserved and duplicate edges are * skipped. */ void clone_out_edges(NGHolder &g, NFAVertex source, NFAVertex dest); /** * \brief Copies all in-edges from source to target. * * Edge properties (aside from index) are preserved. */ void clone_in_edges(NGHolder &g, NFAVertex source, NFAVertex dest); /** \brief True if the graph contains an edge from one of {start, startDs} to * one of {accept, acceptEod}. */ bool isVacuous(const NGHolder &h); /** \brief True if the graph contains no floating vertices (startDs has no * proper successors). */ bool isAnchored(const NGHolder &h); /** \brief True if the graph contains no anchored vertices (start has no * successors aside from startDs or vertices connected to startDs). */ bool isFloating(const NGHolder &h); /** True if the graph contains no back-edges at all, other than the * startDs self-loop. */ bool isAcyclic(const NGHolder &g); /** True if the graph has a cycle reachable from the given source vertex. */ bool hasReachableCycle(const NGHolder &g, NFAVertex src); /** True if g has any cycles which are not self-loops. */ bool hasBigCycles(const NGHolder &g); /** Returns the set of all vertices that appear in any of the graph's cycles. */ std::set findVerticesInCycles(const NGHolder &g); bool can_never_match(const NGHolder &g); /* \brief Does the graph have any edges leading into acceptEod (aside from * accept) or will it have after resolving asserts? */ bool can_match_at_eod(const NGHolder &h); bool can_only_match_at_eod(const NGHolder &g); /** \brief Does this graph become a "firehose", matching between every * byte? */ bool matches_everywhere(const NGHolder &h); struct mbsb_cache { explicit mbsb_cache(const NGHolder &gg) : g(gg) {} std::map, bool> cache; const NGHolder &g; }; /* weaker than straight domination as allows jump edges */ bool mustBeSetBefore(NFAVertex u, NFAVertex v, const NGHolder &g, mbsb_cache &cache); /* adds the literal 's' to the end of the graph before h.accept */ void appendLiteral(NGHolder &h, const ue2_literal &s); /** \brief Fill graph \a outp with a subset of the vertices in \a in (given in * \a in). A vertex mapping is returned in \a v_map_out. */ void fillHolder(NGHolder *outp, const NGHolder &in, const std::deque &vv, unordered_map *v_map_out); /** \brief Clone the graph in \a in into graph \a out, returning a vertex * mapping in \a v_map_out. */ void cloneHolder(NGHolder &out, const NGHolder &in, unordered_map *v_map_out); /** \brief Clone the graph in \a in into graph \a out. */ void cloneHolder(NGHolder &out, const NGHolder &in); /** \brief Build a clone of graph \a in and return a pointer to it. */ std::unique_ptr cloneHolder(const NGHolder &in); /** \brief Clear all reports on vertices that do not have an edge to accept or * acceptEod. */ void clearReports(NGHolder &g); /** \brief Add report \a r_new to every vertex that already has report \a * r_old. */ void duplicateReport(NGHolder &g, ReportID r_old, ReportID r_new); /** Construct a reversed copy of an arbitrary NGHolder, mapping starts to * accepts. */ void reverseHolder(const NGHolder &g, NGHolder &out); #ifndef NDEBUG // Assertions: only available in internal builds. /** * Used in sanity-checking assertions: returns true if all vertices * with edges to accept or acceptEod have at least one report ID. Additionally, * checks that ONLY vertices with edges to accept or acceptEod has reports. */ bool allMatchStatesHaveReports(const NGHolder &g); /** * Assertion: returns true if the graph is triggered and all edges out of start * have tops OR if the graph is not-triggered and all edges out of start have no * tops. */ bool isCorrectlyTopped(const NGHolder &g); #endif // NDEBUG } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_stop.cpp0000644000175000017500000001357113055426554021040 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Stop Alphabet calculation. */ #include "ng_stop.h" #include "ng_depth.h" #include "ng_holder.h" #include "ng_misc_opt.h" #include "ng_util.h" #include "ue2common.h" #include "nfa/castlecompile.h" #include "som/som.h" #include "util/charreach.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/verify_types.h" #include #include #include using namespace std; namespace ue2 { /** Stop alphabet depth threshold. */ static const u32 MAX_STOP_DEPTH = 8; namespace { /** Depths from start, startDs for this graph. */ struct InitDepths { explicit InitDepths(const NGHolder &g) { calcDepthsFrom(g, g.start, start); calcDepthsFrom(g, g.startDs, startDs); } depth maxDist(const NGHolder &g, NFAVertex v) const { u32 idx = g[v].index; assert(idx < start.size() && idx < startDs.size()); const depth &d_start = start.at(idx).max; const depth &d_startDs = startDs.at(idx).max; if (d_start.is_unreachable()) { return d_startDs; } else if (d_startDs.is_unreachable()) { return d_start; } return max(d_start, d_startDs); } private: vector start; vector startDs; }; } // namespace /** Find the set of characters that are not present in the reachability of * graph \p g after a certain depth (currently 8). If a character in this set * is encountered, it means that the NFA is either dead or has not progressed * more than 8 characters from its start states. */ CharReach findStopAlphabet(const NGHolder &g, som_type som) { const depth max_depth(MAX_STOP_DEPTH); const InitDepths depths(g); const map no_vertices; CharReach stopcr; for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } if (depths.maxDist(g, v) >= max_depth) { if (som == SOM_NONE) { stopcr |= reduced_cr(v, g, no_vertices); } else { stopcr |= g[v].char_reach; } } } // Turn alphabet into stops. stopcr.flip(); return stopcr; } /** Calculate the stop alphabet for each depth from 0 to MAX_STOP_DEPTH. Then * build an eight-bit mask per character C, with each bit representing the * depth before the location of character C (if encountered) that the NFA would * be in a predictable start state. */ vector findLeftOffsetStopAlphabet(const NGHolder &g, som_type som) { const depth max_depth(MAX_STOP_DEPTH); const InitDepths depths(g); const map no_vertices; vector reach(MAX_STOP_DEPTH); for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } CharReach v_cr; if (som == SOM_NONE) { v_cr = reduced_cr(v, g, no_vertices); } else { v_cr = g[v].char_reach; } u32 d = min(max_depth, depths.maxDist(g, v)); for (u32 i = 0; i < d; i++) { reach[i] |= v_cr; } } #ifdef DEBUG for (u32 i = 0; i < MAX_STOP_DEPTH; i++) { DEBUG_PRINTF("depth %u, stop chars: ", i); describeClass(stdout, ~reach[i], 20, CC_OUT_TEXT); printf("\n"); } #endif vector stop(N_CHARS, 0); for (u32 i = 0; i < MAX_STOP_DEPTH; i++) { CharReach cr = ~reach[i]; // invert reach for stop chars. const u8 mask = 1U << i; for (size_t c = cr.find_first(); c != cr.npos; c = cr.find_next(c)) { stop[c] |= mask; } } return stop; } vector findLeftOffsetStopAlphabet(const CastleProto &castle, UNUSED som_type som) { const depth max_width = findMaxWidth(castle); DEBUG_PRINTF("castle has reach %s and max width %s\n", describeClass(castle.reach()).c_str(), max_width.str().c_str()); const CharReach escape = ~castle.reach(); // invert reach for stop chars. u32 d = min(max_width, depth(MAX_STOP_DEPTH)); const u8 mask = verify_u8((1U << d) - 1); vector stop(N_CHARS, 0); for (size_t c = escape.find_first(); c != escape.npos; c = escape.find_next(c)) { stop[c] |= mask; } return stop; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_region.h0000644000175000017500000001541313055426554021000 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Region analysis and utility functions. */ #ifndef NG_REGION_H #define NG_REGION_H #include "ng_holder.h" #include "util/container.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include namespace ue2 { /** \brief Assign a region ID to every vertex in the graph. */ ue2::unordered_map assignRegions(const NGHolder &g); /** \brief True if vertices \p a and \p b are in the same region. */ template bool inSameRegion(const Graph &g, NFAVertex a, NFAVertex b, const ue2::unordered_map ®ion_map) { assert(contains(region_map, a) && contains(region_map, b)); return region_map.at(a) == region_map.at(b) && is_special(a, g) == is_special(b, g); } /** \brief True if vertex \p b is in a later region than vertex \p a. */ template bool inLaterRegion(const Graph &g, NFAVertex a, NFAVertex b, const ue2::unordered_map ®ion_map) { assert(contains(region_map, a) && contains(region_map, b)); u32 aa = g[a].index; u32 bb = g[b].index; if (bb == NODE_START || bb == NODE_START_DOTSTAR) { return false; } if (aa == NODE_START || aa == NODE_START_DOTSTAR) { return true; } if (bb == NODE_ACCEPT || bb == NODE_ACCEPT_EOD) { return true; } if (aa == NODE_ACCEPT || aa == NODE_ACCEPT_EOD) { return false; } return region_map.at(a) < region_map.at(b); } /** \brief True if vertex \p b is in an earlier region than vertex \p a. */ template bool inEarlierRegion(const Graph &g, NFAVertex a, NFAVertex b, const ue2::unordered_map ®ion_map) { assert(contains(region_map, a) && contains(region_map, b)); u32 aa = g[a].index; u32 bb = g[b].index; if (bb == NODE_START || bb == NODE_START_DOTSTAR) { return true; } if (aa == NODE_START || aa == NODE_START_DOTSTAR) { return false; } if (bb == NODE_ACCEPT || bb == NODE_ACCEPT_EOD) { return false; } if (aa == NODE_ACCEPT || aa == NODE_ACCEPT_EOD) { return true; } return region_map.at(b) < region_map.at(a); } /** \brief True if vertex \p v is an entry vertex for its region. */ template bool isRegionEntry(const Graph &g, NFAVertex v, const ue2::unordered_map ®ion_map) { // Note that some graph types do not have inv_adjacent_vertices, so we must // use in_edges here. for (const auto &e : in_edges_range(v, g)) { if (!inSameRegion(g, v, source(e, g), region_map)) { return true; } } return false; } /** \brief True if vertex \p v is an exit vertex for its region. */ template bool isRegionExit(const Graph &g, NFAVertex v, const ue2::unordered_map ®ion_map) { for (auto w : adjacent_vertices_range(v, g)) { if (!inSameRegion(g, v, w, region_map)) { return true; } } return false; } /** \brief True if vertex \p v is in a region all on its own. */ template bool isSingletonRegion(const Graph &g, NFAVertex v, const ue2::unordered_map ®ion_map) { for (const auto &e : in_edges_range(v, g)) { auto u = source(e, g); if (u != v && inSameRegion(g, v, u, region_map)) { return false; } for (auto w : ue2::adjacent_vertices_range(u, g)) { if (w != v && inSameRegion(g, v, w, region_map)) { return false; } } } for (auto w : adjacent_vertices_range(v, g)) { if (w != v && inSameRegion(g, v, w, region_map)) { return false; } for (const auto &e : in_edges_range(w, g)) { auto u = source(e, g); if (u != v && inSameRegion(g, v, u, region_map)) { return false; } } return true; } return true; } /** * \brief True if the region containing vertex \p v is optional. The vertex \p v * should be a region leader. */ template bool isOptionalRegion(const Graph &g, NFAVertex v, const ue2::unordered_map ®ion_map) { assert(isRegionEntry(g, v, region_map)); DEBUG_PRINTF("check if r%u is optional (inspecting v%zu)\n", region_map.at(v), g[v].index); // Region zero is never optional. assert(contains(region_map, v)); if (region_map.at(v) == 0) { return false; } // Optional if v has a predecessor in an earlier region that has a // successor in a later one. for (const auto &e : in_edges_range(v, g)) { auto u = source(e, g); if (inSameRegion(g, v, u, region_map)) { continue; } DEBUG_PRINTF(" searching from u=%zu\n", g[u].index); assert(inEarlierRegion(g, v, u, region_map)); for (auto w : adjacent_vertices_range(u, g)) { DEBUG_PRINTF(" searching to w=%zu\n", g[w].index); if (inLaterRegion(g, v, w, region_map)) { return true; } } return false; } return false; } } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_limex.h0000644000175000017500000001210413055426554020625 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Limex NFA construction code. */ #ifndef NG_LIMEX_H #define NG_LIMEX_H #include "ue2common.h" #include "som/som.h" #include "util/alloc.h" #include #include #include struct NFA; namespace ue2 { class CharReach; class NG; class NGHolder; class ReportManager; struct CompileContext; /** \brief Determine if the given graph is implementable as an NFA. * * Returns zero if the NFA is not implementable (usually because it has too * many states for any of our models). Otherwise returns the number of states. * * ReportManager is used by NFA_SUFFIX and NFA_OUTFIX only. NFA_PREFIX and * NFA_INFIX use unmanaged rose-local reports. */ u32 isImplementableNFA(const NGHolder &g, const ReportManager *rm, const CompileContext &cc); /** \brief Late-stage graph reductions. * * This will call \ref removeRedundancy and apply its changes to the given * holder only if it is implementable afterwards. */ void reduceImplementableGraph(NGHolder &g, som_type som, const ReportManager *rm, const CompileContext &cc); /** * \brief For a given graph, count the number of accel states it will have in * an implementation. * * \return the number of accel states, or NFA_MAX_ACCEL_STATES + 1 if an * implementation would not be constructible. */ u32 countAccelStates(const NGHolder &g, const ReportManager *rm, const CompileContext &cc); /** \brief Construct an NFA from the given NFAGraph. * * Returns zero if the NFA is not implementable (usually because it has too * many states for any of our models). Otherwise returns the number of states. * * ReportManager is used by NFA_SUFFIX and NFA_OUTFIX only. NFA_PREFIX and * NFA_INFIX use unmanaged rose-local reports. * * Note: this variant of the function allows a model to be specified with the * \a hint parameter. */ aligned_unique_ptr constructNFA(const NGHolder &g, const ReportManager *rm, const std::map &fixed_depth_tops, const std::map>> &triggers, bool compress_state, const CompileContext &cc); /** \brief Build a reverse NFA from the graph given, which should have already * been reversed. * * Used for reverse NFAs used in SOM mode. */ aligned_unique_ptr constructReversedNFA(const NGHolder &h, const CompileContext &cc); #ifndef RELEASE_BUILD /** \brief Construct an NFA (with model type hint) from the given NFAGraph. * * Returns zero if the NFA is not implementable (usually because it has too * many states for any of our models). Otherwise returns the number of states. * * ReportManager is used by NFA_SUFFIX and NFA_OUTFIX only. NFA_PREFIX and * NFA_INFIX use unmanaged rose-local reports. * * Note: this variant of the function allows a model to be specified with the * \a hint parameter. */ aligned_unique_ptr constructNFA(const NGHolder &g, const ReportManager *rm, const std::map &fixed_depth_tops, const std::map>> &triggers, bool compress_state, u32 hint, const CompileContext &cc); /** \brief Build a reverse NFA (with model type hint) from the graph given, * which should have already been reversed. * * Used for reverse NFAs used in SOM mode. */ aligned_unique_ptr constructReversedNFA(const NGHolder &h, u32 hint, const CompileContext &cc); #endif // RELEASE_BUILD } // namespace ue2 #endif // NG_METEOR_H hyperscan-4.4.1/src/nfagraph/ng_mcclellan.cpp0000644000175000017500000004561013055426554022004 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Build code for McClellan DFA. */ #include "ng_mcclellan.h" #include "grey.h" #include "nfa/dfa_min.h" #include "nfa/rdfa.h" #include "ng_holder.h" #include "ng_mcclellan_internal.h" #include "ng_squash.h" #include "ng_util.h" #include "ue2common.h" #include "util/bitfield.h" #include "util/determinise.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include #include #include #include #include #include using namespace std; using boost::dynamic_bitset; namespace ue2 { #define FINAL_DFA_STATE_LIMIT 16383 #define DFA_STATE_LIMIT 1024 #define NFA_STATE_LIMIT 256 u16 buildAlphabetFromEquivSets(const std::vector &esets, array &alpha, array &unalpha) { u16 i = 0; for (; i < esets.size(); i++) { const CharReach &cr = esets[i]; #ifdef DEBUG DEBUG_PRINTF("eq set: "); for (size_t s = cr.find_first(); s != CharReach::npos; s = cr.find_next(s)) { printf("%02hhx ", (u8)s); } printf("-> %u\n", i); #endif u16 leader = cr.find_first(); for (size_t s = cr.find_first(); s != CharReach::npos; s = cr.find_next(s)) { alpha[s] = i; } unalpha[i] = leader; } for (u16 j = N_CHARS; j < ALPHABET_SIZE; j++, i++) { alpha[j] = i; unalpha[i] = j; } return i; // alphabet size } void calculateAlphabet(const NGHolder &g, array &alpha, array &unalpha, u16 *alphasize) { vector esets(1, CharReach::dot()); for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } const CharReach &cr = g[v].char_reach; for (size_t i = 0; i < esets.size(); i++) { if (esets[i].count() == 1) { continue; } CharReach t = cr & esets[i]; if (t.any() && t != esets[i]) { esets[i] &= ~t; esets.push_back(t); } } } // for deterministic compiles sort(esets.begin(), esets.end()); assert(alphasize); *alphasize = buildAlphabetFromEquivSets(esets, alpha, unalpha); } static bool allExternalReports(const ReportManager &rm, const flat_set &reports) { for (auto report_id : reports) { if (!isExternalReport(rm.getReport(report_id))) { return false; } } return true; } static dstate_id_t successor(const vector &dstates, dstate_id_t c, const array &alpha, symbol_t s) { return dstates[c].next[alpha[s]]; } void getFullTransitionFromState(const raw_dfa &n, dstate_id_t state, dstate_id_t *out_table) { for (u32 i = 0; i < ALPHABET_SIZE; i++) { out_table[i] = successor(n.states, state, n.alpha_remap, i); } } template static void populateInit(const NGHolder &g, const flat_set &unused, stateset *init, stateset *init_deep, vector *v_by_index) { for (auto v : vertices_range(g)) { if (contains(unused, v)) { continue; } u32 vert_id = g[v].index; assert(vert_id < init->size()); if (is_any_start(v, g)) { init->set(vert_id); if (hasSelfLoop(v, g) || is_triggered(g)) { DEBUG_PRINTF("setting %u\n", vert_id); init_deep->set(vert_id); } } } v_by_index->clear(); v_by_index->resize(num_vertices(g), NGHolder::null_vertex()); for (auto v : vertices_range(g)) { u32 vert_id = g[v].index; assert((*v_by_index)[vert_id] == NGHolder::null_vertex()); (*v_by_index)[vert_id] = v; } if (is_triggered(g)) { *init_deep = *init; } } template void populateAccepts(const NGHolder &g, const flat_set &unused, StateSet *accept, StateSet *acceptEod) { for (auto v : inv_adjacent_vertices_range(g.accept, g)) { if (contains(unused, v)) { continue; } accept->set(g[v].index); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (v == g.accept) { continue; } if (contains(unused, v)) { continue; } acceptEod->set(g[v].index); } } static bool canPruneEdgesFromAccept(const ReportManager &rm, const NGHolder &g) { bool seen = false; u32 ekey = 0; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { if (is_special(v, g)) { continue; } for (auto report_id : g[v].reports) { const Report &ir = rm.getReport(report_id); if (!isSimpleExhaustible(ir)) { return false; } if (!seen) { seen = true; ekey = ir.ekey; } else if (ekey != ir.ekey) { return false; } } } /* need to check accept eod does not have any unseen reports as well */ for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { if (is_special(v, g)) { continue; } for (auto report_id : g[v].reports) { const Report &ir = rm.getReport(report_id); if (!isSimpleExhaustible(ir)) { return false; } if (!seen) { seen = true; ekey = ir.ekey; } else if (ekey != ir.ekey) { return false; } } } return true; } static bool overhangMatchesTrigger(const vector > &all_triggers, vector::const_reverse_iterator itb, vector::const_reverse_iterator ite) { for (const auto &trigger : all_triggers) { vector::const_reverse_iterator it = itb; vector::const_reverse_iterator kt = trigger.rbegin(); for (; it != ite && kt != trigger.rend(); ++it, ++kt) { if ((*it & *kt).none()) { /* this trigger does not match the overhang, try next */ goto try_next_trigger; } } return true; try_next_trigger:; } return false; /* no trigger matches the over hang */ } static bool triggerAllowed(const NGHolder &g, const NFAVertex v, const vector > &all_triggers, const vector &trigger) { set curr; set next; curr.insert(v); for (auto it = trigger.rbegin(); it != trigger.rend(); ++it) { next.clear(); for (auto u : curr) { assert(u != g.startDs); /* triggered graphs should not use sds */ if (u == g.start) { if (overhangMatchesTrigger(all_triggers, it, trigger.rend())) { return true; } continue; } if ((g[u].char_reach & *it).none()) { continue; } insert(&next, inv_adjacent_vertices(u, g)); } if (next.empty()) { return false; } next.swap(curr); } return true; } void markToppableStarts(const NGHolder &g, const flat_set &unused, bool single_trigger, const vector> &triggers, dynamic_bitset<> *out) { if (single_trigger) { return; /* no live states can lead to new states */ } for (auto v : vertices_range(g)) { if (contains(unused, v)) { continue; } for (const auto &trigger : triggers) { if (triggerAllowed(g, v, triggers, trigger)) { DEBUG_PRINTF("idx %zu is valid location for top\n", g[v].index); out->set(g[v].index); break; } } } assert(out->test(g[g.start].index)); } namespace { template class Automaton_Base { public: using StateSet = typename Automaton_Traits::StateSet; using StateMap = typename Automaton_Traits::StateMap; Automaton_Base(const ReportManager *rm_in, const NGHolder &graph_in, bool single_trigger, const vector> &triggers, bool prunable_in) : rm(rm_in), graph(graph_in), numStates(num_vertices(graph)), unused(getRedundantStarts(graph_in)), init(Automaton_Traits::init_states(numStates)), initDS(Automaton_Traits::init_states(numStates)), squash(Automaton_Traits::init_states(numStates)), accept(Automaton_Traits::init_states(numStates)), acceptEod(Automaton_Traits::init_states(numStates)), toppable(Automaton_Traits::init_states(numStates)), dead(Automaton_Traits::init_states(numStates)), prunable(prunable_in) { populateInit(graph, unused, &init, &initDS, &v_by_index); populateAccepts(graph, unused, &accept, &acceptEod); start_anchored = DEAD_STATE + 1; if (initDS == init) { start_floating = start_anchored; } else if (initDS.any()) { start_floating = start_anchored + 1; } else { start_floating = DEAD_STATE; } calculateAlphabet(graph, alpha, unalpha, &alphasize); for (const auto &sq : findSquashers(graph)) { NFAVertex v = sq.first; u32 vert_id = graph[v].index; squash.set(vert_id); squash_mask[vert_id] = shrinkStateSet(sq.second); } cr_by_index = populateCR(graph, v_by_index, alpha); if (is_triggered(graph)) { dynamic_bitset<> temp(numStates); markToppableStarts(graph, unused, single_trigger, triggers, &temp); toppable = Automaton_Traits::copy_states(temp, numStates); } } private: // Convert an NFAStateSet (as used by the squash code) into a StateSet StateSet shrinkStateSet(const NFAStateSet &in) const { StateSet out = Automaton_Traits::init_states(numStates); for (size_t i = in.find_first(); i != in.npos && i < out.size(); i = in.find_next(i)) { out.set(i); } return out; } public: void transition(const StateSet &in, StateSet *next) { transition_graph(*this, v_by_index, in, next); } const vector initial() { vector rv = {init}; if (start_floating != DEAD_STATE && start_floating != start_anchored) { rv.push_back(initDS); } return rv; } private: void reports_i(const StateSet &in, bool eod, flat_set &rv) { StateSet acc = in & (eod ? acceptEod : accept); for (size_t i = acc.find_first(); i != StateSet::npos; i = acc.find_next(i)) { NFAVertex v = v_by_index[i]; DEBUG_PRINTF("marking report\n"); const auto &my_reports = graph[v].reports; rv.insert(my_reports.begin(), my_reports.end()); } } public: void reports(const StateSet &in, flat_set &rv) { reports_i(in, false, rv); } void reportsEod(const StateSet &in, flat_set &rv) { reports_i(in, true, rv); } bool canPrune(const flat_set &test_reports) const { if (!rm || !prunable || !canPruneEdgesFromAccept(*rm, graph)) { return false; } return allExternalReports(*rm, test_reports); } private: const ReportManager *rm; public: const NGHolder &graph; u32 numStates; const flat_set unused; vector v_by_index; vector cr_by_index; /* pre alpha'ed */ StateSet init; StateSet initDS; StateSet squash; /* states which allow us to mask out other states */ StateSet accept; StateSet acceptEod; StateSet toppable; /* states which are allowed to be on when a top arrives, * triggered dfas only */ StateSet dead; map squash_mask; bool prunable; array alpha; array unalpha; u16 alphasize; u16 start_anchored; u16 start_floating; }; struct Big_Traits { using StateSet = dynamic_bitset<>; using StateMap = map; static StateSet init_states(u32 num) { return StateSet(num); } static StateSet copy_states(const dynamic_bitset<> &in, UNUSED u32 num) { assert(in.size() == num); return in; } }; class Automaton_Big : public Automaton_Base { public: Automaton_Big(const ReportManager *rm_in, const NGHolder &graph_in, bool single_trigger, const vector> &triggers, bool prunable_in) : Automaton_Base(rm_in, graph_in, single_trigger, triggers, prunable_in) {} }; struct Graph_Traits { using StateSet = bitfield; using StateMap = ue2::unordered_map; static StateSet init_states(UNUSED u32 num) { assert(num <= NFA_STATE_LIMIT); return StateSet(); } static StateSet copy_states(const dynamic_bitset<> &in, u32 num) { StateSet out = init_states(num); for (size_t i = in.find_first(); i != in.npos && i < out.size(); i = in.find_next(i)) { out.set(i); } return out; } }; class Automaton_Graph : public Automaton_Base { public: Automaton_Graph(const ReportManager *rm_in, const NGHolder &graph_in, bool single_trigger, const vector> &triggers, bool prunable_in) : Automaton_Base(rm_in, graph_in, single_trigger, triggers, prunable_in) {} }; } // namespace static bool startIsRedundant(const NGHolder &g) { set start; set startDs; insert(&start, adjacent_vertices(g.start, g)); insert(&startDs, adjacent_vertices(g.startDs, g)); return start == startDs; } flat_set getRedundantStarts(const NGHolder &g) { flat_set dead; if (startIsRedundant(g)) { dead.insert(g.start); } if (proper_out_degree(g.startDs, g) == 0) { dead.insert(g.startDs); } return dead; } unique_ptr buildMcClellan(const NGHolder &graph, const ReportManager *rm, bool single_trigger, const vector> &triggers, const Grey &grey, bool finalChance) { if (!grey.allowMcClellan) { return nullptr; } DEBUG_PRINTF("attempting to build ?%d? mcclellan\n", (int)graph.kind); assert(allMatchStatesHaveReports(graph)); bool prunable = grey.highlanderPruneDFA && has_managed_reports(graph); assert(rm || !has_managed_reports(graph)); if (!has_managed_reports(graph)) { rm = nullptr; } assert(triggers.empty() == !is_triggered(graph)); /* We must be getting desperate if it is an outfix, so use the final chance * state limit logic */ u32 state_limit = (graph.kind == NFA_OUTFIX || finalChance) ? FINAL_DFA_STATE_LIMIT : DFA_STATE_LIMIT; unique_ptr rdfa = ue2::make_unique(graph.kind); const u32 numStates = num_vertices(graph); DEBUG_PRINTF("determinising nfa with %u vertices\n", numStates); if (numStates <= NFA_STATE_LIMIT) { /* Fast path. Automaton_Graph uses a bitfield internally to represent * states and is quicker than Automaton_Big. */ Automaton_Graph n(rm, graph, single_trigger, triggers, prunable); if (determinise(n, rdfa->states, state_limit)) { DEBUG_PRINTF("state limit exceeded\n"); return nullptr; /* over state limit */ } rdfa->start_anchored = n.start_anchored; rdfa->start_floating = n.start_floating; rdfa->alpha_size = n.alphasize; rdfa->alpha_remap = n.alpha; } else { /* Slow path. Too many states to use Automaton_Graph. */ Automaton_Big n(rm, graph, single_trigger, triggers, prunable); if (determinise(n, rdfa->states, state_limit)) { DEBUG_PRINTF("state limit exceeded\n"); return nullptr; /* over state limit */ } rdfa->start_anchored = n.start_anchored; rdfa->start_floating = n.start_floating; rdfa->alpha_size = n.alphasize; rdfa->alpha_remap = n.alpha; } minimize_hopcroft(*rdfa, grey); DEBUG_PRINTF("after determinised into %zu states, building impl dfa " "(a,f) = (%hu,%hu)\n", rdfa->states.size(), rdfa->start_anchored, rdfa->start_floating); return rdfa; } unique_ptr buildMcClellan(const NGHolder &g, const ReportManager *rm, const Grey &grey) { assert(!is_triggered(g)); vector> triggers; return buildMcClellan(g, rm, false, triggers, grey); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_anchored_acyclic.h0000644000175000017500000000400713055426554022764 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Anchored acyclic graph -> DFA analysis. */ #ifndef NG_ANCHORED_ACYCLIC_H #define NG_ANCHORED_ACYCLIC_H namespace ue2 { class NGHolder; class RoseBuild; struct CompileContext; /** \brief Attempt to consume the entire pattern in graph \a h as an anchored * acyclic DFA. Returns true if successful. */ bool splitOffAnchoredAcyclic(RoseBuild &rose, const NGHolder &h, const CompileContext &cc); } // namespace ue2 #endif // NG_ANCHORED_ACYCLIC_H hyperscan-4.4.1/src/nfagraph/ng_prefilter.cpp0000644000175000017500000003074013055426554022044 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Prefilter Reductions. * * This file contains routines for reducing the size of an NFA graph that we * know will be used as a prefilter. * * The approach used is to consider the graph as a chain of region subgraphs, * and to reduce the size of the graph by replacing regions with constructs * that can be implemented in fewer states. * * Right now, the approach used is to replace a region with a bounded repeat of * vertices (with bounds derived from the min/max width of the region * subgraph). These vertices are given the union of the region's character * reachability. * * For regions with bounded max width, this strategy is quite dependent on the * LimEx NFA's bounded repeat functionality. */ #include "ng_prefilter.h" #include "ng_holder.h" #include "ng_region.h" #include "ng_util.h" #include "ng_width.h" #include "ue2common.h" #include "util/compile_context.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/ue2_containers.h" #include "util/graph_range.h" #include #include using namespace std; using boost::adaptors::map_values; namespace ue2 { /** Keep attempting to reduce the size of the graph until the number of * vertices falls below this value. */ static const size_t MAX_COMPONENT_VERTICES = 128; /** Only replace a region with at least this many vertices. */ static const size_t MIN_REPLACE_VERTICES = 2; /** Estimate of how many vertices are required to represent a bounded repeat in * the implementation NFA. */ static const size_t BOUNDED_REPEAT_COUNT = 4; /** Scoring penalty for boundary regions. */ static const size_t PENALTY_BOUNDARY = 32; /** Regions with max bounds greater than this value will have their max bound * replaced with inf. */ static const size_t MAX_REPLACE_BOUND = 10000; namespace { /** Information describing a region. */ struct RegionInfo { explicit RegionInfo(u32 id_in) : id(id_in) {} u32 id; //!< region id deque vertices; //!< vertices in the region CharReach reach; //!< union of region reach depth minWidth = 0; //!< min width of region subgraph depth maxWidth = depth::infinity(); //!< max width of region subgraph bool atBoundary = false; //!< region is next to an accept // Bigger score is better. size_t score() const { // FIXME: charreach should be a signal? size_t numVertices = vertices.size(); if (atBoundary) { return numVertices - min(PENALTY_BOUNDARY, numVertices); } else { return numVertices; } } }; /** Comparator used to order regions for consideration in a priority queue. */ struct RegionInfoQueueComp { bool operator()(const RegionInfo &r1, const RegionInfo &r2) const { size_t score1 = r1.score(), score2 = r2.score(); if (score1 != score2) { return score1 < score2; } if (r1.reach.count() != r2.reach.count()) { return r1.reach.count() < r2.reach.count(); } return r1.id < r2.id; } }; } // namespace static void findWidths(const NGHolder &g, const ue2::unordered_map ®ion_map, RegionInfo &ri) { NGHolder rg; ue2::unordered_map mapping; fillHolder(&rg, g, ri.vertices, &mapping); // Wire our entries to start and our exits to accept. for (auto v : ri.vertices) { NFAVertex v_new = mapping[v]; assert(v_new != NGHolder::null_vertex()); if (isRegionEntry(g, v, region_map) && !edge(rg.start, v_new, rg).second) { add_edge(rg.start, v_new, rg); } if (isRegionExit(g, v, region_map) && !edge(v_new, rg.accept, rg).second) { add_edge(v_new, rg.accept, rg); } } ri.minWidth = findMinWidth(rg); ri.maxWidth = findMaxWidth(rg); } // acc can be either h.accept or h.acceptEod. static void markBoundaryRegions(const NGHolder &h, const ue2::unordered_map ®ion_map, map ®ions, NFAVertex acc) { for (auto v : inv_adjacent_vertices_range(acc, h)) { if (is_special(v, h)) { continue; } u32 id = region_map.at(v); auto ri = regions.find(id); if (ri == regions.end()) { continue; // Not tracking this region as it's too small. } ri->second.atBoundary = true; } } static map findRegionInfo(const NGHolder &h, const ue2::unordered_map ®ion_map) { map regions; for (auto v : vertices_range(h)) { if (is_special(v, h)) { continue; } u32 id = region_map.at(v); RegionInfo &ri = regions.emplace(id, RegionInfo(id)).first->second; ri.vertices.push_back(v); ri.reach |= h[v].char_reach; } // There's no point tracking more information about regions that we won't // consider replacing, so we remove them from the region map. for (auto it = regions.begin(); it != regions.end();) { if (it->second.vertices.size() < MIN_REPLACE_VERTICES) { regions.erase(it++); } else { ++it; } } DEBUG_PRINTF("%zu regions\n", regions.size()); markBoundaryRegions(h, region_map, regions, h.accept); markBoundaryRegions(h, region_map, regions, h.acceptEod); // Determine min/max widths. for (RegionInfo &ri : regions | map_values) { findWidths(h, region_map, ri); DEBUG_PRINTF("region %u %shas widths [%s,%s]\n", ri.id, ri.atBoundary ? "(boundary) " : "", ri.minWidth.str().c_str(), ri.maxWidth.str().c_str()); } return regions; } static void copyInEdges(NGHolder &g, NFAVertex from, NFAVertex to, const ue2::unordered_set &rverts) { for (const auto &e : in_edges_range(from, g)) { NFAVertex u = source(e, g); if (contains(rverts, u)) { continue; } add_edge_if_not_present(u, to, g[e], g); } } static void copyOutEdges(NGHolder &g, NFAVertex from, NFAVertex to, const ue2::unordered_set &rverts) { for (const auto &e : out_edges_range(from, g)) { NFAVertex t = target(e, g); if (contains(rverts, t)) { continue; } add_edge_if_not_present(to, t, g[e], g); if (is_any_accept(t, g)) { const auto &reports = g[from].reports; g[to].reports.insert(reports.begin(), reports.end()); } } } static void replaceRegion(NGHolder &g, const RegionInfo &ri, size_t *verticesAdded, size_t *verticesRemoved) { // TODO: more complex replacements. assert(ri.vertices.size() >= MIN_REPLACE_VERTICES); assert(ri.minWidth.is_finite()); depth minWidth = ri.minWidth; depth maxWidth = ri.maxWidth; if (maxWidth > depth(MAX_REPLACE_BOUND)) { DEBUG_PRINTF("using inf instead of large bound %s\n", maxWidth.str().c_str()); maxWidth = depth::infinity(); } size_t replacementSize; if (minWidth == maxWidth || maxWidth.is_infinite()) { replacementSize = minWidth; // {N} or {N,} } else { replacementSize = maxWidth; // {N,M} case } DEBUG_PRINTF("orig size %zu, replace size %zu\n", ri.vertices.size(), replacementSize); vector verts; verts.reserve(replacementSize); for (size_t i = 0; i < replacementSize; i++) { NFAVertex v = add_vertex(g); g[v].char_reach = ri.reach; if (i > 0) { add_edge(verts.back(), v, g); } verts.push_back(v); } if (maxWidth.is_infinite()) { add_edge(verts.back(), verts.back(), g); } // Set of vertices in region, for quick lookups. const ue2::unordered_set rverts(ri.vertices.begin(), ri.vertices.end()); for (size_t i = 0; i < replacementSize; i++) { NFAVertex v_new = verts[i]; for (auto v_old : ri.vertices) { if (i == 0) { copyInEdges(g, v_old, v_new, rverts); } if (i + 1 >= ri.minWidth) { copyOutEdges(g, v_old, v_new, rverts); } } } remove_vertices(ri.vertices, g, false); *verticesAdded = verts.size(); *verticesRemoved = ri.vertices.size(); } namespace { struct SourceHasEdgeToAccept { explicit SourceHasEdgeToAccept(const NGHolder &g_in) : g(g_in) {} bool operator()(const NFAEdge &e) const { return edge(source(e, g), g.accept, g).second; } const NGHolder &g; }; } static void reduceRegions(NGHolder &h) { map regions = findRegionInfo(h, assignRegions(h)); RegionInfoQueueComp cmp; priority_queue, RegionInfoQueueComp> pq(cmp); size_t numVertices = 0; for (const RegionInfo &ri : regions | map_values) { numVertices += ri.vertices.size(); pq.push(ri); } while (numVertices > MAX_COMPONENT_VERTICES && !pq.empty()) { const RegionInfo &ri = pq.top(); DEBUG_PRINTF("region %u: vertices=%zu reach=%s score=%zu, " "widths=[%s,%s]\n", ri.id, ri.vertices.size(), describeClass(ri.reach).c_str(), ri.score(), ri.minWidth.str().c_str(), ri.maxWidth.str().c_str()); size_t verticesAdded = 0; size_t verticesRemoved = 0; replaceRegion(h, ri, &verticesAdded, &verticesRemoved); DEBUG_PRINTF("%zu vertices removed, %zu vertices added\n", verticesRemoved, verticesAdded); // We are trusting that implementation NFAs will be able to use the // LimEx bounded repeat code here. numVertices -= verticesRemoved; numVertices += BOUNDED_REPEAT_COUNT; DEBUG_PRINTF("numVertices is now %zu\n", numVertices); pq.pop(); } // We may have vertices that have edges to both accept and acceptEod: in // this case, we can optimize for performance by removing the acceptEod // edges. remove_in_edge_if(h.acceptEod, SourceHasEdgeToAccept(h), h); } void prefilterReductions(NGHolder &h, const CompileContext &cc) { if (!cc.grey.prefilterReductions) { return; } if (num_vertices(h) <= MAX_COMPONENT_VERTICES) { DEBUG_PRINTF("graph is already small enough (%zu vertices)\n", num_vertices(h)); return; } DEBUG_PRINTF("before: graph with %zu vertices, %zu edges\n", num_vertices(h), num_edges(h)); renumber_vertices(h); renumber_edges(h); reduceRegions(h); renumber_vertices(h); renumber_edges(h); DEBUG_PRINTF("after: graph with %zu vertices, %zu edges\n", num_vertices(h), num_edges(h)); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_dump.cpp0000644000175000017500000003726013055426554021021 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Dump code for NFA graphs. * * The dump support in this file is for internal use only, and thus is not even * compiled in release builds, where DUMP_SUPPORT is not switched on. */ #include "config.h" #include "ng_dump.h" #include "hwlm/hwlm_build.h" #include "ng.h" #include "ng_util.h" #include "parser/position.h" #include "ue2common.h" #include "nfa/accel.h" #include "nfa/nfa_internal.h" // for MO_INVALID_IDX #include "smallwrite/smallwrite_dump.h" #include "rose/rose_build.h" #include "rose/rose_internal.h" #include "util/bitutils.h" #include "util/dump_charclass.h" #include "util/report.h" #include "util/report_manager.h" #include "util/ue2string.h" #include "hs_compile.h" /* for HS_MODE_* flags */ #include #include #include #include #include #include #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using namespace std; namespace ue2 { static void describeAssert(ostream &os, u32 flags) { #define DESCRIBE_ASSERT_CASE(x) case POS_FLAG_##x: s = #x; break while (flags) { const char *s; switch (1 << findAndClearLSB_32(&flags)) { DESCRIBE_ASSERT_CASE(NOFLOAT); DESCRIBE_ASSERT_CASE(MUST_FLOAT); DESCRIBE_ASSERT_CASE(FIDDLE_ACCEPT); DESCRIBE_ASSERT_CASE(VIRTUAL_START); DESCRIBE_ASSERT_CASE(MULTILINE_START); DESCRIBE_ASSERT_CASE(ASSERT_WORD_TO_WORD); DESCRIBE_ASSERT_CASE(ASSERT_WORD_TO_NONWORD); DESCRIBE_ASSERT_CASE(ASSERT_NONWORD_TO_WORD); DESCRIBE_ASSERT_CASE(ASSERT_NONWORD_TO_NONWORD); DESCRIBE_ASSERT_CASE(ASSERT_WORD_TO_WORD_UCP); DESCRIBE_ASSERT_CASE(ASSERT_WORD_TO_NONWORD_UCP); DESCRIBE_ASSERT_CASE(ASSERT_NONWORD_TO_WORD_UCP); DESCRIBE_ASSERT_CASE(ASSERT_NONWORD_TO_NONWORD_UCP); default: s = "unknown flag"; } os << s << "\\n"; } #undef DESCRIBE_ASSERT_CASE } static void describeReport(ostream &os, const ReportID report, const ReportManager *rm) { if (!rm) { os << "\\nReport: " << report; } else { os << "\\nReport: " << report << " ("; const Report &ir = rm->getReport(report); switch (ir.type) { case EXTERNAL_CALLBACK: os << "EXTERNAL " << ir.onmatch; if (ir.offsetAdjust) { os << " adj " << ir.offsetAdjust; } break; case EXTERNAL_CALLBACK_SOM_STORED: os << "SOM_STORED " << ir.somDistance; break; case EXTERNAL_CALLBACK_SOM_REL: os << "SOM_REL " << ir.somDistance; break; case EXTERNAL_CALLBACK_SOM_ABS: os << "SOM_ABS " << ir.somDistance; break; case EXTERNAL_CALLBACK_SOM_REV_NFA: os << "SOM_REV_NFA " << ir.revNfaIndex; break; case INTERNAL_SOM_LOC_SET: os << "SOM_LOC_SET " << ir.onmatch; break; case INTERNAL_SOM_LOC_SET_IF_UNSET: os << "SOM_LOC_SET_IF_UNSET " << ir.onmatch; break; case INTERNAL_SOM_LOC_SET_IF_WRITABLE: os << "SOM_LOC_SET_IF_WRITABLE " << ir.onmatch; break; case INTERNAL_SOM_LOC_SET_SOM_REV_NFA: os << "SOM_LOC_SET_SOM_REV_NFA " << ir.onmatch << " nfa=" << ir.revNfaIndex; break; case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET: os << "SOM_LOC_SET_SOM_REV_NFA_IF_UNSET " << ir.onmatch << " nfa=" << ir.revNfaIndex; break; case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE: os << "SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE " << ir.onmatch << " nfa=" << ir.revNfaIndex; break; case INTERNAL_SOM_LOC_COPY: os << "SOM_LOC_COPY " << ir.somDistance << " to " << ir.onmatch; break; case INTERNAL_SOM_LOC_COPY_IF_WRITABLE: os << "SOM_LOC_COPY_IF_WRITABLE " << ir.somDistance << " to " << ir.onmatch; break; case INTERNAL_SOM_LOC_MAKE_WRITABLE: os << "SOM_LOC_MAKE_WRITABLE " << ir.onmatch; break; default: os << "no dump code!"; break; } os << ")"; } } namespace { template class NFAWriter { public: explicit NFAWriter(const GraphT &g_in) : g(g_in) {} NFAWriter(const GraphT &g_in, const ReportManager &rm_in) : g(g_in), rm(&rm_in) {} NFAWriter(const GraphT &g_in, const ue2::unordered_map ®ion_map_in) : g(g_in), region_map(®ion_map_in) {} void operator()(ostream& os, const VertexT& v) const { u32 v_index = g[v].index; os << "["; os << "fontsize=11, width=2, height=2, "; os << "label=\"" << v_index; os << "\\n"; if (is_special(v, g)) { switch (v_index) { case NODE_START: os << "START"; break; case NODE_START_DOTSTAR: os << "START-DS"; break; case NODE_ACCEPT: os << "ACCEPT"; break; case NODE_ACCEPT_EOD: os << "ACCEPT-EOD"; break; default: os << "UNKNOWN-SPECIAL"; break; } os << "\\n"; } else { // If it's an assert vertex, then display its info. u32 assert_flags = g[v].assert_flags; if (assert_flags) { describeAssert(os, assert_flags); os << "\\n"; } } // Dump character reachability (in brief). describeClass(os, g[v].char_reach, 5, CC_OUT_DOT); for (const auto &report : g[v].reports) { describeReport(os, report, rm); } os << "\","; if (is_any_start(v, g)) { os << "shape=octagon,"; } os << "]"; // If we have a region map, use it to generate clusters. if (region_map) { auto region_id = region_map->at(v); os << "subgraph cluster_" << region_id << " { label=\"region " << region_id << "\"; style=dashed;" << v_index << ";}"; } } void operator()(ostream& os, const EdgeT& e) const { // Edge label. Print priority. os << "[fontsize=9,label=\""; // print tops if any set. if (!g[e].tops.empty()) { os << "TOP " << as_string_list(g[e].tops) << "\\n"; } // If it's an assert vertex, then display its info. int assert_flags = g[e].assert_flags; if (assert_flags) { os << "\\n"; describeAssert(os, assert_flags); } os << "\"]"; } private: const GraphT &g; const ReportManager *rm = nullptr; const ue2::unordered_map *region_map = nullptr; }; } template void dumpGraphImpl(const char *name, const GraphT &g) { typedef typename boost::graph_traits::vertex_descriptor VertexT; typedef typename boost::graph_traits::edge_descriptor EdgeT; ofstream os(name); NFAWriter writer(g); writeGraphviz(os, g, writer, get(&NFAGraphVertexProps::index, g)); } template void dumpGraphImpl(const char *name, const GraphT &g, const ReportManager &rm) { typedef typename boost::graph_traits::vertex_descriptor VertexT; typedef typename boost::graph_traits::edge_descriptor EdgeT; ofstream os(name); NFAWriter writer(g, rm); writeGraphviz(os, g, writer, get(&NFAGraphVertexProps::index, g)); } template void dumpGraphImpl(const char *name, const GraphT &g, const ue2::unordered_map ®ion_map) { typedef typename boost::graph_traits::vertex_descriptor VertexT; typedef typename boost::graph_traits::edge_descriptor EdgeT; ofstream os(name); NFAWriter writer(g, region_map); writeGraphviz(os, g, writer, get(&NFAGraphVertexProps::index, g)); } // manual instantiation of templated dumpGraph above. template void dumpGraphImpl(const char *, const NGHolder &); void dumpDotWrapperImpl(const NGWrapper &nw, const char *name, const Grey &grey) { if (grey.dumpFlags & Grey::DUMP_INT_GRAPH) { stringstream ss; ss << grey.dumpPath << "Expr_" << nw.expressionIndex << "_" << name << ".dot"; DEBUG_PRINTF("dumping dot graph to '%s'\n", ss.str().c_str()); dumpGraphImpl(ss.str().c_str(), nw); } } void dumpComponentImpl(const NGHolder &g, const char *name, u32 expr, u32 comp, const Grey &grey) { if (grey.dumpFlags & Grey::DUMP_INT_GRAPH) { stringstream ss; ss << grey.dumpPath << "Comp_" << expr << "-" << comp << "_" << name << ".dot"; DEBUG_PRINTF("dumping dot graph to '%s'\n", ss.str().c_str()); dumpGraphImpl(ss.str().c_str(), g); } } void dumpSomSubComponentImpl(const NGHolder &g, const char *name, u32 expr, u32 comp, u32 plan, const Grey &grey) { if (grey.dumpFlags & Grey::DUMP_INT_GRAPH) { stringstream ss; ss << grey.dumpPath << "Comp_" << expr << "-" << comp << "_" << name << "_" << plan << ".dot"; DEBUG_PRINTF("dumping dot graph to '%s'\n", ss.str().c_str()); dumpGraphImpl(ss.str().c_str(), g); } } void dumpHolderImpl(const NGHolder &h, unsigned int stageNumber, const char *stageName, const Grey &grey) { if (grey.dumpFlags & Grey::DUMP_INT_GRAPH) { stringstream ss; ss << grey.dumpPath << "Holder_X_" << stageNumber << "-" << stageName << ".dot"; dumpGraphImpl(ss.str().c_str(), h); } } void dumpHolderImpl(const NGHolder &h, const ue2::unordered_map ®ion_map, unsigned int stageNumber, const char *stageName, const Grey &grey) { if (grey.dumpFlags & Grey::DUMP_INT_GRAPH) { stringstream ss; ss << grey.dumpPath << "Holder_X_" << stageNumber << "-" << stageName << ".dot"; dumpGraphImpl(ss.str().c_str(), h, region_map); } } void dumpSmallWrite(const RoseEngine *rose, const Grey &grey) { if (!grey.dumpFlags) { return; } const struct SmallWriteEngine *smwr = getSmallWrite(rose); stringstream ss; ss << grey.dumpPath << "smallwrite.txt"; FILE *f = fopen(ss.str().c_str(), "w"); smwrDumpText(smwr, f); fclose(f); smwrDumpNFA(smwr, false, grey.dumpPath); } static const char *reportTypeToString(ReportType type) { #define REPORT_TYPE_CASE(x) case x: return #x switch (type) { REPORT_TYPE_CASE(EXTERNAL_CALLBACK); REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_REL); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_IF_UNSET); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_IF_WRITABLE); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_COPY); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_COPY_IF_WRITABLE); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_MAKE_WRITABLE); REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_STORED); REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_ABS); REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_REV_NFA); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_FROM); REPORT_TYPE_CASE(INTERNAL_SOM_LOC_SET_FROM_IF_WRITABLE); REPORT_TYPE_CASE(INTERNAL_ROSE_CHAIN); REPORT_TYPE_CASE(EXTERNAL_CALLBACK_SOM_PASS); } #undef REPORT_TYPE_CASE assert(0); return ""; } static int isReverseNfaReport(const Report &report) { switch (report.type) { case INTERNAL_SOM_LOC_SET_SOM_REV_NFA: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_UNSET: case INTERNAL_SOM_LOC_SET_SOM_REV_NFA_IF_WRITABLE: case EXTERNAL_CALLBACK_SOM_REV_NFA: return 1; default: break; // fall through } return 0; } static int isSomRelSetReport(const Report &report) { switch (report.type) { case INTERNAL_SOM_LOC_SET: case INTERNAL_SOM_LOC_SET_IF_UNSET: case INTERNAL_SOM_LOC_SET_IF_WRITABLE: return 1; default: break; // fall through } return 0; } void dumpReportManager(const ReportManager &rm, const Grey &grey) { if (!grey.dumpFlags) { return; } stringstream ss; ss << grey.dumpPath << "internal_reports.txt"; FILE *f = fopen(ss.str().c_str(), "w"); const vector &reports = rm.reports(); for (size_t i = 0; i < reports.size(); i++) { const Report &report = reports[i]; fprintf(f, "%zu: %s onmatch: %u", i, reportTypeToString(report.type), report.onmatch); u32 dkey = rm.getDkey(report); if (dkey != MO_INVALID_IDX) { fprintf(f, " dkey %u", dkey); } if (report.ekey != INVALID_EKEY) { fprintf(f, " ekey %u", report.ekey); } if (report.hasBounds()) { fprintf(f, " hasBounds (minOffset=%llu, maxOffset=%llu, " "minLength=%llu)", report.minOffset, report.maxOffset, report.minLength); } if (report.quashSom) { fprintf(f, " quashSom"); } if (report.offsetAdjust != 0) { fprintf(f, " offsetAdjust: %d", report.offsetAdjust); } if (isReverseNfaReport(report)) { fprintf(f, " reverse nfa: %u", report.revNfaIndex); } if (isSomRelSetReport(report)) { fprintf(f, " set, adjust: %llu", report.somDistance); } if (report.type == EXTERNAL_CALLBACK_SOM_REL) { fprintf(f, " relative: %llu", report.somDistance); } if (report.type == EXTERNAL_CALLBACK_SOM_ABS) { fprintf(f, " absolute: %llu", report.somDistance); } fprintf(f, "\n"); } fclose(f); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_builder.cpp0000644000175000017500000002132613055426554021476 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief: NFA Graph Builder: used by Glushkov construction to construct an * NGWrapper from a parsed expression. */ #include "grey.h" #include "ng.h" #include "ng_builder.h" #include "ng_util.h" #include "ue2common.h" #include "compiler/compiler.h" // for ParsedExpression #include "util/compile_error.h" #include "util/make_unique.h" #include using namespace std; namespace ue2 { namespace { /** Concrete implementation of NFABuilder interface. */ class NFABuilderImpl : public NFABuilder { public: NFABuilderImpl(ReportManager &rm, const Grey &grey, const ParsedExpression &expr); ~NFABuilderImpl() override; Position makePositions(size_t nPositions) override; Position getStart() const override; Position getStartDotStar() const override; Position getAccept() const override; Position getAcceptEOD() const override; bool isSpecialState(Position p) const override; void setNodeReportID(Position position, int offsetAdjust) override; void addCharReach(Position position, const CharReach &cr) override; void setAssertFlag(Position position, u32 flag) override; u32 getAssertFlag(Position position) override; void addVertex(Position p) override; void addEdge(Position start, Position end) override; bool hasEdge(Position start, Position end) const override; u32 numVertices() const override { return vertIdx; } void cloneRegion(Position first, Position last, unsigned posOffset) override; unique_ptr getGraph() override; private: /** fetch a vertex given its Position ID. */ NFAVertex getVertex(Position pos) const; /** \brief Internal convenience function to add an edge (u, v). */ pair addEdge(NFAVertex u, NFAVertex v); /** \brief We use the ReportManager to hand out new internal reports. */ ReportManager &rm; /** \brief Greybox: used for resource limits. */ const Grey &grey; /** \brief Underlying NGWrapper graph. */ unique_ptr graph; /** \brief mapping from position to vertex. Use \ref getVertex for access. * */ vector id2vertex; /** \brief Index of next vertex. */ u32 vertIdx; }; // class NFABuilderImpl } // namespace NFABuilderImpl::NFABuilderImpl(ReportManager &rm_in, const Grey &grey_in, const ParsedExpression &expr) : rm(rm_in), grey(grey_in), graph(ue2::make_unique( expr.index, expr.highlander, expr.utf8, expr.prefilter, expr.som, expr.id, expr.min_offset, expr.max_offset, expr.min_length)), vertIdx(N_SPECIALS) { // Reserve space for a reasonably-sized NFA id2vertex.reserve(64); id2vertex.resize(N_SPECIALS); id2vertex[NODE_START] = graph->start; id2vertex[NODE_START_DOTSTAR] = graph->startDs; id2vertex[NODE_ACCEPT] = graph->accept; id2vertex[NODE_ACCEPT_EOD] = graph->acceptEod; } NFABuilderImpl::~NFABuilderImpl() { // empty } NFAVertex NFABuilderImpl::getVertex(Position pos) const { assert(id2vertex.size() >= pos); const NFAVertex v = id2vertex[pos]; assert(v != NGHolder::null_vertex()); assert((*graph)[v].index == pos); return v; } void NFABuilderImpl::addVertex(Position pos) { // Enforce resource limit. if (pos > grey.limitGraphVertices) { throw CompileError("Pattern too large."); } NFAVertex v = add_vertex(*graph); if (id2vertex.size() <= pos) { id2vertex.resize(pos + 1); } id2vertex[pos] = v; (*graph)[v].index = pos; } unique_ptr NFABuilderImpl::getGraph() { DEBUG_PRINTF("built graph has %zu vertices and %zu edges\n", num_vertices(*graph), num_edges(*graph)); if (num_edges(*graph) > grey.limitGraphEdges) { throw CompileError("Pattern too large."); } if (num_vertices(*graph) > grey.limitGraphVertices) { throw CompileError("Pattern too large."); } return move(graph); } void NFABuilderImpl::setNodeReportID(Position pos, int offsetAdjust) { Report ir = rm.getBasicInternalReport(*graph, offsetAdjust); DEBUG_PRINTF("setting report id on %u = (%u, %d, %u)\n", pos, graph->reportId, offsetAdjust, ir.ekey); NFAVertex v = getVertex(pos); auto &reports = (*graph)[v].reports; reports.clear(); reports.insert(rm.getInternalId(ir)); } void NFABuilderImpl::addCharReach(Position pos, const CharReach &cr) { NFAVertex v = getVertex(pos); (*graph)[v].char_reach |= cr; } void NFABuilderImpl::setAssertFlag(Position pos, u32 flag) { NFAVertex v = getVertex(pos); (*graph)[v].assert_flags |= flag; } u32 NFABuilderImpl::getAssertFlag(Position pos) { NFAVertex v = getVertex(pos); return (*graph)[v].assert_flags; } pair NFABuilderImpl::addEdge(NFAVertex u, NFAVertex v) { // assert that the edge doesn't already exist assert(edge(u, v, *graph).second == false); return add_edge(u, v, *graph); } void NFABuilderImpl::addEdge(Position startPos, Position endPos) { DEBUG_PRINTF("%u -> %u\n", startPos, endPos); assert(startPos < vertIdx); assert(endPos < vertIdx); NFAVertex u = getVertex(startPos); NFAVertex v = getVertex(endPos); if ((u == graph->start || u == graph->startDs) && v == graph->startDs) { /* standard special -> special edges already exist */ assert(edge(u, v, *graph).second == true); return; } assert(edge(u, v, *graph).second == false); addEdge(u, v); } bool NFABuilderImpl::hasEdge(Position startPos, Position endPos) const { return edge(getVertex(startPos), getVertex(endPos), *graph).second; } Position NFABuilderImpl::getStart() const { return NODE_START; } Position NFABuilderImpl::getStartDotStar() const { return NODE_START_DOTSTAR; } Position NFABuilderImpl::getAccept() const { return NODE_ACCEPT; } Position NFABuilderImpl::getAcceptEOD() const { return NODE_ACCEPT_EOD; } bool NFABuilderImpl::isSpecialState(Position p) const { return (p == NODE_START || p == NODE_START_DOTSTAR || p == NODE_ACCEPT || p == NODE_ACCEPT_EOD); } Position NFABuilderImpl::makePositions(size_t nPositions) { Position base = vertIdx; for (size_t i = 0; i < nPositions; i++) { addVertex(vertIdx++); } DEBUG_PRINTF("built %zu positions from base %u\n", nPositions, base); return base; } void NFABuilderImpl::cloneRegion(Position first, Position last, unsigned posOffset) { NGHolder &g = *graph; assert(posOffset > 0); // walk the nodes between first and last and copy their vertex properties DEBUG_PRINTF("cloning nodes in [%u, %u], offset %u\n", first, last, posOffset); for (Position i = first; i <= last; ++i) { NFAVertex orig = getVertex(i); Position destIdx = i + posOffset; assert(destIdx < vertIdx); NFAVertex dest = getVertex(destIdx); g[dest] = g[orig]; // all properties g[dest].index = destIdx; } } unique_ptr makeNFABuilder(ReportManager &rm, const CompileContext &cc, const ParsedExpression &expr) { return ue2::make_unique(rm, cc.grey, expr); } NFABuilder::~NFABuilder() { } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_limex_accel.h0000644000175000017500000000731513055426554021764 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA acceleration analysis code. */ #ifndef NG_LIMEX_ACCEL_H #define NG_LIMEX_ACCEL_H #include "ng_holder.h" #include "ng_misc_opt.h" #include "ue2common.h" #include "nfa/accelcompile.h" #include "util/accel_scheme.h" #include "util/charreach.h" #include "util/order_check.h" #include "util/ue2_containers.h" #include #include namespace ue2 { /* compile time accel defs */ #define MAX_MERGED_ACCEL_STOPS 200 #define ACCEL_MAX_STOP_CHAR 24 #define ACCEL_MAX_FLOATING_STOP_CHAR 192 /* accelerating sds is important */ #define MULTIACCEL_MIN_LEN 3 #define MULTIACCEL_MAX_LEN_SSE 15 #define MULTIACCEL_MAX_LEN_AVX2 31 // forward-declaration of CompileContext struct CompileContext; void findAccelFriends(const NGHolder &g, NFAVertex v, const std::map &br_cyclic, u32 offset, ue2::flat_set *friends); #define DOUBLE_SHUFTI_LIMIT 20 NFAVertex get_sds_or_proxy(const NGHolder &g); AccelScheme nfaFindAccel(const NGHolder &g, const std::vector &verts, const std::vector &refined_cr, const std::map &br_cyclic, bool allow_wide, bool look_for_double_byte = false); AccelScheme findBestAccelScheme(std::vector > paths, const CharReach &terminating, bool look_for_double_byte = false); /** \brief Check if vertex \a v is an accelerable state (for a limex NFA). If a * single byte accel scheme is found it is placed into *as */ bool nfaCheckAccel(const NGHolder &g, NFAVertex v, const std::vector &refined_cr, const std::map &br_cyclic, AccelScheme *as, bool allow_wide); /** \brief Check if vertex \a v is a multi accelerable state (for a limex NFA). */ MultibyteAccelInfo nfaCheckMultiAccel(const NGHolder &g, const std::vector &verts, const CompileContext &cc); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_small_literal_set.h0000644000175000017500000000405313055426554023212 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Rose construction from NGHolder for cases representing small literal * sets. */ #ifndef NG_SMALL_LITERAL_SET_H #define NG_SMALL_LITERAL_SET_H namespace ue2 { class RoseBuild; class NGHolder; struct CompileContext; /** \brief If the graph represents a small set of literals, feed them directly * to rose. Returns true if successful. */ bool handleSmallLiteralSets(RoseBuild &rose, const NGHolder &h, const CompileContext &cc); } // namespace ue2 #endif // NG_SMALL_LITERAL_SET_H hyperscan-4.4.1/src/nfagraph/ng_holder.h0000644000175000017500000001671413055426554020777 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Definition of the NGHolder type used for to represent general nfa * graphs as well as all associated types (vertex and edge properties, etc). * * The NGHolder also contains the special vertices used to represents starts and * accepts. */ #ifndef NG_HOLDER_H #define NG_HOLDER_H #include "ue2common.h" #include "nfa/nfa_kind.h" #include "util/charreach.h" #include "util/ue2_containers.h" #include "util/ue2_graph.h" namespace ue2 { /** \brief Properties associated with each vertex in an NFAGraph. */ struct NFAGraphVertexProps { /** \brief Set of characters on which this vertex is reachable. */ CharReach char_reach; /** \brief Set of reports raised by this vertex. */ flat_set reports; /** \brief Unique index for this vertex, used for BGL algorithms. */ size_t index = 0; /** \brief Flags associated with assertions. */ u32 assert_flags = 0; }; /** \brief Properties associated with each edge in an NFAGraph. */ struct NFAGraphEdgeProps { /** \brief Unique index for this edge, used for BGL algorithms. */ size_t index = 0; /** \brief For graphs that will be implemented as multi-top engines, this * specifies the top events. Only used on edges from the start vertex. */ ue2::flat_set tops; /** \brief Flags associated with assertions. */ u32 assert_flags = 0; }; /** \brief vertex_index values for special nodes in the NFAGraph. */ enum SpecialNodes { /** \brief Anchored start vertex. WARNING: this may be triggered at various * locations (not just zero) for triggered graphs. */ NODE_START, /** \brief Unanchored start-dotstar vertex. WARNING: this may not have a * proper self-loop. */ NODE_START_DOTSTAR, /** \brief Accept vertex. All vertices that can match at arbitrary offsets * must have an edge to this vertex. */ NODE_ACCEPT, /** \brief Accept-EOD vertex. Vertices that must raise a match at EOD only * must have an edge to this vertex. */ NODE_ACCEPT_EOD, /** \brief Sentinel, number of special vertices. */ N_SPECIALS }; /** \brief Encapsulates an NFAGraph, stores special vertices and other * metadata. * * When constructed, the graph will have the following stylised "special" * edges: * * - (start, startDs) * - (startDs, startDs) (self-loop) * - (accept, acceptEod) */ class NGHolder : public ue2_graph { public: explicit NGHolder(nfa_kind kind); NGHolder(void) : NGHolder(NFA_OUTFIX) {}; virtual ~NGHolder(void); nfa_kind kind; /* Role that this plays in Rose */ static const size_t N_SPECIAL_VERTICES = N_SPECIALS; public: const vertex_descriptor start; //!< Anchored start vertex. const vertex_descriptor startDs; //!< Unanchored start-dotstar vertex. const vertex_descriptor accept; //!< Accept vertex. const vertex_descriptor acceptEod; //!< Accept at EOD vertex. vertex_descriptor getSpecialVertex(u32 id) const; }; typedef NGHolder::vertex_descriptor NFAVertex; typedef NGHolder::edge_descriptor NFAEdge; /** \brief True if the vertex \p v is one of our special vertices. */ template bool is_special(const typename GraphT::vertex_descriptor v, const GraphT &g) { return g[v].index < N_SPECIALS; } /** * \brief Clears all non-special vertices and edges from the graph. * * Note: not the same as the BGL's clear() function, which removes all vertices * and edges. */ void clear_graph(NGHolder &h); /* * \brief Clear and remove all of the vertices pointed to by the given iterator * range. * * If renumber is false, no renumbering of vertex indices is done. * * Note: should not be called with iterators that will be invalidated by vertex * removal (such as NFAGraph::vertex_iterator). */ template void remove_vertices(Iter begin, Iter end, NGHolder &h, bool renumber = true) { if (begin == end) { return; } for (Iter it = begin; it != end; ++it) { NFAVertex v = *it; if (!is_special(v, h)) { clear_vertex(v, h); remove_vertex(v, h); } else { assert(0); } } if (renumber) { renumber_edges(h); renumber_vertices(h); } } /** \brief Clear and remove all of the vertices pointed to by the vertex * descriptors in the given container. * * This is a convenience wrapper around the iterator variant above. */ template void remove_vertices(const Container &c, NGHolder &h, bool renumber = true) { remove_vertices(c.begin(), c.end(), h, renumber); } /* * \brief Clear and remove all of the edges pointed to by the given iterator * range. * * If renumber is false, no renumbering of vertex indices is done. * * Note: should not be called with iterators that will be invalidated by vertex * removal (such as NFAGraph::edge_iterator). */ template void remove_edges(Iter begin, Iter end, NGHolder &h, bool renumber = true) { if (begin == end) { return; } for (Iter it = begin; it != end; ++it) { const NFAEdge &e = *it; remove_edge(e, h); } if (renumber) { renumber_edges(h); } } #define DEFAULT_TOP 0U /** \brief Clear and remove all of the edges pointed to by the edge descriptors * in the given container. * * This is a convenience wrapper around the iterator variant above. */ template void remove_edges(const Container &c, NGHolder &h, bool renumber = true) { remove_edges(c.begin(), c.end(), h, renumber); } inline bool is_triggered(const NGHolder &g) { return is_triggered(g.kind); } inline bool generates_callbacks(const NGHolder &g) { return generates_callbacks(g.kind); } inline bool has_managed_reports(const NGHolder &g) { return has_managed_reports(g.kind); } inline bool inspects_states_for_accepts(const NGHolder &g) { return inspects_states_for_accepts(g.kind); } } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_sep.cpp0000644000175000017500000000627113055426554020641 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Short Exhaustible Passthroughs. * * Analysis code for determining whether a graph should be treated specially * because it is short and contains exhaustible reports; typically we turn * these into outfixes rather than risk them becoming Rose literals. * * For example, the pattern: * * /[a-f]/H * * ... is far better suited to becoming a small outfix that generates one match * and goes dead than being split into six one-byte Rose literals that end up * in the literal matcher. */ #include "ng_sep.h" #include "grey.h" #include "ng_holder.h" #include "ng_reports.h" #include "ng_util.h" #include "ue2common.h" #include "util/graph_range.h" using namespace std; namespace ue2 { static bool checkFromVertex(const NGHolder &g, NFAVertex start) { for (auto v : adjacent_vertices_range(start, g)) { if (v == g.startDs) { continue; } assert(!is_special(v, g)); /* should not be vacuous */ if (!edge(g.startDs, v, g).second) { /* only floating starts */ return false; } else if (out_degree(v, g) == 1 && edge(v, g.accept, g).second) { /* only floating end */ ; /* possible sep */ } else { return false; } } return true; } bool isSEP(const NGHolder &g, const ReportManager &rm, const Grey &grey) { if (!grey.mergeSEP || !can_exhaust(g, rm)) { return false; } if (!checkFromVertex(g, g.start) || !checkFromVertex(g, g.startDs)) { return false; } assert(out_degree(g.start, g) || proper_out_degree(g.startDs, g)); DEBUG_PRINTF("graph is an SEP\n"); return true; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_split.cpp0000644000175000017500000001724313055426554021206 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Functions for splitting NFAGraphs into LHS and RHS. */ #include "ng_split.h" #include "ng_holder.h" #include "ng_prune.h" #include "ng_util.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include #include #include using namespace std; namespace ue2 { static void clearAccepts(NGHolder &g) { for (auto v : inv_adjacent_vertices_range(g.accept, g)) { g[v].reports.clear(); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { g[v].reports.clear(); } clear_in_edges(g.accept, g); clear_in_edges(g.acceptEod, g); add_edge(g.accept, g.acceptEod, g); } static void filterSplitMap(const NGHolder &g, ue2::unordered_map *out_map) { ue2::unordered_set verts; insert(&verts, vertices(g)); ue2::unordered_map::iterator it = out_map->begin(); while (it != out_map->end()) { ue2::unordered_map::iterator jt = it; ++it; if (!contains(verts, jt->second)) { out_map->erase(jt); } } } static void splitLHS(const NGHolder &base, const vector &pivots, const vector &rhs_pivots, NGHolder *lhs, ue2::unordered_map *lhs_map) { assert(lhs && lhs_map); cloneHolder(*lhs, base, lhs_map); clearAccepts(*lhs); for (auto pivot : pivots) { DEBUG_PRINTF("pivot is %zu lv %zu lm %zu\n", base[pivot].index, num_vertices(*lhs), lhs_map->size()); assert(contains(*lhs_map, pivot)); for (auto v : rhs_pivots) { assert(contains(*lhs_map, v)); remove_edge((*lhs_map)[pivot], (*lhs_map)[v], *lhs); } (*lhs)[(*lhs_map)[pivot]].reports.insert(0); add_edge((*lhs_map)[pivot], lhs->accept, *lhs); } /* should do the renumbering unconditionally as we know edges are already * misnumbered */ pruneUseless(*lhs, false); renumber_edges(*lhs); renumber_vertices(*lhs); filterSplitMap(*lhs, lhs_map); switch (base.kind) { case NFA_PREFIX: case NFA_OUTFIX: lhs->kind = NFA_PREFIX; break; case NFA_INFIX: case NFA_SUFFIX: lhs->kind = NFA_INFIX; break; case NFA_EAGER_PREFIX: /* Current code should not be assigning eager until well after all the * splitting is done. */ assert(0); lhs->kind = NFA_EAGER_PREFIX; break; case NFA_REV_PREFIX: case NFA_OUTFIX_RAW: assert(0); break; } } void splitLHS(const NGHolder &base, NFAVertex pivot, NGHolder *lhs, ue2::unordered_map *lhs_map) { vector pivots(1, pivot); vector rhs_pivots; insert(&rhs_pivots, rhs_pivots.end(), adjacent_vertices(pivot, base)); splitLHS(base, pivots, rhs_pivots, lhs, lhs_map); } void splitRHS(const NGHolder &base, const vector &pivots, NGHolder *rhs, ue2::unordered_map *rhs_map) { assert(rhs && rhs_map); cloneHolder(*rhs, base, rhs_map); clear_out_edges(rhs->start, *rhs); clear_out_edges(rhs->startDs, *rhs); add_edge(rhs->start, rhs->startDs, *rhs); add_edge(rhs->startDs, rhs->startDs, *rhs); for (auto pivot : pivots) { assert(contains(*rhs_map, pivot)); NFAEdge e = add_edge(rhs->start, (*rhs_map)[pivot], *rhs); (*rhs)[e].tops.insert(DEFAULT_TOP); } /* should do the renumbering unconditionally as we know edges are already * misnumbered */ pruneUseless(*rhs, false); renumber_edges(*rhs); renumber_vertices(*rhs); filterSplitMap(*rhs, rhs_map); switch (base.kind) { case NFA_PREFIX: case NFA_INFIX: rhs->kind = NFA_INFIX; break; case NFA_SUFFIX: case NFA_OUTFIX: rhs->kind = NFA_SUFFIX; break; case NFA_EAGER_PREFIX: /* Current code should not be assigning eager until well after all the * splitting is done. */ assert(0); rhs->kind = NFA_INFIX; break; case NFA_REV_PREFIX: case NFA_OUTFIX_RAW: assert(0); break; } } /** \brief Fills \a succ with the common successors of the vertices in \a * pivots. */ static void findCommonSuccessors(const NGHolder &g, const vector &pivots, vector &succ) { assert(!pivots.empty()); set adj; set adj_temp; insert(&adj, adjacent_vertices(pivots.at(0), g)); for (auto it = pivots.begin() + 1, ite = pivots.end(); it != ite; ++it) { NFAVertex pivot = *it; adj_temp.clear(); for (auto v : adjacent_vertices_range(pivot, g)) { if (contains(adj, v)) { adj_temp.insert(v); } } adj.swap(adj_temp); } succ.insert(succ.end(), adj.begin(), adj.end()); } void splitGraph(const NGHolder &base, const vector &pivots, NGHolder *lhs, ue2::unordered_map *lhs_map, NGHolder *rhs, ue2::unordered_map *rhs_map) { DEBUG_PRINTF("splitting graph at %zu vertices\n", pivots.size()); assert(!has_parallel_edge(base)); assert(isCorrectlyTopped(base)); /* RHS pivots are built from the common set of successors of pivots. */ vector rhs_pivots; findCommonSuccessors(base, pivots, rhs_pivots); /* generate lhs */ splitLHS(base, pivots, rhs_pivots, lhs, lhs_map); /* generate the rhs */ splitRHS(base, rhs_pivots, rhs, rhs_map); assert(!has_parallel_edge(*lhs)); assert(!has_parallel_edge(*rhs)); assert(isCorrectlyTopped(*lhs)); assert(isCorrectlyTopped(*rhs)); } void splitGraph(const NGHolder &base, NFAVertex pivot, NGHolder *lhs, ue2::unordered_map *lhs_map, NGHolder *rhs, ue2::unordered_map *rhs_map) { vector pivots(1, pivot); splitGraph(base, pivots, lhs, lhs_map, rhs, rhs_map); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_revacc.cpp0000644000175000017500000002530013055426554021307 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Reverse acceleration analysis. */ #include "ng_revacc.h" #include "grey.h" #include "ng_holder.h" #include "ue2common.h" #include "nfa/accel.h" #include "nfa/nfa_internal.h" #include "util/bitutils.h" #include "util/charreach.h" #include "util/graph_range.h" using namespace std; namespace ue2 { static bool isPseudoNoCaseChar(const CharReach &cr) { return cr.count() == 2 && !(cr.find_first() & 32) && cr.test(cr.find_first() | 32); } static bool lookForEodSchemes(const RevAccInfo &rev_info, const u32 minWidth, NFA *nfa) { DEBUG_PRINTF("pure eod triggered pattern\n"); /* 2 char */ for (u8 nocase = 0; nocase < 2; nocase++) { for (u8 i = 1; i < MAX_RACCEL_OFFSET; i++) { const CharReach &cr = rev_info.acceptEodReach[i]; const CharReach &cr2 = rev_info.acceptEodReach[i - 1]; if (!nocase && cr.count() == 1 && cr2.count() == 1) { assert(i < minWidth); if (i >= minWidth) { goto single; } nfa->rAccelType = ACCEL_RDEOD; nfa->rAccelData.array[0] = (u8)cr.find_first(); nfa->rAccelData.array[1] = (u8)cr2.find_first(); nfa->rAccelOffset = i + 1; DEBUG_PRINTF("raccel eod x2 %u %04hx\n", nfa->rAccelOffset, nfa->rAccelData.dc); return true; } else if (nocase && (cr.count() == 1 || isPseudoNoCaseChar(cr)) && (cr2.count() == 1 || isPseudoNoCaseChar(cr2))) { assert(i < minWidth); if (i >= minWidth) { goto single; } nfa->rAccelType = ACCEL_RDEOD_NOCASE; nfa->rAccelData.array[0] = (u8)cr.find_first() & CASE_CLEAR; /* uppercase */ nfa->rAccelData.array[1] = (u8)cr2.find_first() & CASE_CLEAR; nfa->rAccelOffset = i + 1; DEBUG_PRINTF("raccel nc eod x2 %u %04hx\n", nfa->rAccelOffset, nfa->rAccelData.dc); return true; } } } single: /* 1 char */ for (u8 nocase = 0; nocase < 2; nocase++) { for (u8 i = 0; i < MAX_RACCEL_OFFSET; i++) { const CharReach &cr = rev_info.acceptEodReach[i]; if (!nocase && cr.count() == 1) { assert(i < minWidth); if (i >= minWidth) { return false; } nfa->rAccelType = ACCEL_REOD; nfa->rAccelData.c = (u8) cr.find_first(); nfa->rAccelOffset = i + 1; DEBUG_PRINTF("raccel eod %u %02hhx\n", nfa->rAccelOffset, nfa->rAccelData.c); return true; } else if (nocase && isPseudoNoCaseChar(cr)) { assert(i < minWidth); if (i >= minWidth) { return false; } nfa->rAccelType = ACCEL_REOD_NOCASE; nfa->rAccelData.c = (u8)cr.find_first(); /* uppercase */ nfa->rAccelOffset = i + 1; DEBUG_PRINTF("raccel nc eod %u %02hhx\n", nfa->rAccelOffset, nfa->rAccelData.c); return true; } } } return false; } static bool lookForFloatingSchemes(const RevAccInfo &rev_info, const u32 minWidth, NFA *nfa) { /* 2 char */ for (u8 nocase = 0; nocase < 2; nocase++) { for (u8 i = 1; i < MAX_RACCEL_OFFSET; i++) { CharReach cr = rev_info.acceptEodReach[i] | rev_info.acceptReach[i]; CharReach cr2 = rev_info.acceptEodReach[i - 1] | rev_info.acceptReach[i - 1]; if (!nocase && cr.count() == 1 && cr2.count() == 1) { assert((u8)(i - 1) < minWidth); if (i > minWidth) { goto single; } nfa->rAccelType = ACCEL_RDVERM; nfa->rAccelData.array[0] = (u8)cr.find_first(); nfa->rAccelData.array[1] = (u8)cr2.find_first(); nfa->rAccelOffset = i; DEBUG_PRINTF("raccel dverm %u %02hhx%02hhx\n", nfa->rAccelOffset, nfa->rAccelData.array[0], nfa->rAccelData.array[1]); return true; } else if (nocase && (cr.count() == 1 || isPseudoNoCaseChar(cr)) && (cr2.count() == 1 || isPseudoNoCaseChar(cr2))) { assert((u8)(i - 1) < minWidth); if (i > minWidth) { goto single; } nfa->rAccelType = ACCEL_RDVERM_NOCASE; nfa->rAccelData.array[0] = (u8)cr.find_first() & CASE_CLEAR; nfa->rAccelData.array[1] = (u8)cr2.find_first() & CASE_CLEAR; nfa->rAccelOffset = i; DEBUG_PRINTF("raccel dverm %u %02hhx%02hhx nc\n", nfa->rAccelOffset, nfa->rAccelData.array[0], nfa->rAccelData.array[1]); return true; } } } single: /* 1 char */ for (u8 nocase = 0; nocase < 2; nocase++) { for (u8 i = 0; i < MAX_RACCEL_OFFSET; i++) { CharReach cr = rev_info.acceptEodReach[i] | rev_info.acceptReach[i]; if (!nocase && cr.count() == 1) { assert(i < minWidth); if (i >= minWidth) { return false; } nfa->rAccelType = ACCEL_RVERM; nfa->rAccelData.c = (u8)cr.find_first(); nfa->rAccelOffset = i + 1; DEBUG_PRINTF("raccel verm %u %02hhx\n", nfa->rAccelOffset, nfa->rAccelData.c); return true; } else if (nocase && isPseudoNoCaseChar(cr)) { assert(i < minWidth); if (i >= minWidth) { return false; } nfa->rAccelType = ACCEL_RVERM_NOCASE; nfa->rAccelData.c = (u8)cr.find_first(); /* 'uppercase' char */ nfa->rAccelOffset = i + 1; DEBUG_PRINTF("raccel nc verm %u %02hhx\n", nfa->rAccelOffset, nfa->rAccelData.c); return true; } } } return false; } void buildReverseAcceleration(NFA *nfa, const RevAccInfo &rev_info, u32 min_width, bool eod_only) { assert(nfa); if (!rev_info.valid) { return; } nfa->rAccelOffset = 1; assert(rev_info.acceptReach[0].any() || rev_info.acceptEodReach[0].any()); if (rev_info.acceptReach[0].none() && rev_info.acceptEodReach[0].none()) { DEBUG_PRINTF("expected path to accept\n"); return; } if (rev_info.acceptReach[0].none()) { /* eod only */ if (lookForEodSchemes(rev_info, min_width, nfa)) { assert(nfa->rAccelOffset <= min_width); return; } } if (eod_only) { return; } if (!lookForFloatingSchemes(rev_info, min_width, nfa)) { DEBUG_PRINTF("failed to accelerate\n"); } } static void populateRevAccelInfo(const NGHolder &g, NFAVertex terminal, vector *reach) { set vset; for (auto v : inv_adjacent_vertices_range(terminal, g)) { if (!is_special(v, g)) { vset.insert(v); } } for (u8 offset = 0; offset < MAX_RACCEL_OFFSET; offset++) { set next; for (auto v : vset) { const CharReach &cr = g[v].char_reach; (*reach)[offset] |= cr; DEBUG_PRINTF("off %u adding %zu to %zu\n", offset, cr.count(), (*reach)[offset].count()); for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == g.start || u == g.startDs) { /* kill all subsequent offsets by setting to dot, setting * to dot is in someways not accurate as there may be no * data at all but neither case can be accelerated */ for (u8 i = offset + 1; i < MAX_RACCEL_OFFSET; i++) { (*reach)[i].setall(); } break; } else if (!is_special(u, g)) { next.insert(u); } } } swap(vset, next); } } void populateReverseAccelerationInfo(RevAccInfo &rai, const NGHolder &g) { DEBUG_PRINTF("pop rev info\n"); populateRevAccelInfo(g, g.accept, &rai.acceptReach); populateRevAccelInfo(g, g.acceptEod, &rai.acceptEodReach); rai.valid = true; } void mergeReverseAccelerationInfo(RevAccInfo &dest, const RevAccInfo &vic) { DEBUG_PRINTF("merging ra\n"); dest.valid &= vic.valid; for (u8 i = 0; i < MAX_RACCEL_OFFSET; i++) { dest.acceptReach[i] |= vic.acceptReach[i]; dest.acceptEodReach[i] |= vic.acceptEodReach[i]; } } RevAccInfo::RevAccInfo(void) : valid(false), acceptReach(MAX_RACCEL_OFFSET), acceptEodReach(MAX_RACCEL_OFFSET) {} } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng.h0000644000175000017500000001115413055426554017433 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NG, NGHolder, NGWrapper declarations. */ #ifndef NG_H #define NG_H #include "ng_holder.h" #include "ue2common.h" #include "parser/position.h" #include "som/slot_manager.h" #include "som/som.h" #include "util/boundary_reports.h" #include "util/compile_context.h" #include "util/depth.h" #include "util/graph.h" #include "util/report_manager.h" #include "util/ue2_containers.h" #include #include #include #include #include #include namespace ue2 { struct CompileContext; struct ue2_literal; class NGWrapper : public NGHolder { public: NGWrapper(unsigned int expressionIndex, bool highlander, bool utf8, bool prefilter, const som_type som, ReportID rid, u64a min_offset, u64a max_offset, u64a min_length); ~NGWrapper() override; /** index of the expression represented by this graph, used * - down the track in error handling * - identifying parts of an expression in highlander mode */ const unsigned int expressionIndex; const ReportID reportId; /**< user-visible report id */ const bool highlander; /**< user-specified single match only */ const bool utf8; /**< UTF-8 mode */ const bool prefilter; /**< prefiltering mode */ const som_type som; /**< SOM type requested */ u64a min_offset; /**< extparam min_offset value */ u64a max_offset; /**< extparam max_offset value */ u64a min_length; /**< extparam min_length value */ }; class RoseBuild; class SmallWriteBuild; class NG : boost::noncopyable { public: NG(const CompileContext &in_cc, size_t num_patterns, unsigned in_somPrecision); ~NG(); /** \brief Consumes a pattern, returns false or throws a CompileError * exception if the graph cannot be consumed. */ bool addGraph(NGWrapper &w); /** \brief Consumes a graph, cut-down version of addGraph for use by SOM * processing. */ bool addHolder(NGHolder &h); /** \brief Adds a literal to Rose, used by literal shortcut passes (instead of * using \ref addGraph) */ bool addLiteral(const ue2_literal &lit, u32 expr_index, u32 external_report, bool highlander, som_type som); /** \brief Maximum history in bytes available for use by SOM reverse NFAs, * a hack for pattern support (see UE-1903). This is always set to the max * "lookbehind" length. */ const u32 maxSomRevHistoryAvailable; /** \brief The length of the shortest corpus which can match a pattern * contained in the NG (excluding the boundary reports used by vacuous * patterns, which give an effective minWidth of zero). */ depth minWidth; ReportManager rm; SomSlotManager ssm; BoundaryReports boundary; const CompileContext cc; const std::unique_ptr smwr; //!< SmallWrite builder. const std::unique_ptr rose; //!< Rose builder. }; /** \brief Run graph reduction passes. * * Shared with the small write compiler. */ void reduceGraph(NGHolder &g, som_type som, bool utf8, const CompileContext &cc); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_fixed_width.cpp0000644000175000017500000001065413055426554022350 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose mask construction from NGHolder. */ #include "ng_fixed_width.h" #include "grey.h" #include "ng_holder.h" #include "ng_util.h" #include "rose/rose_build.h" #include "util/container.h" #include "ue2common.h" #include #include #include using namespace std; namespace ue2 { static bool findMask(const NGHolder &g, vector *mask, bool *anchored, ue2::flat_set *reports) { DEBUG_PRINTF("looking for a mask pattern\n"); set s_succ; insert(&s_succ, adjacent_vertices(g.start, g)); set sds_succ; insert(&sds_succ, adjacent_vertices(g.startDs, g)); *anchored = sds_succ.size() == 1; /* sds itself */ bool floating = is_subset_of(s_succ, sds_succ); DEBUG_PRINTF("sds %zu s %zu%s%s\n", sds_succ.size(), s_succ.size(), *anchored ? " anchored" : "", floating ? " floating" : ""); if (!*anchored && !floating) { DEBUG_PRINTF("semi-anchored\n"); return false; } set &succs = *anchored ? s_succ : sds_succ; succs.erase(g.startDs); if (succs.size() != 1) { DEBUG_PRINTF("branchy root\n"); return false; } NFAVertex u = *anchored ? g.start : g.startDs; NFAVertex v = *succs.begin(); while (true) { DEBUG_PRINTF("validating vertex %zu\n", g[v].index); assert(v != g.acceptEod); // If we've reached an accept, we MAY have found a valid Rose pattern if (v == g.accept) { DEBUG_PRINTF("accept\n"); insert(reports, g[u].reports); return true; } mask->push_back(g[v].char_reach); if (out_degree(v, g) != 1) { DEBUG_PRINTF("out_degree != 1\n"); return false; /* not a chain */ } u = v; v = *adjacent_vertices(v, g).first; if (in_degree(v, g) != 1) { DEBUG_PRINTF("blargh\n"); /* picks up cases where there is no path * to case accept (large cycles), * ensures term */ return false; } } } bool handleFixedWidth(RoseBuild &rose, const NGHolder &g, const Grey &grey) { if (!grey.roseMasks) { return false; } if (in_degree(g.acceptEod,g) != 1) { DEBUG_PRINTF("EOD anchoring not supported\n"); return false; } ue2::flat_set reports; bool anchored = false; vector mask; if (!findMask(g, &mask, &anchored, &reports)) { return false; } DEBUG_PRINTF("%smasky masky\n", anchored ? "anchored " : ""); assert(!mask.empty()); assert(!reports.empty()); if (rose.add(anchored, mask, reports)) { DEBUG_PRINTF("added as rose mask\n"); return true; } else { DEBUG_PRINTF("failed to add masky\n"); return false; } } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng.cpp0000644000175000017500000004477013055426554020000 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NG, NGHolder, NGWrapper and graph handling. */ #include "grey.h" #include "ng.h" #include "ng_anchored_acyclic.h" #include "ng_anchored_dots.h" #include "ng_asserts.h" #include "ng_calc_components.h" #include "ng_cyclic_redundancy.h" #include "ng_dump.h" #include "ng_edge_redundancy.h" #include "ng_equivalence.h" #include "ng_extparam.h" #include "ng_fixed_width.h" #include "ng_haig.h" #include "ng_literal_component.h" #include "ng_literal_decorated.h" #include "ng_misc_opt.h" #include "ng_puff.h" #include "ng_prefilter.h" #include "ng_prune.h" #include "ng_redundancy.h" #include "ng_region.h" #include "ng_region_redundancy.h" #include "ng_reports.h" #include "ng_rose.h" #include "ng_sep.h" #include "ng_small_literal_set.h" #include "ng_som.h" #include "ng_vacuous.h" #include "ng_violet.h" #include "ng_utf8.h" #include "ng_util.h" #include "ng_width.h" #include "ue2common.h" #include "nfa/goughcompile.h" #include "rose/rose_build.h" #include "smallwrite/smallwrite_build.h" #include "util/compile_error.h" #include "util/container.h" #include "util/depth.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/ue2string.h" using namespace std; namespace ue2 { NG::NG(const CompileContext &in_cc, size_t num_patterns, unsigned in_somPrecision) : maxSomRevHistoryAvailable(in_cc.grey.somMaxRevNfaLength), minWidth(depth::infinity()), rm(in_cc.grey), ssm(in_somPrecision), cc(in_cc), smwr(makeSmallWriteBuilder(num_patterns, rm, cc)), rose(makeRoseBuilder(rm, ssm, *smwr, cc, boundary)) { } NG::~NG() { // empty } /** \brief SOM handling code, called by \ref addComponent. * * \return true if the component was handled completely by something (e.g. a * Haig outfix), false if SOM could be established but implementation via an * engine will be required. * * \throw CompileError if SOM cannot be supported for the component. */ static bool addComponentSom(NG &ng, NGHolder &g, const NGWrapper &w, const som_type som, const u32 comp_id) { DEBUG_PRINTF("doing som\n"); dumpComponent(g, "03_presom", w.expressionIndex, comp_id, ng.cc.grey); assert(hasCorrectlyNumberedVertices(g)); assert(allMatchStatesHaveReports(w)); // First, we try the "SOM chain" support in ng_som.cpp. sombe_rv rv = doSom(ng, g, w, comp_id, som); if (rv == SOMBE_HANDLED_INTERNAL) { return false; } else if (rv == SOMBE_HANDLED_ALL) { return true; } assert(rv == SOMBE_FAIL); /* Next, Sombe style approaches */ rv = doSomWithHaig(ng, g, w, comp_id, som); if (rv == SOMBE_HANDLED_INTERNAL) { return false; } else if (rv == SOMBE_HANDLED_ALL) { return true; } assert(rv == SOMBE_FAIL); // If the previous approach could not support this pattern, we try treating // it monolithically, as a Haig outfix. vector > triggers; /* empty for outfix */ assert(g.kind == NFA_OUTFIX); dumpComponent(g, "haig", w.expressionIndex, comp_id, ng.cc.grey); makeReportsSomPass(ng.rm, g); auto haig = attemptToBuildHaig(g, som, ng.ssm.somPrecision(), triggers, ng.cc.grey); if (haig) { DEBUG_PRINTF("built haig outfix\n"); ng.rose->addOutfix(g, *haig); return true; } /* Our various strategies for supporting SOM for this pattern have failed. * Provide a generic pattern not supported/too large return value as it is * unclear what the meaning of a specific SOM error would be */ throw CompileError(w.expressionIndex, "Pattern is too large."); assert(0); // unreachable return false; } void reduceGraph(NGHolder &g, som_type som, bool utf8, const CompileContext &cc) { if (!cc.grey.performGraphSimplification) { return; } // We run reduction passes until either the graph stops changing or we hit // a (small) limit. if (!som) { mergeCyclicDotStars(g); } const unsigned MAX_PASSES = 3; for (unsigned pass = 1; pass <= MAX_PASSES; pass++) { bool changed = false; DEBUG_PRINTF("reduce pass %u/%u\n", pass, MAX_PASSES); changed |= removeEdgeRedundancy(g, som, cc); changed |= reduceGraphEquivalences(g, cc); changed |= removeRedundancy(g, som); changed |= removeCyclicPathRedundancy(g); if (!changed) { DEBUG_PRINTF("graph unchanged after pass %u, stopping\n", pass); break; } } if (utf8) { utf8DotRestoration(g, som); } /* Minor non-redundancy improvements */ if (improveGraph(g, som)) { /* may be some more edges to remove */ removeEdgeRedundancy(g, som, cc); } removeCyclicDominated(g, som); if (!som) { mergeCyclicDotStars(g); } if (!som) { removeSiblingsOfStartDotStar(g); } } static bool addComponent(NG &ng, NGHolder &g, const NGWrapper &w, const som_type som, const u32 comp_id) { const CompileContext &cc = ng.cc; assert(hasCorrectlyNumberedVertices(g)); DEBUG_PRINTF("expr=%u, comp=%u: %zu vertices, %zu edges\n", w.expressionIndex, comp_id, num_vertices(g), num_edges(g)); dumpComponent(g, "01_begin", w.expressionIndex, comp_id, ng.cc.grey); assert(allMatchStatesHaveReports(w)); reduceGraph(g, som, w.utf8, cc); dumpComponent(g, "02_reduced", w.expressionIndex, comp_id, ng.cc.grey); // There may be redundant regions that we can remove if (cc.grey.performGraphSimplification) { removeRegionRedundancy(g, som); } // "Short Exhaustible Passthrough" patterns always become outfixes. if (!som && isSEP(g, ng.rm, cc.grey)) { DEBUG_PRINTF("graph is SEP\n"); if (ng.rose->addOutfix(g)) { return true; } } // Start Of Match handling. if (som) { if (addComponentSom(ng, g, w, som, comp_id)) { return true; } } assert(allMatchStatesHaveReports(w)); if (splitOffAnchoredAcyclic(*ng.rose, g, cc)) { return true; } if (handleSmallLiteralSets(*ng.rose, g, cc) || handleFixedWidth(*ng.rose, g, cc.grey)) { return true; } if (handleDecoratedLiterals(*ng.rose, g, cc)) { return true; } if (doViolet(*ng.rose, g, w.prefilter, cc)) { return true; } if (splitOffRose(*ng.rose, g, w.prefilter, cc)) { return true; } if (splitOffPuffs(*ng.rose, ng.rm, g, w.prefilter, cc)) { return true; } if (handleSmallLiteralSets(*ng.rose, g, cc) || handleFixedWidth(*ng.rose, g, cc.grey)) { return true; } if (handleDecoratedLiterals(*ng.rose, g, cc)) { return true; } if (doViolet(*ng.rose, g, w.prefilter, cc)) { return true; } if (splitOffRose(*ng.rose, g, w.prefilter, cc)) { return true; } // A final pass at cyclic redundancy and Rose // TODO: investigate - coverage results suggest that this never succeeds? if (cc.grey.performGraphSimplification) { if (removeCyclicPathRedundancy(g) || removeCyclicDominated(g, som)) { if (handleFixedWidth(*ng.rose, g, cc.grey)) { return true; } } } if (finalChanceRose(*ng.rose, g, w.prefilter, cc)) { return true; } DEBUG_PRINTF("testing for outfix\n"); assert(allMatchStatesHaveReports(g)); if (ng.rose->addOutfix(g)) { return true; } return false; } // Returns true if all components have been added. static bool processComponents(NG &ng, NGWrapper &w, deque> &g_comp, const som_type som) { const u32 num_components = g_comp.size(); u32 failed = 0; for (u32 i = 0; i < num_components; i++) { if (!g_comp[i]) { continue; } if (addComponent(ng, *g_comp[i], w, som, i)) { g_comp[i].reset(); continue; } if (som) { /* bail immediately */ return false; } failed++; } if (!failed) { DEBUG_PRINTF("all components claimed\n"); return true; } DEBUG_PRINTF("%u components still remain\n", failed); return false; } bool NG::addGraph(NGWrapper &w) { // remove reports that aren't on vertices connected to accept. clearReports(w); som_type som = w.som; if (som && isVacuous(w)) { throw CompileError(w.expressionIndex, "Start of match is not " "currently supported for patterns which match an " "empty buffer."); } dumpDotWrapper(w, "01_initial", cc.grey); assert(allMatchStatesHaveReports(w)); /* ensure utf8 starts at cp boundary */ ensureCodePointStart(rm, w); resolveAsserts(rm, w); dumpDotWrapper(w, "02_post_assert_resolve", cc.grey); assert(allMatchStatesHaveReports(w)); pruneUseless(w); pruneEmptyVertices(w); if (can_never_match(w)) { throw CompileError(w.expressionIndex, "Pattern can never match."); } optimiseVirtualStarts(w); /* good for som */ handleExtendedParams(rm, w, cc); if (w.min_length) { // We have a minimum length constraint, which we currently use SOM to // satisfy. som = SOM_LEFT; ssm.somPrecision(8); } if (som) { rose->setSom(); } // first, we can perform graph work that can be done on an individual // expression basis. if (w.utf8) { relaxForbiddenUtf8(w); } if (w.highlander && !w.min_length && !w.min_offset) { // In highlander mode: if we don't have constraints on our reports that // may prevent us accepting our first match (i.e. extended params) we // can prune the other out-edges of all vertices connected to accept. pruneHighlanderAccepts(w, rm); } dumpDotWrapper(w, "02b_fairly_early", cc.grey); // If we're a vacuous pattern, we can handle this early. if (splitOffVacuous(boundary, rm, w)) { DEBUG_PRINTF("split off vacuous\n"); } // We might be done at this point: if we've run out of vertices, we can // stop processing. if (num_vertices(w) == N_SPECIALS) { DEBUG_PRINTF("all vertices claimed by vacuous handling\n"); return true; } // Now that vacuous edges have been removed, update the min width exclusive // of boundary reports. minWidth = min(minWidth, findMinWidth(w)); // Add the pattern to the small write builder. smwr->add(w); if (!som) { removeSiblingsOfStartDotStar(w); } dumpDotWrapper(w, "03_early", cc.grey); // Perform a reduction pass to merge sibling character classes together. if (cc.grey.performGraphSimplification) { removeRedundancy(w, som); prunePathsRedundantWithSuccessorOfCyclics(w, som); } dumpDotWrapper(w, "04_reduced", cc.grey); // If we've got some literals that span the graph from start to accept, we // can split them off into Rose from here. if (!som) { if (splitOffLiterals(*this, w)) { DEBUG_PRINTF("some vertices claimed by literals\n"); } } // We might be done at this point: if we've run out of vertices, we can // stop processing. if (num_vertices(w) == N_SPECIALS) { DEBUG_PRINTF("all vertices claimed before calc components\n"); return true; } // Split the graph into a set of connected components. deque> g_comp = calcComponents(w); assert(!g_comp.empty()); if (!som) { for (u32 i = 0; i < g_comp.size(); i++) { assert(g_comp[i]); reformLeadingDots(*g_comp[i]); } recalcComponents(g_comp); } if (processComponents(*this, w, g_comp, som)) { return true; } // If we're in prefiltering mode, we can run the prefilter reductions and // have another shot at accepting the graph. if (cc.grey.prefilterReductions && w.prefilter) { for (u32 i = 0; i < g_comp.size(); i++) { if (!g_comp[i]) { continue; } prefilterReductions(*g_comp[i], cc); } if (processComponents(*this, w, g_comp, som)) { return true; } } // We must have components that could not be compiled. for (u32 i = 0; i < g_comp.size(); i++) { if (g_comp[i]) { DEBUG_PRINTF("could not compile component %u with %zu vertices\n", i, num_vertices(*g_comp[i])); throw CompileError(w.expressionIndex, "Pattern is too large."); } } assert(0); // should have thrown. return false; } /** \brief Used from SOM mode to add an arbitrary NGHolder as an engine. */ bool NG::addHolder(NGHolder &w) { DEBUG_PRINTF("adding holder of %zu states\n", num_vertices(w)); assert(allMatchStatesHaveReports(w)); assert(hasCorrectlyNumberedVertices(w)); /* We don't update the global minWidth here as we care about the min width * of the whole pattern - not a just a prefix of it. */ bool prefilter = false; //dumpDotComp(comp, w, *this, 20, "prefix_init"); som_type som = SOM_NONE; /* the prefixes created by the SOM code do not themselves track som */ bool utf8 = false; // handling done earlier reduceGraph(w, som, utf8, cc); // There may be redundant regions that we can remove if (cc.grey.performGraphSimplification) { removeRegionRedundancy(w, som); } // "Short Exhaustible Passthrough" patterns always become outfixes. if (isSEP(w, rm, cc.grey)) { DEBUG_PRINTF("graph is SEP\n"); if (rose->addOutfix(w)) { return true; } } if (splitOffAnchoredAcyclic(*rose, w, cc)) { return true; } if (handleSmallLiteralSets(*rose, w, cc) || handleFixedWidth(*rose, w, cc.grey)) { return true; } if (handleDecoratedLiterals(*rose, w, cc)) { return true; } if (splitOffRose(*rose, w, prefilter, cc)) { return true; } if (splitOffPuffs(*rose, rm, w, prefilter, cc)) { return true; } if (splitOffRose(*rose, w, prefilter, cc)) { return true; } if (finalChanceRose(*rose, w, prefilter, cc)) { return true; } DEBUG_PRINTF("trying for outfix\n"); if (rose->addOutfix(w)) { DEBUG_PRINTF("ok\n"); return true; } DEBUG_PRINTF("trying for outfix - failed\n"); DEBUG_PRINTF("nobody would take us\n"); return false; } bool NG::addLiteral(const ue2_literal &literal, u32 expr_index, u32 external_report, bool highlander, som_type som) { assert(!literal.empty()); if (!cc.grey.shortcutLiterals) { return false; } // We can't natively handle arbitrary literals with mixed case sensitivity // in Rose -- they require mechanisms like benefits masks, which have // length limits etc. Better to let those go through full graph processing. if (mixed_sensitivity(literal)) { DEBUG_PRINTF("mixed sensitivity\n"); return false; } // Register external report and validate highlander constraints. rm.registerExtReport(external_report, external_report_info(highlander, expr_index)); ReportID id; if (som) { assert(!highlander); // not allowed, checked earlier. Report r = makeSomRelativeCallback(external_report, 0, literal.length()); id = rm.getInternalId(r); rose->setSom(); } else { u32 ekey = highlander ? rm.getExhaustibleKey(external_report) : INVALID_EKEY; Report r = makeECallback(external_report, 0, ekey); id = rm.getInternalId(r); } DEBUG_PRINTF("success: graph is literal '%s', report ID %u\n", dumpString(literal).c_str(), id); rose->add(false, false, literal, {id}); minWidth = min(minWidth, depth(literal.length())); /* inform small write handler about this literal */ smwr->add(literal, id); return true; } NGWrapper::NGWrapper(unsigned int ei, bool highlander_in, bool utf8_in, bool prefilter_in, som_type som_in, ReportID r, u64a min_offset_in, u64a max_offset_in, u64a min_length_in) : expressionIndex(ei), reportId(r), highlander(highlander_in), utf8(utf8_in), prefilter(prefilter_in), som(som_in), min_offset(min_offset_in), max_offset(max_offset_in), min_length(min_length_in) { // All special nodes/edges are added in NGHolder's constructor. DEBUG_PRINTF("built %p: expr=%u report=%u%s%s%s%s " "min_offset=%llu max_offset=%llu min_length=%llu\n", this, expressionIndex, reportId, highlander ? " highlander" : "", utf8 ? " utf8" : "", prefilter ? " prefilter" : "", (som != SOM_NONE) ? " som" : "", min_offset, max_offset, min_length); } NGWrapper::~NGWrapper() {} } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_netflow.h0000644000175000017500000000362213055426554021172 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Network flow (min flow, max cut) algorithms. */ #ifndef NG_NETFLOW_H #define NG_NETFLOW_H #include "ng_holder.h" #include "ue2common.h" #include namespace ue2 { class NGHolder; /** Returns a min cut (in \p cutset) for the graph in \p h. */ std::vector findMinCut(NGHolder &h, const std::vector &scores); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_builder.h0000644000175000017500000000673013055426554021145 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief: NFA Graph Builder: used by Glushkov construction to construct an * NGWrapper from a parsed expression. */ #ifndef NG_BUILDER_H #define NG_BUILDER_H #include "ue2common.h" #include "parser/position.h" #include #include namespace ue2 { class CharReach; class NGWrapper; class ReportManager; struct CompileContext; class ParsedExpression; /** \brief Abstract builder interface. Use \ref makeNFABuilder to construct * one. Used by GlushkovBuildState. */ class NFABuilder : boost::noncopyable { public: virtual ~NFABuilder(); virtual Position makePositions(size_t nPositions) = 0; virtual Position getStart() const = 0; virtual Position getStartDotStar() const = 0; virtual Position getAccept() const = 0; virtual Position getAcceptEOD() const = 0; virtual bool isSpecialState(Position p) const = 0; virtual void setNodeReportID(Position position, int offsetAdjust) = 0; virtual void addCharReach(Position position, const CharReach &cr) = 0; /* or-in vertex assertions */ virtual void setAssertFlag(Position position, u32 flag) = 0; virtual u32 getAssertFlag(Position position) = 0; virtual void addVertex(Position p) = 0; virtual void addEdge(Position start, Position end) = 0; virtual bool hasEdge(Position start, Position end) const = 0; virtual u32 numVertices() const = 0; virtual void cloneRegion(Position first, Position last, unsigned posOffset) = 0; /** * \brief Returns the built NGWrapper graph. * Note that this builder cannot be used after this call. */ virtual std::unique_ptr getGraph() = 0; }; /** Construct a usable NFABuilder. */ std::unique_ptr makeNFABuilder(ReportManager &rm, const CompileContext &cc, const ParsedExpression &expr); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_som_add_redundancy.h0000644000175000017500000000352013055426554023333 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Add redundancy to graph to assist in SOM analysis. */ #ifndef NG_SOM_ADD_REDUNDANCY_H #define NG_SOM_ADD_REDUNDANCY_H #include "util/depth.h" #include namespace ue2 { class NGHolder; bool addSomRedundancy(NGHolder &g, std::vector &depths); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_anchored_dots.h0000644000175000017500000000345713055426554022336 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Analysis pass to reform leading dots. */ #ifndef NG_ANCHORED_BOUNDED_REPEATS_H #define NG_ANCHORED_BOUNDED_REPEATS_H namespace ue2 { class NGHolder; /* should not be used if SoM is required */ void reformLeadingDots(NGHolder &g); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_equivalence.cpp0000644000175000017500000005563513055426554022363 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Equivalence class graph reduction pass. */ #include "ng_equivalence.h" #include "grey.h" #include "ng_depth.h" #include "ng_holder.h" #include "ng_util.h" #include "util/compile_context.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/ue2_containers.h" #include #include #include #include #include using namespace std; namespace ue2 { enum EquivalenceType { LEFT_EQUIVALENCE, RIGHT_EQUIVALENCE, }; namespace { class VertexInfo; // custom comparison functor for unordered_set and flat_set struct VertexInfoPtrCmp { // for flat_set bool operator()(const VertexInfo *a, const VertexInfo *b) const; // for unordered_set size_t operator()(const VertexInfo *a) const; }; /** Precalculated (and maintained) information about a vertex. */ class VertexInfo { public: VertexInfo(NFAVertex v_in, const NGHolder &g) : v(v_in), vert_index(g[v].index), cr(g[v].char_reach), equivalence_class(~0), vertex_flags(g[v].assert_flags) {} flat_set pred; //!< predecessors of this vertex flat_set succ; //!< successors of this vertex NFAVertex v; size_t vert_index; CharReach cr; CharReach pred_cr; CharReach succ_cr; flat_set edge_tops; /**< tops on edge from start */ unsigned equivalence_class; unsigned vertex_flags; }; } typedef ue2::unordered_set VertexInfoSet; // compare two vertex info pointers on their vertex index bool VertexInfoPtrCmp::operator()(const VertexInfo *a, const VertexInfo *b) const { return a->vert_index < b->vert_index; } // provide a "hash" for vertex info pointer by returning its vertex index size_t VertexInfoPtrCmp::operator()(const VertexInfo *a) const { return a->vert_index; } namespace { // to avoid traversing infomap each time we need to check the class during // partitioning, we will cache the information pertaining to a particular class class ClassInfo { public: struct ClassDepth { ClassDepth() {} ClassDepth(const NFAVertexDepth &d) : d1(d.fromStart), d2(d.fromStartDotStar) {} ClassDepth(const NFAVertexRevDepth &rd) : d1(rd.toAccept), d2(rd.toAcceptEod) {} DepthMinMax d1; DepthMinMax d2; }; ClassInfo(const NGHolder &g, const VertexInfo &vi, const ClassDepth &d_in, EquivalenceType eq) : /* reports only matter for right-equiv */ rs(eq == RIGHT_EQUIVALENCE ? g[vi.v].reports : flat_set()), vertex_flags(vi.vertex_flags), edge_tops(vi.edge_tops), cr(vi.cr), adjacent_cr(eq == LEFT_EQUIVALENCE ? vi.pred_cr : vi.succ_cr), /* treat non-special vertices the same */ node_type(min(g[vi.v].index, size_t{N_SPECIALS})), depth(d_in) {} bool operator==(const ClassInfo &b) const { return node_type == b.node_type && depth.d1 == b.depth.d1 && depth.d2 == b.depth.d2 && cr == b.cr && adjacent_cr == b.adjacent_cr && edge_tops == b.edge_tops && vertex_flags == b.vertex_flags && rs == b.rs; } friend size_t hash_value(const ClassInfo &c) { size_t val = 0; boost::hash_combine(val, boost::hash_range(begin(c.rs), end(c.rs))); boost::hash_combine(val, c.vertex_flags); boost::hash_combine(val, c.cr); boost::hash_combine(val, c.adjacent_cr); boost::hash_combine(val, c.node_type); boost::hash_combine(val, c.depth.d1); boost::hash_combine(val, c.depth.d2); return val; } private: flat_set rs; /* for right equiv only */ unsigned vertex_flags; flat_set edge_tops; CharReach cr; CharReach adjacent_cr; unsigned node_type; ClassDepth depth; }; // work queue class. this contraption has two goals: // 1. uniqueness of elements // 2. FILO operation class WorkQueue { public: explicit WorkQueue(unsigned c) { q.reserve(c); } // unique push void push(unsigned id) { if (ids.insert(id).second) { q.push_back(id); } } // pop unsigned pop() { unsigned id = q.back(); ids.erase(id); q.pop_back(); return id; } void append(WorkQueue &other) { for (const auto &e : other) { push(e); } } void clear() { ids.clear(); q.clear(); } bool empty() const { return ids.empty(); } vector::const_iterator begin() const { return q.begin(); } vector::const_iterator end() const { return q.end(); } size_t capacity() const { return q.capacity(); } private: unordered_set ids; //!< stores id's, for uniqueness vector q; //!< vector of id's that we use as FILO. }; } static bool outIsIrreducible(NFAVertex &v, const NGHolder &g) { unsigned nonSpecialVertices = 0; for (auto w : adjacent_vertices_range(v, g)) { if (!is_special(w, g) && w != v) { nonSpecialVertices++; } } return nonSpecialVertices == 1; } static bool inIsIrreducible(NFAVertex &v, const NGHolder &g) { unsigned nonSpecialVertices = 0; for (auto u : inv_adjacent_vertices_range(v, g)) { if (!is_special(u, g) && u != v) { nonSpecialVertices++; } } return nonSpecialVertices == 1; } /** Cheaply check whether this graph can't be reduced at all, because it is * just a chain of vertices with no other edges. */ static bool isIrreducible(const NGHolder &g) { for (auto v : vertices_range(g)) { // skip specials if (is_special(v, g)) { continue; } // we want meaningful in_degree to be 1. we also want to make sure we // don't count self-loop + 1 incoming edge as not irreducible if (in_degree(v, g) != 1 && !inIsIrreducible(v, g)) { return false; } // we want meaningful out_degree to be 1. we also want to make sure we // don't count self-loop + 1 outgoing edge as not irreducible if (out_degree(v, g) != 1 && !outIsIrreducible(v, g)) { return false; } } return true; } #ifndef NDEBUG static bool hasEdgeAsserts(NFAVertex v, const NGHolder &g) { for (const auto &e : in_edges_range(v, g)) { if (g[e].assert_flags != 0) { return true; } } for (const auto &e : out_edges_range(v, g)) { if (g[e].assert_flags != 0) { return true; } } return false; } #endif // populate VertexInfo table static vector> getVertexInfos(const NGHolder &g) { const size_t num_verts = num_vertices(g); vector> infos; infos.reserve(num_verts * 2); vector vertex_map; // indexed by vertex_index property vertex_map.resize(num_verts); for (auto v : vertices_range(g)) { infos.push_back(make_unique(v, g)); vertex_map[g[v].index] = infos.back().get(); } // now, go through each vertex and populate its predecessor and successor // lists for (auto &vi : infos) { assert(vi); NFAVertex v = vi->v; // find predecessors for (const auto &e : in_edges_range(v, g)) { NFAVertex u = source(e, g); VertexInfo *u_vi = vertex_map[g[u].index]; vi->pred_cr |= u_vi->cr; vi->pred.insert(u_vi); // also set up edge tops if (is_triggered(g) && u == g.start) { vi->edge_tops = g[e].tops; } } // find successors for (auto w : adjacent_vertices_range(v, g)) { VertexInfo *w_vi = vertex_map[g[w].index]; vi->succ_cr |= w_vi->cr; vi->succ.insert(w_vi); } assert(!hasEdgeAsserts(vi->v, g)); } return infos; } // store equivalence class in VertexInfo for each vertex static vector partitionGraph(vector> &infos, WorkQueue &work_queue, const NGHolder &g, EquivalenceType eq) { const size_t num_verts = infos.size(); vector classes; unordered_map classinfomap; // assume we will have lots of classes, so we don't waste time resizing // these structures. classes.reserve(num_verts); classinfomap.reserve(num_verts); // get distances from start (or accept) for all vertices // only one of them is used at a time, never both vector depths; vector rdepths; if (eq == LEFT_EQUIVALENCE) { calcDepths(g, depths); } else { calcDepths(g, rdepths); } // partition the graph based on CharReach for (auto &vi : infos) { assert(vi); ClassInfo::ClassDepth depth; if (eq == LEFT_EQUIVALENCE) { depth = depths[vi->vert_index]; } else { depth = rdepths[vi->vert_index]; } ClassInfo ci(g, *vi, depth, eq); auto ii = classinfomap.find(ci); if (ii == classinfomap.end()) { // vertex is in a new equivalence class by itself. unsigned eq_class = classes.size(); vi->equivalence_class = eq_class; classes.push_back({vi.get()}); classinfomap.emplace(move(ci), eq_class); } else { // vertex is added to an existing class. unsigned eq_class = ii->second; vi->equivalence_class = eq_class; classes.at(eq_class).insert(vi.get()); // we now know that this particular class has more than one // vertex, so we add it to the work queue work_queue.push(eq_class); } } DEBUG_PRINTF("partitioned, %zu equivalence classes\n", classes.size()); return classes; } // generalized equivalence processing (left and right) // basically, goes through every vertex in a class and checks if all successor or // predecessor classes match in all vertices. if classes mismatch, a vertex is // split into a separate class, along with all vertices having the same set of // successor/predecessor classes. the opposite side (successors for left // equivalence, predecessors for right equivalence) classes get revalidated in // case of a split. static void equivalence(vector &classes, WorkQueue &work_queue, EquivalenceType eq_type) { // now, go through the work queue until it's empty map, VertexInfoSet> tentative_classmap; flat_set cur_classes; // local work queue, to store classes we want to revalidate in case of split WorkQueue reval_queue(work_queue.capacity()); while (!work_queue.empty()) { // dequeue our class from the work queue unsigned cur_class = work_queue.pop(); // get all vertices in current equivalence class VertexInfoSet &cur_class_vertices = classes.at(cur_class); if (cur_class_vertices.size() < 2) { continue; } // clear data from previous iterations tentative_classmap.clear(); DEBUG_PRINTF("doing equivalence pass for class %u, %zd vertices\n", cur_class, cur_class_vertices.size()); // go through vertices in this class for (VertexInfo *vi : cur_class_vertices) { cur_classes.clear(); // get vertex lists for equivalence vertices and vertices for // revalidation in case of split const auto &eq_vertices = (eq_type == LEFT_EQUIVALENCE) ? vi->pred : vi->succ; const auto &reval_vertices = (eq_type == LEFT_EQUIVALENCE) ? vi->succ : vi->pred; // go through equivalence and note the classes for (const VertexInfo *tmp : eq_vertices) { cur_classes.insert(tmp->equivalence_class); } // note all the classes that need to be reevaluated for (const VertexInfo *tmp : reval_vertices) { reval_queue.push(tmp->equivalence_class); } VertexInfoSet &tentative_classes = tentative_classmap[cur_classes]; tentative_classes.insert(vi); } // if we found more than one class, split and revalidate everything if (tentative_classmap.size() > 1) { auto tmi = tentative_classmap.begin(); // start from the second class for (++tmi; tmi != tentative_classmap.end(); ++tmi) { const VertexInfoSet &vertices_to_split = tmi->second; unsigned new_class = classes.size(); VertexInfoSet new_class_vertices; for (VertexInfo *vi : vertices_to_split) { vi->equivalence_class = new_class; // note: we cannot use the cur_class_vertices ref, as it is // invalidated by modifications to the classes vector. classes[cur_class].erase(vi); new_class_vertices.insert(vi); } classes.push_back(move(new_class_vertices)); if (contains(tmi->first, cur_class)) { reval_queue.push(new_class); } } work_queue.append(reval_queue); } reval_queue.clear(); } } static bool require_separate_eod_vertex(const VertexInfoSet &vert_infos, const NGHolder &g) { /* We require separate eod and normal accept vertices for a class if we have * both normal accepts and eod accepts AND the reports are different for eod * and non-eod reports. */ flat_set non_eod; flat_set eod; for (const VertexInfo *vi : vert_infos) { NFAVertex v = vi->v; if (edge(v, g.accept, g).second) { insert(&non_eod, g[v].reports); } if (edge(v, g.acceptEod, g).second) { insert(&eod, g[v].reports); } } if (non_eod.empty() || eod.empty()) { return false; } return non_eod != eod; } static void mergeClass(vector> &infos, NGHolder &g, unsigned eq_class, VertexInfoSet &cur_class_vertices, set *toRemove) { DEBUG_PRINTF("Replacing %zd vertices from equivalence class %u with a " "single vertex.\n", cur_class_vertices.size(), eq_class); // replace equivalence class with a single vertex: // 1. create new vertex with matching properties // 2. wire all predecessors to new vertex // 2a. update info for new vertex with new predecessors // 2b. update each predecessor's successor list // 3. wire all successors to new vertex // 3a. update info for new vertex with new successors // 3b. update each successor's predecessor list // 4. remove old vertex // any differences between vertex properties were resolved during // initial partitioning, so we assume that every vertex in equivalence // class has the same CharReach et al. // so, we find the first vertex in our class and get all its properties /* For left equivalence, if the members have different reporting behaviour * we sometimes require two vertices to be created (one connected to accept * and one to accepteod) */ NFAVertex old_v = (*cur_class_vertices.begin())->v; NFAVertex new_v = clone_vertex(g, old_v); /* set up new vertex with same * props */ g[new_v].reports.clear(); /* populated as we pull in succs */ // store this vertex in our global vertex list infos.push_back(make_unique(new_v, g)); VertexInfo *new_vertex_info = infos.back().get(); NFAVertex new_v_eod = NGHolder::null_vertex(); VertexInfo *new_vertex_info_eod = nullptr; if (require_separate_eod_vertex(cur_class_vertices, g)) { new_v_eod = clone_vertex(g, old_v); g[new_v_eod].reports.clear(); infos.push_back(make_unique(new_v_eod, g)); new_vertex_info_eod = infos.back().get(); } const auto &edgetops = (*cur_class_vertices.begin())->edge_tops; for (VertexInfo *old_vertex_info : cur_class_vertices) { assert(old_vertex_info->equivalence_class == eq_class); // mark this vertex for removal toRemove->insert(old_vertex_info->v); // for each predecessor, add edge to new vertex and update info for (VertexInfo *pred_info : old_vertex_info->pred) { // update info for new vertex new_vertex_info->pred.insert(pred_info); if (new_vertex_info_eod) { new_vertex_info_eod->pred.insert(pred_info); } // update info for predecessor pred_info->succ.erase(old_vertex_info); // if edge doesn't exist, create it NFAEdge e = add_edge_if_not_present(pred_info->v, new_v, g); // put edge tops, if applicable if (!edgetops.empty()) { assert(g[e].tops.empty() || g[e].tops == edgetops); g[e].tops = edgetops; } pred_info->succ.insert(new_vertex_info); if (new_v_eod) { NFAEdge ee = add_edge_if_not_present(pred_info->v, new_v_eod, g); // put edge tops, if applicable if (!edgetops.empty()) { assert(g[e].tops.empty() || g[e].tops == edgetops); g[ee].tops = edgetops; } pred_info->succ.insert(new_vertex_info_eod); } } // for each successor, add edge from new vertex and update info for (VertexInfo *succ_info : old_vertex_info->succ) { NFAVertex succ_v = succ_info->v; // update info for successor succ_info->pred.erase(old_vertex_info); if (new_v_eod && succ_v == g.acceptEod) { // update info for new vertex new_vertex_info_eod->succ.insert(succ_info); insert(&g[new_v_eod].reports, g[old_vertex_info->v].reports); add_edge_if_not_present(new_v_eod, succ_v, g); succ_info->pred.insert(new_vertex_info_eod); } else { // update info for new vertex new_vertex_info->succ.insert(succ_info); // if edge doesn't exist, create it add_edge_if_not_present(new_v, succ_v, g); succ_info->pred.insert(new_vertex_info); if (is_any_accept(succ_v, g)) { insert(&g[new_v].reports, g[old_vertex_info->v].reports); } } } } // update classmap new_vertex_info->equivalence_class = eq_class; cur_class_vertices.insert(new_vertex_info); } // walk through vertices of an equivalence class and replace them with a single // vertex (or, in rare cases for left equiv, a pair if we cannot satisfy the // report behaviour with a single vertex). static bool mergeEquivalentClasses(vector &classes, vector> &infos, NGHolder &g) { bool merged = false; set toRemove; // go through all classes and merge classes with more than one vertex for (unsigned eq_class = 0; eq_class < classes.size(); eq_class++) { // get all vertices in current equivalence class VertexInfoSet &cur_class_vertices = classes[eq_class]; // we don't care for single-vertex classes if (cur_class_vertices.size() > 1) { merged = true; mergeClass(infos, g, eq_class, cur_class_vertices, &toRemove); } } // remove all dead vertices DEBUG_PRINTF("removing %zd vertices.\n", toRemove.size()); remove_vertices(toRemove, g); return merged; } static bool reduceGraphEquivalences(NGHolder &g, EquivalenceType eq_type) { // create a list of equivalence classes to check WorkQueue work_queue(num_vertices(g)); // get information on every vertex in the graph // new vertices are allocated here, and stored in infos auto infos = getVertexInfos(g); // partition the graph auto classes = partitionGraph(infos, work_queue, g, eq_type); // do equivalence processing equivalence(classes, work_queue, eq_type); // replace equivalent classes with single vertices // new vertices are (possibly) allocated here, and stored in infos return mergeEquivalentClasses(classes, infos, g); } bool reduceGraphEquivalences(NGHolder &g, const CompileContext &cc) { if (!cc.grey.equivalenceEnable) { DEBUG_PRINTF("equivalence processing disabled in grey box\n"); return false; } renumber_vertices(g); // Cheap check: if all the non-special vertices have in-degree one and // out-degree one, there's no redundancy in this here graph and we can // vamoose. if (isIrreducible(g)) { DEBUG_PRINTF("skipping equivalence processing, graph is irreducible\n"); return false; } // take note if we have merged any vertices bool merge = false; merge |= reduceGraphEquivalences(g, LEFT_EQUIVALENCE); merge |= reduceGraphEquivalences(g, RIGHT_EQUIVALENCE); return merge; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_restructuring.cpp0000644000175000017500000001567713055426554023004 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief State numbering and late graph restructuring code. */ #include "ng_restructuring.h" #include "grey.h" #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" #include "util/graph_range.h" #include #include #include using namespace std; namespace ue2 { /** Connect the start vertex to each of the vertices in \p tops. This is useful * temporarily for when we need to run a graph algorithm that expects a single * source vertex. */ static void wireStartToTops(NGHolder &g, const flat_set &tops, vector &tempEdges) { for (NFAVertex v : tops) { assert(!isLeafNode(v, g)); const NFAEdge &e = add_edge(g.start, v, g); tempEdges.push_back(e); } } /** * Returns true if start's successors (aside from startDs) are subset of * startDs's proper successors or if start has no successors other than startDs. */ static bool startIsRedundant(const NGHolder &g) { /* We ignore startDs as the self-loop may have been stripped as an * optimisation for repeats (improveLeadingRepeats()). */ set start; insert(&start, adjacent_vertices_range(g.start, g)); start.erase(g.startDs); // Trivial case: start has no successors other than startDs. if (start.empty()) { DEBUG_PRINTF("start has no out-edges other than to startDs\n"); return true; } set startDs; insert(&startDs, adjacent_vertices_range(g.startDs, g)); startDs.erase(g.startDs); if (!is_subset_of(start, startDs)) { DEBUG_PRINTF("out-edges of start and startDs aren't equivalent\n"); return false; } return true; } static void getStateOrdering(NGHolder &g, const flat_set &tops, vector &ordering) { // First, wire up our "tops" to start so that we have a single source, // which will give a nicer topo order. vector tempEdges; wireStartToTops(g, tops, tempEdges); renumber_vertices(g); vector temp = getTopoOrdering(g); remove_edges(tempEdges, g); // Move {start, startDs} to the end, so they'll be first when we reverse // the ordering (if they are required). temp.erase(remove(temp.begin(), temp.end(), g.startDs)); temp.erase(remove(temp.begin(), temp.end(), g.start)); if (proper_out_degree(g.startDs, g)) { temp.push_back(g.startDs); } if (!startIsRedundant(g)) { temp.push_back(g.start); } // Walk ordering, remove vertices that shouldn't be participating in state // numbering, such as accepts. for (auto v : temp) { if (is_any_accept(v, g)) { continue; // accepts don't need states } ordering.push_back(v); } // Output of topo order was in reverse. reverse(ordering.begin(), ordering.end()); } // Returns the number of states. static ue2::unordered_map getStateIndices(const NGHolder &h, const vector &ordering) { ue2::unordered_map states; for (const auto &v : vertices_range(h)) { states[v] = NO_STATE; } u32 stateNum = 0; for (auto v : ordering) { DEBUG_PRINTF("assigning state num %u to vertex %zu\n", stateNum, h[v].index); states[v] = stateNum++; } return states; } /** UE-1648: A state with a single successor that happens to be a predecessor * can be given any ol' state ID by the topological ordering, so we sink it * next to its pred. This enables better merging. */ static void optimiseTightLoops(const NGHolder &g, vector &ordering) { deque> candidates; auto start = ordering.begin(); for (auto it = ordering.begin(), ite = ordering.end(); it != ite; ++it) { NFAVertex v = *it; if (is_special(v, g)) { continue; } if (out_degree(v, g) == 1) { NFAVertex t = *(adjacent_vertices(v, g).first); if (v == t) { continue; } if (edge(t, v, g).second && find(start, it, t) != ite) { candidates.push_back(make_pair(v, t)); } } } for (const auto &cand : candidates) { NFAVertex v = cand.first, u = cand.second; auto u_it = find(ordering.begin(), ordering.end(), u); auto v_it = find(ordering.begin(), ordering.end(), v); // Only move candidates backwards in the ordering, and only move them // when necessary. if (u_it >= v_it || distance(u_it, v_it) == 1) { continue; } DEBUG_PRINTF("moving vertex %zu next to %zu\n", g[v].index, g[u].index); ordering.erase(v_it); ordering.insert(++u_it, v); } } unordered_map numberStates(NGHolder &h, const flat_set &tops) { DEBUG_PRINTF("numbering states for holder %p\n", &h); vector ordering; getStateOrdering(h, tops, ordering); optimiseTightLoops(h, ordering); return getStateIndices(h, ordering); } u32 countStates(const unordered_map &state_ids) { if (state_ids.empty()) { return 0; } u32 max_state = 0; for (const auto &m : state_ids) { if (m.second != NO_STATE) { max_state = max(m.second, max_state); } } u32 num_states = max_state + 1; return num_states; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_redundancy.cpp0000644000175000017500000007147113055426554022212 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA graph reductions. * * This code attempts to make the NFA graph smaller by performing a number of * local transformations: * * ### (1) removal of redundant vertices: * * v is redundant wrt to u if succ(v) is a subset of succ(u) * AND pred(v) is a subset of pred(u) * AND cr(v) is a subset of cr(u) * * ### (2) 'diamond' transformation: * * given succ(v) == succ(u) and pred(v) == pred(u), * v and u can be replaced by w with succ(w) = succ(v), pred(w) = pred(v), * and cr(w) = union(cr(v), cr(u)) * * ### (3) locally identifiable left equivalence: * * given pred(v) == pred(u) (**) and cr(v) == cr(u), * v and u can be replaced by w with pred(w) = pred(v), cr(w) = cr(v), * and succ(w) = union(succ(v), succ(u)) * * ### (4) locally identifiable right equivalence: * * given succ(v) == succ(u) (**) and cr(v) == cr(u), * v and u can be replaced by w with succ(w) = succ(v), cr(w) = cr(v), * and pred(w) = union(pred(v), pred(u)) * * NOTE (**): for left and right equivalence, we can also do the transform if * set(u) contains u, set(v) contains v and the sets are otherwise equal. This * enables equivalent vertices with self-loops to be merged. * * If v and u raise accepts, they can only be merged if they raise the same * report IDs. * * Transformations are applied repeatedly until the graph stops changing. * * Note that the final graph may depend on the order in which these * transformations are applied. In order to reduce the non-determinism the * following order is imposed: (1); (2); (3) + (4). */ #include "ng_redundancy.h" #include "ng_holder.h" #include "ng_calc_components.h" #include "ng_dominators.h" #include "ng_prune.h" #include "ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include #include #include #include #include #include #include using namespace std; namespace ue2 { namespace { /** Precalculated (and maintained) information about a vertex. */ class VertexInfo { public: flat_set pred; //!< predecessors of this vertex flat_set succ; //!< successors of this vertex bool isAccept = false; //!< does this vertex lead to accept? bool isRemoved = false; //!< have we already removed this vertex? size_t inDegree() const { return pred.size(); } size_t outDegree() const { return succ.size(); } }; class VertexInfoMap { public: explicit VertexInfoMap(const NGHolder &gg) : g(gg), infos(num_vertices(gg)) {} VertexInfo &operator[](NFAVertex v) { u32 i = g[v].index; assert(i < infos.size()); return infos[i]; } const VertexInfo &operator[](NFAVertex v) const { u32 i = g[v].index; assert(i < infos.size()); return infos[i]; } private: const NGHolder &g; vector infos; }; } // namespace /** Populates the info map with their predecessor and successor states, and * whether they are accept states. */ static void populateContainers(const NGHolder &g, VertexInfoMap &infoMap) { for (auto v : vertices_range(g)) { VertexInfo &info = infoMap[v]; assert(info.pred.empty() && info.succ.empty()); // Build successor and predecessor sets insert(&info.pred, inv_adjacent_vertices(v, g)); insert(&info.succ, adjacent_vertices(v, g)); // Note whether the vertex is an accept state if (!is_special(v, g)) { if (contains(info.succ, g.accept) || contains(info.succ, g.acceptEod)) { info.isAccept = true; } } } } /** Helper function to take the intersection of two sorted vertex sets * in-place. */ static void inplaceIntersection(vector &vset1, const flat_set &vset2) { const NFAVertex GONE = NGHolder::null_vertex(); vector::iterator it = vset1.begin(), ite = vset1.end(); flat_set::const_iterator jt = vset2.begin(), jte = vset2.end(); while ((it != ite) && (jt != jte)) { assert(*it != GONE); if (*it < *jt) { // present in vset1 but not in vset2. Set to null, remove in a // second pass. *it = GONE; ++it; } else if (*jt < *it) { // present in vset2 but not in vset1, skip. ++jt; } else { // present in both sets. ++it; ++jt; } } // Left overs are only in that set. vset1.erase(it, ite); // Remove nulls created above. vset1.erase(remove(vset1.begin(), vset1.end(), GONE), vset1.end()); } /** Find the intersection of the successors of our predecessors. */ static void succPredIntersection(const NFAVertex v, const flat_set &predSet, const VertexInfoMap &infoMap, vector &intersection, bool considerSelf = true /* follow self loops */) { /* find a good seed for the intersection */ const flat_set *best = nullptr; for (auto u : predSet) { if (!considerSelf && u == v) { continue; } const flat_set &succSet = infoMap[u].succ; if (!best || succSet.size() <= best->size()) { best = &succSet; // Break out if we've reduced our intersection to [v] if (best->size() == 1) { assert(*(best->begin()) == v); intersection.push_back(v); return; } } } if (best) { insert(&intersection, intersection.end(), *best); } for (auto u : predSet) { if (!considerSelf && u == v) { continue; } inplaceIntersection(intersection, infoMap[u].succ); // Check: intersection should always be at least size 1 assert(!intersection.empty()); // Break out if we've reduced our intersection to [v] if (intersection.size() == 1) { assert(*intersection.begin() == v); return; } } } /** Find the intersection of the predecessors of our successors. */ static void predSuccIntersection(const NFAVertex v, const flat_set &succSet, const VertexInfoMap &infoMap, vector &intersection, bool considerSelf = true /* follow self loops */) { /* find a good seed for the intersection */ const flat_set *best = nullptr; for (auto w : succSet) { if (!considerSelf && w == v) { continue; } const flat_set &predSet = infoMap[w].pred; if (!best || predSet.size() <= best->size()) { best = &predSet; // Break out if we've reduced our intersection to [v] if (best->size() == 1) { assert(*(best->begin()) == v); intersection.push_back(v); return; } } } if (best) { insert(&intersection, intersection.end(), *best); } for (auto w : succSet) { if (!considerSelf && w == v) { continue; } inplaceIntersection(intersection, infoMap[w].pred); // Check: intersection should always be at least size 1 assert(!intersection.empty()); // Break out if we've reduced our intersection to [v] if (intersection.size() == 1) { assert(*intersection.begin() == v); return; } } } /** Update containers to take into account the removal of vertex v. */ static void markForRemoval(const NFAVertex v, VertexInfoMap &infoMap, set &removable) { VertexInfo &info = infoMap[v]; assert(!info.isRemoved); assert(!contains(removable, v)); info.isRemoved = true; removable.insert(v); // remove v from its predecessors' successors for (auto u : info.pred) { infoMap[u].succ.erase(v); } // remove v from its successors' predecessors for (auto w : info.succ) { infoMap[w].pred.erase(v); } } static bool hasInEdgeTops(const NGHolder &g, NFAVertex v) { NFAEdge e = edge(g.start, v, g); return e && !g[e].tops.empty(); } /** Transform (1), removal of redundant vertices. */ static bool doUselessMergePass(NGHolder &g, som_type som, VertexInfoMap &infoMap, set &removable) { /* useless merges can be done in any order, no need to take any care with * ordering */ // Temporary vectors used for intersections below vector succPredSet, predSuccSet, intersection; bool changed = false; for (auto v : vertices_range(g)) { VertexInfo &info = infoMap[v]; if (info.isRemoved) { continue; } assert(!contains(removable, v)); if (is_special(v, g)) { continue; } /* we do not need to check for out edge tops - as only specials (start) * can have tops and they are already disqualified. */ if (hasInEdgeTops(g, v)) { continue; // Conservatively skip anything with nonzero tops. } if (info.pred.empty() || info.succ.empty()) { DEBUG_PRINTF("vertex %zu has empty pred/succ list\n", g[v].index); assert(0); // non-special states should always have succ/pred lists continue; } // The following cases are more complex and rely on the intersection of // Succ(Pred(v)) and Pred(Succ(v)) // Compute intersections, operating on the smaller set first // Note that we use vectors here, as set_intersection underneath // guarantees sorted output, and vectors were quite a bit // faster than sets or lists. succPredSet.clear(); predSuccSet.clear(); if (info.pred.size() <= info.succ.size()) { succPredIntersection(v, info.pred, infoMap, succPredSet); if (succPredSet.size() == 1) { // nobody in here but us chickens assert(*succPredSet.begin() == v); continue; } predSuccIntersection(v, info.succ, infoMap, predSuccSet); if (predSuccSet.size() == 1) { assert(*predSuccSet.begin() == v); continue; } } else { predSuccIntersection(v, info.succ, infoMap, predSuccSet); if (predSuccSet.size() == 1) { assert(*predSuccSet.begin() == v); continue; } succPredIntersection(v, info.pred, infoMap, succPredSet); if (succPredSet.size() == 1) { assert(*succPredSet.begin() == v); continue; } } // Find the intersection of Succ(Pred(v)) and Pred(Succ(v)) intersection.clear(); set_intersection(succPredSet.begin(), succPredSet.end(), predSuccSet.begin(), predSuccSet.end(), back_inserter(intersection)); /* Boring if it is just us in the intersection */ if (intersection.size() < 2) { continue; } // Compare char_reach, mark v for removal if any members of // the intersection have an equal or greater reach const CharReach &currReach = g[v].char_reach; const auto &currReports = g[v].reports; for (auto t : intersection) { const VertexInfo &info2 = infoMap[t]; /* start is never a succ of a state, so will never be in the * predsucc/succpred intersection */ assert(t != g.start); if (t == v || info2.isRemoved) { continue; } // For each candidate C to make V redundant, check: // if V is an accept state, C must be an accept state for // the same pattern // pred(C) is a superset of pred(V) // succ(C) is a superset of succ(V) // reach(C) is a superset of reach(V) // // Note: pred/sec tests are covered by the intersections // calculated above. /* note: links to accepts are also tracked in succs */ if (info.isAccept && currReports != g[t].reports) { continue; } if (som) { if (t == g.startDs) { continue; } if (is_virtual_start(t, g) != is_virtual_start(v, g)) { continue; } } /* we do not need to check for out edge tops - as only start * can have tops and it has already been ruled out. */ if (hasInEdgeTops(g, t)) { continue; // Conservatively skip anything with nonzero tops. } CharReach &otherReach = g[t].char_reach; if (currReach.isSubsetOf(otherReach)) { DEBUG_PRINTF("removing redundant vertex %zu (keeping %zu)\n", g[v].index, g[t].index); markForRemoval(v, infoMap, removable); changed = true; break; } } } return changed; } /** Transform (2), diamond merge pass. */ static bool doDiamondMergePass(NGHolder &g, som_type som, VertexInfoMap &infoMap, set &removable) { // Temporary vectors used for intersections below vector succPredSet, predSuccSet, intersection; bool changed = false; for (auto v : vertices_range(g)) { VertexInfo &info = infoMap[v]; if (info.isRemoved) { continue; } assert(!contains(removable, v)); if (is_special(v, g)) { continue; } /* we do not need to check for out edge tops - as only specials (start) * can have tops and they are already disqualified. */ if (hasInEdgeTops(g, v)) { continue; // Conservatively skip anything with nonzero tops. } if (info.pred.empty() || info.succ.empty()) { assert(0); // non-special states should always have succ/pred lists continue; } // The following cases are more complex and rely on the intersection of // Succ(Pred(v)) and Pred(Succ(v)) // Compute intersections, operating on the smaller set first // Note that we use vectors here, as set_intersection underneath // guarantees sorted output, and vectors were quite a bit faster than // sets or lists. succPredSet.clear(); predSuccSet.clear(); if (info.pred.size() <= info.succ.size()) { succPredIntersection(v, info.pred, infoMap, succPredSet); if (succPredSet.size() == 1) { // nobody in here but us chickens assert(*succPredSet.begin() == v); continue; } predSuccIntersection(v, info.succ, infoMap, predSuccSet); if (predSuccSet.size() == 1) { assert(*predSuccSet.begin() == v); continue; } } else { predSuccIntersection(v, info.succ, infoMap, predSuccSet); if (predSuccSet.size() == 1) { assert(*predSuccSet.begin() == v); continue; } succPredIntersection(v, info.pred, infoMap, succPredSet); if (succPredSet.size() == 1) { assert(*succPredSet.begin() == v); continue; } } // Find the intersection of Succ(Pred(v)) and Pred(Succ(v)) intersection.clear(); set_intersection(succPredSet.begin(), succPredSet.end(), predSuccSet.begin(), predSuccSet.end(), back_inserter(intersection)); /* Boring if it is just us in the intersection */ if (intersection.size() < 2) { continue; } const CharReach &currReach = g[v].char_reach; const auto &currReports = g[v].reports; for (auto t : intersection) { const VertexInfo &info2 = infoMap[t]; if (t == v || info2.isRemoved || is_special(t, g)) { continue; } /* note: links to accepts are also tracked in succs */ if (info.isAccept && currReports != g[t].reports) { continue; } /* we do not need to check for out edge tops - as only specials * (start) can have tops and they are already disqualified. */ if (hasInEdgeTops(g, t)) { continue; // Conservatively skip anything with nonzero tops. } if (som) { if (is_virtual_start(v, g) != is_virtual_start(t, g)) { continue; // can only merge like with like. } } // If in-degree of v == in-degree of target // and out-degree of v == out-degree of target // (because pred and succ are supersets) // then combine charreach of v into target and remove v if (info.inDegree() == info2.inDegree() && info.outDegree() == info2.outDegree()) { // add character reachability of v into target CharReach &otherReach = g[t].char_reach; otherReach |= currReach; // v can be removed DEBUG_PRINTF("removing redundant vertex %zu and merging " "reachability with vertex %zu\n", g[v].index, g[t].index); markForRemoval(v, infoMap, removable); changed = true; break; } } } return changed; } namespace { struct ReachMismatch {}; class ReachSubsetVisitor : public boost::default_dfs_visitor { public: explicit ReachSubsetVisitor(const CharReach &r) : cr(r) {} template void discover_vertex(const Vertex &v, const Graph &g) const { if (is_any_start(v, g)) { return; // start vertices are OK } else if (is_special(v, g)) { assert(0); throw ReachMismatch(); // other special nodes?? } const CharReach &vcr = g[v].char_reach; DEBUG_PRINTF("checking if vcr (%zu) is subset of (%zu)\n", vcr.count(), cr.count()); if (vcr != (vcr & cr)) { throw ReachMismatch(); } } private: const CharReach &cr; }; /** Terminator function for DFS used in pathReachSubset. */ template class VertexIs { public: explicit VertexIs(const Vertex &v) : vertex(v) {} bool operator()(const Vertex &v, const Graph &) const { return v == vertex; } private: Vertex vertex; }; } // namespace /** Returns true if every vertex on paths leading to edge \p e has reachability * which is a subset of the reachability of \p dom */ static bool reversePathReachSubset(const NFAEdge &e, const NFAVertex &dom, const NGHolder &g) { const CharReach &domReach = g[dom].char_reach; if (domReach.all()) { return true; } NFAVertex start = source(e, g); using RevGraph = boost::reverse_graph; map vertexColor; // Walk the graph backwards from v, examining each node. We fail (return // false) if we encounter a node with reach NOT a subset of domReach, and // we stop searching at dom. try { depth_first_visit(RevGraph(g), start, ReachSubsetVisitor(domReach), make_assoc_property_map(vertexColor), VertexIs(dom)); } catch(ReachMismatch&) { return false; } return true; } /** Returns true if every vertex on paths leading from edge \p e has * reachability which is a subset of the reachability of \p dom */ static bool forwardPathReachSubset(const NFAEdge &e, const NFAVertex &dom, const NGHolder &g) { const CharReach &domReach = g[dom].char_reach; if (domReach.all()) { return true; } NFAVertex start = target(e, g); map vertexColor; // Walk the graph forward from v, examining each node. We fail (return // false) if we encounter a node with reach NOT a subset of domReach, and // we stop searching at dom. try { depth_first_visit(g, start, ReachSubsetVisitor(domReach), make_assoc_property_map(vertexColor), VertexIs(dom)); } catch(ReachMismatch&) { return false; } return true; } static bool allOutsSpecial(NFAVertex v, const NGHolder &g) { for (auto w : adjacent_vertices_range(v, g)) { if (!is_special(w, g)) { return false; } } return true; } static bool allInsSpecial(NFAVertex v, const NGHolder &g) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (!is_special(u, g)) { return false; } } return true; } /** Cheaply check whether this graph can't be reduced at all, because it is * just a chain of vertices with no other edges. */ static bool isIrreducible(const NGHolder &g) { for (auto v : vertices_range(g)) { // skip specials if (is_special(v, g)) { continue; } if (in_degree(v, g) != 1 && !allInsSpecial(v, g)) { return false; } if (out_degree(v, g) != 1 && !allOutsSpecial(v, g)) { return false; } } /* if calcComponents got sleepy and went home, the above checks don't hold * as it assumes there is only one connected component. */ if (isAlternationOfClasses(g)) { return false; } return true; } static u32 findCyclic(const NGHolder &g, vector &cyclic) { u32 count = 0; cyclic.resize(num_vertices(g)); for (auto v : vertices_range(g)) { assert(g[v].index < cyclic.size()); if (hasSelfLoop(v, g)) { count++; cyclic[g[v].index] = true; } } return count; } static void findCyclicDom(NGHolder &g, vector &cyclic, set &dead, som_type som) { ue2::unordered_map dominators = findDominators(g); for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } // Path in through a dominator (e.g. '.+a?foobar') NFAVertex dom = dominators[v]; if (dom && cyclic[g[dom].index] && edge(dom, v, g).second) { if (som && dom == g.startDs) { continue; } DEBUG_PRINTF("vertex %zu is dominated by directly-connected cyclic " "vertex %zu\n", g[v].index, g[dom].index); // iff all paths through in-edge e of v involve vertices whose // reachability is a subset of reach(dom), we can delete edge e. for (const auto &e : in_edges_range(v, g)) { if (source(e, g) == dom) { continue; } if (reversePathReachSubset(e, dom, g)) { DEBUG_PRINTF("edge (%zu, %zu) can be removed: leading " "paths share dom reach\n", g[source(e, g)].index, g[target(e, g)].index); dead.insert(e); if (source(e, g) == v) { cyclic[g[v].index] = false; } continue; } } } } } static void findCyclicPostDom(NGHolder &g, vector &cyclic, set &dead) { ue2::unordered_map postdominators = findPostDominators(g); for (auto v : vertices_range(g)) { if (is_special(v, g)) { continue; } // Path out through a post-dominator (e.g. a?.+foobar') NFAVertex postdom = postdominators[v]; if (postdom && cyclic[g[postdom].index] && edge(v, postdom, g).second) { DEBUG_PRINTF("vertex %zu is postdominated by directly-connected " "cyclic vertex %zu\n", g[v].index, g[postdom].index); // iff all paths through in-edge e of v involve vertices whose // reachability is a subset of reach(dom), we can delete edge e. for (const auto &e : out_edges_range(v, g)) { if (target(e, g) == postdom) { continue; } if (forwardPathReachSubset(e, postdom, g)) { DEBUG_PRINTF("edge (%zu, %zu) can be removed: trailing " "paths share postdom reach\n", g[source(e, g)].index, g[target(e, g)].index); if (target(e, g) == v) { cyclic[g[v].index] = false; } dead.insert(e); continue; } } } } } bool removeRedundancy(NGHolder &g, som_type som) { DEBUG_PRINTF("rr som = %d\n", (int)som); renumber_vertices(g); // Cheap check: if all the non-special vertices have in-degree one and // out-degree one, there's no redundancy in this here graph and we can // vamoose. if (isIrreducible(g)) { return false; } VertexInfoMap infoMap(g); // Populate maps of successors and predecessors, and accept status populateContainers(g, infoMap); /* Run multiple passes: terminate when a full pass doesn't remove * any vertices */ bool doUseless = true; bool doDiamond = true; set removable; while (doUseless || doDiamond) { if (doUseless && doUselessMergePass(g, som, infoMap, removable)) { doDiamond = true; } doUseless = false; if (doDiamond && doDiamondMergePass(g, som, infoMap, removable)) { doUseless = true; } doDiamond = false; } DEBUG_PRINTF("found %zu removable vertices overall.\n", removable.size()); remove_vertices(removable, g); return !removable.empty(); } /** UE-524: remove edges into nodes that are dominated by cyclic nodes with * reachability that is a superset of all paths feeding into that edge. */ bool removeCyclicDominated(NGHolder &g, som_type som) { set dead; vector cyclic; bool changed = false; findCyclic(g, cyclic); findCyclicDom(g, cyclic, dead, som); if (!dead.empty()) { remove_edges(dead, g); pruneUseless(g); dead.clear(); cyclic.clear(); // need to recalculate cyclic as ids have changed findCyclic(g, cyclic); changed = true; } findCyclicPostDom(g, cyclic, dead); if (!dead.empty()) { remove_edges(dead, g); pruneUseless(g); dead.clear(); changed = true; } return changed; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_small_literal_set.cpp0000644000175000017500000001774313055426554023557 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Rose construction from NGHolder for cases representing small literal * sets. */ #include "ng_small_literal_set.h" #include "grey.h" #include "ng_util.h" #include "ng_holder.h" #include "rose/rose_build.h" #include "util/compare.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph_range.h" #include "util/order_check.h" #include "util/ue2string.h" #include "ue2common.h" #include #include #include #include using namespace std; using boost::adaptors::map_keys; namespace ue2 { /** \brief The maximum number of literals to accept per pattern. */ static const size_t MAX_LITERAL_SET_SIZE = 30; /** * \brief The maximum number of literals to accept per pattern where at least * one is weak (has period < MIN_STRONG_PERIOD). */ static const size_t MAX_WEAK_LITERAL_SET_SIZE = 20; /** * \brief The minimum string period to consider a literal "strong" (and not * apply the weak size limit). */ static const size_t MIN_STRONG_PERIOD = 3; namespace { struct sls_literal { bool anchored; bool eod; ue2_literal s; explicit sls_literal(bool a) : anchored(a), eod(false) {} sls_literal append(char c, bool nocase) const { sls_literal rv(anchored); rv.s = s; rv.s.push_back(ue2_literal::elem(c, nocase)); return rv; } }; static bool operator<(const sls_literal &a, const sls_literal &b) { ORDER_CHECK(anchored); ORDER_CHECK(eod); ORDER_CHECK(s); return false; } } // namespace static bool checkLongMixedSensitivityLiterals( const map> &literals) { const size_t len = MAX_MASK2_WIDTH; for (const sls_literal &lit : literals | map_keys) { if (mixed_sensitivity(lit.s) && lit.s.length() > len) { return false; } } return true; } static bool findLiterals(const NGHolder &g, map> *literals) { vector order = getTopoOrdering(g); vector> built(num_vertices(g)); vector read_count(num_vertices(g)); for (auto it = order.rbegin(); it != order.rend(); ++it) { NFAVertex v = *it; set &out = built[g[v].index]; read_count[g[v].index] = out_degree(v, g); DEBUG_PRINTF("setting read_count to %zu for %zu\n", read_count[g[v].index], g[v].index); assert(out.empty()); if (v == g.start) { out.insert(sls_literal(true)); continue; } else if (v == g.startDs) { out.insert(sls_literal(false)); continue; } bool eod = v == g.acceptEod; bool accept = v == g.accept || v == g.acceptEod; const CharReach &cr = g[v].char_reach; for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == g.accept) { continue; } if (u == g.start && edge(g.startDs, v, g).second) { /* floating start states may have connections to start and * startDs - don't create duplicate anchored literals */ DEBUG_PRINTF("skipping as floating\n"); continue; } set &in = built[g[u].index]; DEBUG_PRINTF("getting from %zu (%zu reads to go)\n", g[u].index, read_count[g[u].index]); assert(!in.empty()); assert(read_count[g[u].index]); for (const sls_literal &lit : in) { if (accept) { sls_literal accept_lit = lit; // copy accept_lit.eod = eod; insert(&(*literals)[accept_lit], g[u].reports); continue; } for (size_t c = cr.find_first(); c != cr.npos; c = cr.find_next(c)) { bool nocase = ourisalpha(c) && cr.test(mytoupper(c)) && cr.test(mytolower(c)); if (nocase && (char)c == mytolower(c)) { continue; /* uppercase already handled us */ } out.insert(lit.append((u8)c, nocase)); if (out.size() + literals->size() > MAX_LITERAL_SET_SIZE) { DEBUG_PRINTF("too big %zu + %zu\n", out.size(), literals->size()); return false; } } } read_count[g[u].index]--; if (!read_count[g[u].index]) { DEBUG_PRINTF("clearing %zu as finished reading\n", g[u].index); in.clear(); } } } return true; } static size_t min_period(const map> &literals) { size_t rv = SIZE_MAX; for (const sls_literal &lit : literals | map_keys) { rv = min(rv, minStringPeriod(lit.s)); } DEBUG_PRINTF("min period %zu\n", rv); return rv; } // If this component is just a small set of literals and can be handled by // Rose, feed it directly into rose. bool handleSmallLiteralSets(RoseBuild &rose, const NGHolder &g, const CompileContext &cc) { if (!cc.grey.allowSmallLiteralSet) { return false; } if (!isAcyclic(g)) { /* literal sets would typically be acyclic... */ DEBUG_PRINTF("not acyclic\n"); return false; } DEBUG_PRINTF("looking for literals\n"); map> literals; if (!findLiterals(g, &literals)) { DEBUG_PRINTF(":(\n"); return false; } assert(!literals.empty()); if (literals.size() > MAX_LITERAL_SET_SIZE) { /* try a mask instead */ DEBUG_PRINTF("too many literals\n"); return false; } size_t period = min_period(literals); if (period < MIN_STRONG_PERIOD && literals.size() > MAX_WEAK_LITERAL_SET_SIZE) { DEBUG_PRINTF("too many literals with weak period\n"); return false; } if (!checkLongMixedSensitivityLiterals(literals)) { DEBUG_PRINTF("long mixed\n"); return false; } DEBUG_PRINTF("adding %zu literals\n", literals.size()); for (const auto &m : literals) { const sls_literal &lit = m.first; const auto &reports = m.second; rose.add(lit.anchored, lit.eod, lit.s, reports); } return true; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_width.cpp0000644000175000017500000001732313055426554021171 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Functions for finding the min/max width of the input required to * match a pattern. */ #include "ng_width.h" #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" #include "util/depth.h" #include "util/graph.h" #include #include #include #include #include using namespace std; namespace ue2 { namespace { /** * Filter out special edges, or in the top-specific variant, start edges that * don't have the right top set. */ struct SpecialEdgeFilter { SpecialEdgeFilter() {} explicit SpecialEdgeFilter(const NGHolder &h_in) : h(&h_in) {} SpecialEdgeFilter(const NGHolder &h_in, u32 top_in) : h(&h_in), single_top(true), top(top_in) {} bool operator()(const NFAEdge &e) const { NFAVertex u = source(e, *h); NFAVertex v = target(e, *h); if ((is_any_start(u, *h) && is_any_start(v, *h)) || (is_any_accept(u, *h) && is_any_accept(v, *h))) { return false; } if (single_top) { if (u == h->start && !contains((*h)[e].tops, top)) { return false; } if (u == h->startDs) { return false; } } return true; } private: const NGHolder *h = nullptr; bool single_top = false; u32 top = 0; }; } // namespace static depth findMinWidth(const NGHolder &h, const SpecialEdgeFilter &filter, NFAVertex src) { if (isLeafNode(src, h)) { return depth::unreachable(); } boost::filtered_graph g(h, filter); assert(hasCorrectlyNumberedVertices(h)); const size_t num = num_vertices(h); vector distance(num, depth::unreachable()); distance.at(g[src].index) = depth(0); auto index_map = get(&NFAGraphVertexProps::index, g); // Since we are interested in the single-source shortest paths on a graph // with the same weight on every edge, using BFS will be faster than // Dijkstra here. breadth_first_search(g, src, visitor(make_bfs_visitor(record_distances( make_iterator_property_map(distance.begin(), index_map), boost::on_tree_edge())))); DEBUG_PRINTF("d[accept]=%s, d[acceptEod]=%s\n", distance.at(NODE_ACCEPT).str().c_str(), distance.at(NODE_ACCEPT_EOD).str().c_str()); depth d = min(distance.at(NODE_ACCEPT), distance.at(NODE_ACCEPT_EOD)); if (d.is_unreachable()) { return d; } assert(d.is_finite()); assert(d > depth(0)); return d - depth(1); } static depth findMaxWidth(const NGHolder &h, const SpecialEdgeFilter &filter, NFAVertex src) { if (isLeafNode(src, h)) { return depth::unreachable(); } if (hasReachableCycle(h, src)) { // There's a cycle reachable from this src, so we have inf width. return depth::infinity(); } boost::filtered_graph g(h, filter); assert(hasCorrectlyNumberedVertices(h)); const size_t num = num_vertices(h); vector distance(num); vector colors(num); auto index_map = get(&NFAGraphVertexProps::index, g); // DAG shortest paths with negative edge weights. dag_shortest_paths(g, src, distance_map(make_iterator_property_map(distance.begin(), index_map)) .weight_map(boost::make_constant_property(-1)) .color_map(make_iterator_property_map(colors.begin(), index_map))); depth acceptDepth, acceptEodDepth; if (colors.at(NODE_ACCEPT) == boost::white_color) { acceptDepth = depth::unreachable(); } else { acceptDepth = -1 * distance.at(NODE_ACCEPT); } if (colors.at(NODE_ACCEPT_EOD) == boost::white_color) { acceptEodDepth = depth::unreachable(); } else { acceptEodDepth = -1 * distance.at(NODE_ACCEPT_EOD); } depth d; if (acceptDepth.is_unreachable()) { d = acceptEodDepth; } else if (acceptEodDepth.is_unreachable()) { d = acceptDepth; } else { d = max(acceptDepth, acceptEodDepth); } if (d.is_unreachable()) { // If we're actually reachable, we'll have a min width, so we can // return infinity in this case. if (findMinWidth(h, filter, src).is_reachable()) { return depth::infinity(); } return d; } // Invert sign and subtract one for start transition. assert(d.is_finite() && d > depth(0)); return d - depth(1); } static depth findMinWidth(const NGHolder &h, const SpecialEdgeFilter &filter) { depth startDepth = findMinWidth(h, filter, h.start); depth dotstarDepth = findMinWidth(h, filter, h.startDs); DEBUG_PRINTF("startDepth=%s, dotstarDepth=%s\n", startDepth.str().c_str(), dotstarDepth.str().c_str()); if (startDepth.is_unreachable()) { assert(dotstarDepth.is_finite()); return dotstarDepth; } else if (dotstarDepth.is_unreachable()) { assert(startDepth.is_finite()); return startDepth; } else { assert(min(startDepth, dotstarDepth).is_finite()); return min(startDepth, dotstarDepth); } } depth findMinWidth(const NGHolder &h) { return findMinWidth(h, SpecialEdgeFilter(h)); } depth findMinWidth(const NGHolder &h, u32 top) { return findMinWidth(h, SpecialEdgeFilter(h, top)); } static depth findMaxWidth(const NGHolder &h, const SpecialEdgeFilter &filter) { depth startDepth = findMaxWidth(h, filter, h.start); depth dotstarDepth = findMaxWidth(h, filter, h.startDs); DEBUG_PRINTF("startDepth=%s, dotstarDepth=%s\n", startDepth.str().c_str(), dotstarDepth.str().c_str()); if (startDepth.is_unreachable()) { return dotstarDepth; } else if (dotstarDepth.is_unreachable()) { return startDepth; } else { return max(startDepth, dotstarDepth); } } depth findMaxWidth(const NGHolder &h) { return findMaxWidth(h, SpecialEdgeFilter(h)); } depth findMaxWidth(const NGHolder &h, u32 top) { return findMaxWidth(h, SpecialEdgeFilter(h, top)); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_literal_component.cpp0000644000175000017500000001527513055426554023574 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Literal Component Splitting. Identifies literals that span the * graph and moves them into Rose. */ #include "grey.h" #include "ng.h" #include "ng_literal_component.h" #include "ng_prune.h" #include "ng_util.h" #include "ue2common.h" #include "rose/rose_build.h" #include "util/container.h" #include "util/graph.h" #include "util/graph_range.h" #include "util/ue2string.h" using namespace std; namespace ue2 { static bool isLiteralChar(const NGWrapper &g, NFAVertex v, bool &nocase, bool &casefixed) { const CharReach &cr = g[v].char_reach; const size_t num = cr.count(); if (num > 2) { return false; // char class } if (!casefixed) { if (num == 2 && cr.isCaselessChar()) { nocase = true; casefixed = true; return true; } else if (num == 1) { if (cr.isAlpha()) { nocase = false; casefixed = true; } // otherwise, still acceptable but we can't fix caselessness yet return true; } } else { // nocase property is fixed if (nocase) { if ((num == 2 && cr.isCaselessChar()) || (num == 1 && !cr.isAlpha())) { return true; } } else { return (num == 1); } } return false; } static void addToString(string &s, const NGHolder &g, NFAVertex v) { const CharReach &cr = g[v].char_reach; assert(cr.count() == 1 || cr.isCaselessChar()); char c = (char)cr.find_first(); s.push_back(c); } static bool splitOffLiteral(NG &ng, NGWrapper &g, NFAVertex v, const bool anchored, set &dead) { DEBUG_PRINTF("examine vertex %zu\n", g[v].index); bool nocase = false, casefixed = false; assert(!is_special(v, g)); size_t reqInDegree; if (anchored) { reqInDegree = 1; assert(edge(g.start, v, g).second); } else { reqInDegree = 2; assert(edge(g.start, v, g).second); assert(edge(g.startDs, v, g).second); } if (in_degree(v, g) > reqInDegree) { DEBUG_PRINTF("extra in-edges\n"); return false; } if (!isLiteralChar(g, v, nocase, casefixed)) { DEBUG_PRINTF("not literal\n"); return false; } string literal; addToString(literal, g, v); // Remaining vertices must come in a chain, each with one in-edge and one // out-edge only. NFAVertex u; while (1) { if (out_degree(v, g) != 1) { DEBUG_PRINTF("branches, not literal\n"); return false; } u = v; // previous vertex v = *(adjacent_vertices(v, g).first); DEBUG_PRINTF("loop, v=%zu\n", g[v].index); if (is_special(v, g)) { if (v == g.accept || v == g.acceptEod) { break; // OK } else { assert(0); // start? return false; } } else { // Ordinary, must be literal if (!isLiteralChar(g, v, nocase, casefixed)) { DEBUG_PRINTF("not literal\n"); return false; } if (in_degree(v, g) != 1) { DEBUG_PRINTF("branches, not literal\n"); return false; } } addToString(literal, g, v); } // Successfully found a literal; there might be multiple report IDs, in // which case we add all the reports. assert(!is_special(u, g)); bool eod = v == g.acceptEod; assert(eod || v == g.accept); DEBUG_PRINTF("success: found %s literal '%s'\n", anchored ? "anchored" : "unanchored", escapeString(literal).c_str()); // Literals of length 1 are better served going through later optimisation // passes, where they might be combined together into a character class. if (literal.length() == 1) { DEBUG_PRINTF("skipping literal of length 1\n"); return false; } ng.rose->add(anchored, eod, ue2_literal(literal, nocase), g[u].reports); // Remove the terminal vertex. Later, we rely on pruneUseless to remove the // other vertices in this chain, since they'll no longer lead to an accept. dead.insert(u); return true; } /** \brief Split off literals. True if any changes were made to the graph. */ bool splitOffLiterals(NG &ng, NGWrapper &g) { if (!ng.cc.grey.allowLiteral) { return false; } bool changed = false; set dead; ue2::unordered_set unanchored; // for faster lookup. insert(&unanchored, adjacent_vertices(g.startDs, g)); // Anchored literals. for (auto v : adjacent_vertices_range(g.start, g)) { if (!is_special(v, g) && !contains(unanchored, v)) { changed |= splitOffLiteral(ng, g, v, true, dead); } } // Unanchored literals. for (auto v : adjacent_vertices_range(g.startDs, g)) { if (!is_special(v, g)) { changed |= splitOffLiteral(ng, g, v, false, dead); } } if (changed) { remove_vertices(dead, g); pruneUseless(g); return true; } return false; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_edge_redundancy.cpp0000644000175000017500000003516013055426554023171 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Edge redundancy graph reductions. */ #include "ng_edge_redundancy.h" #include "ng_holder.h" #include "ng_prune.h" #include "ng_util.h" #include "ue2common.h" #include "parser/position.h" #include "util/compile_context.h" #include "util/container.h" #include "util/graph_range.h" #include "util/ue2_containers.h" #include #include using namespace std; namespace ue2 { /* reverse edge redundancy removal is possible but is not implemented as it * regressed rose pattern support in the regression suite: 19026 - 19027 * (foo.{1,5}b?ar) * * If rose becomes smarter we can reimplement. */ static never_inline bool checkVerticesFwd(const NGHolder &g, const set &sad, const set &happy) { /* need to check if for each vertex in sad if it has an edge to a happy * vertex */ for (auto u : sad) { bool ok = false; for (auto v : adjacent_vertices_range(u, g)) { if (contains(happy, v)) { ok = true; break; } } if (!ok) { return false; } } return true; } static never_inline bool checkVerticesRev(const NGHolder &g, const set &sad, const set &happy) { /* need to check if for each vertex in sad if it has an edge to a happy * vertex */ for (auto v : sad) { bool ok = false; for (auto u : inv_adjacent_vertices_range(v, g)) { if (contains(happy, u)) { ok = true; break; } } if (!ok) { return false; } } return true; } /** \brief Redundant self-loop removal. * * A self loop on a vertex v can be removed if: * * For every vertex u in pred(v) either: * 1: u has a self loop and cr(v) subset of cr(u) * OR * 2: u has an edge to vertex satisfying criterion 1 * * Note: we remove all dead loops at the end of the pass and do not check the * live status of the loops we are depending on during the analysis. * * We don't end up in situations where we remove a group of loops which depend * on each other as: * * - there must be at least one vertex not in the group which is a pred of some * member of the group (as we don't remove loops on specials) * * For each pred vertex of the group: * - the vertex must be 'sad' as it is not part of the group * - therefore it must have edges to each member of the group (to happy, trans) * - therefore the group is enabled simultaneously * - due to internal group edges, all members will still be active after the * next character. * * Actually, the vertex redundancy code will merge the entire group into one * cyclic state. */ static bool removeEdgeRedundancyNearCyclesFwd(NGHolder &g, bool ignore_starts) { unsigned dead_count = 0; set happy; set sad; for (auto v : vertices_range(g)) { if (is_special(v, g) || !hasSelfLoop(v, g)) { continue; } const CharReach &cr_v = g[v].char_reach; happy.clear(); sad.clear(); for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; } if (!hasSelfLoop(u, g)) { sad.insert(u); continue; } if (ignore_starts) { if (u == g.startDs || is_virtual_start(u, g)) { sad.insert(u); continue; } } const CharReach &cr_u = g[u].char_reach; if ((cr_u & cr_v) != cr_v) { sad.insert(u); continue; } happy.insert(u); } if (!happy.empty() && checkVerticesFwd(g, sad, happy)) { dead_count++; remove_edge(v, v, g); } } DEBUG_PRINTF("found %u removable edges.\n", dead_count); return dead_count; } /** \brief Redundant self-loop removal (reverse version). * * A self loop on a vertex v can be removed if: * * For every vertex u in succ(v) either: * 1: u has a self loop and cr(v) is a subset of cr(u). * OR * 2: u is not an accept and u has an edge from a vertex satisfying * criterion 1. * OR * 3: u is in an accept and u has an edge from a vertex v' satisfying * criterion 1 and report(v) == report(v'). */ static bool removeEdgeRedundancyNearCyclesRev(NGHolder &g) { unsigned dead_count = 0; set happy; set sad; for (auto v : vertices_range(g)) { if (is_special(v, g) || !hasSelfLoop(v, g)) { continue; } const CharReach &cr_v = g[v].char_reach; happy.clear(); sad.clear(); for (auto u : adjacent_vertices_range(v, g)) { if (u == v) { continue; } if (!hasSelfLoop(u, g)) { sad.insert(u); continue; } assert(!is_special(u, g)); const CharReach &cr_u = g[u].char_reach; if (!cr_v.isSubsetOf(cr_u)) { sad.insert(u); continue; } happy.insert(u); } if (!happy.empty() && checkVerticesRev(g, sad, happy)) { dead_count++; remove_edge(v, v, g); } } DEBUG_PRINTF("found %u removable edges.\n", dead_count); return dead_count; } static bool parentsSubsetOf(const NGHolder &g, NFAVertex v, const flat_set &other_parents, NFAVertex other, map &done) { map::const_iterator dit = done.find(v); if (dit != done.end()) { return dit->second; } for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v && contains(other_parents, other)) { continue; } if (!contains(other_parents, u)) { done[v] = false; return false; } } done[v] = true; return true; } static bool checkFwdCandidate(const NGHolder &g, NFAVertex fixed_src, const flat_set &fixed_parents, const NFAEdge &candidate, map &done) { NFAVertex w = source(candidate, g); NFAVertex v = target(candidate, g); const CharReach &cr_w = g[w].char_reach; const CharReach &cr_u = g[fixed_src].char_reach; /* There is no reason why self loops cannot be considered by this * transformation but the removal is already handled by many other * transformations. */ if (w == v) { return false; } if (is_special(w, g)) { return false; } if (!cr_w.isSubsetOf(cr_u)) { return false; } /* check that each parent of w is also a parent of u */ if (!parentsSubsetOf(g, w, fixed_parents, fixed_src, done)) { return false; } DEBUG_PRINTF("edge (%zu, %zu) killed by edge (%zu, %zu)\n", g[w].index, g[v].index, g[fixed_src].index, g[v].index); return true; } static never_inline void checkLargeOutU(const NGHolder &g, NFAVertex u, const flat_set &parents_u, flat_set &possible_w, map &done, set *dead) { /* only vertices with at least one parent in common with u need to be * considered, and we also only consider potential siblings with subset * reach. */ possible_w.clear(); const CharReach &cr_u = g[u].char_reach; for (auto p : parents_u) { for (auto v : adjacent_vertices_range(p, g)) { const CharReach &cr_w = g[v].char_reach; if (cr_w.isSubsetOf(cr_u)) { possible_w.insert(v); } } } // If there's only one, it's us, and we have no work to do. if (possible_w.size() <= 1) { assert(possible_w.empty() || *possible_w.begin() == u); return; } for (const auto &e : out_edges_range(u, g)) { const NFAVertex v = target(e, g); if (is_special(v, g)) { continue; } if (contains(*dead, e)) { continue; } /* Now need check to find any edges which can be removed due to the * existence of edge e */ for (const auto &e2 : in_edges_range(v, g)) { if (e == e2 || contains(*dead, e2)) { continue; } const NFAVertex w = source(e2, g); if (!contains(possible_w, w)) { continue; } if (checkFwdCandidate(g, u, parents_u, e2, done)) { dead->insert(e2); } } } } static never_inline void checkSmallOutU(const NGHolder &g, NFAVertex u, const flat_set &parents_u, map &done, set *dead) { for (const auto &e : out_edges_range(u, g)) { const NFAVertex v = target(e, g); if (is_special(v, g)) { continue; } if (contains(*dead, e)) { continue; } /* Now need check to find any edges which can be removed due to the * existence of edge e */ for (const auto &e2 : in_edges_range(v, g)) { if (e == e2 || contains(*dead, e2)) { continue; } if (checkFwdCandidate(g, u, parents_u, e2, done)) { dead->insert(e2); } } } } /** \brief Forward edge redundancy pass. * * An edge e from w to v is redundant if there exists an edge e' such that: * e' is from u to v * and: reach(w) is a subset of reach(u) * and: proper_pred(w) is a subset of pred(u) * and: self_loop(w) implies self_loop(u) or edge from (w to u) * * Note: edges to accepts also require report ID checks. */ static bool removeEdgeRedundancyFwd(NGHolder &g, bool ignore_starts) { set dead; map done; flat_set parents_u; flat_set possible_w; for (auto u : vertices_range(g)) { if (ignore_starts && (u == g.startDs || is_virtual_start(u, g))) { continue; } parents_u.clear(); pred(g, u, &parents_u); done.clear(); if (out_degree(u, g) > 1) { checkLargeOutU(g, u, parents_u, possible_w, done, &dead); } else { checkSmallOutU(g, u, parents_u, done, &dead); } } if (dead.empty()) { return false; } DEBUG_PRINTF("found %zu removable non-selfloops.\n", dead.size()); remove_edges(dead, g); pruneUseless(g); return true; } /** Entry point: Runs all the edge redundancy passes. If SoM is tracked, * don't consider startDs or virtual starts as cyclic vertices. */ bool removeEdgeRedundancy(NGHolder &g, som_type som, const CompileContext &cc) { if (!cc.grey.removeEdgeRedundancy) { return false; } bool changed = false; changed |= removeEdgeRedundancyNearCyclesFwd(g, som); changed |= removeEdgeRedundancyNearCyclesRev(g); changed |= removeEdgeRedundancyFwd(g, som); return changed; } /** \brief Removes optional stuff from the front of floating patterns, since it's * redundant with startDs. * * For each successor of startDs, remove any in-edges that aren't from either * start or startDs. This allows us to prune redundant vertices at the start of * a pattern: * * /(hat)?stand --> /stand/ * */ bool removeSiblingsOfStartDotStar(NGHolder &g) { vector dead; for (auto v : adjacent_vertices_range(g.startDs, g)) { DEBUG_PRINTF("checking %zu\n", g[v].index); if (is_special(v, g)) { continue; } for (const auto &e : in_edges_range(v, g)) { NFAVertex u = source(e, g); if (is_special(u, g)) { continue; } DEBUG_PRINTF("removing %zu->%zu\n", g[u].index, g[v].index); dead.push_back(e); } } if (dead.empty()) { return false; } DEBUG_PRINTF("found %zu removable edges.\n", dead.size()); remove_edges(dead, g); pruneUseless(g); return true; } /** Removes all edges into virtual starts other than those from start/startDs, * providing there is an edge from startDs. This operation is an optimisation * for SOM mode. (see UE-1544) */ bool optimiseVirtualStarts(NGHolder &g) { vector dead; for (auto v : adjacent_vertices_range(g.startDs, g)) { u32 flags = g[v].assert_flags; if (!(flags & POS_FLAG_VIRTUAL_START)) { continue; } for (const auto &e : in_edges_range(v, g)) { if (!is_any_start(source(e, g), g)) { dead.push_back(e); } } } if (dead.empty()) { return false; } DEBUG_PRINTF("removing %zu edges into virtual starts\n", dead.size()); remove_edges(dead, g); pruneUseless(g); return true; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_stop.h0000644000175000017500000000502613055426554020501 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Stop Alphabet calculation. */ #ifndef NG_STOP_H #define NG_STOP_H #include "ue2common.h" #include "som/som.h" #include namespace ue2 { struct CastleProto; class CharReach; class NGHolder; /** Find the set of characters that are not present in the reachability of * graph \p g after a certain depth (currently 8). If a character in this set * is encountered, it means that the NFA is either dead or has not progressed * more than 8 characters from its start states. */ CharReach findStopAlphabet(const NGHolder &g, som_type som); /** Calculate the stop alphabet for each depth from 0 to MAX_STOP_DEPTH. Then * build an eight-bit mask per character C, with each bit representing the * depth before the location of character C (if encountered) that the NFA would * be in a predictable start state. */ std::vector findLeftOffsetStopAlphabet(const NGHolder &g, som_type som); std::vector findLeftOffsetStopAlphabet(const CastleProto &c, som_type som); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_sep.h0000644000175000017500000000343213055426554020302 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Short Exhaustible Passthroughs. */ #ifndef NG_SEP_H #define NG_SEP_H namespace ue2 { struct Grey; class NGHolder; class ReportManager; bool isSEP(const NGHolder &g, const ReportManager &rm, const Grey &grey); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_reports.cpp0000644000175000017500000000576513055426554021557 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Utility functions for working with Report ID sets. */ #include "ng_reports.h" #include "ng_holder.h" #include "util/container.h" #include "util/compile_context.h" #include "util/graph_range.h" #include "util/report_manager.h" using namespace std; namespace ue2 { /** Returns the set of all reports in the graph. */ set all_reports(const NGHolder &g) { set rv; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { insert(&rv, g[v].reports); } for (auto v : inv_adjacent_vertices_range(g.acceptEod, g)) { insert(&rv, g[v].reports); } return rv; } /** True if *all* reports in the graph are exhaustible. */ bool can_exhaust(const NGHolder &g, const ReportManager &rm) { for (ReportID report_id : all_reports(g)) { if (rm.getReport(report_id).ekey == INVALID_EKEY) { return false; } } return true; } /** Derive a maximum offset for the graph from the max_offset values of its * reports. Returns MAX_OFFSET for inf. */ u64a findMaxOffset(const NGHolder &g, const ReportManager &rm) { u64a maxOffset = 0; set reports = all_reports(g); assert(!reports.empty()); for (ReportID report_id : all_reports(g)) { const Report &ir = rm.getReport(report_id); if (ir.hasBounds()) { maxOffset = max(maxOffset, ir.maxOffset); } else { return MAX_OFFSET; } } return maxOffset; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_dump.h0000644000175000017500000001332313055426554020460 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Dump code for NFA graphs. */ #ifndef NG_DUMP_H #define NG_DUMP_H #include "grey.h" #include "ng_holder.h" // for graph types #include "ue2common.h" #include "util/ue2_containers.h" #ifdef DUMP_SUPPORT #include #endif struct RoseEngine; namespace ue2 { class NGHolder; class NG; class NGWrapper; class ReportManager; // Implementations for stubs below -- all have the suffix "Impl". #ifdef DUMP_SUPPORT template void dumpGraphImpl(const char *name, const GraphT &g); template void dumpGraphImpl(const char *name, const GraphT &g, const ReportManager &rm); void dumpDotWrapperImpl(const NGWrapper &w, const char *name, const Grey &grey); void dumpComponentImpl(const NGHolder &g, const char *name, u32 expr, u32 comp, const Grey &grey); void dumpSomSubComponentImpl(const NGHolder &g, const char *name, u32 expr, u32 comp, u32 plan, const Grey &grey); void dumpHolderImpl(const NGHolder &h, unsigned int stageNumber, const char *stageName, const Grey &grey); // Variant that takes a region map as well. void dumpHolderImpl(const NGHolder &h, const ue2::unordered_map ®ion_map, unsigned int stageNumber, const char *stageName, const Grey &grey); template static inline void dumpGraph(UNUSED const char *name, UNUSED const GraphT &g) { dumpGraphImpl(name, g); } #endif // DUMP_SUPPORT // Stubs which call through to dump code if compiled in. UNUSED static inline void dumpDotWrapper(UNUSED const NGWrapper &w, UNUSED const char *name, UNUSED const Grey &grey) { #ifdef DUMP_SUPPORT dumpDotWrapperImpl(w, name, grey); #endif } UNUSED static inline void dumpComponent(UNUSED const NGHolder &h, UNUSED const char *name, UNUSED u32 expr, UNUSED u32 comp, UNUSED const Grey &grey) { #ifdef DUMP_SUPPORT dumpComponentImpl(h, name, expr, comp, grey); #endif } UNUSED static inline void dumpSomSubComponent(UNUSED const NGHolder &h, UNUSED const char *name, UNUSED u32 expr, UNUSED u32 comp, UNUSED u32 plan, UNUSED const Grey &grey) { #ifdef DUMP_SUPPORT dumpSomSubComponentImpl(h, name, expr, comp, plan, grey); #endif } UNUSED static inline void dumpHolder(UNUSED const NGHolder &h, UNUSED unsigned int stageNumber, UNUSED const char *name, UNUSED const Grey &grey) { #ifdef DUMP_SUPPORT dumpHolderImpl(h, stageNumber, name, grey); #endif } UNUSED static inline void dumpHolder(UNUSED const NGHolder &h, UNUSED const ue2::unordered_map ®ion_map, UNUSED unsigned int stageNumber, UNUSED const char *name, UNUSED const Grey &grey) { #ifdef DUMP_SUPPORT dumpHolderImpl(h, region_map, stageNumber, name, grey); #endif } #ifdef DUMP_SUPPORT void dumpReportManager(const ReportManager &rm, const Grey &grey); void dumpSmallWrite(const RoseEngine *rose, const Grey &grey); #else static UNUSED void dumpReportManager(const ReportManager &, const Grey &) { } static UNUSED void dumpSmallWrite(const RoseEngine *, const Grey &) { } #endif #ifdef DUMP_SUPPORT // replace boost's graphviz writer template static void writeGraphviz(std::ostream &out, const GraphT &g, WriterT w, const VertexID &vertex_id) { const std::string delimiter(" -> "); out << "digraph G {" << std::endl; typename boost::graph_traits::vertex_iterator i, end; for(boost::tie(i,end) = vertices(g); i != end; ++i) { out << get(vertex_id, *i); w(out, *i); // print vertex attributes out << ";" << std::endl; } typename boost::graph_traits::edge_iterator ei, edge_end; for(boost::tie(ei, edge_end) = edges(g); ei != edge_end; ++ei) { out << (get(vertex_id, source(*ei, g))) << delimiter << (get(vertex_id, target(*ei, g))) << " "; w(out, *ei); // print edge attributes out << ";" << std::endl; } out << "}" << std::endl; } #endif // DUMP_SUPPORT } // namespace ue2 #endif // NG_DUMP_H hyperscan-4.4.1/src/nfagraph/ng_puff.cpp0000644000175000017500000004301713055426554021011 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Puff construction from NGHolder. */ #include "ng_puff.h" #include "grey.h" #include "ng_depth.h" #include "ng_holder.h" #include "ng_prune.h" #include "ng_repeat.h" #include "ng_reports.h" #include "ng_util.h" #include "ue2common.h" #include "nfa/nfa_api_queue.h" #include "nfa/mpvcompile.h" #include "rose/rose_build.h" #include "util/compile_context.h" #include "util/graph_range.h" #include "util/report_manager.h" #include using namespace std; namespace ue2 { static const unsigned MIN_PUFF_LENGTH = 16; static const unsigned HEAD_BACKOFF = 16; static size_t countChain(const NGHolder &g, NFAVertex v) { size_t count = 0; while (v) { DEBUG_PRINTF("counting vertex %zu\n", g[v].index); if (is_special(v, g)) { break; } count++; v = getSoleDestVertex(g, v); } DEBUG_PRINTF("done %zu\n", count); return count; } static void wireNewAccepts(NGHolder &g, NFAVertex head, const flat_set &chain_reports) { for (auto u : inv_adjacent_vertices_range(head, g)) { if (is_special(u, g)) { continue; } DEBUG_PRINTF("adding edge: %zu -> accept\n", g[u].index); assert(!edge(u, g.accept, g).second); assert(!edge(u, g.acceptEod, g).second); add_edge(u, g.accept, g); // Replace reports with our chain reports. auto &u_reports = g[u].reports; u_reports.clear(); u_reports.insert(chain_reports.begin(), chain_reports.end()); } } static bool isFixedDepth(const NGHolder &g, NFAVertex v) { // If the vertex is reachable from startDs, it can't be fixed depth. vector depthFromStartDs; calcDepthsFrom(g, g.startDs, depthFromStartDs); u32 idx = g[v].index; const DepthMinMax &ds = depthFromStartDs.at(idx); if (ds.min.is_reachable()) { DEBUG_PRINTF("vertex reachable from startDs\n"); return false; } vector depthFromStart; calcDepthsFrom(g, g.start, depthFromStart); /* we can still consider the head of a puff chain as at fixed depth if * it has a self-loop: so we look at all the preds of v (other than v * itself) */ assert(v && !is_special(v, g)); u32 count = 0; for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; // self-loop } count++; idx = g[u].index; const DepthMinMax &d = depthFromStart.at(idx); if (d.min != d.max) { return false; } } return count != 0; // at least one fixed-depth pred } static bool singleStart(const NGHolder &g) { set seen; for (auto v : adjacent_vertices_range(g.start, g)) { if (!is_special(v, g)) { DEBUG_PRINTF("saw %zu\n", g[v].index); seen.insert(v); } } for (auto v : adjacent_vertices_range(g.startDs, g)) { if (!is_special(v, g)) { DEBUG_PRINTF("saw %zu\n", g[v].index); seen.insert(v); } } DEBUG_PRINTF("comp has %zu starts\n", seen.size()); return seen.size() == 1; } static bool triggerResetsPuff(const NGHolder &g, NFAVertex head) { const CharReach puff_escapes = ~g[head].char_reach; for (auto u : inv_adjacent_vertices_range(head, g)) { if (!g[u].char_reach.isSubsetOf(puff_escapes)) { DEBUG_PRINTF("no reset on trigger %zu %zu\n", g[u].index, g[head].index); return false; } } DEBUG_PRINTF("reset on trigger\n"); return true; } /** ".*[X]{N}" can be treated as ".*[X]{N,}" (misc_opt does reverse transform) * */ static bool triggerFloodsPuff(const NGHolder &g, NFAVertex head) { DEBUG_PRINTF("head = %zu\n", g[head].index); const CharReach &puff_cr = g[head].char_reach; /* we can use the pred of the head as the base of our check if it the cr * matches as if * head cr subsetof pred cr: if head is being pushed on then puff must * still being pushed on * pred cr subsetof head cr: if the puff matches then head must be also * always be on if the is connected to a wide enough cyclic */ if (proper_in_degree(head, g) == 1 && puff_cr == g[getSoleSourceVertex(g, head)].char_reach) { head = getSoleSourceVertex(g, head); DEBUG_PRINTF("temp new head = %zu\n", g[head].index); } for (auto s : inv_adjacent_vertices_range(head, g)) { DEBUG_PRINTF("s = %zu\n", g[s].index); if (!puff_cr.isSubsetOf(g[s].char_reach)) { DEBUG_PRINTF("no flood on trigger %zu %zu\n", g[s].index, g[head].index); return false; } if (!hasSelfLoop(s, g) && s != g.start) { DEBUG_PRINTF("no self loop\n"); return false; } if (s == g.start && !edge(g.startDs, head, g).second) { DEBUG_PRINTF("not float\n"); return false; } } DEBUG_PRINTF("reset on trigger\n"); return true; } static u32 allowedSquashDistance(const CharReach &cr, u32 min_width, const NGHolder &g, NFAVertex pv, bool prefilter) { CharReach accept_cr; DEBUG_PRINTF("hello |cr|=%zu %d\n", cr.count(), (int)cr.find_first()); if (prefilter) { /* a later prefilter stage make weaken the lead up so we can't be sure * that all the triggers will be squashing the puffette. */ return 0; } /* TODO: inspect further back in the pattern */ for (auto u : inv_adjacent_vertices_range(pv, g)) { accept_cr |= g[u].char_reach; } DEBUG_PRINTF("|accept_cr|=%zu\n", accept_cr.count()); if ((accept_cr & cr).any()) { return 0; /* the accept byte doesn't always kill the puffette. TODO: * maybe if we look further back we could find something that * would kill the puffette... */ } DEBUG_PRINTF("returning squash distance of %u\n", min_width); return min_width; } /** Gives a stronger puff trigger when the trigger is connected to a wide * cyclic state (aside from sds) */ static void improveHead(NGHolder &g, NFAVertex *a, vector *nodes) { DEBUG_PRINTF("attempting to improve puff trigger\n"); assert(!nodes->empty()); const CharReach &puff_cr = g[nodes->back()].char_reach; if (puff_cr.all()) { return; /* we can't really do much with this one */ } /* add the runway */ DEBUG_PRINTF("backing off - allowing a decent header\n"); assert(nodes->size() > HEAD_BACKOFF); for (u32 i = 0; i < HEAD_BACKOFF - 1; i++) { nodes->pop_back(); } *a = nodes->back(); nodes->pop_back(); } static void constructPuff(NGHolder &g, const NFAVertex a, const NFAVertex puffv, const CharReach &cr, const ReportID report, u32 width, bool fixed_depth, bool unbounded, bool auto_restart, RoseBuild &rose, ReportManager &rm, flat_set &chain_reports, bool prefilter) { DEBUG_PRINTF("constructing Puff for report %u\n", report); DEBUG_PRINTF("a = %zu\n", g[a].index); const Report &puff_report = rm.getReport(report); const bool simple_exhaust = isSimpleExhaustible(puff_report); const bool pureAnchored = a == g.start && singleStart(g); if (!pureAnchored) { if (a == g.startDs || a == g.start) { DEBUG_PRINTF("add outfix ar(false)\n"); raw_puff rp(width, unbounded, report, cr, auto_restart, simple_exhaust); rose.addOutfix(rp); return; } DEBUG_PRINTF("add chain tail\n"); u32 qi = ~0U; u32 event = MQE_TOP; raw_puff rp(width, unbounded, report, cr); rose.addChainTail(rp, &qi, &event); assert(qi != ~0U); u32 squashDistance = allowedSquashDistance(cr, width, g, puffv, prefilter); Report ir = makeMpvTrigger(event, squashDistance); /* only need to trigger once if floatingUnboundedDot */ bool floatingUnboundedDot = unbounded && cr.all() && !fixed_depth; if (floatingUnboundedDot) { ir.ekey = rm.getUnassociatedExhaustibleKey(); } ReportID id = rm.getInternalId(ir); chain_reports.insert(id); } else { DEBUG_PRINTF("add outfix ar(%d)\n", (int)auto_restart); assert(!auto_restart || unbounded); raw_puff rp(width, unbounded, report, cr, auto_restart, simple_exhaust); rose.addOutfix(rp); } } static bool doComponent(RoseBuild &rose, ReportManager &rm, NGHolder &g, NFAVertex a, set &dead, const CompileContext &cc, bool prefilter) { DEBUG_PRINTF("hello\n"); vector nodes; const CharReach &cr = g[a].char_reach; bool isDot = cr.all(); bool unbounded = false; bool exhaustible = can_exhaust(g, rm); while (true) { if (is_special(a, g)) { DEBUG_PRINTF("stopped puffing due to special vertex\n"); break; } if (g[a].char_reach != cr) { DEBUG_PRINTF("stopped puffing due to change in character " "reachability\n"); break; } if (proper_in_degree(a, g) != 1) { DEBUG_PRINTF("stopped puffing due to in degree != 1\n"); break; } size_t outDegree = out_degree(a, g); if (outDegree != 1 && (!hasSelfLoop(a, g) || outDegree != 2)) { DEBUG_PRINTF("stopping puffing due to out degree\n"); break; } if (hasSelfLoop(a, g)) { DEBUG_PRINTF("has self-loop, marking unbounded\n"); unbounded = true; } nodes.push_back(a); DEBUG_PRINTF("vertex %zu has in_degree %zu\n", g[a].index, in_degree(a, g)); a = getSoleSourceVertex(g, a); assert(a); /* already checked that old a had a proper in degree of 1 */ // Snark: we can't handle this case, because we can only handle a // single report ID on a vertex if (is_match_vertex(a, g)) { DEBUG_PRINTF("stop puffing due to vertex that leads to accept\n"); if (!nodes.empty()) { nodes.pop_back(); } break; } } if (!nodes.empty() && proper_in_degree(nodes.back(), g) != 1) { for (auto u : inv_adjacent_vertices_range(nodes.back(), g)) { if (is_special(u, g)) { DEBUG_PRINTF("pop\n"); a = nodes.back(); nodes.pop_back(); break; } } } if (a != g.startDs && edge(g.startDs, a, g).second && proper_out_degree(a, g) == 1 && g[a].char_reach == cr) { nodes.push_back(a); a = g.startDs; } bool auto_restart = false; DEBUG_PRINTF("a = %zu\n", g[a].index); if (nodes.size() < MIN_PUFF_LENGTH || a == g.startDs) { DEBUG_PRINTF("bad %zu %zu\n", nodes.size(), g[a].index); if (nodes.size() < MIN_PUFF_LENGTH) { return false; } else { DEBUG_PRINTF("mark unbounded\n"); unbounded = true; a = g.start; auto_restart = !isDot; } } bool supported = false; bool fixed_depth = isFixedDepth(g, nodes.back()); if (exhaustible) { supported = true; } else if (fixed_depth) { supported = true; } else if (unbounded) { /* any C{n, } can be supported as all ranges will be squashed together * only need to track the first */ supported = true; } else if (triggerResetsPuff(g, nodes.back())) { supported = true; } else if (triggerFloodsPuff(g, nodes.back())) { DEBUG_PRINTF("trigger floods puff\n"); supported = true; unbounded = true; } if (!supported) { DEBUG_PRINTF("not supported\n"); return false; } if (cc.grey.puffImproveHead && a != g.start) { if (edge(g.startDs, a, g).second) { goto skip_improve; /* direct sds cases are better handled by auto * restarting puffettes */ } if (fixed_depth) { goto skip_improve; /* no danger of trigger floods */ } /* if we come after something literalish don't bother */ if (g[a].char_reach.count() <= 2 && in_degree(a, g) == 1 && g[getSoleSourceVertex(g, a)].char_reach.count() <= 2) { goto skip_improve; } if (nodes.size() < MIN_PUFF_LENGTH + HEAD_BACKOFF) { return false; /* not enough of the puff left to worth bothering about */ } improveHead(g, &a, &nodes); skip_improve:; } assert(!nodes.empty()); const auto &reports = g[nodes[0]].reports; assert(!reports.empty()); for (auto report : reports) { const Report &ir = rm.getReport(report); const bool highlander = ir.ekey != INVALID_EKEY; if (!unbounded && highlander && !isSimpleExhaustible(ir)) { DEBUG_PRINTF("report %u is bounded highlander but not simple " "exhaustible\n", report); return false; } if (ir.type == INTERNAL_ROSE_CHAIN) { DEBUG_PRINTF("puffettes cannot be chained together\n"); return false; } } NFAVertex puffv = nodes.back(); assert(puffv != NGHolder::null_vertex()); u32 width = countChain(g, nodes.back()); flat_set chain_reports; for (auto report : reports) { constructPuff(g, a, puffv, cr, report, width, fixed_depth, unbounded, auto_restart, rose, rm, chain_reports, prefilter); } if (!chain_reports.empty()) { wireNewAccepts(g, puffv, chain_reports); } dead.insert(nodes.begin(), nodes.end()); return true; } bool splitOffPuffs(RoseBuild &rose, ReportManager &rm, NGHolder &g, bool prefilter, const CompileContext &cc) { if (!cc.grey.allowPuff) { return false; } size_t count = 0; set dead; for (auto v : inv_adjacent_vertices_range(g.accept, g)) { if (doComponent(rose, rm, g, v, dead, cc, prefilter)) { count++; } } if (!dead.empty()) { remove_vertices(dead, g); pruneUseless(g); } DEBUG_PRINTF("puffs: %zu\n", count); return num_vertices(g) <= N_SPECIALS; } bool isPuffable(const NGHolder &g, bool fixed_depth, const ReportManager &rm, const Grey &grey) { if (!grey.allowPuff) { return false; } if (!onlyOneTop(g)) { DEBUG_PRINTF("more than one top\n"); return false; } const set reports = all_reports(g); if (reports.size() != 1) { DEBUG_PRINTF("too many reports\n"); return false; } const Report &ir = rm.getReport(*reports.begin()); if (ir.type == INTERNAL_ROSE_CHAIN) { DEBUG_PRINTF("puffettes cannot be chained together\n"); return false; } PureRepeat repeat; if (!isPureRepeat(g, repeat)) { DEBUG_PRINTF("not pure bounded repeat\n"); return false; } if (repeat.bounds.min == depth(0)) { DEBUG_PRINTF("repeat min bound is zero\n"); return false; } // We can puff if: // (a) repeat is {N,}; or // (b) repeat is {N} and fixed-depth, or highlander (and will accept the // first match) DEBUG_PRINTF("repeat is %s\n", repeat.bounds.str().c_str()); if (repeat.bounds.max.is_infinite()) { return true; } if (repeat.bounds.min == repeat.bounds.max) { if (fixed_depth) { DEBUG_PRINTF("fixed depth\n"); return true; } const bool highlander = ir.ekey != INVALID_EKEY; // If we're highlander, we must be simple-exhaustible as well. if (highlander && isSimpleExhaustible(ir)) { return true; } } return false; } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_prefilter.h0000644000175000017500000000341013055426554021503 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Prefilter Reductions. */ #ifndef NG_PREFILTER_H #define NG_PREFILTER_H namespace ue2 { class NGHolder; struct CompileContext; void prefilterReductions(NGHolder &h, const CompileContext &cc); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_repeat.cpp0000644000175000017500000024316513055426554021337 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Bounded repeat analysis. */ #include "ng_repeat.h" #include "grey.h" #include "ng_depth.h" #include "ng_holder.h" #include "ng_limex_accel.h" #include "ng_prune.h" #include "ng_reports.h" #include "ng_som_util.h" #include "ng_undirected.h" #include "ng_util.h" #include "nfa/accel.h" #include "nfa/limex_limits.h" #include "nfa/repeat_internal.h" #include "nfa/repeatcompile.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/report_manager.h" #include #include #include #include #include #include #include #include #include using namespace std; using boost::depth_first_search; using boost::depth_first_visit; namespace ue2 { namespace { /** \brief Filter that retains only edges between vertices with the same * reachability. */ template struct ReachFilter { ReachFilter() {} explicit ReachFilter(const Graph *g_in) : g(g_in) {} // Convenience typedefs. typedef typename boost::graph_traits Traits; typedef typename Traits::vertex_descriptor VertexDescriptor; typedef typename Traits::edge_descriptor EdgeDescriptor; bool operator()(const EdgeDescriptor &e) const { assert(g); VertexDescriptor u = source(e, *g), v = target(e, *g); // Disallow special vertices, as otherwise we will try to remove them // later. if (is_special(u, *g) || is_special(v, *g)) { return false; } // Vertices must have the same reach. const CharReach &cr_u = (*g)[u].char_reach; const CharReach &cr_v = (*g)[v].char_reach; return cr_u == cr_v; } const Graph *g = nullptr; }; typedef boost::filtered_graph> RepeatGraph; struct ReachSubgraph { vector vertices; depth repeatMin = 0; depth repeatMax = 0; u32 minPeriod = 1; bool is_reset = false; enum RepeatType historyType = REPEAT_RING; bool bad = false; // if true, ignore this case }; } // namespace static void findInitDepths(const NGHolder &g, ue2::unordered_map &depths) { vector d; calcDepths(g, d); for (auto v : vertices_range(g)) { u32 idx = g[v].index; assert(idx < d.size()); depths.insert(make_pair(v, d[idx])); } } static vector buildTopoOrder(const RepeatGraph &g) { /* Note: RepeatGraph is a filtered version of NGHolder and still has * NFAVertex as its vertex descriptor */ typedef ue2::unordered_set EdgeSet; EdgeSet deadEdges; // We don't have indices spanning [0,N] on our filtered graph, so we // provide a colour map. ue2::unordered_map colours; depth_first_search(g, visitor(BackEdges(deadEdges)). color_map(make_assoc_property_map(colours))); auto acyclic_g = make_filtered_graph(g, make_bad_edge_filter(&deadEdges)); vector topoOrder; topological_sort(acyclic_g, back_inserter(topoOrder), color_map(make_assoc_property_map(colours))); reverse(topoOrder.begin(), topoOrder.end()); return topoOrder; } static void proper_pred(const NGHolder &g, NFAVertex v, ue2::unordered_set &p) { pred(g, v, &p); p.erase(v); // self-loops } static void proper_succ(const NGHolder &g, NFAVertex v, ue2::unordered_set &s) { succ(g, v, &s); s.erase(v); // self-loops } static bool roguePredecessor(const NGHolder &g, NFAVertex v, const ue2::unordered_set &involved, const ue2::unordered_set &pred) { u32 seen = 0; for (auto u : inv_adjacent_vertices_range(v, g)) { if (contains(involved, u)) { continue; } if (!contains(pred, u)) { DEBUG_PRINTF("%zu is a rogue pred\n", g[u].index); return true; } seen++; } // We must have edges from either (a) none of our external predecessors, or // (b) all of our external predecessors. if (!seen) { return false; } return pred.size() != seen; } static bool rogueSuccessor(const NGHolder &g, NFAVertex v, const ue2::unordered_set &involved, const ue2::unordered_set &succ) { u32 seen = 0; for (auto w : adjacent_vertices_range(v, g)) { if (contains(involved, w)) { continue; } if (!contains(succ, w)) { DEBUG_PRINTF("%zu is a rogue succ\n", g[w].index); return true; } seen++; } // We must have edges to either (a) none of our external successors, or // (b) all of our external successors. if (!seen) { return false; } return succ.size() != seen; } static bool hasDifferentTops(const NGHolder &g, const vector &verts) { /* TODO: check that we need this now that we allow multiple tops */ const flat_set *tops = nullptr; for (auto v : verts) { for (const auto &e : in_edges_range(v, g)) { NFAVertex u = source(e, g); if (u != g.start && u != g.startDs) { continue; // Only edges from starts have valid top properties. } DEBUG_PRINTF("edge (%zu,%zu) with %zu tops\n", g[u].index, g[v].index, g[e].tops.size()); if (!tops) { tops = &g[e].tops; } else if (g[e].tops != *tops) { return true; // More than one set of tops. } } } return false; } static bool vertexIsBad(const NGHolder &g, NFAVertex v, const ue2::unordered_set &involved, const ue2::unordered_set &tail, const ue2::unordered_set &pred, const ue2::unordered_set &succ, const flat_set &reports) { DEBUG_PRINTF("check vertex %zu\n", g[v].index); // We must drop any vertex that is the target of a back-edge within // our subgraph. The tail set contains all vertices that are after v in a // topo ordering. for (auto u : inv_adjacent_vertices_range(v, g)) { if (contains(tail, u)) { DEBUG_PRINTF("back-edge (%zu,%zu) in subgraph found\n", g[u].index, g[v].index); return true; } } // If this vertex has an entry from outside our subgraph, it must have // edges from *all* the vertices in pred and no other external entries. // Similarly for exits. if (roguePredecessor(g, v, involved, pred)) { DEBUG_PRINTF("preds for %zu not well-formed\n", g[v].index); return true; } if (rogueSuccessor(g, v, involved, succ)) { DEBUG_PRINTF("succs for %zu not well-formed\n", g[v].index); return true; } // All reporting vertices should have the same reports. if (is_match_vertex(v, g) && reports != g[v].reports) { DEBUG_PRINTF("report mismatch to %zu\n", g[v].index); return true; } return false; } static void splitSubgraph(const NGHolder &g, const deque &verts, const u32 minNumVertices, queue &q) { DEBUG_PRINTF("entry\n"); // We construct a copy of the graph using just the vertices we want, rather // than using a filtered_graph -- this way is faster. NGHolder verts_g; ue2::unordered_map verts_map; // in g -> in verts_g fillHolder(&verts_g, g, verts, &verts_map); NFAUndirectedGraph ug; ue2::unordered_map old2new; createUnGraph(verts_g, true, true, ug, old2new); ue2::unordered_map repeatMap; size_t num = connected_components(ug, make_assoc_property_map(repeatMap)); DEBUG_PRINTF("found %zu connected repeat components\n", num); assert(num > 0); vector rs(num); for (auto v : verts) { NFAUndirectedVertex vu = old2new.at(verts_map.at(v)); auto rit = repeatMap.find(vu); if (rit == repeatMap.end()) { continue; /* not part of a repeat */ } u32 comp_id = rit->second; assert(comp_id < num); rs[comp_id].vertices.push_back(v); } for (const auto &rsi : rs) { DEBUG_PRINTF("repeat with %zu vertices\n", rsi.vertices.size()); assert(!rsi.vertices.empty()); if (rsi.vertices.size() >= minNumVertices) { DEBUG_PRINTF("enqueuing\n"); q.push(rsi); } } } static void findFirstReports(const NGHolder &g, const ReachSubgraph &rsi, flat_set &reports) { for (auto v : rsi.vertices) { if (is_match_vertex(v, g)) { reports = g[v].reports; return; } } } static void checkReachSubgraphs(const NGHolder &g, vector &rs, const u32 minNumVertices) { if (rs.empty()) { return; } DEBUG_PRINTF("%zu subgraphs\n", rs.size()); vector rs_out; queue q; for (const auto &rsi : rs) { if (rsi.vertices.size() < minNumVertices) { continue; } q.push(rsi); } while (!q.empty()) { const ReachSubgraph &rsi = q.front(); if (rsi.vertices.size() < minNumVertices) { q.pop(); // Too small for consideration as a repeat. continue; } DEBUG_PRINTF("subgraph with %zu vertices\n", rsi.vertices.size()); // Check that all the edges from outside have the same tops. TODO: we // don't have to throw the whole subgraph out, we could do this check // on a per vertex basis. if (hasDifferentTops(g, rsi.vertices)) { DEBUG_PRINTF("different tops!\n"); q.pop(); continue; } ue2::unordered_set involved(rsi.vertices.begin(), rsi.vertices.end()); ue2::unordered_set tail(involved); // to look for back-edges. ue2::unordered_set pred, succ; proper_pred(g, rsi.vertices.front(), pred); proper_succ(g, rsi.vertices.back(), succ); flat_set reports; findFirstReports(g, rsi, reports); bool recalc = false; deque verts; for (auto v : rsi.vertices) { tail.erase(v); // now contains all vertices _after_ this one. if (vertexIsBad(g, v, involved, tail, pred, succ, reports)) { recalc = true; continue; } verts.push_back(v); } if (recalc) { if (verts.size() < minNumVertices) { DEBUG_PRINTF("subgraph got too small\n"); q.pop(); continue; } splitSubgraph(g, verts, minNumVertices, q); } else { DEBUG_PRINTF("subgraph is ok\n"); rs_out.push_back(rsi); } q.pop(); } rs.swap(rs_out); } namespace { class DistanceSet { private: // We use boost::icl to do the heavy lifting. typedef boost::icl::closed_interval ClosedInterval; typedef boost::icl::interval_set IntervalSet; IntervalSet distances; public: // Add a distance. void insert(u32 d) { distances.insert(d); } void add(const DistanceSet &a) { distances += a.distances; // union operation } // Increment all the distances by one and add. void add_incremented(const DistanceSet &a) { for (const auto &d : a.distances) { u32 lo = lower(d) + 1; u32 hi = upper(d) + 1; distances.insert(boost::icl::construct(lo, hi)); } } #ifdef DEBUG void dump() const { if (distances.empty()) { printf(""); return; } for (const auto &d : distances) { printf("[%u,%u] ", lower(d), upper(d)); } } #endif // True if this distance set is a single contiguous interval. bool is_contiguous() const { IntervalSet::const_iterator it = distances.begin(); if (it == distances.end()) { return false; } ++it; return (it == distances.end()); } pair get_range() const { assert(is_contiguous()); return make_pair(lower(distances), upper(distances)); } }; } /** * Returns false if the given bounds are too large to be implemented with our * runtime engines that handle bounded repeats. */ static bool tooLargeToImplement(const depth &repeatMin, const depth &repeatMax) { if (!repeatMin.is_finite()) { DEBUG_PRINTF("non-finite min bound %s\n", repeatMin.str().c_str()); assert(0); // this is a surprise! return true; } if ((u32)repeatMin >= REPEAT_INF) { DEBUG_PRINTF("min bound %s too large\n", repeatMin.str().c_str()); return true; } if (repeatMax.is_finite() && (u32)repeatMax >= REPEAT_INF) { DEBUG_PRINTF("finite max bound %s too large\n", repeatMax.str().c_str()); return true; } return false; } /** Returns false if the graph is not a supported bounded repeat. */ static bool processSubgraph(const NGHolder &g, ReachSubgraph &rsi, u32 minNumVertices) { DEBUG_PRINTF("reach subgraph has %zu vertices\n", rsi.vertices.size()); if (rsi.vertices.size() < minNumVertices) { DEBUG_PRINTF("too small, min is %u\n", minNumVertices); return false; } NFAVertex first = rsi.vertices.front(); NFAVertex last = rsi.vertices.back(); typedef ue2::unordered_map DistanceMap; DistanceMap dist; // Initial distance sets. for (auto u : inv_adjacent_vertices_range(first, g)) { if (u == first) { continue; // no self-loops } DEBUG_PRINTF("pred vertex %zu\n", g[u].index); dist[u].insert(0); } for (auto v : rsi.vertices) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; // no self-loops } auto di = dist.find(u); if (di == dist.end()) { assert(0); return false; } dist[v].add_incremented(di->second); } } // Remove pred distances from our map. for (auto u : inv_adjacent_vertices_range(first, g)) { if (u == first) { continue; // no self-loops } dist.erase(u); } // Calculate final union of distances. DistanceSet final_d; for (auto v : adjacent_vertices_range(last, g)) { if (v == last) { continue; // no self-loops } for (auto u : inv_adjacent_vertices_range(v, g)) { if (u == v) { continue; // no self-loops } auto di = dist.find(u); if (di == dist.end()) { continue; } final_d.add(di->second); } } #ifdef DEBUG DEBUG_PRINTF("final_d dists: "); final_d.dump(); printf("\n"); #endif if (!final_d.is_contiguous()) { // not handled right now DEBUG_PRINTF("not contiguous!\n"); return false; } pair range = final_d.get_range(); if (range.first > depth::max_value() || range.second > depth::max_value()) { DEBUG_PRINTF("repeat (%u,%u) not representable with depths\n", range.first, range.second); return false; } rsi.repeatMin = range.first; rsi.repeatMax = range.second; // If we've got a self-loop anywhere, we've got inf max. if (anySelfLoop(g, rsi.vertices.begin(), rsi.vertices.end())) { DEBUG_PRINTF("repeat contains self-loop, setting max to INF\n"); rsi.repeatMax = depth::infinity(); } // If our pattern contains a bounded repeat that we wouldn't be able to // implement as runtime, then we have no strategy that leads to // implementation -- it's not like falling back to a DFA or other // non-repeat engine is going to succeed. if (tooLargeToImplement(rsi.repeatMin, rsi.repeatMax)) { throw CompileError("Pattern too large."); } return true; } static bool allPredsInSubgraph(NFAVertex v, const NGHolder &g, const ue2::unordered_set &involved) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (!contains(involved, u)) { return false; } } return true; } static void buildTugTrigger(NGHolder &g, NFAVertex cyclic, NFAVertex v, const ue2::unordered_set &involved, ue2::unordered_map &depths, vector &tugs) { if (allPredsInSubgraph(v, g, involved)) { // We can transform this vertex into a tug trigger in-place. DEBUG_PRINTF("all preds in subgraph, vertex %zu becomes tug\n", g[v].index); add_edge(cyclic, v, g); tugs.push_back(v); return; } // Some predecessors of v are not in the subgraph, so we need to clone v // and split up its in-edges. NFAVertex t = clone_vertex(g, v); depths[t] = depths[v]; DEBUG_PRINTF("there are other paths, cloned tug %zu from vertex %zu\n", g[t].index, g[v].index); tugs.push_back(t); add_edge(cyclic, t, g); // New vertex gets all of v's successors, including v itself if it's // cyclic. clone_out_edges(g, v, t); } static NFAVertex createCyclic(NGHolder &g, ReachSubgraph &rsi) { NFAVertex last = rsi.vertices.back(); NFAVertex cyclic = clone_vertex(g, last); add_edge(cyclic, cyclic, g); DEBUG_PRINTF("created cyclic vertex %zu\n", g[cyclic].index); return cyclic; } static NFAVertex createPos(NGHolder &g, ReachSubgraph &rsi) { NFAVertex pos = add_vertex(g); NFAVertex first = rsi.vertices.front(); g[pos].char_reach = g[first].char_reach; DEBUG_PRINTF("created pos vertex %zu\n", g[pos].index); return pos; } // 2 if v is directly connected to an accept, or 1 if one hop away, // or 0 otherwise. static u32 isCloseToAccept(const NGHolder &g, NFAVertex v) { if (is_any_accept(v, g)) { return 2; } for (auto w : adjacent_vertices_range(v, g)) { if (is_any_accept(w, g)) { return 1; } } return 0; } static u32 unpeelAmount(const NGHolder &g, const ReachSubgraph &rsi) { const NFAVertex last = rsi.vertices.back(); u32 rv = 0; for (auto v : adjacent_vertices_range(last, g)) { rv = max(rv, isCloseToAccept(g, v)); } return rv; } static void unpeelNearEnd(NGHolder &g, ReachSubgraph &rsi, ue2::unordered_map &depths, vector *succs) { u32 unpeel = unpeelAmount(g, rsi); DEBUG_PRINTF("unpeeling %u vertices\n", unpeel); while (unpeel) { NFAVertex last = rsi.vertices.back(); NFAVertex first = rsi.vertices.front(); NFAVertex d = clone_vertex(g, last); depths[d] = depths[last]; DEBUG_PRINTF("created vertex %zu\n", g[d].index); for (auto v : *succs) { add_edge(d, v, g); } if (rsi.repeatMin > depth(1)) { rsi.repeatMin -= 1; } else { /* Skip edge for the cyclic state; note that we must clone their * edge properties as they may include tops. */ for (const auto &e : in_edges_range(first, g)) { add_edge(source(e, g), d, g[e], g); } } succs->clear(); succs->push_back(d); rsi.repeatMax -= 1; assert(rsi.repeatMin > depth(0)); assert(rsi.repeatMax > depth(0)); unpeel--; } } /** Fetch the set of successor vertices of this subgraph. */ static void getSuccessors(const NGHolder &g, const ReachSubgraph &rsi, vector *succs) { assert(!rsi.vertices.empty()); // Successors come from successors of last vertex. NFAVertex last = rsi.vertices.back(); for (auto v : adjacent_vertices_range(last, g)) { if (v == last) { /* ignore self loop */ continue; } succs->push_back(v); } } /** Disconnect the given subgraph from its predecessors and successors in the * NFA graph and replace it with a cyclic state. */ static void replaceSubgraphWithSpecial(NGHolder &g, ReachSubgraph &rsi, vector *repeats, ue2::unordered_map &depths, ue2::unordered_set &created) { assert(!rsi.bad); assert(rsi.repeatMin > depth(0)); assert(rsi.repeatMax >= rsi.repeatMin); assert(rsi.repeatMax > depth(2)); /* may need to unpeel 2 vertices */ DEBUG_PRINTF("entry\n"); const ue2::unordered_set involved(rsi.vertices.begin(), rsi.vertices.end()); vector succs; getSuccessors(g, rsi, &succs); unpeelNearEnd(g, rsi, depths, &succs); // Create our replacement cyclic state with the same reachability and // report info as the last vertex in our topo-ordered list. NFAVertex cyclic = createCyclic(g, rsi); created.insert(cyclic); // One more special vertex is necessary: the positive trigger (same // reach as cyclic). NFAVertex pos_trigger = createPos(g, rsi); created.insert(pos_trigger); add_edge(pos_trigger, cyclic, g); // Update depths for our new vertices. NFAVertex first = rsi.vertices.front(), last = rsi.vertices.back(); depths[pos_trigger] = depths[first]; depths[cyclic].fromStart = unionDepthMinMax(depths[first].fromStart, depths[last].fromStart); depths[cyclic].fromStartDotStar = unionDepthMinMax( depths[first].fromStartDotStar, depths[last].fromStartDotStar); // Wire predecessors to positive trigger. for (const auto &e : in_edges_range(first, g)) { add_edge(source(e, g), pos_trigger, g[e], g); } // Wire cyclic state to tug trigger states built from successors. vector tugs; for (auto v : succs) { buildTugTrigger(g, cyclic, v, involved, depths, tugs); } created.insert(tugs.begin(), tugs.end()); assert(!tugs.empty()); // Wire pos trigger to tugs if min repeat is one -- this deals with cases // where we can get a pos and tug trigger on the same byte. if (rsi.repeatMin == depth(1)) { for (auto v : tugs) { add_edge(pos_trigger, v, g); } } // Remove the vertices/edges in the subgraph. remove_vertices(rsi.vertices, g, false); erase_all(&depths, rsi.vertices); repeats->push_back(BoundedRepeatData(rsi.historyType, rsi.repeatMin, rsi.repeatMax, rsi.minPeriod, cyclic, pos_trigger, tugs)); } /** Variant for Rose-specific graphs that terminate in a sole accept, so we can * use a "lazy tug". See UE-1636. */ static void replaceSubgraphWithLazySpecial(NGHolder &g, ReachSubgraph &rsi, vector *repeats, ue2::unordered_map &depths, ue2::unordered_set &created) { assert(!rsi.bad); assert(rsi.repeatMin); assert(rsi.repeatMax >= rsi.repeatMin); DEBUG_PRINTF("entry\n"); const ue2::unordered_set involved(rsi.vertices.begin(), rsi.vertices.end()); vector succs; getSuccessors(g, rsi, &succs); // Create our replacement cyclic state with the same reachability and // report info as the last vertex in our topo-ordered list. NFAVertex cyclic = createCyclic(g, rsi); created.insert(cyclic); // One more special vertex is necessary: the positive trigger (same // reach as cyclic). NFAVertex pos_trigger = createPos(g, rsi); created.insert(pos_trigger); add_edge(pos_trigger, cyclic, g); // Update depths for our new vertices. NFAVertex first = rsi.vertices.front(), last = rsi.vertices.back(); depths[pos_trigger] = depths[first]; depths[cyclic].fromStart = unionDepthMinMax(depths[first].fromStart, depths[last].fromStart); depths[cyclic].fromStartDotStar = unionDepthMinMax( depths[first].fromStartDotStar, depths[last].fromStartDotStar); // Wire predecessors to positive trigger. for (const auto &e : in_edges_range(first, g)) { add_edge(source(e, g), pos_trigger, g[e], g); } // In the rose case, our tug is our cyclic, and it's wired to our // successors (which should be just the accept). vector tugs; assert(succs.size() == 1); for (auto v : succs) { add_edge(cyclic, v, g); } // Wire pos trigger to accept if min repeat is one -- this deals with cases // where we can get a pos and tug trigger on the same byte. if (rsi.repeatMin == depth(1)) { for (auto v : succs) { add_edge(pos_trigger, v, g); g[pos_trigger].reports = g[cyclic].reports; } } // Remove the vertices/edges in the subgraph. remove_vertices(rsi.vertices, g, false); erase_all(&depths, rsi.vertices); repeats->push_back(BoundedRepeatData(rsi.historyType, rsi.repeatMin, rsi.repeatMax, rsi.minPeriod, cyclic, pos_trigger, tugs)); } static bool isCompBigEnough(const RepeatGraph &rg, const u32 minRepeat) { // filtered_graph doesn't filter the num_vertices call. size_t n = 0; RepeatGraph::vertex_iterator vi, ve; for (tie(vi, ve) = vertices(rg); vi != ve; ++vi) { if (++n >= minRepeat) { return true; } } return false; } // Marks the subgraph as bad if it can't be handled. static void reprocessSubgraph(const NGHolder &h, const Grey &grey, ReachSubgraph &rsi) { vector rs(1, rsi); checkReachSubgraphs(h, rs, grey.minExtBoundedRepeatSize); if (rs.size() != 1) { DEBUG_PRINTF("subgraph split into %zu\n", rs.size()); rsi.bad = true; return; } rsi = rs.back(); // Potentially modified. if (processSubgraph(h, rsi, grey.minExtBoundedRepeatSize)) { DEBUG_PRINTF("reprocessed subgraph is {%s,%s} repeat\n", rsi.repeatMin.str().c_str(), rsi.repeatMax.str().c_str()); } else { DEBUG_PRINTF("reprocessed subgraph is bad\n"); rsi.bad = true; } } /** Remove vertices from the beginning and end of the vertex set that are * involved in other repeats as a result of earlier repeat transformations. */ static bool peelSubgraph(const NGHolder &g, const Grey &grey, ReachSubgraph &rsi, const ue2::unordered_set &created) { assert(!rsi.bad); if (created.empty()) { return true; } if (rsi.vertices.empty()) { return false; } // Peel involved vertices from the front. vector::iterator zap = rsi.vertices.end(); for (auto it = rsi.vertices.begin(), ite = rsi.vertices.end(); it != ite; ++it) { if (!contains(created, *it)) { zap = it; break; } else { DEBUG_PRINTF("%zu is involved in another repeat\n", g[*it].index); } } DEBUG_PRINTF("peeling %zu vertices from front\n", distance(rsi.vertices.begin(), zap)); rsi.vertices.erase(rsi.vertices.begin(), zap); // Peel involved vertices and vertices with edges to involved vertices from // the back; otherwise we may try to transform a POS into a TUG. zap = rsi.vertices.begin(); for (auto it = rsi.vertices.rbegin(), ite = rsi.vertices.rend(); it != ite; ++it) { if (!contains(created, *it) && !contains_any_of(created, adjacent_vertices(*it, g))) { zap = it.base(); // Note: erases everything after it. break; } else { DEBUG_PRINTF("%zu is involved in another repeat\n", g[*it].index); } } DEBUG_PRINTF("peeling %zu vertices from back\n", distance(zap, rsi.vertices.end())); rsi.vertices.erase(zap, rsi.vertices.end()); // If vertices in the middle are involved in other repeats, it's a definite // no-no. for (auto v : rsi.vertices) { if (contains(created, v)) { DEBUG_PRINTF("vertex %zu is in another repeat\n", g[v].index); return false; } } reprocessSubgraph(g, grey, rsi); return !rsi.bad; } /** For performance reasons, it's nice not to have an exceptional state right * next to a startDs state: that way we can do double-byte accel, whereas * otherwise the NEG trigger would limit us to single. This might be a good * idea to extend to cyclic states, too. */ static void peelStartDotStar(const NGHolder &g, const ue2::unordered_map &depths, const Grey &grey, ReachSubgraph &rsi) { if (rsi.vertices.size() < 1) { return; } NFAVertex first = rsi.vertices.front(); if (depths.at(first).fromStartDotStar.min == depth(1)) { DEBUG_PRINTF("peeling start front vertex %zu\n", g[first].index); rsi.vertices.erase(rsi.vertices.begin()); reprocessSubgraph(g, grey, rsi); } } static void buildReachSubgraphs(const NGHolder &g, vector &rs, const u32 minNumVertices) { const ReachFilter fil(&g); const RepeatGraph rg(g, fil); if (!isCompBigEnough(rg, minNumVertices)) { DEBUG_PRINTF("component not big enough, bailing\n"); return; } NFAUndirectedGraph ug; unordered_map old2new; createUnGraph(rg, true, true, ug, old2new); unordered_map repeatMap; unsigned int num; num = connected_components(ug, make_assoc_property_map(repeatMap)); DEBUG_PRINTF("found %u connected repeat components\n", num); // Now, we build a set of topo-ordered ReachSubgraphs. vector topoOrder = buildTopoOrder(rg); rs.resize(num); for (auto v : topoOrder) { NFAUndirectedVertex vu = old2new[v]; auto rit = repeatMap.find(vu); if (rit == repeatMap.end()) { continue; /* not part of a repeat */ } u32 comp_id = rit->second; assert(comp_id < num); rs[comp_id].vertices.push_back(v); } #ifdef DEBUG for (size_t i = 0; i < rs.size(); i++) { DEBUG_PRINTF("rs %zu has %zu vertices.\n", i, rs[i].vertices.size()); } #endif } static bool hasSkipEdges(const NGHolder &g, const ReachSubgraph &rsi) { assert(!rsi.vertices.empty()); const NFAVertex first = rsi.vertices.front(); const NFAVertex last = rsi.vertices.back(); // All of the preds of first must have edges to all the successors of last. for (auto u : inv_adjacent_vertices_range(first, g)) { for (auto v : adjacent_vertices_range(last, g)) { if (!edge(u, v, g).second) { return false; } } } return true; } /* depth info is valid as calculated at entry */ static bool entered_at_fixed_offset(NFAVertex v, const NGHolder &g, const ue2::unordered_map &depths, const ue2::unordered_set &reached_by_fixed_tops) { DEBUG_PRINTF("|reached_by_fixed_tops| %zu\n", reached_by_fixed_tops.size()); if (is_triggered(g) && !contains(reached_by_fixed_tops, v)) { /* can't do this for infix/suffixes unless we know trigger literals * can only occur at one offset */ DEBUG_PRINTF("bad top(s) for %zu\n", g[v].index); return false; } if (depths.at(v).fromStartDotStar.min.is_reachable()) { DEBUG_PRINTF("reachable from startDs\n"); return false; } /* look at preds as v may be cyclic */ const depth &first = depths.at(v).fromStart.min; assert(first.is_reachable()); if (!first.is_finite()) { DEBUG_PRINTF("first not finite\n"); return false; } DEBUG_PRINTF("first is at least %s from start\n", first.str().c_str()); for (auto u : inv_adjacent_vertices_range(v, g)) { const depth &u_max_depth = depths.at(u).fromStart.max; DEBUG_PRINTF("pred %zu max depth %s from start\n", g[u].index, u_max_depth.str().c_str()); if (u_max_depth != first - depth(1)) { return false; } } return true; } static NFAVertex buildTriggerStates(NGHolder &g, const vector &trigger, u32 top) { NFAVertex u = g.start; for (const auto &cr : trigger) { NFAVertex v = add_vertex(g); g[v].char_reach = cr; add_edge(u, v, g); if (u == g.start) { g[edge(u, v, g)].tops.insert(top); } u = v; } DEBUG_PRINTF("trigger len=%zu has sink %zu\n", trigger.size(), g[u].index); return u; } /** * For triggered graphs, replace the "top" edges from start with the triggers * they represent, for the purposes of determining sole entry. */ static void addTriggers(NGHolder &g, const map>> &triggers) { if (!is_triggered(g)) { assert(triggers.empty()); return; } vector dead; map> starts_by_top; for (const auto &e : out_edges_range(g.start, g)) { const NFAVertex &v = target(e, g); if (v == g.startDs) { continue; } const auto &tops = g[e].tops; // The caller may not have given us complete trigger information. If we // don't have any triggers for a particular top, we should just leave // it alone. for (u32 top : tops) { if (!contains(triggers, top)) { DEBUG_PRINTF("no triggers for top %u\n", top); goto next_edge; } starts_by_top[top].push_back(v); } dead.push_back(e); next_edge:; } remove_edges(dead, g); for (const auto &m : starts_by_top) { const auto &top = m.first; const auto &starts = m.second; assert(contains(triggers, top)); const auto &top_triggers = triggers.at(top); for (const auto &trigger : top_triggers) { NFAVertex u = buildTriggerStates(g, trigger, top); for (const auto &v : starts) { add_edge_if_not_present(u, v, g); } } } } static CharReach predReach(const NGHolder &g, NFAVertex v) { CharReach cr; for (auto u : inv_adjacent_vertices_range(v, g)) { cr |= g[u].char_reach; } return cr; } /** * Filter the given vertex map (which maps from vertices in another graph to * vertices in subg) so that it only contains vertices that actually exist in * subg. */ static void filterMap(const NGHolder &subg, ue2::unordered_map &vmap) { NGHolder::vertex_iterator vi, ve; tie(vi, ve) = vertices(subg); const ue2::unordered_set remaining_verts(vi, ve); ue2::unordered_map fmap; // filtered map for (const auto &m : vmap) { if (contains(remaining_verts, m.second)) { fmap.insert(m); } } vmap.swap(fmap); } /** Construct a graph for sole entry analysis that only considers paths through * the bounded repeat. */ static void buildRepeatGraph(NGHolder &rg, ue2::unordered_map &rg_map, const NGHolder &g, const ReachSubgraph &rsi, const map>> &triggers) { cloneHolder(rg, g, &rg_map); assert(rg.kind == g.kind); clear_in_edges(rg.accept, rg); clear_in_edges(rg.acceptEod, rg); add_edge(rg.accept, rg.acceptEod, rg); // Find the set of vertices in rg involved in the repeat. ue2::unordered_set rg_involved; for (const auto &v : rsi.vertices) { assert(contains(rg_map, v)); rg_involved.insert(rg_map.at(v)); } // Remove all out-edges from repeat vertices that aren't to other repeat // vertices, then connect terminal repeat vertices to accept. for (const auto &v : rsi.vertices) { NFAVertex rv = rg_map.at(v); remove_out_edge_if(rv, [&](const NFAEdge &e) { return !contains(rg_involved, target(e, rg)); }, rg); if (!has_successor(rv, rg)) { // no interior out-edges add_edge(rv, rg.accept, rg); } } pruneUseless(rg); if (is_triggered(rg)) { // Add vertices for all our triggers addTriggers(rg, triggers); renumber_vertices(rg); // We don't know anything about how often this graph is triggered, so we // make the start vertex cyclic for the purposes of this analysis ONLY. add_edge(rg.start, rg.start, rg); } filterMap(rg, rg_map); // All of our repeat vertices should have vertices in rg. assert(all_of(begin(rsi.vertices), end(rsi.vertices), [&](const NFAVertex &v) { return contains(rg_map, v); })); } /** * Construct an input DAG which accepts on all entries to the repeat. */ static void buildInputGraph(NGHolder &lhs, ue2::unordered_map &lhs_map, const NGHolder &g, const NFAVertex first, const map>> &triggers) { DEBUG_PRINTF("building lhs with first=%zu\n", g[first].index); cloneHolder(lhs, g, &lhs_map); assert(g.kind == lhs.kind); addTriggers(lhs, triggers); renumber_vertices(lhs); // Replace each back-edge (u,v) with an edge (startDs,v), which will // generate entries at at least the rate of the loop created by that // back-edge. set dead; BackEdges > backEdgeVisitor(dead); depth_first_search(lhs, visitor(backEdgeVisitor).root_vertex(lhs.start)); for (const auto &e : dead) { const NFAVertex u = source(e, lhs), v = target(e, lhs); if (u == v) { continue; // Self-loops are OK. } DEBUG_PRINTF("replacing back-edge (%zu,%zu) with edge (startDs,%zu)\n", lhs[u].index, lhs[v].index, lhs[v].index); add_edge_if_not_present(lhs.startDs, v, lhs); remove_edge(e, lhs); } clear_in_edges(lhs.accept, lhs); clear_in_edges(lhs.acceptEod, lhs); add_edge(lhs.accept, lhs.acceptEod, lhs); // Wire the predecessors of the first repeat vertex to accept, then prune. NFAVertex lhs_first = lhs_map.at(first); for (auto u : inv_adjacent_vertices_range(lhs_first, lhs)) { add_edge_if_not_present(u, lhs.accept, lhs); } pruneUseless(lhs); filterMap(lhs, lhs_map); } /** * Maximum number of vertices in the input DAG to actually allow sole entry * calculation (as very large cases make sentClearsTail take a long, long time * to complete.) */ static const size_t MAX_SOLE_ENTRY_VERTICES = 10000; /** True if (1) fixed offset or (2) reentries to this subgraph must involve a * character which escapes the repeat, meaning that we only need to store a * single offset at runtime. See UE-1361. */ static bool hasSoleEntry(const NGHolder &g, const ReachSubgraph &rsi, const ue2::unordered_map &depths, const ue2::unordered_set &reached_by_fixed_tops, const map>> &triggers) { DEBUG_PRINTF("checking repeat {%s,%s}\n", rsi.repeatMin.str().c_str(), rsi.repeatMax.str().c_str()); NFAVertex first = rsi.vertices.front(); const CharReach &repeatReach = g[first].char_reach; /* trivial case first is at a fixed depth */ if (entered_at_fixed_offset(first, g, depths, reached_by_fixed_tops)) { DEBUG_PRINTF("fixed depth\n"); return true; } DEBUG_PRINTF("repeat reach is %s\n", describeClass(repeatReach).c_str()); // Nothing can escape a dot repeat. if (repeatReach.all()) { DEBUG_PRINTF("dot repeat cannot be escaped\n"); return false; } // Another easy case: if the union of the reach of all entries to the // repeat will always escape the repeat, we have sole entry. if (predReach(g, first).isSubsetOf(~repeatReach)) { DEBUG_PRINTF("pred reach %s, which is subset of repeat escape\n", describeClass(predReach(g, first)).c_str()); return true; } NGHolder rg; ue2::unordered_map rg_map; buildRepeatGraph(rg, rg_map, g, rsi, triggers); assert(rg.kind == g.kind); NGHolder lhs; ue2::unordered_map lhs_map; buildInputGraph(lhs, lhs_map, g, first, triggers); assert(lhs.kind == g.kind); if (num_vertices(lhs) > MAX_SOLE_ENTRY_VERTICES) { DEBUG_PRINTF("too many vertices (%zu) for sole entry test.\n", num_vertices(lhs)); return false; } // Split the repeat graph into two regions: vertices in the LHS input DAG // are in one region, vertices in the bounded repeat are in another. const u32 lhs_region = 1; const u32 repeat_region = 2; ue2::unordered_map region_map; for (const auto &v : rsi.vertices) { assert(!is_special(v, g)); // no specials in repeats assert(contains(rg_map, v)); DEBUG_PRINTF("rg vertex %zu in repeat\n", rg[rg_map.at(v)].index); region_map.emplace(rg_map.at(v), repeat_region); } for (const auto &v : vertices_range(rg)) { if (!contains(region_map, v)) { DEBUG_PRINTF("rg vertex %zu in lhs (trigger)\n", rg[v].index); region_map.emplace(v, lhs_region); } } u32 bad_region = 0; if (sentClearsTail(rg, region_map, lhs, lhs_region, &bad_region)) { DEBUG_PRINTF("input dag clears repeat: sole entry\n"); return true; } DEBUG_PRINTF("not sole entry\n"); return false; } namespace { template struct StrawWalker { StrawWalker(const NGHolder &h_in, const Graph &g_in, const vector &all_repeats) : h(h_in), g(g_in), repeats(all_repeats) {} /** True if v is a cyclic that belongs to a bounded repeat (one without an * inf max bound). */ bool isBoundedRepeatCyclic(NFAVertex v) const { for (const auto &r : repeats) { if (r.repeatMax.is_finite() && r.cyclic == v) { return true; } } return false; } NFAVertex step(NFAVertex v) const { typename Graph::adjacency_iterator ai, ae; tie(ai, ae) = adjacent_vertices(v, g); assert(ai != ae); NFAVertex next = *ai; if (next == v) { // Ignore self loop. ++ai; if (ai == ae) { return NGHolder::null_vertex(); } next = *ai; } ++ai; if (ai != ae && *ai == v) { // Ignore self loop ++ai; } if (ai != ae) { DEBUG_PRINTF("more than one succ\n"); set succs; insert(&succs, adjacent_vertices(v, g)); succs.erase(v); for (tie(ai, ae) = adjacent_vertices(v, g); ai != ae; ++ai) { next = *ai; DEBUG_PRINTF("checking %zu\n", g[next].index); if (next == v) { continue; } set lsuccs; insert(&lsuccs, adjacent_vertices(next, g)); if (lsuccs != succs) { continue; } // Ensure that if v is in connected to accept, the reports // on `next` much match. if (is_match_vertex(v, h) && g[v].reports != g[next].reports) { DEBUG_PRINTF("report mismatch\n"); continue; } return next; } DEBUG_PRINTF("bailing\n"); return NGHolder::null_vertex(); } return next; } NFAVertex walk(NFAVertex v, vector &straw) const { DEBUG_PRINTF("walk from %zu\n", g[v].index); ue2::unordered_set visited; straw.clear(); while (!is_special(v, g)) { DEBUG_PRINTF("checking %zu\n", g[v].index); NFAVertex next = step(v); if (next == NGHolder::null_vertex()) { break; } if (!visited.insert(next).second) { DEBUG_PRINTF("already visited %zu, bailing\n", g[next].index); break; /* don't want to get stuck in any complicated loops */ } const CharReach &reach_v = g[v].char_reach; const CharReach &reach_next = g[next].char_reach; if (!reach_v.isSubsetOf(reach_next)) { DEBUG_PRINTF("%zu's reach is not a superset of %zu's\n", g[next].index, g[v].index); break; } // If this is cyclic with the right reach, we're done. Note that // startDs fulfils this requirement. if (hasSelfLoop(next, g) && !isBoundedRepeatCyclic(next)) { DEBUG_PRINTF("found cyclic %zu\n", g[next].index); return next; } v = next; straw.push_back(v); } straw.clear(); return NGHolder::null_vertex(); } private: const NGHolder &h; // underlying graph const Graph &g; const vector &repeats; }; } // namespace static NFAVertex walkStrawToCyclicRev(const NGHolder &g, NFAVertex v, const vector &all_repeats, vector &straw) { typedef boost::reverse_graph RevGraph; const RevGraph revg(g); auto cyclic = StrawWalker(g, revg, all_repeats).walk(v, straw); reverse(begin(straw), end(straw)); // path comes from cyclic return cyclic; } static NFAVertex walkStrawToCyclicFwd(const NGHolder &g, NFAVertex v, const vector &all_repeats, vector &straw) { return StrawWalker(g, g, all_repeats).walk(v, straw); } /** True if entries to this subgraph must pass through a cyclic state with * reachability that is a superset of the reach of the repeat, and * reachabilities along this path "nest" into the reaches of their * predecessors. * * This is what is called a 'straw' in the region code. */ static bool hasCyclicSupersetEntryPath(const NGHolder &g, const ReachSubgraph &rsi, const vector &all_repeats) { // Cope with peeling by following a chain of single vertices backwards // until we encounter our cyclic, all of which must have superset reach. vector straw; return walkStrawToCyclicRev(g, rsi.vertices.front(), all_repeats, straw) != NGHolder::null_vertex(); } static bool hasCyclicSupersetExitPath(const NGHolder &g, const ReachSubgraph &rsi, const vector &all_repeats) { vector straw; return walkStrawToCyclicFwd(g, rsi.vertices.back(), all_repeats, straw) != NGHolder::null_vertex(); } static bool leadsOnlyToAccept(const NGHolder &g, const ReachSubgraph &rsi) { const NFAVertex u = rsi.vertices.back(); for (auto v : adjacent_vertices_range(u, g)) { if (v != g.accept) { return false; } } assert(out_degree(u, g)); return true; } static bool allSimpleHighlander(const ReportManager &rm, const flat_set &reports) { assert(!reports.empty()); for (auto report : reports) { if (!isSimpleExhaustible(rm.getReport(report))) { return false; } } return true; } // Finds a single, fairly unrefined trigger for the repeat by walking backwards // and collecting the unioned reach at each step. static vector getUnionedTrigger(const NGHolder &g, const NFAVertex v) { const size_t MAX_TRIGGER_STEPS = 32; vector trigger; ue2::flat_set curr, next; insert(&curr, inv_adjacent_vertices(v, g)); if (contains(curr, g.start)) { DEBUG_PRINTF("start in repeat's immediate preds\n"); trigger.push_back(CharReach::dot()); // Trigger could be anything! return trigger; } for (size_t num_steps = 0; num_steps < MAX_TRIGGER_STEPS; num_steps++) { next.clear(); trigger.push_back(CharReach()); CharReach &cr = trigger.back(); for (auto v_c : curr) { cr |= g[v_c].char_reach; insert(&next, inv_adjacent_vertices(v_c, g)); } DEBUG_PRINTF("cr[%zu]=%s\n", num_steps, describeClass(cr).c_str()); if (next.empty() || contains(next, g.start)) { break; } curr.swap(next); } reverse(trigger.begin(), trigger.end()); return trigger; } static vector> getRepeatTriggers(const NGHolder &g, const NFAVertex sink) { const size_t MAX_TRIGGER_STEPS = 32; const size_t UNIONED_FALLBACK_THRESHOLD = 100; using Path = deque; vector> triggers; deque q; // work queue deque done; // finished paths size_t max_len = MAX_TRIGGER_STEPS; // Find a set of paths leading to vertex v by depth first search. for (auto u : inv_adjacent_vertices_range(sink, g)) { if (is_any_start(u, g)) { triggers.push_back({}); // empty return triggers; } q.push_back(Path(1, u)); } while (!q.empty()) { Path &path = q.front(); NFAVertex v = path.back(); if (path.size() >= max_len) { max_len = min(max_len, path.size()); done.push_back(path); goto next_path; } for (auto u : inv_adjacent_vertices_range(v, g)) { if (is_any_start(u, g)) { // Found an accept. There's no point expanding this path any // further, we're done. max_len = min(max_len, path.size()); done.push_back(path); goto next_path; } if (path.size() + 1 >= max_len) { done.push_back(path); done.back().push_back(u); } else { q.push_back(path); // copy q.back().push_back(u); } } next_path: q.pop_front(); // If our queue or our finished trigger list gets too large, fall back // to generating a single trigger with union reach. if (q.size() + done.size() > UNIONED_FALLBACK_THRESHOLD) { DEBUG_PRINTF("search too large, fall back to union trigger\n"); triggers.clear(); triggers.push_back(getUnionedTrigger(g, sink)); return triggers; } } assert(!done.empty()); // Convert our path list into a set of unique triggers. ue2::unordered_set> unique_triggers; for (const auto &path : done) { vector reach_path; for (auto jt = path.rbegin(), jte = path.rend(); jt != jte; ++jt) { reach_path.push_back(g[*jt].char_reach); } unique_triggers.insert(reach_path); } insert(&triggers, triggers.end(), unique_triggers); sort(triggers.begin(), triggers.end()); DEBUG_PRINTF("built %zu unique triggers, max_len=%zu\n", triggers.size(), max_len); return triggers; } static void findMinPeriod(const NGHolder &g, const map>> &triggers, ReachSubgraph &rsi) { const auto v = rsi.vertices.front(); const CharReach &cr = g[v].char_reach; vector> repeat_triggers; if (is_triggered(g)) { // Construct a temporary copy of the graph that also contains its // triggers, potentially lengthening the repeat's triggers. NGHolder tg; unordered_map tg_map; cloneHolder(tg, g, &tg_map); addTriggers(tg, triggers); assert(contains(tg_map, v)); repeat_triggers = getRepeatTriggers(tg, tg_map.at(v)); } else { // Not triggered, no need to mutate the graph. repeat_triggers = getRepeatTriggers(g, v); } rsi.minPeriod = minPeriod(repeat_triggers, cr, &rsi.is_reset); DEBUG_PRINTF("%zu triggers, minPeriod=%u, is_reset=%d\n", repeat_triggers.size(), rsi.minPeriod, (int)rsi.is_reset); } static void selectHistoryScheme(const NGHolder &g, const ReportManager *rm, ReachSubgraph &rsi, const ue2::unordered_map &depths, const ue2::unordered_set &reached_by_fixed_tops, const map>> &triggers, const vector &all_repeats, const bool simple_model_selection) { // {N,} cases use the FIRST history mechanism. if (rsi.repeatMax.is_infinite()) { DEBUG_PRINTF("selected FIRST history\n"); rsi.historyType = REPEAT_FIRST; return; } /* If we have a repeat which only raises a highlander, only the first match * matters */ if (rm && leadsOnlyToAccept(g, rsi) && allSimpleHighlander(*rm, g[rsi.vertices.back()].reports)) { DEBUG_PRINTF("selected FIRST history (as highlander)\n"); rsi.historyType = REPEAT_FIRST; rsi.repeatMax = depth::infinity(); /* for consistency */ return; } // {N,M} cases can use the FIRST mechanism if they follow a cyclic which // includes their reachability via a "straw" path. (see UE-1589) if (hasCyclicSupersetEntryPath(g, rsi, all_repeats)) { DEBUG_PRINTF("selected FIRST history due to cyclic pred with " "superset of reach\n"); rsi.historyType = REPEAT_FIRST; rsi.repeatMax = depth::infinity(); /* will continue to pump out matches */ return; } // Similarly, {N,M} cases can use the FIRST mechanism if they precede a // cyclic which includes their reachability via a "straw" path. if (hasCyclicSupersetExitPath(g, rsi, all_repeats)) { DEBUG_PRINTF("selected FIRST history due to cyclic succ with " "superset of reach\n"); rsi.historyType = REPEAT_FIRST; rsi.repeatMax = depth::infinity(); /* will continue to pump out matches */ return; } // Could have skip edges and therefore be a {0,N} repeat. if (rsi.repeatMin == depth(1) && hasSkipEdges(g, rsi)) { DEBUG_PRINTF("selected LAST history\n"); rsi.historyType = REPEAT_LAST; return; } // Fill minPeriod, is_reset flags findMinPeriod(g, triggers, rsi); // If we can't re-enter this cyclic state, we have a reset case. // This check can be very expensive, so we don't do it if we've been asked // for simple model selection. if (!simple_model_selection && !rsi.is_reset && hasSoleEntry(g, rsi, depths, reached_by_fixed_tops, triggers)) { DEBUG_PRINTF("repeat is sole entry -> reset\n"); rsi.is_reset = true; } // We can lean on the common selection code for the remainder of our repeat // models. rsi.historyType = chooseRepeatType(rsi.repeatMin, rsi.repeatMax, rsi.minPeriod, rsi.is_reset); } static void buildFeeder(NGHolder &g, const BoundedRepeatData &rd, ue2::unordered_set &created, const vector &straw) { if (!g[rd.cyclic].char_reach.all()) { // Create another cyclic feeder state with flipped reach. It has an // edge from the repeat's cyclic state and pos_trigger, an edge to the // straw, and edges from every vertex along the straw. NFAVertex feeder = clone_vertex(g, rd.cyclic); created.insert(feeder); g[feeder].char_reach.flip(); add_edge(feeder, feeder, g); add_edge(rd.pos_trigger, feeder, g); add_edge(rd.cyclic, feeder, g); add_edge(feeder, straw.front(), g); // An edge from every vertex in the straw. for (auto v : straw) { add_edge(v, feeder, g); } // An edge to the feeder from the first vertex in the straw and all of // its predecessors (other than the feeder itself, we've already // created that edge!) for (auto u : inv_adjacent_vertices_range(straw.front(), g)) { if (u == feeder) { continue; } add_edge(u, feeder, g); } DEBUG_PRINTF("added feeder %zu\n", g[feeder].index); } else { // No neg trigger means feeder is empty, and unnecessary. assert(g[rd.pos_trigger].char_reach.all()); } } /** * If we have a leading first repeat, we can split startDs so that it is not * cyclic so that the repeat is only triggered once, rather than every byte. If we * perform this transform we must create another cyclic state to retrigger the * repeat after we see an escape for the repeat. * * We do not use the anchored start state to allow us to restart the NFA at a deep * offset. */ static bool improveLeadingRepeat(NGHolder &g, BoundedRepeatData &rd, ue2::unordered_set &created, const vector &all_repeats) { assert(edge(g.startDs, g.startDs, g).second); // UE-1617: can rewire FIRST history cases that are preceded by // startDs. if (rd.type != REPEAT_FIRST) { return false; } const CharReach &cyc_cr = g[rd.cyclic].char_reach; // This transformation is only worth doing if this would allow us to // accelerate the cyclic state (UE-2055). if ((~cyc_cr).count() > ACCEL_MAX_STOP_CHAR) { DEBUG_PRINTF("we wouldn't be able to accel this case\n"); return false; } vector straw; NFAVertex pred = walkStrawToCyclicRev(g, rd.pos_trigger, all_repeats, straw); if (pred != g.startDs) { DEBUG_PRINTF("straw walk doesn't lead to startDs\n"); return false; } // This transformation is only safe if the straw path from startDs that // we've discovered can *only* lead to this repeat, since we're going to // remove the self-loop on startDs. if (proper_out_degree(g.startDs, g) > 1) { DEBUG_PRINTF("startDs has other successors\n"); return false; } for (const auto &v : straw) { if (proper_out_degree(v, g) != 1) { DEBUG_PRINTF("branch between startDs and repeat, from vertex %zu\n", g[v].index); return false; } } if (g[rd.pos_trigger].char_reach.count() < ACCEL_MAX_STOP_CHAR) { DEBUG_PRINTF("entry is narrow, could be accelerable\n"); return false; } assert(!straw.empty()); /* If there is overlap between the feeder and the first vertex in the straw * fun things happen. TODO: handle fun things happening (requires more * edges and more vertices). */ if (!g[straw.front()].char_reach.isSubsetOf(cyc_cr)) { DEBUG_PRINTF("straw has `interesting' reach\n"); return false; } DEBUG_PRINTF("repeat can be improved by removing startDs loop!\n"); // Remove the self-loop on startDs! What a blast! remove_edge(g.startDs, g.startDs, g); // Wire up feeder state to straw. buildFeeder(g, rd, created, straw); return true; } static vector makeOwnStraw(NGHolder &g, BoundedRepeatData &rd, const vector &straw) { // Straw runs from startDs to our pos trigger. assert(!straw.empty()); assert(edge(g.startDs, straw.front(), g).second); assert(edge(straw.back(), rd.pos_trigger, g).second); vector own_straw; for (const auto &v : straw) { NFAVertex v2 = clone_vertex(g, v); if (hasSelfLoop(v, g)) { add_edge(v2, v2, g); } if (!own_straw.empty()) { add_edge(own_straw.back(), v2, g); } own_straw.push_back(v2); } // Wire our straw to start, not startDs. add_edge(g.start, own_straw.front(), g); // Swap over to using our own straw to get to the POS trigger. remove_edge(straw.back(), rd.pos_trigger, g); add_edge(own_straw.back(), rd.pos_trigger, g); return own_straw; } /** * Specialized version of improveLeadingRepeat for outfixes, in which we can * rewire the straw to start instead of removing the startDs self-loop. */ static bool improveLeadingRepeatOutfix(NGHolder &g, BoundedRepeatData &rd, ue2::unordered_set &created, const vector &all_repeats) { assert(g.kind == NFA_OUTFIX); // UE-1617: can rewire FIRST history cases that are preceded by // startDs. if (rd.type != REPEAT_FIRST) { return false; } const CharReach &cyc_cr = g[rd.cyclic].char_reach; // This transformation is only worth doing if this would allow us to // accelerate the cyclic state (UE-2055). if ((~cyc_cr).count() > ACCEL_MAX_STOP_CHAR) { DEBUG_PRINTF("we wouldn't be able to accel this case\n"); return false; } vector straw; NFAVertex pred = walkStrawToCyclicRev(g, rd.pos_trigger, all_repeats, straw); if (pred != g.startDs) { DEBUG_PRINTF("straw walk doesn't lead to startDs\n"); return false; } if (g[rd.pos_trigger].char_reach.count() < ACCEL_MAX_STOP_CHAR) { DEBUG_PRINTF("entry is narrow, could be accelerable\n"); return false; } assert(!straw.empty()); /* If there is overlap between the feeder and the first vertex in the straw * fun things happen. TODO: handle fun things happening (requires more * edges and more vertices). */ if (!g[straw.front()].char_reach.isSubsetOf(cyc_cr)) { DEBUG_PRINTF("straw has `interesting' reach\n"); return false; } DEBUG_PRINTF("repeat can be improved by rebuilding its entry\n"); const auto own_straw = makeOwnStraw(g, rd, straw); insert(&created, own_straw); // Wire up feeder state to our new straw. buildFeeder(g, rd, created, own_straw); // We may no longer need the original straw. pruneUseless(g); return true; } /** Returns true if doing the bounded repeat transformation on this case * results in a smaller NFA model. */ static bool givesBetterModel(const NGHolder &g, const vector &rs) { static const u32 MAX_FAST_STATES = 128; // bigger NFAs are fat and slow. // We use vertex count as an upper bound for the number of states. u32 curr_states = num_vertices(g) - 2; // accepts don't have states if (curr_states <= MAX_FAST_STATES) { return false; } if (curr_states > NFA_MAX_STATES) { return true; } u32 expected_states = curr_states; for (const auto &rsi : rs) { /* may be off as unpeeling not done yet */ expected_states += 2; /* cyclic and pos */ expected_states -= rsi.vertices.size(); } return ROUNDUP_N(curr_states, 128) != ROUNDUP_N(expected_states, 128); } /** True if this repeat terminates with a vertex that leads only to accept. */ static bool endsInAccept(const NGHolder &g, const ReachSubgraph &rsi) { NFAVertex last = rsi.vertices.back(); return getSoleDestVertex(g, last) == g.accept; } static bool endsInAcceptEod(const NGHolder &g, const ReachSubgraph &rsi) { NFAVertex last = rsi.vertices.back(); return getSoleDestVertex(g, last) == g.acceptEod; } namespace { class pfti_visitor : public boost::default_dfs_visitor { public: pfti_visitor(ue2::unordered_map &top_depths_in, const depth &our_depth_in) : top_depths(top_depths_in), our_depth(our_depth_in) {} void discover_vertex(NFAVertex v, UNUSED const NGHolder &g) { DEBUG_PRINTF("discovered %zu (depth %s)\n", g[v].index, our_depth.str().c_str()); auto it = top_depths.find(v); if (it != top_depths.end() && it->second != our_depth) { // already seen at a different depth, remove from consideration. it->second = depth::infinity(); } else { top_depths[v] = our_depth; } } ue2::unordered_map &top_depths; const depth &our_depth; }; } // namespace static void populateFixedTopInfo(const map &fixed_depth_tops, const NGHolder &g, ue2::unordered_set *reached_by_fixed_tops) { if (fixed_depth_tops.empty()) { return; /* we will never find anything */ } assert(!proper_out_degree(g.startDs, g)); ue2::unordered_map top_depths; vector colours(num_vertices(g)); for (const auto &e : out_edges_range(g.start, g)) { NFAVertex v = target(e, g); if (v == g.startDs) { continue; } depth td = depth::infinity(); for (u32 top : g[e].tops) { if (!contains(fixed_depth_tops, top)) { td = depth::infinity(); break; } depth td_t = fixed_depth_tops.at(top); if (td == td_t) { continue; } else if (td == depth::infinity()) { td = td_t; } else { td = depth::infinity(); break; } } DEBUG_PRINTF("scanning from %zu depth=%s\n", g[v].index, td.str().c_str()); /* for each vertex reachable from v update its map to reflect that it is * reachable from a top of depth td. */ depth_first_visit(g, v, pfti_visitor(top_depths, td), make_iterator_property_map(colours.begin(), get(vertex_index, g))); } for (const auto &v_depth : top_depths) { const NFAVertex v = v_depth.first; const depth &d = v_depth.second; if (d.is_finite()) { DEBUG_PRINTF("%zu reached by fixed tops at depth %s\n", g[v].index, d.str().c_str()); reached_by_fixed_tops->insert(v); } } } #ifndef NDEBUG /** Assertion use only. Returns true if the given bounded repeats share any * vertices, which we don't allow. */ static bool hasOverlappingRepeats(UNUSED const NGHolder &g, const vector &repeats) { ue2::unordered_set involved; for (const auto &br : repeats) { if (contains(involved, br.cyclic)) { DEBUG_PRINTF("already seen cyclic %zu\n", g[br.cyclic].index); return true; } if (contains(involved, br.pos_trigger)) { DEBUG_PRINTF("already seen pos %zu\n", g[br.pos_trigger].index); return true; } for (auto v : br.tug_triggers) { if (contains(involved, v)) { DEBUG_PRINTF("already seen tug %zu\n", g[v].index); return true; } } involved.insert(br.cyclic); involved.insert(br.pos_trigger); involved.insert(br.tug_triggers.begin(), br.tug_triggers.end()); } return false; } #endif // NDEBUG /** * Identifies so-called "nasty" repeats, in which the reachability of both the * repeat itself and its tugs are wide, which means that executing the NFA will * likely be bogged down in exception processing. */ static bool repeatIsNasty(const NGHolder &g, const ReachSubgraph &rsi, const ue2::unordered_map &depths) { if (num_vertices(g) > NFA_MAX_STATES) { // We may have no choice but to implement this repeat to get the graph // down to a tractable number of vertices. return false; } if (!generates_callbacks(g) && endsInAccept(g, rsi)) { DEBUG_PRINTF("would generate a lazy tug, repeat is OK\n"); return false; } const NFAVertex first = rsi.vertices.front(); DEBUG_PRINTF("min depth from startds = %s\n", depths.at(first).fromStartDotStar.min.str().c_str()); if (depths.at(first).fromStartDotStar.min > depth(2)) { return false; } NFAVertex last = rsi.vertices.back(); const CharReach &cyclicreach = g[last].char_reach; CharReach tugreach; for (auto v : adjacent_vertices_range(last, g)) { if (v == last || is_special(v, g)) { continue; } tugreach |= g[v].char_reach; } // Deal with unpeeled cases. if (tugreach.none()) { tugreach = cyclicreach; } DEBUG_PRINTF("tugreach.count=%zu, cyclicreach.count=%zu\n", tugreach.count(), cyclicreach.count()); return (tugreach.count() > 200) && (cyclicreach.count() > 200); } void analyseRepeats(NGHolder &g, const ReportManager *rm, const map &fixed_depth_tops, const map>> &triggers, vector *repeats, bool streaming, bool simple_model_selection, const Grey &grey, bool *reformed_start_ds) { if (!grey.allowExtendedNFA || !grey.allowLimExNFA) { return; } // Quick sanity test. assert(allMatchStatesHaveReports(g)); #ifndef NDEBUG // So we can assert that the number of tops hasn't changed at the end of // this analysis. const ue2::flat_set allTops = getTops(g); #endif // Later on, we're (a little bit) dependent on depth information for // unpeeling and so forth. Note that these depths MUST be maintained when // new vertices are added. ue2::unordered_map depths; findInitDepths(g, depths); // Construct our list of subgraphs with the same reach using BGL magic. vector rs; buildReachSubgraphs(g, rs, grey.minExtBoundedRepeatSize); // Validate and split subgraphs. checkReachSubgraphs(g, rs, grey.minExtBoundedRepeatSize); // Identify which subgraphs represent bounded repeats in forms ("cliches") // that we accept, and mark the others as bad. for (auto &rsi: rs) { if (!processSubgraph(g, rsi, grey.minExtBoundedRepeatSize)) { rsi.bad = true; continue; } DEBUG_PRINTF("rsi min %s=max=%s\n", rsi.repeatMin.str().c_str(), rsi.repeatMax.str().c_str()); // Identify repeats with wide cyclic and tug reach which will produce // low-performance implementations and avoid doing them. if (repeatIsNasty(g, rsi, depths)) { DEBUG_PRINTF("marking nasty repeat as bad\n"); rsi.bad = true; } } // Remove bad cases, then sort remaining subgraphs in descending size // order. rs.erase(remove_if(rs.begin(), rs.end(), [](const ReachSubgraph &r) { return r.bad; }), rs.end()); stable_sort(rs.begin(), rs.end(), [](const ReachSubgraph &a, const ReachSubgraph &b) { return a.vertices.size() > b.vertices.size(); }); if (!streaming && !givesBetterModel(g, rs)) { /* in block mode, there is no state space so we are only looking for * performance wins */ DEBUG_PRINTF("repeat would not reduce NFA model size, skipping\n"); return; } if (rs.empty()) { /* no good repeats */ return; } // Store a copy of the original, unmodified graph in case we need to revert // back: in particular, due to tug cloning it is possible to build a graph // that was bigger than the original. See UE-2370. FIXME: smarter analysis // could make this unnecessary? const unique_ptr orig_g(cloneHolder(g)); ue2::unordered_set reached_by_fixed_tops; if (is_triggered(g)) { populateFixedTopInfo(fixed_depth_tops, g, &reached_by_fixed_tops); } // Go to town on the remaining acceptable subgraphs. ue2::unordered_set created; for (auto &rsi : rs) { DEBUG_PRINTF("subgraph (beginning vertex %zu) is a {%s,%s} repeat\n", g[rsi.vertices.front()].index, rsi.repeatMin.str().c_str(), rsi.repeatMax.str().c_str()); if (!peelSubgraph(g, grey, rsi, created)) { DEBUG_PRINTF("peel failed, skipping\n"); continue; } // Attempt to peel a vertex if we're up against startDs, for // performance reasons. peelStartDotStar(g, depths, grey, rsi); // Our peeling passes may have killed off this repeat. if (rsi.bad) { continue; } selectHistoryScheme(g, rm, rsi, depths, reached_by_fixed_tops, triggers, *repeats, simple_model_selection); if (!generates_callbacks(g) && endsInAccept(g, rsi)) { DEBUG_PRINTF("accepty-rosy graph\n"); replaceSubgraphWithLazySpecial(g, rsi, repeats, depths, created); } else if (endsInAcceptEod(g, rsi)) { DEBUG_PRINTF("accepty-rosy graph\n"); replaceSubgraphWithLazySpecial(g, rsi, repeats, depths, created); } else { replaceSubgraphWithSpecial(g, rsi, repeats, depths, created); } // Some of our analyses require correctly numbered vertices, so we // renumber after changes. renumber_vertices(g); } bool modified_start_ds = false; // We may be able to make improvements to the graph for performance // reasons. Note that this may do 'orrible things like remove the startDs // cycle, this should only happen quite late in the graph lifecycle. if (repeats->size() == 1) { if (g.kind == NFA_OUTFIX) { improveLeadingRepeatOutfix(g, repeats->back(), created, *repeats); // (Does not modify startDs, so we don't need to set // reformed_start_ds for this case.) } else { modified_start_ds = improveLeadingRepeat(g, repeats->back(), created, *repeats); } } if (reformed_start_ds) { *reformed_start_ds = modified_start_ds; } if (!repeats->empty()) { if (num_vertices(g) > NFA_MAX_STATES) { // We've managed to build an unimplementable NFA. Swap back to the // original. DEBUG_PRINTF("NFA has %zu vertices; swapping back to the " "original graph\n", num_vertices(g)); clear_graph(g); assert(orig_g); cloneHolder(g, *orig_g); repeats->clear(); } // Sanity test: we don't want any repeats that share special vertices // as our construction code later can't cope with it. assert(!hasOverlappingRepeats(g, *repeats)); // We have modified the graph, so we need to ensure that our edges // and vertices are correctly numbered. renumber_vertices(g); renumber_edges(g); // Remove stray report IDs. clearReports(g); } // Quick sanity tests. assert(allMatchStatesHaveReports(g)); assert(!is_triggered(g) || getTops(g) == allTops); } /** * \brief True if the non-special vertices in the given graph all have the same * character reachability. */ static bool allOneReach(const NGHolder &g) { const CharReach *cr = nullptr; for (const auto &v : vertices_range(g)) { if (is_special(v, g)) { continue; } if (!cr) { cr = &g[v].char_reach; } else { if (*cr != g[v].char_reach) { return false; } } } return true; } bool isPureRepeat(const NGHolder &g, PureRepeat &repeat) { assert(allMatchStatesHaveReports(g)); DEBUG_PRINTF("entry\n"); // Must be start anchored. assert(edge(g.startDs, g.startDs, g).second); if (out_degree(g.startDs, g) > 1) { DEBUG_PRINTF("Unanchored\n"); return false; } // Must not be EOD-anchored. assert(edge(g.accept, g.acceptEod, g).second); if (in_degree(g.acceptEod, g) > 1) { DEBUG_PRINTF("EOD anchored\n"); return false; } // Must have precisely one top. if (is_triggered(g) && !onlyOneTop(g)) { DEBUG_PRINTF("Too many tops\n"); return false; } if (!allOneReach(g)) { DEBUG_PRINTF("vertices with different reach\n"); return false; } // We allow this code to report true for any repeat, even for '.*' or '.+' // cases. const u32 minNumVertices = 1; vector rs; buildReachSubgraphs(g, rs, minNumVertices); checkReachSubgraphs(g, rs, minNumVertices); if (rs.size() != 1) { DEBUG_PRINTF("too many subgraphs\n"); return false; } ReachSubgraph &rsi = *rs.begin(); if (!processSubgraph(g, rsi, minNumVertices)) { DEBUG_PRINTF("not a supported repeat\n"); return false; } if (rsi.vertices.size() + N_SPECIALS != num_vertices(g)) { DEBUG_PRINTF("repeat doesn't span graph\n"); return false; } assert(!rsi.bad); assert(rsi.vertices.size() >= minNumVertices); const NFAVertex v = rsi.vertices.back(); repeat.reach = g[v].char_reach; repeat.bounds.min = rsi.repeatMin; repeat.bounds.max = rsi.repeatMax; insert(&repeat.reports, g[v].reports); if (isVacuous(g)) { // This graph might be a {0,N} or {0,} repeat. For this to be true, we // must have found a {1,N} or {1,} repeat and the start vertex must // have the same report set as the vertices in the repeat. if (repeat.bounds.min == depth(1) && g[g.start].reports == g[v].reports) { repeat.bounds.min = 0; DEBUG_PRINTF("graph is %s repeat\n", repeat.bounds.str().c_str()); } else { DEBUG_PRINTF("not a supported repeat\n"); return false; } } assert(all_reports(g) == set(begin(g[v].reports), end(g[v].reports))); return true; } void findRepeats(const NGHolder &h, u32 minRepeatVertices, vector *repeats_out) { // Construct our list of subgraphs with the same reach using BGL magic. vector rs; buildReachSubgraphs(h, rs, minRepeatVertices); checkReachSubgraphs(h, rs, minRepeatVertices); for (auto &rsi : rs) { if (!processSubgraph(h, rsi, minRepeatVertices)) { continue; } DEBUG_PRINTF("rsi min=%s max=%s\n", rsi.repeatMin.str().c_str(), rsi.repeatMax.str().c_str()); depth repeatMax = rsi.repeatMax; vector all_repeats; /* we don't mutate the graph in * this path */ if (hasCyclicSupersetEntryPath(h, rsi, all_repeats)) { DEBUG_PRINTF("selected FIRST history due to cyclic pred with " "superset of reach\n"); repeatMax = depth::infinity(); /* will continue to pump out matches */ } if (hasCyclicSupersetExitPath(h, rsi, all_repeats)) { DEBUG_PRINTF("selected FIRST history due to cyclic succ with " "superset of reach\n"); repeatMax = depth::infinity(); /* will continue to pump out matches */ } repeats_out->push_back(GraphRepeatInfo()); GraphRepeatInfo &ri = repeats_out->back(); ri.vertices.swap(rsi.vertices); ri.repeatMin = rsi.repeatMin; ri.repeatMax = repeatMax; } } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_utf8.cpp0000644000175000017500000002263113055426554020736 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief UTF-8 transforms and operations. */ #include "ng_utf8.h" #include "ng.h" #include "ng_prune.h" #include "ng_util.h" #include "util/graph_range.h" #include "util/unicode_def.h" #include #include using namespace std; namespace ue2 { static void allowIllegal(NGWrapper &w, NFAVertex v, u8 pred_char) { if (in_degree(v, w) != 1) { DEBUG_PRINTF("unexpected pred\n"); assert(0); /* should be true due to the early stage of this analysis */ return; } CharReach &cr = w[v].char_reach; if (pred_char == 0xe0) { assert(cr.isSubsetOf(CharReach(0xa0, 0xbf))); if (cr == CharReach(0xa0, 0xbf)) { cr |= CharReach(0x80, 0x9f); } } else if (pred_char == 0xf0) { assert(cr.isSubsetOf(CharReach(0x90, 0xbf))); if (cr == CharReach(0x90, 0xbf)) { cr |= CharReach(0x80, 0x8f); } } else if (pred_char == 0xf4) { assert(cr.isSubsetOf(CharReach(0x80, 0x8f))); if (cr == CharReach(0x80, 0x8f)) { cr |= CharReach(0x90, 0xbf); } } else { assert(0); /* unexpected pred */ } } /** \brief Relax forbidden UTF-8 sequences. * * Some byte sequences can not appear in valid UTF-8 as they encode code points * above \\x{10ffff} or they represent overlong encodings. As we require valid * UTF-8 input, we have no defined behaviour in these cases, as a result we can * accept them if it simplifies the graph. */ void relaxForbiddenUtf8(NGWrapper &w) { if (!w.utf8) { return; } const CharReach e0(0xe0); const CharReach f0(0xf0); const CharReach f4(0xf4); for (auto v : vertices_range(w)) { const CharReach &cr = w[v].char_reach; if (cr == e0 || cr == f0 || cr == f4) { u8 pred_char = cr.find_first(); for (auto t : adjacent_vertices_range(v, w)) { allowIllegal(w, t, pred_char); } } } } static bool hasPredInSet(const NGHolder &g, NFAVertex v, const set &s) { for (auto u : inv_adjacent_vertices_range(v, g)) { if (contains(s, u)) { return true; } } return false; } static bool hasSuccInSet(const NGHolder &g, NFAVertex v, const set &s) { for (auto w : adjacent_vertices_range(v, g)) { if (contains(s, w)) { return true; } } return false; } static void findSeeds(const NGHolder &h, const bool som, vector *seeds) { set bad; /* from zero-width asserts near accepts, etc */ for (auto v : inv_adjacent_vertices_range(h.accept, h)) { const CharReach &cr = h[v].char_reach; if (!isutf8ascii(cr) && !isutf8start(cr)) { bad.insert(v); } } for (auto v : inv_adjacent_vertices_range(h.acceptEod, h)) { const CharReach &cr = h[v].char_reach; if (!isutf8ascii(cr) && !isutf8start(cr)) { bad.insert(v); } } // we want to be careful with asserts connected to starts // as well as they may not finish a code point for (auto v : vertices_range(h)) { if (is_virtual_start(v, h)) { bad.insert(v); insert(&bad, adjacent_vertices(v, h)); } } /* we cannot handle vertices connected to accept as would report matches in * the middle of codepoints. acceptEod is not a problem as the input must * end at a codepoint boundary */ bad.insert(h.accept); // If we're in SOM mode, we don't want to mess with vertices that have a // direct edge from startDs. if (som) { insert(&bad, adjacent_vertices(h.startDs, h)); } set already_seeds; /* already marked as seeds */ for (auto v : vertices_range(h)) { const CharReach &cr = h[v].char_reach; if (!isutf8ascii(cr) || !hasSelfLoop(v, h)) { continue; } if (hasSuccInSet(h, v, bad)) { continue; } // Skip vertices that are directly connected to other vertices already // in the seeds list: we can't collapse two of these directly next to // each other. if (hasPredInSet(h, v, already_seeds) || hasSuccInSet(h, v, already_seeds)) { continue; } DEBUG_PRINTF("%zu is a seed\n", h[v].index); seeds->push_back(v); already_seeds.insert(v); } } static bool expandCyclic(NGHolder &h, NFAVertex v) { DEBUG_PRINTF("inspecting %zu\n", h[v].index); bool changes = false; auto v_preds = preds(v, h); auto v_succs = succs(v, h); set start_siblings; set end_siblings; CharReach &v_cr = h[v].char_reach; /* We need to find start vertices which have all of our preds. * As we have a self loop, it must be one of our succs. */ for (auto a : adjacent_vertices_range(v, h)) { auto a_preds = preds(a, h); if (a_preds == v_preds && isutf8start(h[a].char_reach)) { DEBUG_PRINTF("%zu is a start v\n", h[a].index); start_siblings.insert(a); } } /* We also need to find full cont vertices which have all our own succs; * As we have a self loop, it must be one of our preds. */ for (auto a : inv_adjacent_vertices_range(v, h)) { auto a_succs = succs(a, h); if (a_succs == v_succs && h[a].char_reach == UTF_CONT_CR) { DEBUG_PRINTF("%zu is a full tail cont\n", h[a].index); end_siblings.insert(a); } } for (auto s : start_siblings) { if (out_degree(s, h) != 1) { continue; } const CharReach &cr = h[s].char_reach; if (cr.isSubsetOf(UTF_TWO_START_CR)) { if (end_siblings.find(*adjacent_vertices(s, h).first) == end_siblings.end()) { DEBUG_PRINTF("%zu is odd\n", h[s].index); continue; } } else if (cr.isSubsetOf(UTF_THREE_START_CR)) { NFAVertex m = *adjacent_vertices(s, h).first; if (h[m].char_reach != UTF_CONT_CR || out_degree(m, h) != 1) { continue; } if (end_siblings.find(*adjacent_vertices(m, h).first) == end_siblings.end()) { DEBUG_PRINTF("%zu is odd\n", h[s].index); continue; } } else if (cr.isSubsetOf(UTF_FOUR_START_CR)) { NFAVertex m1 = *adjacent_vertices(s, h).first; if (h[m1].char_reach != UTF_CONT_CR || out_degree(m1, h) != 1) { continue; } NFAVertex m2 = *adjacent_vertices(m1, h).first; if (h[m2].char_reach != UTF_CONT_CR || out_degree(m2, h) != 1) { continue; } if (end_siblings.find(*adjacent_vertices(m2, h).first) == end_siblings.end()) { DEBUG_PRINTF("%zu is odd\n", h[s].index); continue; } } else { DEBUG_PRINTF("%zu is bad\n", h[s].index); continue; } v_cr |= cr; clear_vertex(s, h); changes = true; } if (changes) { v_cr |= UTF_CONT_CR; /* we need to add in cont reach */ v_cr.set(0xc0); /* we can also add in the forbidden bytes as we require * valid unicode data */ v_cr.set(0xc1); v_cr |= CharReach(0xf5, 0xff); } return changes; } /** \brief Contract cycles of UTF-8 code points down to a single cyclic vertex * where possible, based on the assumption that we will always be matching * against well-formed input. */ void utf8DotRestoration(NGHolder &h, bool som) { vector seeds; /* cyclic ascii vertices */ findSeeds(h, som, &seeds); bool changes = false; for (auto v : seeds) { changes |= expandCyclic(h, v); } if (changes) { pruneUseless(h); } } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_depth.h0000644000175000017500000000634613055426554020626 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief NFA graph vertex depth calculations. */ #ifndef STRUCTURAL_ANALYSIS_H #define STRUCTURAL_ANALYSIS_H #include "nfagraph/ng_holder.h" #include "ue2common.h" #include "util/depth.h" #include namespace ue2 { class NGHolder; /** * \brief Encapsulates min/max depths relative to the start and startDs * vertices. */ struct NFAVertexDepth { DepthMinMax fromStart; DepthMinMax fromStartDotStar; }; /** * \brief Encapsulates min/max depths relative to the accept and acceptEod * vertices. */ struct NFAVertexRevDepth { DepthMinMax toAccept; DepthMinMax toAcceptEod; }; /** * \brief Encapsulates min/max depths relative to all of our special vertices. */ struct NFAVertexBidiDepth { DepthMinMax fromStart; DepthMinMax fromStartDotStar; DepthMinMax toAccept; DepthMinMax toAcceptEod; }; /** * \brief Calculate depths from start and startDs. * Fills the vector \p depths (indexed by \p vertex_index). */ void calcDepths(const NGHolder &g, std::vector &depths); /** * \brief Calculate depths to accept and acceptEod. * Fills the vector \p depths (indexed by \p vertex_index). */ void calcDepths(const NGHolder &g, std::vector &depths); /** * \brief Calculate depths to/from all special vertices. * Fills the vector \p depths (indexed by \p vertex_index). */ void calcDepths(const NGHolder &g, std::vector &depths); /** Calculate the (min, max) depths from the given \p src to every vertex in * the graph and return them in a vector, indexed by \p vertex_index. */ void calcDepthsFrom(const NGHolder &g, const NFAVertex src, std::vector &depths); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_prune.h0000644000175000017500000000573013055426554020647 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Functions for pruning unreachable vertices or reports from the graph. */ #ifndef NG_PRUNE_H #define NG_PRUNE_H #include "ue2common.h" namespace ue2 { class NGHolder; class ReportManager; /** Remove any vertices that can't be reached by traversing the graph in * reverse from acceptEod. */ void pruneUnreachable(NGHolder &g); /** Remove any vertices which can't be reached by traversing the graph forward * from start or in reverse from acceptEod. If \p renumber is false, no * vertex/edge renumbering is done. */ void pruneUseless(NGHolder &g, bool renumber = true); /** Remove any vertices with empty reachability. */ void pruneEmptyVertices(NGHolder &g); /** Remove any edges from vertices that generate accepts (for Highlander * graphs). */ void pruneHighlanderAccepts(NGHolder &g, const ReportManager &rm); /** * Prune highlander reports that are dominated by earlier ones in the graph. */ void pruneHighlanderDominated(NGHolder &g, const ReportManager &rm); /** Removes the given Report ID from vertices connected to accept, and then * prunes useless vertices that have had their report sets reduced to empty. */ void pruneReport(NGHolder &g, ReportID report); /** Removes all Report IDs bar the given one from vertices connected to accept, * and then prunes useless vertices that have had their report sets reduced to * empty. */ void pruneAllOtherReports(NGHolder &g, ReportID report); } // namespace ue2 #endif // NG_PRUNE_H hyperscan-4.4.1/src/nfagraph/ng_literal_analysis.h0000644000175000017500000000747413055426554023064 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Literal analysis and scoring. */ #ifndef NG_LITERAL_ANALYSIS_H #define NG_LITERAL_ANALYSIS_H #include #include #include "ng_holder.h" #include "util/ue2string.h" namespace ue2 { #define NO_LITERAL_AT_EDGE_SCORE 10000000ULL #define INVALID_EDGE_CAP 100000000ULL /* special-to-special score */ class NGHolder; /** * Fetch the literal set for a given vertex, returning it in \p s. Note: does * NOT take into account any constraints due to streaming mode requirements. * * if only_first_encounter is requested, the output set may drop literals * generated by revisiting the destination vertex. */ std::set getLiteralSet(const NGHolder &g, const NFAVertex &v, bool only_first_encounter = true); std::set getLiteralSet(const NGHolder &g, const NFAEdge &e); /** * Returns true if we are unable to use a mixed sensitivity literal in rose (as * our literal matchers are generally either case sensitive or not). * * Shortish mixed sensitivity literals can be handled by confirm checks in rose * and are not flagged as bad. */ bool bad_mixed_sensitivity(const ue2_literal &s); /** * Score all the edges in the given graph, returning them in \p scores indexed * by edge_index. */ std::vector scoreEdges(const NGHolder &h, const flat_set &known_bad = {}); /** Returns a score for a literal set. Lower scores are better. */ u64a scoreSet(const std::set &s); /** Compress a literal set to fewer literals. */ u64a compressAndScore(std::set &s); /** * Compress a literal set to fewer literals and replace any long mixed * sensitivity literals with supported literals. */ u64a sanitizeAndCompressAndScore(std::set &s); bool splitOffLeadingLiteral(const NGHolder &g, ue2_literal *lit_out, NGHolder *rhs); bool splitOffAnchoredLeadingLiteral(const NGHolder &g, ue2_literal *lit_out, NGHolder *rhs); bool getTrailingLiteral(const NGHolder &g, ue2_literal *lit_out); /** \brief Returns true if the given literal is the only thing in the graph, * from (start or startDs) to accept. */ bool literalIsWholeGraph(const NGHolder &g, const ue2_literal &lit); } // namespace ue2 #endif hyperscan-4.4.1/src/nfagraph/ng_execute.cpp0000644000175000017500000003066413055426554021517 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Execute an NFA over a given input, returning the set of states that * are active afterwards. * * Note: although our external interfaces for execute_graph() use std::set, we * use a dynamic bitset containing the vertex indices internally for * performance. */ #include "ng_execute.h" #include "ng_holder.h" #include "ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/dump_charclass.h" #include "util/graph_range.h" #include "util/ue2string.h" #include #include #include #include #include using namespace std; using boost::dynamic_bitset; namespace ue2 { struct StateInfo { StateInfo(NFAVertex v, const CharReach &cr) : vertex(v), reach(cr) {} StateInfo() : vertex(NGHolder::null_vertex()) {} NFAVertex vertex; CharReach reach; }; #ifdef DEBUG static std::string dumpStates(const dynamic_bitset<> &s) { std::ostringstream oss; for (size_t i = s.find_first(); i != s.npos; i = s.find_next(i)) { oss << i << " "; } return oss.str(); } #endif static void step(const NGHolder &g, const vector &info, const dynamic_bitset<> &in, dynamic_bitset<> *out) { out->reset(); for (size_t i = in.find_first(); i != in.npos; i = in.find_next(i)) { NFAVertex u = info[i].vertex; for (auto v : adjacent_vertices_range(u, g)) { out->set(g[v].index); } } } static void filter_by_reach(const vector &info, dynamic_bitset<> *states, const CharReach &cr) { for (size_t i = states->find_first(); i != states->npos; i = states->find_next(i)) { if ((info[i].reach & cr).none()) { states->reset(i); } } } template static void execute_graph_i(const NGHolder &g, const vector &info, const inputT &input, dynamic_bitset<> *states, bool kill_sds) { dynamic_bitset<> &curr = *states; dynamic_bitset<> next(curr.size()); DEBUG_PRINTF("%zu states in\n", states->count()); for (const auto &e : input) { DEBUG_PRINTF("processing %s\n", describeClass(e).c_str()); step(g, info, curr, &next); if (kill_sds) { next.reset(NODE_START_DOTSTAR); } filter_by_reach(info, &next, e); next.swap(curr); if (curr.empty()) { DEBUG_PRINTF("went dead\n"); break; } } DEBUG_PRINTF("%zu states out\n", states->size()); } static dynamic_bitset<> makeStateBitset(const NGHolder &g, const flat_set &in) { dynamic_bitset<> work_states(num_vertices(g)); for (const auto &v : in) { u32 idx = g[v].index; work_states.set(idx); } return work_states; } static flat_set getVertices(const dynamic_bitset<> &in, const vector &info) { flat_set out; for (size_t i = in.find_first(); i != in.npos; i = in.find_next(i)) { out.insert(info[i].vertex); } return out; } static vector makeInfoTable(const NGHolder &g) { vector info(num_vertices(g)); for (auto v : vertices_range(g)) { u32 idx = g[v].index; const CharReach &cr = g[v].char_reach; assert(idx < info.size()); info[idx] = StateInfo(v, cr); } return info; } flat_set execute_graph(const NGHolder &g, const ue2_literal &input, const flat_set &initial_states, bool kill_sds) { assert(hasCorrectlyNumberedVertices(g)); auto info = makeInfoTable(g); auto work_states = makeStateBitset(g, initial_states); execute_graph_i(g, info, input, &work_states, kill_sds); return getVertices(work_states, info); } flat_set execute_graph(const NGHolder &g, const vector &input, const flat_set &initial_states) { assert(hasCorrectlyNumberedVertices(g)); auto info = makeInfoTable(g); auto work_states = makeStateBitset(g, initial_states); execute_graph_i(g, info, input, &work_states, false); return getVertices(work_states, info); } namespace { class eg_visitor : public boost::default_dfs_visitor { public: eg_visitor(const NGHolder &running_g_in, const vector &info_in, const NGHolder &input_g_in, map > &states_in) : vertex_count(num_vertices(running_g_in)), running_g(running_g_in), info(info_in), input_g(input_g_in), states(states_in), succs(vertex_count) {} void finish_vertex(NFAVertex input_v, const boost::reverse_graph &) { if (input_v == input_g.accept) { return; } assert(input_v != input_g.acceptEod); DEBUG_PRINTF("finished p%zu\n", input_g[input_v].index); /* finish vertex is called on vertex --> implies that all its parents * (in the forward graph) are also finished. Our parents will have * pushed all of their successors for us into our stateset. */ states[input_v].resize(vertex_count); dynamic_bitset<> our_states = states[input_v]; states[input_v].reset(); filter_by_reach(info, &our_states, input_g[input_v].char_reach); if (input_v != input_g.startDs && edge(input_v, input_v, input_g).second) { bool changed; do { DEBUG_PRINTF("actually not finished -> have self loop\n"); succs.reset(); step(running_g, info, our_states, &succs); filter_by_reach(info, &succs, input_g[input_v].char_reach); dynamic_bitset<> our_states2 = our_states | succs; changed = our_states2 != our_states; our_states.swap(our_states2); } while (changed); } DEBUG_PRINTF(" active rstates: %s\n", dumpStates(our_states).c_str()); succs.reset(); step(running_g, info, our_states, &succs); /* we need to push into all our (forward) children their successors * from us. */ for (auto v : adjacent_vertices_range(input_v, input_g)) { DEBUG_PRINTF("pushing our states to pstate %zu\n", input_g[v].index); if (v == input_g.startDs) { /* no need for intra start edges */ continue; } states[v].resize(vertex_count); // May not yet exist if (v != input_g.accept) { states[v] |= succs; } else { /* accept is a magical pseudo state which does not consume * characters and we are using to collect the output states. We * must fill it with our states rather than our succs. */ DEBUG_PRINTF("prev outputted rstates: %s\n", dumpStates(states[v]).c_str()); DEBUG_PRINTF("outputted rstates: %s\n", dumpStates(our_states).c_str()); states[v] |= our_states; DEBUG_PRINTF("new outputted rstates: %s\n", dumpStates(states[v]).c_str()); } } /* note: the states at this vertex are no longer required */ } private: const size_t vertex_count; const NGHolder &running_g; const vector &info; const NGHolder &input_g; map > &states; /* vertex in input_g -> set of states in running_g */ dynamic_bitset<> succs; // temp use internally }; } // namespace flat_set execute_graph(const NGHolder &running_g, const NGHolder &input_dag, const flat_set &input_start_states, const flat_set &initial_states) { DEBUG_PRINTF("g has %zu vertices, input_dag has %zu vertices\n", num_vertices(running_g), num_vertices(input_dag)); assert(hasCorrectlyNumberedVertices(running_g)); assert(in_degree(input_dag.acceptEod, input_dag) == 1); map colours; /* could just a topo order, but really it is time to pull a slightly bigger * gun: DFS */ boost::reverse_graph revg(input_dag); map > dfs_states; auto info = makeInfoTable(running_g); auto input_fs = makeStateBitset(running_g, initial_states); for (auto v : input_start_states) { dfs_states[v] = input_fs; } depth_first_visit(revg, input_dag.accept, eg_visitor(running_g, info, input_dag, dfs_states), make_assoc_property_map(colours)); auto states = getVertices(dfs_states[input_dag.accept], info); #ifdef DEBUG DEBUG_PRINTF(" output rstates:"); for (const auto &v : states) { printf(" %zu", running_g[v].index); } printf("\n"); #endif return states; } flat_set execute_graph(const NGHolder &running_g, const NGHolder &input_dag, const flat_set &initial_states) { auto input_start_states = {input_dag.start, input_dag.startDs}; return execute_graph(running_g, input_dag, input_start_states, initial_states); } static bool can_die_early(const NGHolder &g, const vector &info, const dynamic_bitset<> &s, map, u32> &visited, u32 age_limit) { if (contains(visited, s) && visited[s] >= age_limit) { /* we have already (or are in the process) of visiting here with a * looser limit. */ return false; } visited[s] = age_limit; if (s.none()) { DEBUG_PRINTF("dead\n"); return true; } if (age_limit == 0) { return false; } dynamic_bitset<> all_succ(s.size()); step(g, info, s, &all_succ); all_succ.reset(NODE_START_DOTSTAR); for (u32 i = 0; i < N_CHARS; i++) { dynamic_bitset<> next = all_succ; filter_by_reach(info, &next, CharReach(i)); if (can_die_early(g, info, next, visited, age_limit - 1)) { return true; } } return false; } bool can_die_early(const NGHolder &g, u32 age_limit) { if (proper_out_degree(g.startDs, g)) { return false; } const vector &info = makeInfoTable(g); map, u32> visited; return can_die_early(g, info, makeStateBitset(g, {g.start}), visited, age_limit); } } // namespace ue2 hyperscan-4.4.1/src/nfagraph/ng_fixed_width.h0000644000175000017500000000350413055426554022011 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Rose mask construction from NGHolder. */ #ifndef NG_FIXED_WIDTH_H #define NG_FIXED_WIDTH_H namespace ue2 { class RoseBuild; class NGHolder; struct Grey; bool handleFixedWidth(RoseBuild &build, const NGHolder &g, const Grey &grey); } // namespace ue2 #endif // NG_FIXED_WIDTH_H hyperscan-4.4.1/src/database.c0000644000175000017500000003106013055426554016776 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Runtime code for hs_database manipulation. */ #include #include #include "allocator.h" #include "hs_common.h" #include "hs_internal.h" #include "hs_version.h" #include "ue2common.h" #include "database.h" #include "crc32.h" #include "rose/rose_internal.h" #include "util/unaligned.h" static really_inline int db_correctly_aligned(const void *db) { return ISALIGNED_N(db, alignof(unsigned long long)); } HS_PUBLIC_API hs_error_t hs_free_database(hs_database_t *db) { if (db && db->magic != HS_DB_MAGIC) { return HS_INVALID; } hs_database_free(db); return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_serialize_database(const hs_database_t *db, char **bytes, size_t *serialized_length) { if (!db || !bytes || !serialized_length) { return HS_INVALID; } if (!db_correctly_aligned(db)) { return HS_BAD_ALIGN; } hs_error_t ret = validDatabase(db); if (ret != HS_SUCCESS) { return ret; } size_t length = sizeof(struct hs_database) + db->length; char *out = hs_misc_alloc(length); ret = hs_check_alloc(out); if (ret != HS_SUCCESS) { hs_misc_free(out); return ret; } memset(out, 0, length); u32 *buf = (u32 *)out; *buf = db->magic; buf++; *buf = db->version; buf++; *buf = db->length; buf++; memcpy(buf, &db->platform, sizeof(u64a)); buf += 2; *buf = db->crc32; buf++; *buf = db->reserved0; buf++; *buf = db->reserved1; buf++; const char *bytecode = hs_get_bytecode(db); memcpy(buf, bytecode, db->length); *bytes = out; *serialized_length = length; return HS_SUCCESS; } // check that the database header's platform is compatible with the current // runtime platform. static hs_error_t db_check_platform(const u64a p) { if (p != hs_current_platform && p != hs_current_platform_no_avx2) { return HS_DB_PLATFORM_ERROR; } // passed all checks return HS_SUCCESS; } // Decode and check the database header, returning appropriate errors or // HS_SUCCESS if it's OK. The header should be allocated on the stack // and later copied into the deserialized database. static hs_error_t db_decode_header(const char **bytes, const size_t length, struct hs_database *header) { if (!*bytes) { return HS_INVALID; } if (length < sizeof(struct hs_database)) { return HS_INVALID; } // There's no requirement, really, that the serialized stream of bytes // we've been given is 4-byte aligned, so we use unaligned loads here. const u32 *buf = (const u32 *)*bytes; // Zero header so that none of it (e.g. its padding) is uninitialized. memset(header, 0, sizeof(struct hs_database)); header->magic = unaligned_load_u32(buf++); if (header->magic != HS_DB_MAGIC) { return HS_INVALID; } header->version = unaligned_load_u32(buf++); if (header->version != HS_DB_VERSION) { return HS_DB_VERSION_ERROR; } header->length = unaligned_load_u32(buf++); if (length != sizeof(struct hs_database) + header->length) { DEBUG_PRINTF("bad length %zu, expecting %zu\n", length, sizeof(struct hs_database) + header->length); return HS_INVALID; } header->platform = unaligned_load_u64a(buf); buf += 2; header->crc32 = unaligned_load_u32(buf++); header->reserved0 = unaligned_load_u32(buf++); header->reserved1 = unaligned_load_u32(buf++); *bytes = (const char *)buf; return HS_SUCCESS; // Header checks out } // Check the CRC on a database static hs_error_t db_check_crc(const hs_database_t *db) { const char *bytecode = hs_get_bytecode(db); u32 crc = Crc32c_ComputeBuf(0, bytecode, db->length); if (crc != db->crc32) { DEBUG_PRINTF("crc mismatch! 0x%x != 0x%x\n", crc, db->crc32); return HS_INVALID; } return HS_SUCCESS; } static void db_copy_bytecode(const char *serialized, hs_database_t *db) { // we need to align things manually uintptr_t shift = (uintptr_t)db->bytes & 0x3f; db->bytecode = offsetof(struct hs_database, bytes) - shift; char *bytecode = (char *)db + db->bytecode; // Copy the bytecode into place memcpy(bytecode, serialized, db->length); } HS_PUBLIC_API hs_error_t hs_deserialize_database_at(const char *bytes, const size_t length, hs_database_t *db) { if (!bytes || !db) { return HS_INVALID; } // We require the user to deserialize into an 8-byte aligned region. if (!ISALIGNED_N(db, 8)) { return HS_BAD_ALIGN; } // Decode the header hs_database_t header; hs_error_t ret = db_decode_header(&bytes, length, &header); if (ret != HS_SUCCESS) { return ret; } // Make sure the serialized database is for our platform ret = db_check_platform(header.platform); if (ret != HS_SUCCESS) { return ret; } // Zero new space for safety size_t dblength = sizeof(struct hs_database) + header.length; memset(db, 0, dblength); // Copy the decoded header into place memcpy(db, &header, sizeof(header)); // Copy the bytecode into the correctly-aligned location, set offsets db_copy_bytecode(bytes, db); if (db_check_crc(db) != HS_SUCCESS) { return HS_INVALID; } return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_deserialize_database(const char *bytes, const size_t length, hs_database_t **db) { if (!bytes || !db) { return HS_INVALID; } *db = NULL; // Decode and check the header hs_database_t header; hs_error_t ret = db_decode_header(&bytes, length, &header); if (ret != HS_SUCCESS) { return ret; } // Make sure the serialized database is for our platform ret = db_check_platform(header.platform); if (ret != HS_SUCCESS) { return ret; } // Allocate space for new database size_t dblength = sizeof(struct hs_database) + header.length; struct hs_database *tempdb = hs_database_alloc(dblength); ret = hs_check_alloc(tempdb); if (ret != HS_SUCCESS) { hs_database_free(tempdb); return ret; } // Zero new space for safety memset(tempdb, 0, dblength); // Copy the decoded header into place memcpy(tempdb, &header, sizeof(header)); // Copy the bytecode into the correctly-aligned location, set offsets db_copy_bytecode(bytes, tempdb); if (db_check_crc(tempdb) != HS_SUCCESS) { hs_database_free(tempdb); return HS_INVALID; } *db = tempdb; return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_database_size(const hs_database_t *db, size_t *size) { if (!size) { return HS_INVALID; } hs_error_t ret = validDatabase(db); if (unlikely(ret != HS_SUCCESS)) { return ret; } *size = sizeof(struct hs_database) + db->length; return HS_SUCCESS; } HS_PUBLIC_API hs_error_t hs_serialized_database_size(const char *bytes, const size_t length, size_t *size) { // Decode and check the header hs_database_t header; hs_error_t ret = db_decode_header(&bytes, length, &header); if (ret != HS_SUCCESS) { return ret; } if (!size) { return HS_INVALID; } *size = sizeof(struct hs_database) + header.length; return HS_SUCCESS; } hs_error_t dbIsValid(const hs_database_t *db) { if (db->magic != HS_DB_MAGIC) { DEBUG_PRINTF("bad magic\n"); return HS_INVALID; } if (db->version != HS_DB_VERSION) { DEBUG_PRINTF("bad version\n"); return HS_DB_VERSION_ERROR; } if (db_check_platform(db->platform) != HS_SUCCESS) { DEBUG_PRINTF("bad platform\n"); return HS_DB_PLATFORM_ERROR; } if (!ISALIGNED_16(hs_get_bytecode(db))) { DEBUG_PRINTF("bad alignment\n"); return HS_INVALID; } hs_error_t rv = db_check_crc(db); if (rv != HS_SUCCESS) { DEBUG_PRINTF("bad crc\n"); return rv; } return HS_SUCCESS; } #if defined(_WIN32) #define SNPRINTF_COMPAT _snprintf #else #define SNPRINTF_COMPAT snprintf #endif /** Allocate a buffer and prints the database info into it. Returns an * appropriate error code on failure, or HS_SUCCESS on success. */ static hs_error_t print_database_string(char **s, u32 version, const platform_t plat, u32 raw_mode) { assert(s); *s = NULL; u8 release = (version >> 8) & 0xff; u8 minor = (version >> 16) & 0xff; u8 major = (version >> 24) & 0xff; const char *avx2 = (plat & HS_PLATFORM_NOAVX2) ? "NOAVX2" : " AVX2"; const char *mode = NULL; if (raw_mode == HS_MODE_STREAM) { mode = "STREAM"; } else if (raw_mode == HS_MODE_VECTORED) { mode = "VECTORED"; } else { assert(raw_mode == HS_MODE_BLOCK); mode = "BLOCK"; } // Initial allocation size, which should be large enough to print our info. // If it isn't, snprintf will tell us and we can resize appropriately. size_t len = 256; while (1) { char *buf = hs_misc_alloc(len); hs_error_t ret = hs_check_alloc(buf); if (ret != HS_SUCCESS) { hs_misc_free(buf); return ret; } // Note: SNPRINTF_COMPAT is a macro defined above, to cope with systems // that don't have snprintf but have a workalike. int p_len = SNPRINTF_COMPAT( buf, len, "Version: %u.%u.%u Features: %s Mode: %s", major, minor, release, avx2, mode); if (p_len < 0) { DEBUG_PRINTF("snprintf output error, returned %d\n", p_len); hs_misc_free(buf); break; } else if ((size_t)p_len < len) { // output fit within buffer. assert(buf[p_len] == '\0'); *s = buf; return HS_SUCCESS; } else { // output didn't fit: resize and reallocate. len = (size_t)p_len + 1; // must add one for null terminator. hs_misc_free(buf); } } return HS_NOMEM; } HS_PUBLIC_API hs_error_t hs_serialized_database_info(const char *bytes, size_t length, char **info) { if (!info) { return HS_INVALID; } *info = NULL; // Decode and check the header hs_database_t header; hs_error_t ret = db_decode_header(&bytes, length, &header); if (ret != HS_SUCCESS) { return ret; } u32 mode = unaligned_load_u32(bytes + offsetof(struct RoseEngine, mode)); return print_database_string(info, header.version, header.platform, mode); } HS_PUBLIC_API hs_error_t hs_database_info(const hs_database_t *db, char **info) { if (!info) { return HS_INVALID; } *info = NULL; if (!db || !db_correctly_aligned(db) || db->magic != HS_DB_MAGIC) { return HS_INVALID; } platform_t plat; plat = db->platform; const struct RoseEngine *rose = hs_get_bytecode(db); return print_database_string(info, db->version, plat, rose->mode); } hyperscan-4.4.1/src/parser/0000755000175000017500000000000013055426554016362 5ustar sleuthkidsleuthkidhyperscan-4.4.1/src/parser/dump.cpp0000644000175000017500000002261013055426554020034 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "dump.h" #include "position.h" #include "ConstComponentVisitor.h" #include "ComponentBackReference.h" #include "ComponentClass.h" #include "ComponentCondReference.h" #include "ComponentRepeat.h" #include "ComponentAlternation.h" #include "ComponentAssertion.h" #include "ComponentAtomicGroup.h" #include "ComponentBoundary.h" #include "ComponentByte.h" #include "ComponentEmpty.h" #include "ComponentEUS.h" #include "ComponentSequence.h" #include "ComponentWordBoundary.h" #include "Utf8ComponentClass.h" #include "AsciiComponentClass.h" #include "util/charreach.h" #include "util/dump_charclass.h" #include #include #ifndef DUMP_SUPPORT #error No dump support! #endif using std::ostream; using std::string; using std::endl; namespace ue2 { class DumpVisitor : public ConstComponentVisitor { private: void indent() { level++; } void outdent() { assert(level > 0); level--; } std::string filler() const { return string(level * 2, ' '); } public: explicit DumpVisitor(ostream &s) : os(s), level(0) {} ~DumpVisitor() override; void pre(const AsciiComponentClass &c) override { os << filler() << "ASCII CLASS" << endl << filler() << " "; describeClass(os, c.cr, 256, CC_OUT_TEXT); os << endl; indent(); } void post(const AsciiComponentClass &) override { outdent(); } void pre(const ComponentAlternation &) override { os << filler() << "ALTERNATION" << endl; indent(); } void post(const ComponentAlternation &) override { outdent(); } void pre(const ComponentAssertion &c) override { os << filler() << "ASSERTION ("; switch (c.m_sense) { case ComponentAssertion::POS: os << "POSITIVE "; break; case ComponentAssertion::NEG: os << "NEGATIVE "; break; } switch (c.m_dir) { case ComponentAssertion::LOOKAHEAD: os << "LOOKAHEAD"; break; case ComponentAssertion::LOOKBEHIND: os << "LOOKBEHIND"; break; } os << ")" << endl; indent(); } void post(const ComponentAssertion &) override { outdent(); } void pre(const ComponentAtomicGroup &) override { os << filler() << "ATOMIC GROUP" << endl; indent(); } void post(const ComponentAtomicGroup &) override { outdent(); } void pre(const ComponentBackReference &c) override { if (!c.name.empty()) { os << filler() << "BACKREF " << c.name << std::endl; } else { os << filler() << "BACKREF " << c.ref_id << std::endl; } indent(); } void post(const ComponentBackReference &) override { outdent(); } void pre(const ComponentBoundary &c) override { os << filler() << "BOUNDARY" << endl << filler() << " "; switch (c.m_bound) { case ComponentBoundary::BEGIN_STRING: os << "ComponentBoundary::BEGIN_STRING"; break; case ComponentBoundary::END_STRING: os << "ComponentBoundary::END_STRING"; break; case ComponentBoundary::END_STRING_OPTIONAL_LF: os << "ComponentBoundary::END_STRING_OPTIONAL_LF"; break; case ComponentBoundary::BEGIN_LINE: os << "ComponentBoundary::BEGIN_LINE"; break; case ComponentBoundary::END_LINE: os << "ComponentBoundary::END_LINE"; break; } os << endl; indent(); } void post(const ComponentBoundary &) override { outdent(); } void pre(const ComponentByte &) override { os << filler() << "BYTE" << endl; indent(); } void post(const ComponentByte &) override { outdent(); } void pre(const ComponentCondReference &c) override { os << filler() << "CONDITIONAL REFERENCE" << endl; switch (c.kind) { case ComponentCondReference::CONDITION_NUMBER: os << filler() << "REFERENCES GROUP WITH NUMBER " << c.ref_id << endl; break; case ComponentCondReference::CONDITION_NAME: os << filler() << "REFERENCES GROUP WITH NAME " << c.ref_name << endl; break; case ComponentCondReference::CONDITION_ASSERTION: os << filler() << "REFERENCES FOLLOWING ASSERTION" << endl; break; } indent(); } void post(const ComponentCondReference &) override { outdent(); } void pre(const ComponentEmpty &) override { os << filler() << "EMPTY" << endl; indent(); } void post(const ComponentEmpty &) override { outdent(); } void pre(const ComponentEUS &) override { os << filler() << "EUS" << endl; indent(); } void post(const ComponentEUS &) override { outdent(); } void pre(const ComponentRepeat &c) override { os << filler() << "REPEAT (" << c.m_min << ", "; if (c.m_max == ComponentRepeat::NoLimit) { os << "NoLimit"; } else { os << c.m_max; } os << ") "; switch (c.type) { case ComponentRepeat::REPEAT_NONGREEDY: os << "non-greedy"; break; case ComponentRepeat::REPEAT_GREEDY: os << "greedy"; break; case ComponentRepeat::REPEAT_POSSESSIVE: os << "possessive"; break; } os << endl; indent(); } void post(const ComponentRepeat &) override { outdent(); } void pre(const ComponentSequence &c) override { os << filler() << "SEQUENCE "; if (c.capture_index == ComponentSequence::NOT_CAPTURED) { os << "(not captured) "; } else { os << "(capture index " << c.capture_index << ") "; } if (!c.capture_name.empty()) { os << "(capture name '" << c.capture_name << "')"; } os << endl; indent(); if (c.children.empty()) { os << filler() << " " << endl; } } void post(const ComponentSequence &) override { outdent(); } void pre(const ComponentWordBoundary &c) override { os << filler() << (c.negated ? "NON-WORD-BOUNDARY ('\\B')" : "WORD-BOUNDARY ('\\b')") << endl; indent(); } void post(const ComponentWordBoundary &) override { outdent(); } void pre(const UTF8ComponentClass &c) override { os << filler() << "UTF8 CLASS" << endl << filler() << " "; if (c.cps.none()) { os << ""; } else { for (auto it = c.cps.begin(), ite = c.cps.end(); it != ite; ++it) { os << std::hex << *it << " "; } } os << endl; indent(); } void post(const UTF8ComponentClass &) override { outdent(); } // not used void during(const AsciiComponentClass &) override {} void during(const ComponentAlternation &) override {} void during(const ComponentAssertion &) override {} void during(const ComponentAtomicGroup &) override {} void during(const ComponentBackReference &) override {} void during(const ComponentBoundary &) override {} void during(const ComponentByte &) override {} void during(const ComponentCondReference &) override {} void during(const ComponentEmpty &) override {} void during(const ComponentEUS &) override {} void during(const ComponentRepeat &) override {} void during(const ComponentSequence &) override {} void during(const ComponentWordBoundary &) override {} void during(const UTF8ComponentClass &) override {} private: ostream &os; unsigned level; }; DumpVisitor::~DumpVisitor() {} void dumpTree(ostream &os, const Component *const root) { assert(root); DumpVisitor vis(os); root->accept(vis); } } // namespace ue2 hyperscan-4.4.1/src/parser/position_info.h0000644000175000017500000000410613055426554021413 0ustar sleuthkidsleuthkid/* * 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 POSITION_INFO_H #define POSITION_INFO_H #include "ue2common.h" #include "position.h" namespace ue2 { /** Class representing a component state. */ class PositionInfo { public: PositionInfo(unsigned int p) : pos(p), flags(0) {} bool operator<(const PositionInfo &other) const { return pos < other.pos; } bool operator==(const PositionInfo &other) const { return pos == other.pos; } Position pos; //!< state number int flags; //!< from POS_FLAG_* above }; } // namespace ue2 #endif /* POSITION_INFO_H */ hyperscan-4.4.1/src/parser/AsciiComponentClass.h0000644000175000017500000000626413055426554022444 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Character classes and their mnemonics. */ #ifndef ASCIICOMPONENTCLASS_H #define ASCIICOMPONENTCLASS_H #include "ComponentClass.h" #include "util/charreach.h" namespace ue2 { class AsciiComponentClass : public ComponentClass { friend class ConstructLiteralVisitor; friend class DumpVisitor; friend class PrintVisitor; friend class CaselessVisitor; friend class SimplifyVisitor; friend class SimplifyCandidatesVisitor; public: explicit AsciiComponentClass(const ParseMode &mode_in); ~AsciiComponentClass() override {} AsciiComponentClass *clone() const override; Component *accept(ComponentVisitor &v) override { Component *c = v.visit(this); v.post(this); return c; } void accept(ConstComponentVisitor &v) const override { v.pre(*this); v.during(*this); v.post(*this); } bool class_empty(void) const override; void add(PredefinedClass c, bool negative) override; void add(unichar c) override; void finalize(void) override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &) override; std::vector first(void) const override; std::vector last(void) const override; protected: void createRange(unichar to) override; private: Position position; CharReach cr; // Private copy ctor. Use clone instead. AsciiComponentClass(const AsciiComponentClass &other) : ComponentClass(other), position(other.position), cr(other.cr) {} }; } // namespace ue2 #endif // ASCIICOMPONENTCLASS_H hyperscan-4.4.1/src/parser/ComponentBackReference.cpp0000644000175000017500000000520513055426554023432 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Back-references (/([a-f]{3}).*\\1/) */ #include "ComponentBackReference.h" #include "buildstate.h" #include "position.h" #include "position_info.h" #include "nfagraph/ng_builder.h" #include "util/charreach.h" #include using namespace std; namespace ue2 { ComponentBackReference::ComponentBackReference(unsigned int id) : ref_id(id) {} ComponentBackReference::ComponentBackReference(const string &s) : name(s), ref_id(0) {} ComponentBackReference * ComponentBackReference::clone() const { return new ComponentBackReference(*this); } vector ComponentBackReference::first() const { assert(0); return vector(); } vector ComponentBackReference::last() const { assert(0); return vector(); } bool ComponentBackReference::empty(void) const { return true; } void ComponentBackReference::notePositions(GlushkovBuildState &) { assert(0); } void ComponentBackReference::buildFollowSet(GlushkovBuildState &, const vector &) { assert(0); } } // namespace hyperscan-4.4.1/src/parser/ComponentByte.h0000644000175000017500000000527613055426554021333 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Single bytes (\\C metachar) */ #ifndef _RE_COMPONENTBYTE_H_ #define _RE_COMPONENTBYTE_H_ #include "Component.h" namespace ue2 { class ComponentByte : public Component { friend class DumpVisitor; public: ComponentByte(void); ~ComponentByte() override; ComponentByte *clone() const override; Component *accept(ComponentVisitor &v) override { Component *c = v.visit(this); v.post(this); return c; } void accept(ConstComponentVisitor &v) const override { v.pre(*this); v.during(*this); v.post(*this); } std::vector first() const override; std::vector last() const override; bool empty() const override { return false; } void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &, const std::vector &) override { // all follow set construction is handled by firsts/lasts return; } private: Position position; ComponentByte(const ComponentByte &other) : Component(other), position(other.position) {} }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/prefilter.h0000644000175000017500000000361713055426554020536 0ustar sleuthkidsleuthkid/* * 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 PARSER_PREFILTER_H #define PARSER_PREFILTER_H #include namespace ue2 { class Component; struct ParseMode; /** * \brief Applies prefiltering transformations to the given component. * * May reseat the given Component pointer. */ void prefilterTree(std::unique_ptr &root, const ParseMode &mode); } // namespace ue2 #endif // PARSER_PREFILTER_H hyperscan-4.4.1/src/parser/check_refs.h0000644000175000017500000000400613055426554020627 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Component tree analysis that checks that references (such as * back-refs, conditionals) have valid referents. */ #ifndef PARSER_CHECK_REFS_H_ #define PARSER_CHECK_REFS_H_ #include "util/ue2_containers.h" #include namespace ue2 { class Component; class ComponentSequence; void checkReferences(const Component &root, unsigned int groupIndices, const ue2::flat_set &groupNames); } // namespace ue2 #endif // PARSER_CHECK_REFS_H_ hyperscan-4.4.1/src/parser/ComponentAtomicGroup.cpp0000644000175000017500000000575513055426554023216 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Atomic groups (?>...) */ #include "ComponentAtomicGroup.h" #include "buildstate.h" #include "position.h" #include using namespace std; namespace ue2 { ComponentAtomicGroup *ComponentAtomicGroup::clone() const { return new ComponentAtomicGroup(*this); } Component *ComponentAtomicGroup::accept(ComponentVisitor &v) { Component *c = v.visit(this); if (c != this) { v.post(this); return c; } for (auto i = children.begin(), e = children.end(); i != e; ++i) { Component *child = i->get(); c = (*i)->accept(v); if (c != child) { // Child has been replaced (new Component pointer) or we've been // instructed to delete it (null). i->reset(c); } } // Remove deleted children. children.erase(remove(children.begin(), children.end(), nullptr), children.end()); v.post(this); return this; } void ComponentAtomicGroup::accept(ConstComponentVisitor &v) const { v.pre(*this); for (auto i = children.begin(), e = children.end(); i != e; ++i) { (*i)->accept(v); if (i + 1 != e) { v.during(*this); } } v.post(*this); } void ComponentAtomicGroup::notePositions(GlushkovBuildState &) { assert(0); } void ComponentAtomicGroup::buildFollowSet(GlushkovBuildState &, const vector &) { assert(0); } } // namespace hyperscan-4.4.1/src/parser/ComponentAssertion.cpp0000644000175000017500000000736513055426554022733 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Lookahead/lookbehind zero-width assertions. */ #include "ComponentAssertion.h" #include "buildstate.h" #include "position.h" #include "position_info.h" #include "ue2common.h" #include #include using namespace std; namespace ue2 { ComponentAssertion::ComponentAssertion(enum Direction dir, enum Sense sense) : m_dir(dir), m_sense(sense) {} ComponentAssertion::~ComponentAssertion() { } ComponentAssertion *ComponentAssertion::clone() const { return new ComponentAssertion(*this); } Component * ComponentAssertion::accept(ComponentVisitor &v) { Component *c = v.visit(this); if (c != this) { v.post(this); return c; } for (auto i = children.begin(), e = children.end(); i != e; ++i) { Component *child = i->get(); c = (*i)->accept(v); if (c != child) { // Child has been replaced (new Component pointer) or we've been // instructed to delete it (null). i->reset(c); } } // Remove deleted children. children.erase(remove(children.begin(), children.end(), nullptr), children.end()); v.post(this); return this; } void ComponentAssertion::accept(ConstComponentVisitor &v) const { v.pre(*this); for (auto i = children.begin(), e = children.end(); i != e; ++i) { (*i)->accept(v); if (i + 1 != e) { v.during(*this); } } v.post(*this); } vector ComponentAssertion::first() const { assert(0); return vector(); } vector ComponentAssertion::last() const { assert(0); return vector(); } bool ComponentAssertion::empty() const { return true; } void ComponentAssertion::notePositions(GlushkovBuildState &) { assert(0); } void ComponentAssertion::buildFollowSet(GlushkovBuildState &, const vector &) { assert(0); } bool ComponentAssertion::repeatable() const { // If this assertion has no children (it's an empty sequence, like that // produced by '(?!)') then PCRE would throw a "nothing to repeat" error. // So we do as well. return !children.empty(); } } // namespace ue2 hyperscan-4.4.1/src/parser/ComponentAlternation.h0000644000175000017500000000560313055426554022702 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Alternations (foo|bar|baz). */ #ifndef COMPONENT_ALTERNATION_H #define COMPONENT_ALTERNATION_H #include "Component.h" #include "position.h" #include namespace ue2 { class PositionInfo; class ComponentAlternation : public Component { friend class DumpVisitor; friend class SimplifyVisitor; public: ComponentAlternation(); ~ComponentAlternation() override; ComponentAlternation *clone() const override; Component *accept(ComponentVisitor &v) override; void accept(ConstComponentVisitor &v) const override; size_t numBranches() const { return children.size(); } void append(std::unique_ptr component); std::vector first() const override; std::vector last() const override; bool empty(void) const override; bool vacuous_everywhere() const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; bool checkEmbeddedStartAnchor(bool at_start) const override; bool checkEmbeddedEndAnchor(bool at_end) const override; void optimise(bool connected_to_sds) override; private: std::vector> children; ComponentAlternation(const ComponentAlternation &other); }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/ComponentBoundary.cpp0000644000175000017500000001355713055426554022547 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Boundary assertions (^, $, \\A, \\Z, \\z) */ #include "ComponentBoundary.h" #include "buildstate.h" #include "parse_error.h" #include "position.h" #include "position_info.h" #include "Parser.h" #include "util/charreach.h" #include "nfagraph/ng_builder.h" #include using namespace std; namespace ue2 { ComponentBoundary::ComponentBoundary(enum Boundary bound) : m_bound(bound), m_newline(GlushkovBuildState::POS_UNINITIALIZED) {} ComponentBoundary::~ComponentBoundary() { } ComponentBoundary::ComponentBoundary(const ComponentBoundary &other) : Component(other), m_bound(other.m_bound), m_newline(other.m_newline), m_first(other.m_first), m_last(other.m_last) {} ComponentBoundary * ComponentBoundary::clone() const { return new ComponentBoundary(*this); } vector ComponentBoundary::first() const { return m_first; } vector ComponentBoundary::last() const { return m_last; } bool ComponentBoundary::empty() const { return true; } bool ComponentBoundary::repeatable() const { return false; } static Position makeNewline(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); Position newline = builder.makePositions(1); builder.addCharReach(newline, CharReach('\n')); return newline; } void ComponentBoundary::notePositions(GlushkovBuildState & bs) { NFABuilder &builder = bs.getBuilder(); const Position startState = builder.getStart(); switch (m_bound) { case BEGIN_STRING: // beginning of data stream ('^') { PositionInfo epsilon(GlushkovBuildState::POS_EPSILON); epsilon.flags = POS_FLAG_NOFLOAT; m_first.push_back(epsilon); // We have the start vertex in firsts so that we can discourage // the mid-pattern use of boundaries. m_first.push_back(startState); break; } case BEGIN_LINE: // multiline anchor: beginning of stream or a newline { PositionInfo epsilon(GlushkovBuildState::POS_EPSILON); epsilon.flags = POS_FLAG_NOFLOAT; m_first.push_back(epsilon); // We have the start vertex in firsts so that we can discourage // the mid-pattern use of boundaries. m_first.push_back(startState); // Newline m_newline = makeNewline(bs); builder.setAssertFlag(m_newline, POS_FLAG_MULTILINE_START); builder.setAssertFlag(m_newline, POS_FLAG_VIRTUAL_START); PositionInfo nl(m_newline); nl.flags = POS_FLAG_MUST_FLOAT | POS_FLAG_FIDDLE_ACCEPT; m_first.push_back(nl); m_last.push_back(nl); recordPosBounds(m_newline, m_newline + 1); break; } case END_STRING: // end of data stream ('\z') { PositionInfo epsilon(GlushkovBuildState::POS_EPSILON); epsilon.flags = POS_FLAG_WIRE_EOD | POS_FLAG_NO_NL_EOD | POS_FLAG_NO_NL_ACCEPT | POS_FLAG_ONLY_ENDS; m_first.push_back(epsilon); break; } case END_STRING_OPTIONAL_LF: // end of data with optional LF ('$') { PositionInfo epsilon(GlushkovBuildState::POS_EPSILON); epsilon.flags = POS_FLAG_WIRE_EOD | POS_FLAG_WIRE_NL_EOD | POS_FLAG_NO_NL_ACCEPT | POS_FLAG_ONLY_ENDS; m_first.push_back(epsilon); break; } case END_LINE: // multiline anchor: end of data or a newline { PositionInfo epsilon(GlushkovBuildState::POS_EPSILON); epsilon.flags = POS_FLAG_WIRE_EOD | POS_FLAG_WIRE_NL_EOD | POS_FLAG_WIRE_NL_ACCEPT | POS_FLAG_ONLY_ENDS; m_first.push_back(epsilon); break; } default: // unsupported assert(0); break; } } void ComponentBoundary::buildFollowSet(GlushkovBuildState &, const vector &) { } bool ComponentBoundary::checkEmbeddedStartAnchor(bool at_start) const { if (at_start) { return at_start; } if (m_bound == BEGIN_STRING || m_bound == BEGIN_LINE) { throw ParseError("Embedded start anchors not supported."); } return at_start; } bool ComponentBoundary::checkEmbeddedEndAnchor(bool at_end) const { if (at_end) { return at_end; } if (m_bound != BEGIN_STRING && m_bound != BEGIN_LINE) { throw ParseError("Embedded end anchors not supported."); } return at_end; } } // namespace hyperscan-4.4.1/src/parser/shortcut_literal.h0000644000175000017500000000357513055426554022134 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Shortcut literal pass: directly add literal components to Rose. */ #ifndef SHORTCUT_LITERAL_H #define SHORTCUT_LITERAL_H namespace ue2 { class NG; class ParsedExpression; /** \brief True if the literal expression \a expr could be added to Rose. */ bool shortcutLiteral(NG &ng, const ParsedExpression &expr); } // namespace ue2 #endif hyperscan-4.4.1/src/parser/Component.h0000644000175000017500000001175013055426554020501 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Base class for all components. */ #ifndef _RE_COMPONENT_H_ #define _RE_COMPONENT_H_ #include "ComponentVisitor.h" #include "ConstComponentVisitor.h" #include "position.h" #include "ue2common.h" #include #include #include namespace ue2 { class GlushkovBuildState; class PositionInfo; enum EmptyPathType { NOT_EMPTY, /**< component must consume characters */ EPS_ONLY_PATHS, /**< eps path with no overhanging asserts */ BOUNDARY_PATHS /**< eps paths some with overhanging asserts */ }; /** \brief Base class for regular expression parse tree components. */ class Component { friend class DumpVisitor; public: /** \brief Constructor. */ Component(); /** \brief Destructor. */ virtual ~Component(); /** \brief Returns a newly-allocated deep copy of this component. */ virtual Component *clone() const = 0; /** \brief Apply the given visitor functor. */ virtual Component *accept(ComponentVisitor &v) = 0; /** \brief Apply the given const visitor functor. */ virtual void accept(ConstComponentVisitor &v) const = 0; /** \brief Glushkov construction First() function. * \return set of initial positions in this component. */ virtual std::vector first() const = 0; /** \brief Glushkov construction Last() function. * \return set of final positions in this component. */ virtual std::vector last() const = 0; /** \brief Glushkov construction Empty() function. * \return true iff the component accepts epsilon. * * Note: ^, $, etc are considered empty. */ virtual bool empty() const = 0; /** \brief True iff epsilon can pass through the component. * * Note: ^, $, etc are not vacuous everywhere. */ virtual bool vacuous_everywhere(void) const; /** \brief True iff the component is repeatable on its own, without being * encapsulated in a sequence first. * * This is true for most components, but not for repeats, anchors and word * boundaries. */ virtual bool repeatable() const; /** \brief Optimisation pass on the component tree. * * Called before \ref notePositions. May modify to the component tree. * Assumes no start of match information is required. */ virtual void optimise(bool connected_to_sds); /** \brief Informs the Glushkov build process of the positions used by this * component. */ virtual void notePositions(GlushkovBuildState &bs) = 0; /** \brief Glushkov construction Follow() function. * * Constructs (in \a bs) the set of positions in this component reachable * from the positions in \a lastPos. * * \throw ParseError on failure */ virtual void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) = 0; /** \brief Return value is used for chaining, throws if finds embedded * anchor. */ virtual bool checkEmbeddedStartAnchor(bool at_start) const; /* \brief Return value is used for chaining, throws if finds embedded * anchor. */ virtual bool checkEmbeddedEndAnchor(bool at_end) const; protected: /** \brief Called during \ref notePositions. */ void recordPosBounds(u32 b, u32 e); u32 pos_begin; u32 pos_end; // Protected copy ctor. Use clone instead. Component(const Component &other) : pos_begin(other.pos_begin), pos_end(other.pos_end) {} }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/ComponentBackReference.h0000644000175000017500000000603013055426554023074 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Back-references (/([a-f]{3}).*\\1/) */ #ifndef _RE_COMPONENTBACKREFERENCE_H_ #define _RE_COMPONENTBACKREFERENCE_H_ #include "Component.h" #include namespace ue2 { class ComponentBackReference : public Component { friend class DumpVisitor; friend class PrintVisitor; friend class ReferenceVisitor; public: explicit ComponentBackReference(unsigned int id); explicit ComponentBackReference(const std::string &s); ~ComponentBackReference() override {} ComponentBackReference *clone() const override; Component *accept(ComponentVisitor &v) override { Component *c = v.visit(this); v.post(this); return c; } void accept(ConstComponentVisitor &v) const override { v.pre(*this); v.during(*this); v.post(*this); } unsigned int getRefID() const { return ref_id; } const std::string &getRefName() const { return name; } std::vector first() const override; std::vector last() const override; bool empty(void) const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; private: // Private copy ctor. Use clone instead. ComponentBackReference(const ComponentBackReference &other) : Component(other), name(other.name), ref_id(other.ref_id) {} std::string name; unsigned int ref_id; }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/ComponentBoundary.h0000644000175000017500000000706513055426554022211 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Boundary assertions (^, $, \\A, \\Z, \\z) */ #ifndef _RE_COMPONENTBOUNDARY_H_ #define _RE_COMPONENTBOUNDARY_H_ #include "Component.h" #include "position.h" namespace ue2 { /** \brief Encapsulates a line/string boundary assertion. */ class ComponentBoundary : public Component { friend class DumpVisitor; friend class PrintVisitor; friend class UnsafeBoundsVisitor; friend class MultilineVisitor; public: enum Boundary { BEGIN_STRING, //!< beginning of data stream END_STRING, //!< end of data stream END_STRING_OPTIONAL_LF, //!< end of data stream with an optional // linefeed BEGIN_LINE, //!< '(^|\\n)' END_LINE //!< '($|\\n)' }; explicit ComponentBoundary(enum Boundary bound); ~ComponentBoundary() override; ComponentBoundary *clone() const override; Component *accept(ComponentVisitor &v) override { Component *c = v.visit(this); v.post(this); return c; } void accept(ConstComponentVisitor &v) const override { v.pre(*this); v.during(*this); v.post(*this); } std::vector first() const override; std::vector last() const override; bool empty() const override; bool repeatable() const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; bool checkEmbeddedStartAnchor(bool at_start) const override; bool checkEmbeddedEndAnchor(bool at_end) const override; private: enum Boundary m_bound; //!< \brief which assertion is that? Position m_newline; //!< \brief special newline state std::vector m_first; //!< \brief positions returned for first() std::vector m_last; //!< \brief positions returned for last() ComponentBoundary(const ComponentBoundary &other); }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/buildstate.h0000644000175000017500000000762413055426554020704 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Glushkov construction. */ #ifndef BUILDSTATE_H #define BUILDSTATE_H #include "ue2common.h" #include "position.h" #include #include #include namespace ue2 { class NFABuilder; class PositionInfo; /** \brief Machinery for Glushkov construction. * * Abstract base class; use \ref makeGlushkovBuildState to get one of these you * can use. */ class GlushkovBuildState : boost::noncopyable { public: /** \brief Represents an uninitialized state. */ static const Position POS_UNINITIALIZED; /** \brief Represents an epsilon transition in the firsts of a component. */ static const Position POS_EPSILON; virtual ~GlushkovBuildState(); /** \brief Returns a reference to the NFABuilder being used. */ virtual NFABuilder &getBuilder() = 0; /** \brief Returns a const reference to the NFABuilder being used. */ virtual const NFABuilder &getBuilder() const = 0; /** \brief Wire up edges from the lasts of one component to the firsts of * another. */ virtual void connectRegions(const std::vector &lasts, const std::vector &firsts) = 0; /** \brief Wire the lasts of the main sequence to accepts. */ virtual void connectAccepts(const std::vector &lasts) = 0; /** \brief Wire up a pair of positions. */ virtual void addSuccessor(Position from, Position to) = 0; /** \brief Clone the vertex properties and edges of all vertices between * two positions. */ virtual void cloneFollowSet(Position from, Position to, u32 offset) = 0; /** \brief Build the prioritised list of edges out of our successor map. */ virtual void buildEdges() = 0; }; /** \brief Returns a new GlushkovBuildState object. */ std::unique_ptr makeGlushkovBuildState(NFABuilder &b, bool prefilter); /** \brief Replace all epsilons with the given positions. */ void replaceEpsilons(std::vector &target, const std::vector &source); /** \brief Eliminate lower-priority duplicate PositionInfo entries. * * Scans through a list of positions and retains only the highest priority * version of a given (position, flags) entry. */ void cleanupPositions(std::vector &a); } // namespace ue2 #endif hyperscan-4.4.1/src/parser/parse_error.h0000644000175000017500000000453613055426554021066 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Parse/Compile exceptions. */ #ifndef PARSE_ERROR_H_A02047D1AA16C9 #define PARSE_ERROR_H_A02047D1AA16C9 #include "util/compile_error.h" #include namespace ue2 { /** \brief Error thrown internally by the Parser interface. */ class ParseError : public CompileError { public: // Note: 'why' should describe why the error occurred and end with a // full stop, but no line break. explicit ParseError(const std::string &why) : CompileError(why) {} ~ParseError() override; }; class LocatedParseError : public ParseError { public: explicit LocatedParseError(const std::string &why) : ParseError(".") { reason = why; // don't use ParseError ctor } ~LocatedParseError() override; void locate(size_t offset); }; } // namespace ue2 #endif /* PARSE_ERROR_H_A02047D1AA16C9 */ hyperscan-4.4.1/src/parser/ComponentRepeat.cpp0000644000175000017500000002631713055426554022202 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Repeats ('*', '+', '?', '{M,N}', etc) */ #include "ComponentRepeat.h" #include "buildstate.h" #include "nfagraph/ng_builder.h" #include "parse_error.h" #include "Parser.h" #include "position.h" #include "position_dump.h" #include "position_info.h" #include "ue2common.h" #include "util/make_unique.h" #include #include using namespace std; namespace ue2 { /** \brief Hard limit on the maximum repeat for bounded repeats. */ static constexpr u32 MAX_REPEAT = 32767; /** \brief If expanding a repeat would lead to this many positions being * generated, we fail the pattern. */ static constexpr u32 MAX_POSITIONS_EXPANDED = 500000; // arbitrarily huge /* no edge priorities means that if our subcomponent can be empty, our min * extent is effectively zero. */ ComponentRepeat::ComponentRepeat(unique_ptr sub_comp_in, u32 min, u32 max, enum RepeatType t) : type(t), sub_comp(move(sub_comp_in)), m_min(min), m_max(max), posFirst(GlushkovBuildState::POS_UNINITIALIZED), posLast(GlushkovBuildState::POS_UNINITIALIZED) { assert(sub_comp); assert(max > 0); assert(m_min <= m_max); if (m_min > MAX_REPEAT) { throw ParseError("Bounded repeat is too large."); } if (m_max != NoLimit && m_max > MAX_REPEAT) { throw ParseError("Bounded repeat is too large."); } } ComponentRepeat::~ComponentRepeat() {} ComponentRepeat *ComponentRepeat::clone() const { return new ComponentRepeat(*this); } ComponentRepeat::ComponentRepeat(const ComponentRepeat &other) : Component(other), type(other.type), sub_comp(unique_ptr(other.sub_comp->clone())), m_min(other.m_min), m_max(other.m_max), m_firsts(other.m_firsts), m_lasts(other.m_lasts), posFirst(other.posFirst), posLast(other.posLast) {} bool ComponentRepeat::empty() const { return m_min == 0 || sub_comp->empty(); } bool ComponentRepeat::repeatable() const { return false; } static void addBase(Position base, vector &firsts, vector &lasts) { for (auto &e : firsts) { if (e.pos != GlushkovBuildState::POS_EPSILON) { e.pos += base; } } for (auto &e : lasts) { e.pos += base; } } static void checkPositions(vector &v, const GlushkovBuildState &bs) { const NFABuilder& builder = bs.getBuilder(); for (const auto &e : v) { if (builder.isSpecialState(e.pos)) { throw ParseError("Embedded anchors not supported."); } } } void ComponentRepeat::notePositions(GlushkovBuildState &bs) { assert(m_max > 0); assert(m_max == NoLimit || m_max < MAX_REPEAT); /* Note: We can construct smaller subgraphs if we're not maintaining edge * priorities. */ // We create one copy only through a recursive call to notePositions(), // first() and last(). Then we clone its positions and store the // appropriate firsts and lasts values for the copies. posFirst = bs.getBuilder().numVertices(); sub_comp->notePositions(bs); u32 copies = m_max < NoLimit ? m_max : MAX(m_min, 1); DEBUG_PRINTF("building %u copies of repeated region\n", copies); m_firsts.clear(); m_lasts.clear(); m_firsts.resize(copies); m_lasts.resize(copies); m_firsts[0] = sub_comp->first(); m_lasts[0] = sub_comp->last(); postSubNotePositionHook(); posLast = bs.getBuilder().numVertices() - 1; u32 vcount = posLast + 1 - posFirst; // If we're making more than one copy, then our firsts and lasts must only // contain vertices inside [posFirst, posLast]: anything else means we have // an embedded anchor or otherwise weird situation. if (copies > 1) { checkPositions(m_firsts[0], bs); checkPositions(m_lasts[0], bs); } // Avoid enormous expansions if (vcount * copies > MAX_POSITIONS_EXPANDED) { throw ParseError("Bounded repeat is too large."); } // Add positions for the rest of the copies size_t copyPositions = vcount * (copies - 1); bs.getBuilder().makePositions(copyPositions); // Calculate our firsts and lasts for the copies for (u32 i = 1; i < copies; ++i) { m_firsts[i] = m_firsts[0]; m_lasts[i] = m_lasts[0]; u32 base = i * vcount; addBase(base, m_firsts[i], m_lasts[i]); } recordPosBounds(posFirst, bs.getBuilder().numVertices()); // Each optional repeat has an epsilon at the end of its firsts list. for (u32 i = m_min; i < m_firsts.size(); i++) { m_firsts[i].push_back(GlushkovBuildState::POS_EPSILON); } } vector ComponentRepeat::first() const { if (!m_max) { return {}; } assert(!m_firsts.empty()); // notePositions should already have run const vector &firsts = m_firsts.front(); DEBUG_PRINTF("firsts = %s\n", dumpPositions(begin(firsts), end(firsts)).c_str()); return firsts; } void ComponentRepeat::buildFollowSet(GlushkovBuildState &bs, const vector &lastPos) { if (!m_max) { return; } DEBUG_PRINTF("enter\n"); // Wire up the first (the "real") entry DEBUG_PRINTF("initial repeat\n"); sub_comp->buildFollowSet(bs, lastPos); // Clone the subgraph we just added N times, where N is the minimum extent // of the graph minus one, wiring them up in a linear sequence u32 copies = m_firsts.size(); DEBUG_PRINTF("cloning %u copies of repeat\n", copies - 1); for (u32 rep = 1; rep < copies; rep++) { u32 offset = (posLast + 1 - posFirst) * rep; if (offset > 0) { bs.cloneFollowSet(posFirst, posLast, offset); } } wireRepeats(bs); DEBUG_PRINTF("leave\n"); } void ComponentRepeat::optimise(bool connected_to_sds) { DEBUG_PRINTF("opt %d\n", (int)connected_to_sds); if (!connected_to_sds) { return; } DEBUG_PRINTF("setting m_max to %u\n", m_min); m_max = m_min; } bool ComponentRepeat::vacuous_everywhere() const { return !m_min; } bool ComponentRepeat::checkEmbeddedStartAnchor(bool at_start) const { at_start = sub_comp->checkEmbeddedStartAnchor(at_start); if (m_max > 1) { at_start = sub_comp->checkEmbeddedStartAnchor(at_start); } return at_start; } bool ComponentRepeat::checkEmbeddedEndAnchor(bool at_end) const { at_end = sub_comp->checkEmbeddedEndAnchor(at_end); if (m_max > 1) { at_end = sub_comp->checkEmbeddedEndAnchor(at_end); } return at_end; } Component *ComponentRepeat::accept(ComponentVisitor &v) { Component *c = v.visit(this); if (c != this) { v.post(this); return c; } c = sub_comp->accept(v); if (c != sub_comp.get()) { sub_comp.reset(c); } v.post(this); return !sub_comp ? nullptr : this; } void ComponentRepeat::accept(ConstComponentVisitor &v) const { v.pre(*this); sub_comp->accept(v); v.post(*this); } vector ComponentRepeat::last() const { vector lasts; if (!m_max) { return lasts; } assert(!m_firsts.empty()); // notePositions should already have run assert(!m_lasts.empty()); const auto &l = m_min ? m_lasts[m_min - 1] : m_lasts[0]; lasts.insert(lasts.end(), l.begin(), l.end()); if (!m_min || m_min != m_lasts.size()) { lasts.insert(lasts.end(), m_lasts.back().begin(), m_lasts.back().end()); } DEBUG_PRINTF("lasts = %s\n", dumpPositions(lasts.begin(), lasts.end()).c_str()); return lasts; } void ComponentRepeat::wireRepeats(GlushkovBuildState &bs) { /* note: m_lasts[0] already valid */ u32 copies = m_firsts.size(); const bool isEmpty = sub_comp->empty(); const vector &optLasts = m_min ? m_lasts[m_min - 1] : m_lasts[0]; if (!copies) { goto inf_check; } DEBUG_PRINTF("wiring up %u mand repeats\n", m_min); for (u32 rep = 1; rep < m_min; rep++) { bs.connectRegions(m_lasts[rep - 1], m_firsts[rep]); if (isEmpty) { m_lasts[rep].insert(m_lasts[rep].end(), m_lasts[rep - 1].begin(), m_lasts[rep - 1].end()); } } DEBUG_PRINTF("wiring up %d optional repeats\n", copies - m_min); for (u32 rep = MAX(m_min, 1); rep < copies; rep++) { vector lasts = m_lasts[rep - 1]; if (rep != m_min) { lasts.insert(lasts.end(), optLasts.begin(), optLasts.end()); sort(lasts.begin(), lasts.end()); lasts.erase(unique(lasts.begin(), lasts.end()), lasts.end()); } bs.connectRegions(lasts, m_firsts[rep]); } inf_check: // If we have no max bound, we need a self-loop as well. if (m_max == NoLimit) { DEBUG_PRINTF("final repeat self-loop\n"); bs.connectRegions(m_lasts.back(), m_firsts.back()); } } static bool hasPositionFlags(const Component &c) { for (const auto &e : c.first()) { if (e.flags) { return true; } } return false; } void ComponentRepeat::postSubNotePositionHook() { // UE-444 optimization: we can REWRITE m_min under various circumstances, // so that we create smaller NFA graphs. Note that this is _not_ possible // if our subcomponent contains a flagged position, e.g. nofloat. if (!hasPositionFlags(*sub_comp) && sub_comp->empty()) { m_min = 0; } } unique_ptr makeComponentRepeat(unique_ptr sub_comp, u32 min, u32 max, ComponentRepeat::RepeatType t) { return ue2::make_unique(move(sub_comp), min, max, t); } } // namespace ue2 hyperscan-4.4.1/src/parser/utf8_validate.cpp0000644000175000017500000001200013055426554021616 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "utf8_validate.h" #include "ue2common.h" #include "util/unicode_def.h" #include namespace ue2 { static bool hasValidContBytes(const u8 *s, size_t num) { /* continuer bytes must all be of the form 10xx xxxx */ for (size_t i = 0; i < num; i++) { if ((s[i] & 0xc0) != UTF_CONT_BYTE_HEADER) { return false; } } return true; } static bool isAllowedCodepoint(u32 val) { if (val >= 0xd800 && val <= 0xdfff) { return false; // High and low surrogate halves } if (val > 0x10ffff) { return false; // As per limit in RFC 3629 } return true; } bool isValidUtf8(const char *expression) { if (!expression) { return true; } const size_t len = strlen(expression); const u8 *s = (const u8 *)expression; u32 val; size_t i = 0; while (i < len) { DEBUG_PRINTF("byte %zu: 0x%02x\n", i, s[i]); // One octet. if (s[i] < 0x7f) { DEBUG_PRINTF("one octet\n"); i++; continue; } // Two octets. if ((s[i] & 0xe0) == UTF_TWO_BYTE_HEADER) { DEBUG_PRINTF("two octets\n"); if (i + 2 > len) { break; } if (!hasValidContBytes(&s[i] + 1, 1)) { break; } val = ((s[i] & 0x1f) << 6) | (s[i + 1] & UTF_CONT_BYTE_VALUE_MASK); DEBUG_PRINTF("val=0x%x\n", val); if (val < 1U << 7) { DEBUG_PRINTF("overlong encoding\n"); break; } if (!isAllowedCodepoint(val)) { DEBUG_PRINTF("codepoint not allowed\n"); break; } i += 2; continue; } // Three octets. if ((s[i] & 0xf0) == UTF_THREE_BYTE_HEADER) { DEBUG_PRINTF("three octets\n"); if (i + 3 > len) { break; } if (!hasValidContBytes(&s[i] + 1, 2)) { break; } val = ((s[i] & 0xf) << 12) | ((s[i + 1] & UTF_CONT_BYTE_VALUE_MASK) << 6) | (s[i + 2] & UTF_CONT_BYTE_VALUE_MASK); if (val < 1U << 11) { DEBUG_PRINTF("overlong encoding\n"); break; } if (!isAllowedCodepoint(val)) { DEBUG_PRINTF("codepoint not allowed\n"); break; } i += 3; continue; } // Four octets. if ((s[i] & 0xf8) == UTF_FOUR_BYTE_HEADER) { DEBUG_PRINTF("four octets\n"); if (i + 4 > len) { break; } if (!hasValidContBytes(&s[i] + 1, 3)) { break; } val = ((s[i] & 0xf) << 18) | ((s[i + 1] & UTF_CONT_BYTE_VALUE_MASK) << 12) | ((s[i + 2] & UTF_CONT_BYTE_VALUE_MASK) << 6) | (s[i + 3] & UTF_CONT_BYTE_VALUE_MASK); if (val < 1U << 16) { DEBUG_PRINTF("overlong encoding\n"); break; } if (!isAllowedCodepoint(val)) { DEBUG_PRINTF("codepoint not allowed\n"); break; } i += 4; continue; } // Something else? DEBUG_PRINTF("bad byte 0x%02x\n", s[i]); break; } DEBUG_PRINTF("i=%zu, len=%zu\n", i, len); return i == len; } } // namespace ue2 hyperscan-4.4.1/src/parser/Component.cpp0000644000175000017500000000446413055426554021040 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Base class for all components. */ #include "Component.h" #include "buildstate.h" #include "position.h" #include "position_info.h" #include "ue2common.h" using namespace std; namespace ue2 { Component::Component() : pos_begin(GlushkovBuildState::POS_UNINITIALIZED), pos_end(GlushkovBuildState::POS_UNINITIALIZED) {} Component::~Component() {} bool Component::repeatable() const { return true; } void Component::recordPosBounds(u32 b, u32 e) { pos_begin = b; pos_end = e; } void Component::optimise(bool) { } bool Component::vacuous_everywhere(void) const { return false; } bool Component::checkEmbeddedStartAnchor(bool) const { return false; } bool Component::checkEmbeddedEndAnchor(bool) const { return false; } } // namespace ue2 hyperscan-4.4.1/src/parser/ucp_table.h0000644000175000017500000066156213055426554020511 0ustar sleuthkidsleuthkid/* * 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 UCP_TABLE_H #define UCP_TABLE_H /* Generated by tools/scripts/ucp.py based on unicode database * * Do not hand edit */ namespace ue2 { class CodePointSet; void make_caseless(CodePointSet *cps); bool flip_case(unichar *c); CodePointSet getUcpC(void); CodePointSet getUcpCc(void); CodePointSet getUcpCf(void); CodePointSet getUcpCn(void); CodePointSet getUcpCo(void); CodePointSet getUcpCs(void); CodePointSet getUcpL(void); CodePointSet getUcpL_and(void); CodePointSet getUcpLl(void); CodePointSet getUcpLm(void); CodePointSet getUcpLo(void); CodePointSet getUcpLt(void); CodePointSet getUcpLu(void); CodePointSet getUcpM(void); CodePointSet getUcpMc(void); CodePointSet getUcpMe(void); CodePointSet getUcpMn(void); CodePointSet getUcpN(void); CodePointSet getUcpNd(void); CodePointSet getUcpNl(void); CodePointSet getUcpNo(void); CodePointSet getUcpP(void); CodePointSet getUcpPc(void); CodePointSet getUcpPd(void); CodePointSet getUcpPe(void); CodePointSet getUcpPf(void); CodePointSet getUcpPi(void); CodePointSet getUcpPo(void); CodePointSet getUcpPs(void); CodePointSet getUcpS(void); CodePointSet getUcpSc(void); CodePointSet getUcpSk(void); CodePointSet getUcpSm(void); CodePointSet getUcpSo(void); CodePointSet getUcpXan(void); CodePointSet getUcpXps(void); CodePointSet getUcpXsp(void); CodePointSet getUcpXwd(void); CodePointSet getUcpZ(void); CodePointSet getUcpZl(void); CodePointSet getUcpZp(void); CodePointSet getUcpZs(void); CodePointSet getUcpArabic(void); CodePointSet getUcpArmenian(void); CodePointSet getUcpAvestan(void); CodePointSet getUcpBalinese(void); CodePointSet getUcpBamum(void); CodePointSet getUcpBassa_Vah(void); CodePointSet getUcpBatak(void); CodePointSet getUcpBengali(void); CodePointSet getUcpBopomofo(void); CodePointSet getUcpBrahmi(void); CodePointSet getUcpBraille(void); CodePointSet getUcpBuginese(void); CodePointSet getUcpBuhid(void); CodePointSet getUcpCanadian_Aboriginal(void); CodePointSet getUcpCarian(void); CodePointSet getUcpCaucasian_Albanian(void); CodePointSet getUcpChakma(void); CodePointSet getUcpCham(void); CodePointSet getUcpCherokee(void); CodePointSet getUcpCommon(void); CodePointSet getUcpCoptic(void); CodePointSet getUcpCuneiform(void); CodePointSet getUcpCypriot(void); CodePointSet getUcpCyrillic(void); CodePointSet getUcpDeseret(void); CodePointSet getUcpDevanagari(void); CodePointSet getUcpDuployan(void); CodePointSet getUcpEgyptian_Hieroglyphs(void); CodePointSet getUcpElbasan(void); CodePointSet getUcpEthiopic(void); CodePointSet getUcpGeorgian(void); CodePointSet getUcpGlagolitic(void); CodePointSet getUcpGothic(void); CodePointSet getUcpGrantha(void); CodePointSet getUcpGreek(void); CodePointSet getUcpGujarati(void); CodePointSet getUcpGurmukhi(void); CodePointSet getUcpHan(void); CodePointSet getUcpHangul(void); CodePointSet getUcpHanunoo(void); CodePointSet getUcpHebrew(void); CodePointSet getUcpHiragana(void); CodePointSet getUcpImperial_Aramaic(void); CodePointSet getUcpInherited(void); CodePointSet getUcpInscriptional_Pahlavi(void); CodePointSet getUcpInscriptional_Parthian(void); CodePointSet getUcpJavanese(void); CodePointSet getUcpKaithi(void); CodePointSet getUcpKannada(void); CodePointSet getUcpKatakana(void); CodePointSet getUcpKayah_Li(void); CodePointSet getUcpKharoshthi(void); CodePointSet getUcpKhmer(void); CodePointSet getUcpKhojki(void); CodePointSet getUcpKhudawadi(void); CodePointSet getUcpLao(void); CodePointSet getUcpLatin(void); CodePointSet getUcpLepcha(void); CodePointSet getUcpLimbu(void); CodePointSet getUcpLinear_A(void); CodePointSet getUcpLinear_B(void); CodePointSet getUcpLisu(void); CodePointSet getUcpLycian(void); CodePointSet getUcpLydian(void); CodePointSet getUcpMahajani(void); CodePointSet getUcpMalayalam(void); CodePointSet getUcpMandaic(void); CodePointSet getUcpManichaean(void); CodePointSet getUcpMeetei_Mayek(void); CodePointSet getUcpMende_Kikakui(void); CodePointSet getUcpMeroitic_Cursive(void); CodePointSet getUcpMeroitic_Hieroglyphs(void); CodePointSet getUcpMiao(void); CodePointSet getUcpModi(void); CodePointSet getUcpMongolian(void); CodePointSet getUcpMro(void); CodePointSet getUcpMyanmar(void); CodePointSet getUcpNabataean(void); CodePointSet getUcpNew_Tai_Lue(void); CodePointSet getUcpNko(void); CodePointSet getUcpOgham(void); CodePointSet getUcpOl_Chiki(void); CodePointSet getUcpOld_Italic(void); CodePointSet getUcpOld_North_Arabian(void); CodePointSet getUcpOld_Permic(void); CodePointSet getUcpOld_Persian(void); CodePointSet getUcpOld_South_Arabian(void); CodePointSet getUcpOld_Turkic(void); CodePointSet getUcpOriya(void); CodePointSet getUcpOsmanya(void); CodePointSet getUcpPahawh_Hmong(void); CodePointSet getUcpPalmyrene(void); CodePointSet getUcpPau_Cin_Hau(void); CodePointSet getUcpPhags_Pa(void); CodePointSet getUcpPhoenician(void); CodePointSet getUcpPsalter_Pahlavi(void); CodePointSet getUcpRejang(void); CodePointSet getUcpRunic(void); CodePointSet getUcpSamaritan(void); CodePointSet getUcpSaurashtra(void); CodePointSet getUcpSharada(void); CodePointSet getUcpShavian(void); CodePointSet getUcpSiddham(void); CodePointSet getUcpSinhala(void); CodePointSet getUcpSora_Sompeng(void); CodePointSet getUcpSundanese(void); CodePointSet getUcpSyloti_Nagri(void); CodePointSet getUcpSyriac(void); CodePointSet getUcpTagalog(void); CodePointSet getUcpTagbanwa(void); CodePointSet getUcpTai_Le(void); CodePointSet getUcpTai_Tham(void); CodePointSet getUcpTai_Viet(void); CodePointSet getUcpTakri(void); CodePointSet getUcpTamil(void); CodePointSet getUcpTelugu(void); CodePointSet getUcpThaana(void); CodePointSet getUcpThai(void); CodePointSet getUcpTibetan(void); CodePointSet getUcpTifinagh(void); CodePointSet getUcpTirhuta(void); CodePointSet getUcpUgaritic(void); CodePointSet getUcpVai(void); CodePointSet getUcpWarang_Citi(void); CodePointSet getUcpYi(void); #ifdef UCP_TABLE_DEFINE_FN static const unichar ucp_C_def[] = { 0x0, 0x1f, 0x7f, 0x9f, 0xad, 0xad, 0x378, 0x379, 0x380, 0x383, 0x38b, 0x38b, 0x38d, 0x38d, 0x3a2, 0x3a2, 0x530, 0x530, 0x557, 0x558, 0x560, 0x560, 0x588, 0x588, 0x58b, 0x58c, 0x590, 0x590, 0x5c8, 0x5cf, 0x5eb, 0x5ef, 0x5f5, 0x605, 0x61c, 0x61d, 0x6dd, 0x6dd, 0x70e, 0x70f, 0x74b, 0x74c, 0x7b2, 0x7bf, 0x7fb, 0x7ff, 0x82e, 0x82f, 0x83f, 0x83f, 0x85c, 0x85d, 0x85f, 0x89f, 0x8b3, 0x8e3, 0x984, 0x984, 0x98d, 0x98e, 0x991, 0x992, 0x9a9, 0x9a9, 0x9b1, 0x9b1, 0x9b3, 0x9b5, 0x9ba, 0x9bb, 0x9c5, 0x9c6, 0x9c9, 0x9ca, 0x9cf, 0x9d6, 0x9d8, 0x9db, 0x9de, 0x9de, 0x9e4, 0x9e5, 0x9fc, 0xa00, 0xa04, 0xa04, 0xa0b, 0xa0e, 0xa11, 0xa12, 0xa29, 0xa29, 0xa31, 0xa31, 0xa34, 0xa34, 0xa37, 0xa37, 0xa3a, 0xa3b, 0xa3d, 0xa3d, 0xa43, 0xa46, 0xa49, 0xa4a, 0xa4e, 0xa50, 0xa52, 0xa58, 0xa5d, 0xa5d, 0xa5f, 0xa65, 0xa76, 0xa80, 0xa84, 0xa84, 0xa8e, 0xa8e, 0xa92, 0xa92, 0xaa9, 0xaa9, 0xab1, 0xab1, 0xab4, 0xab4, 0xaba, 0xabb, 0xac6, 0xac6, 0xaca, 0xaca, 0xace, 0xacf, 0xad1, 0xadf, 0xae4, 0xae5, 0xaf2, 0xb00, 0xb04, 0xb04, 0xb0d, 0xb0e, 0xb11, 0xb12, 0xb29, 0xb29, 0xb31, 0xb31, 0xb34, 0xb34, 0xb3a, 0xb3b, 0xb45, 0xb46, 0xb49, 0xb4a, 0xb4e, 0xb55, 0xb58, 0xb5b, 0xb5e, 0xb5e, 0xb64, 0xb65, 0xb78, 0xb81, 0xb84, 0xb84, 0xb8b, 0xb8d, 0xb91, 0xb91, 0xb96, 0xb98, 0xb9b, 0xb9b, 0xb9d, 0xb9d, 0xba0, 0xba2, 0xba5, 0xba7, 0xbab, 0xbad, 0xbba, 0xbbd, 0xbc3, 0xbc5, 0xbc9, 0xbc9, 0xbce, 0xbcf, 0xbd1, 0xbd6, 0xbd8, 0xbe5, 0xbfb, 0xbff, 0xc04, 0xc04, 0xc0d, 0xc0d, 0xc11, 0xc11, 0xc29, 0xc29, 0xc3a, 0xc3c, 0xc45, 0xc45, 0xc49, 0xc49, 0xc4e, 0xc54, 0xc57, 0xc57, 0xc5a, 0xc5f, 0xc64, 0xc65, 0xc70, 0xc77, 0xc80, 0xc80, 0xc84, 0xc84, 0xc8d, 0xc8d, 0xc91, 0xc91, 0xca9, 0xca9, 0xcb4, 0xcb4, 0xcba, 0xcbb, 0xcc5, 0xcc5, 0xcc9, 0xcc9, 0xcce, 0xcd4, 0xcd7, 0xcdd, 0xcdf, 0xcdf, 0xce4, 0xce5, 0xcf0, 0xcf0, 0xcf3, 0xd00, 0xd04, 0xd04, 0xd0d, 0xd0d, 0xd11, 0xd11, 0xd3b, 0xd3c, 0xd45, 0xd45, 0xd49, 0xd49, 0xd4f, 0xd56, 0xd58, 0xd5f, 0xd64, 0xd65, 0xd76, 0xd78, 0xd80, 0xd81, 0xd84, 0xd84, 0xd97, 0xd99, 0xdb2, 0xdb2, 0xdbc, 0xdbc, 0xdbe, 0xdbf, 0xdc7, 0xdc9, 0xdcb, 0xdce, 0xdd5, 0xdd5, 0xdd7, 0xdd7, 0xde0, 0xde5, 0xdf0, 0xdf1, 0xdf5, 0xe00, 0xe3b, 0xe3e, 0xe5c, 0xe80, 0xe83, 0xe83, 0xe85, 0xe86, 0xe89, 0xe89, 0xe8b, 0xe8c, 0xe8e, 0xe93, 0xe98, 0xe98, 0xea0, 0xea0, 0xea4, 0xea4, 0xea6, 0xea6, 0xea8, 0xea9, 0xeac, 0xeac, 0xeba, 0xeba, 0xebe, 0xebf, 0xec5, 0xec5, 0xec7, 0xec7, 0xece, 0xecf, 0xeda, 0xedb, 0xee0, 0xeff, 0xf48, 0xf48, 0xf6d, 0xf70, 0xf98, 0xf98, 0xfbd, 0xfbd, 0xfcd, 0xfcd, 0xfdb, 0xfff, 0x10c6, 0x10c6, 0x10c8, 0x10cc, 0x10ce, 0x10cf, 0x1249, 0x1249, 0x124e, 0x124f, 0x1257, 0x1257, 0x1259, 0x1259, 0x125e, 0x125f, 0x1289, 0x1289, 0x128e, 0x128f, 0x12b1, 0x12b1, 0x12b6, 0x12b7, 0x12bf, 0x12bf, 0x12c1, 0x12c1, 0x12c6, 0x12c7, 0x12d7, 0x12d7, 0x1311, 0x1311, 0x1316, 0x1317, 0x135b, 0x135c, 0x137d, 0x137f, 0x139a, 0x139f, 0x13f5, 0x13ff, 0x169d, 0x169f, 0x16f9, 0x16ff, 0x170d, 0x170d, 0x1715, 0x171f, 0x1737, 0x173f, 0x1754, 0x175f, 0x176d, 0x176d, 0x1771, 0x1771, 0x1774, 0x177f, 0x17de, 0x17df, 0x17ea, 0x17ef, 0x17fa, 0x17ff, 0x180e, 0x180f, 0x181a, 0x181f, 0x1878, 0x187f, 0x18ab, 0x18af, 0x18f6, 0x18ff, 0x191f, 0x191f, 0x192c, 0x192f, 0x193c, 0x193f, 0x1941, 0x1943, 0x196e, 0x196f, 0x1975, 0x197f, 0x19ac, 0x19af, 0x19ca, 0x19cf, 0x19db, 0x19dd, 0x1a1c, 0x1a1d, 0x1a5f, 0x1a5f, 0x1a7d, 0x1a7e, 0x1a8a, 0x1a8f, 0x1a9a, 0x1a9f, 0x1aae, 0x1aaf, 0x1abf, 0x1aff, 0x1b4c, 0x1b4f, 0x1b7d, 0x1b7f, 0x1bf4, 0x1bfb, 0x1c38, 0x1c3a, 0x1c4a, 0x1c4c, 0x1c80, 0x1cbf, 0x1cc8, 0x1ccf, 0x1cf7, 0x1cf7, 0x1cfa, 0x1cff, 0x1df6, 0x1dfb, 0x1f16, 0x1f17, 0x1f1e, 0x1f1f, 0x1f46, 0x1f47, 0x1f4e, 0x1f4f, 0x1f58, 0x1f58, 0x1f5a, 0x1f5a, 0x1f5c, 0x1f5c, 0x1f5e, 0x1f5e, 0x1f7e, 0x1f7f, 0x1fb5, 0x1fb5, 0x1fc5, 0x1fc5, 0x1fd4, 0x1fd5, 0x1fdc, 0x1fdc, 0x1ff0, 0x1ff1, 0x1ff5, 0x1ff5, 0x1fff, 0x1fff, 0x200b, 0x200f, 0x202a, 0x202e, 0x2060, 0x206f, 0x2072, 0x2073, 0x208f, 0x208f, 0x209d, 0x209f, 0x20be, 0x20cf, 0x20f1, 0x20ff, 0x218a, 0x218f, 0x23fb, 0x23ff, 0x2427, 0x243f, 0x244b, 0x245f, 0x2b74, 0x2b75, 0x2b96, 0x2b97, 0x2bba, 0x2bbc, 0x2bc9, 0x2bc9, 0x2bd2, 0x2bff, 0x2c2f, 0x2c2f, 0x2c5f, 0x2c5f, 0x2cf4, 0x2cf8, 0x2d26, 0x2d26, 0x2d28, 0x2d2c, 0x2d2e, 0x2d2f, 0x2d68, 0x2d6e, 0x2d71, 0x2d7e, 0x2d97, 0x2d9f, 0x2da7, 0x2da7, 0x2daf, 0x2daf, 0x2db7, 0x2db7, 0x2dbf, 0x2dbf, 0x2dc7, 0x2dc7, 0x2dcf, 0x2dcf, 0x2dd7, 0x2dd7, 0x2ddf, 0x2ddf, 0x2e43, 0x2e7f, 0x2e9a, 0x2e9a, 0x2ef4, 0x2eff, 0x2fd6, 0x2fef, 0x2ffc, 0x2fff, 0x3040, 0x3040, 0x3097, 0x3098, 0x3100, 0x3104, 0x312e, 0x3130, 0x318f, 0x318f, 0x31bb, 0x31bf, 0x31e4, 0x31ef, 0x321f, 0x321f, 0x32ff, 0x32ff, 0x4db6, 0x4dbf, 0x9fcd, 0x9fff, 0xa48d, 0xa48f, 0xa4c7, 0xa4cf, 0xa62c, 0xa63f, 0xa69e, 0xa69e, 0xa6f8, 0xa6ff, 0xa78f, 0xa78f, 0xa7ae, 0xa7af, 0xa7b2, 0xa7f6, 0xa82c, 0xa82f, 0xa83a, 0xa83f, 0xa878, 0xa87f, 0xa8c5, 0xa8cd, 0xa8da, 0xa8df, 0xa8fc, 0xa8ff, 0xa954, 0xa95e, 0xa97d, 0xa97f, 0xa9ce, 0xa9ce, 0xa9da, 0xa9dd, 0xa9ff, 0xa9ff, 0xaa37, 0xaa3f, 0xaa4e, 0xaa4f, 0xaa5a, 0xaa5b, 0xaac3, 0xaada, 0xaaf7, 0xab00, 0xab07, 0xab08, 0xab0f, 0xab10, 0xab17, 0xab1f, 0xab27, 0xab27, 0xab2f, 0xab2f, 0xab60, 0xab63, 0xab66, 0xabbf, 0xabee, 0xabef, 0xabfa, 0xabff, 0xd7a4, 0xd7af, 0xd7c7, 0xd7ca, 0xd7fc, 0xf8ff, 0xfa6e, 0xfa6f, 0xfada, 0xfaff, 0xfb07, 0xfb12, 0xfb18, 0xfb1c, 0xfb37, 0xfb37, 0xfb3d, 0xfb3d, 0xfb3f, 0xfb3f, 0xfb42, 0xfb42, 0xfb45, 0xfb45, 0xfbc2, 0xfbd2, 0xfd40, 0xfd4f, 0xfd90, 0xfd91, 0xfdc8, 0xfdef, 0xfdfe, 0xfdff, 0xfe1a, 0xfe1f, 0xfe2e, 0xfe2f, 0xfe53, 0xfe53, 0xfe67, 0xfe67, 0xfe6c, 0xfe6f, 0xfe75, 0xfe75, 0xfefd, 0xff00, 0xffbf, 0xffc1, 0xffc8, 0xffc9, 0xffd0, 0xffd1, 0xffd8, 0xffd9, 0xffdd, 0xffdf, 0xffe7, 0xffe7, 0xffef, 0xfffb, 0xfffe, 0xffff, 0x1000c, 0x1000c, 0x10027, 0x10027, 0x1003b, 0x1003b, 0x1003e, 0x1003e, 0x1004e, 0x1004f, 0x1005e, 0x1007f, 0x100fb, 0x100ff, 0x10103, 0x10106, 0x10134, 0x10136, 0x1018d, 0x1018f, 0x1019c, 0x1019f, 0x101a1, 0x101cf, 0x101fe, 0x1027f, 0x1029d, 0x1029f, 0x102d1, 0x102df, 0x102fc, 0x102ff, 0x10324, 0x1032f, 0x1034b, 0x1034f, 0x1037b, 0x1037f, 0x1039e, 0x1039e, 0x103c4, 0x103c7, 0x103d6, 0x103ff, 0x1049e, 0x1049f, 0x104aa, 0x104ff, 0x10528, 0x1052f, 0x10564, 0x1056e, 0x10570, 0x105ff, 0x10737, 0x1073f, 0x10756, 0x1075f, 0x10768, 0x107ff, 0x10806, 0x10807, 0x10809, 0x10809, 0x10836, 0x10836, 0x10839, 0x1083b, 0x1083d, 0x1083e, 0x10856, 0x10856, 0x1089f, 0x108a6, 0x108b0, 0x108ff, 0x1091c, 0x1091e, 0x1093a, 0x1093e, 0x10940, 0x1097f, 0x109b8, 0x109bd, 0x109c0, 0x109ff, 0x10a04, 0x10a04, 0x10a07, 0x10a0b, 0x10a14, 0x10a14, 0x10a18, 0x10a18, 0x10a34, 0x10a37, 0x10a3b, 0x10a3e, 0x10a48, 0x10a4f, 0x10a59, 0x10a5f, 0x10aa0, 0x10abf, 0x10ae7, 0x10aea, 0x10af7, 0x10aff, 0x10b36, 0x10b38, 0x10b56, 0x10b57, 0x10b73, 0x10b77, 0x10b92, 0x10b98, 0x10b9d, 0x10ba8, 0x10bb0, 0x10bff, 0x10c49, 0x10e5f, 0x10e7f, 0x10fff, 0x1104e, 0x11051, 0x11070, 0x1107e, 0x110bd, 0x110bd, 0x110c2, 0x110cf, 0x110e9, 0x110ef, 0x110fa, 0x110ff, 0x11135, 0x11135, 0x11144, 0x1114f, 0x11177, 0x1117f, 0x111c9, 0x111cc, 0x111ce, 0x111cf, 0x111db, 0x111e0, 0x111f5, 0x111ff, 0x11212, 0x11212, 0x1123e, 0x112af, 0x112eb, 0x112ef, 0x112fa, 0x11300, 0x11304, 0x11304, 0x1130d, 0x1130e, 0x11311, 0x11312, 0x11329, 0x11329, 0x11331, 0x11331, 0x11334, 0x11334, 0x1133a, 0x1133b, 0x11345, 0x11346, 0x11349, 0x1134a, 0x1134e, 0x11356, 0x11358, 0x1135c, 0x11364, 0x11365, 0x1136d, 0x1136f, 0x11375, 0x1147f, 0x114c8, 0x114cf, 0x114da, 0x1157f, 0x115b6, 0x115b7, 0x115ca, 0x115ff, 0x11645, 0x1164f, 0x1165a, 0x1167f, 0x116b8, 0x116bf, 0x116ca, 0x1189f, 0x118f3, 0x118fe, 0x11900, 0x11abf, 0x11af9, 0x11fff, 0x12399, 0x123ff, 0x1246f, 0x1246f, 0x12475, 0x12fff, 0x1342f, 0x167ff, 0x16a39, 0x16a3f, 0x16a5f, 0x16a5f, 0x16a6a, 0x16a6d, 0x16a70, 0x16acf, 0x16aee, 0x16aef, 0x16af6, 0x16aff, 0x16b46, 0x16b4f, 0x16b5a, 0x16b5a, 0x16b62, 0x16b62, 0x16b78, 0x16b7c, 0x16b90, 0x16eff, 0x16f45, 0x16f4f, 0x16f7f, 0x16f8e, 0x16fa0, 0x1afff, 0x1b002, 0x1bbff, 0x1bc6b, 0x1bc6f, 0x1bc7d, 0x1bc7f, 0x1bc89, 0x1bc8f, 0x1bc9a, 0x1bc9b, 0x1bca0, 0x1cfff, 0x1d0f6, 0x1d0ff, 0x1d127, 0x1d128, 0x1d173, 0x1d17a, 0x1d1de, 0x1d1ff, 0x1d246, 0x1d2ff, 0x1d357, 0x1d35f, 0x1d372, 0x1d3ff, 0x1d455, 0x1d455, 0x1d49d, 0x1d49d, 0x1d4a0, 0x1d4a1, 0x1d4a3, 0x1d4a4, 0x1d4a7, 0x1d4a8, 0x1d4ad, 0x1d4ad, 0x1d4ba, 0x1d4ba, 0x1d4bc, 0x1d4bc, 0x1d4c4, 0x1d4c4, 0x1d506, 0x1d506, 0x1d50b, 0x1d50c, 0x1d515, 0x1d515, 0x1d51d, 0x1d51d, 0x1d53a, 0x1d53a, 0x1d53f, 0x1d53f, 0x1d545, 0x1d545, 0x1d547, 0x1d549, 0x1d551, 0x1d551, 0x1d6a6, 0x1d6a7, 0x1d7cc, 0x1d7cd, 0x1d800, 0x1e7ff, 0x1e8c5, 0x1e8c6, 0x1e8d7, 0x1edff, 0x1ee04, 0x1ee04, 0x1ee20, 0x1ee20, 0x1ee23, 0x1ee23, 0x1ee25, 0x1ee26, 0x1ee28, 0x1ee28, 0x1ee33, 0x1ee33, 0x1ee38, 0x1ee38, 0x1ee3a, 0x1ee3a, 0x1ee3c, 0x1ee41, 0x1ee43, 0x1ee46, 0x1ee48, 0x1ee48, 0x1ee4a, 0x1ee4a, 0x1ee4c, 0x1ee4c, 0x1ee50, 0x1ee50, 0x1ee53, 0x1ee53, 0x1ee55, 0x1ee56, 0x1ee58, 0x1ee58, 0x1ee5a, 0x1ee5a, 0x1ee5c, 0x1ee5c, 0x1ee5e, 0x1ee5e, 0x1ee60, 0x1ee60, 0x1ee63, 0x1ee63, 0x1ee65, 0x1ee66, 0x1ee6b, 0x1ee6b, 0x1ee73, 0x1ee73, 0x1ee78, 0x1ee78, 0x1ee7d, 0x1ee7d, 0x1ee7f, 0x1ee7f, 0x1ee8a, 0x1ee8a, 0x1ee9c, 0x1eea0, 0x1eea4, 0x1eea4, 0x1eeaa, 0x1eeaa, 0x1eebc, 0x1eeef, 0x1eef2, 0x1efff, 0x1f02c, 0x1f02f, 0x1f094, 0x1f09f, 0x1f0af, 0x1f0b0, 0x1f0c0, 0x1f0c0, 0x1f0d0, 0x1f0d0, 0x1f0f6, 0x1f0ff, 0x1f10d, 0x1f10f, 0x1f12f, 0x1f12f, 0x1f16c, 0x1f16f, 0x1f19b, 0x1f1e5, 0x1f203, 0x1f20f, 0x1f23b, 0x1f23f, 0x1f249, 0x1f24f, 0x1f252, 0x1f2ff, 0x1f32d, 0x1f32f, 0x1f37e, 0x1f37f, 0x1f3cf, 0x1f3d3, 0x1f3f8, 0x1f3ff, 0x1f4ff, 0x1f4ff, 0x1f54b, 0x1f54f, 0x1f57a, 0x1f57a, 0x1f5a4, 0x1f5a4, 0x1f643, 0x1f644, 0x1f6d0, 0x1f6df, 0x1f6ed, 0x1f6ef, 0x1f6f4, 0x1f6ff, 0x1f774, 0x1f77f, 0x1f7d5, 0x1f7ff, 0x1f80c, 0x1f80f, 0x1f848, 0x1f84f, 0x1f85a, 0x1f85f, 0x1f888, 0x1f88f, 0x1f8ae, 0x1ffff, 0x2a6d7, 0x2a6ff, 0x2b735, 0x2b73f, 0x2b81e, 0x2f7ff, 0x2fa1e, 0xe00ff, 0xe01f0, 0x10ffff }; UCP_FN(C) static const unichar ucp_Cc_def[] = { 0x0, 0x1f, 0x7f, 0x9f }; UCP_FN(Cc) static const unichar ucp_Cf_def[] = { 0xad, 0xad, 0x600, 0x605, 0x61c, 0x61c, 0x6dd, 0x6dd, 0x70f, 0x70f, 0x180e, 0x180e, 0x200b, 0x200f, 0x202a, 0x202e, 0x2060, 0x2064, 0x2066, 0x206f, 0xfeff, 0xfeff, 0xfff9, 0xfffb, 0x110bd, 0x110bd, 0x1bca0, 0x1bca3, 0x1d173, 0x1d17a, 0xe0001, 0xe0001, 0xe0020, 0xe007f }; UCP_FN(Cf) static const unichar ucp_Cn_def[] = { 0x378, 0x379, 0x380, 0x383, 0x38b, 0x38b, 0x38d, 0x38d, 0x3a2, 0x3a2, 0x530, 0x530, 0x557, 0x558, 0x560, 0x560, 0x588, 0x588, 0x58b, 0x58c, 0x590, 0x590, 0x5c8, 0x5cf, 0x5eb, 0x5ef, 0x5f5, 0x5ff, 0x61d, 0x61d, 0x70e, 0x70e, 0x74b, 0x74c, 0x7b2, 0x7bf, 0x7fb, 0x7ff, 0x82e, 0x82f, 0x83f, 0x83f, 0x85c, 0x85d, 0x85f, 0x89f, 0x8b3, 0x8e3, 0x984, 0x984, 0x98d, 0x98e, 0x991, 0x992, 0x9a9, 0x9a9, 0x9b1, 0x9b1, 0x9b3, 0x9b5, 0x9ba, 0x9bb, 0x9c5, 0x9c6, 0x9c9, 0x9ca, 0x9cf, 0x9d6, 0x9d8, 0x9db, 0x9de, 0x9de, 0x9e4, 0x9e5, 0x9fc, 0xa00, 0xa04, 0xa04, 0xa0b, 0xa0e, 0xa11, 0xa12, 0xa29, 0xa29, 0xa31, 0xa31, 0xa34, 0xa34, 0xa37, 0xa37, 0xa3a, 0xa3b, 0xa3d, 0xa3d, 0xa43, 0xa46, 0xa49, 0xa4a, 0xa4e, 0xa50, 0xa52, 0xa58, 0xa5d, 0xa5d, 0xa5f, 0xa65, 0xa76, 0xa80, 0xa84, 0xa84, 0xa8e, 0xa8e, 0xa92, 0xa92, 0xaa9, 0xaa9, 0xab1, 0xab1, 0xab4, 0xab4, 0xaba, 0xabb, 0xac6, 0xac6, 0xaca, 0xaca, 0xace, 0xacf, 0xad1, 0xadf, 0xae4, 0xae5, 0xaf2, 0xb00, 0xb04, 0xb04, 0xb0d, 0xb0e, 0xb11, 0xb12, 0xb29, 0xb29, 0xb31, 0xb31, 0xb34, 0xb34, 0xb3a, 0xb3b, 0xb45, 0xb46, 0xb49, 0xb4a, 0xb4e, 0xb55, 0xb58, 0xb5b, 0xb5e, 0xb5e, 0xb64, 0xb65, 0xb78, 0xb81, 0xb84, 0xb84, 0xb8b, 0xb8d, 0xb91, 0xb91, 0xb96, 0xb98, 0xb9b, 0xb9b, 0xb9d, 0xb9d, 0xba0, 0xba2, 0xba5, 0xba7, 0xbab, 0xbad, 0xbba, 0xbbd, 0xbc3, 0xbc5, 0xbc9, 0xbc9, 0xbce, 0xbcf, 0xbd1, 0xbd6, 0xbd8, 0xbe5, 0xbfb, 0xbff, 0xc04, 0xc04, 0xc0d, 0xc0d, 0xc11, 0xc11, 0xc29, 0xc29, 0xc3a, 0xc3c, 0xc45, 0xc45, 0xc49, 0xc49, 0xc4e, 0xc54, 0xc57, 0xc57, 0xc5a, 0xc5f, 0xc64, 0xc65, 0xc70, 0xc77, 0xc80, 0xc80, 0xc84, 0xc84, 0xc8d, 0xc8d, 0xc91, 0xc91, 0xca9, 0xca9, 0xcb4, 0xcb4, 0xcba, 0xcbb, 0xcc5, 0xcc5, 0xcc9, 0xcc9, 0xcce, 0xcd4, 0xcd7, 0xcdd, 0xcdf, 0xcdf, 0xce4, 0xce5, 0xcf0, 0xcf0, 0xcf3, 0xd00, 0xd04, 0xd04, 0xd0d, 0xd0d, 0xd11, 0xd11, 0xd3b, 0xd3c, 0xd45, 0xd45, 0xd49, 0xd49, 0xd4f, 0xd56, 0xd58, 0xd5f, 0xd64, 0xd65, 0xd76, 0xd78, 0xd80, 0xd81, 0xd84, 0xd84, 0xd97, 0xd99, 0xdb2, 0xdb2, 0xdbc, 0xdbc, 0xdbe, 0xdbf, 0xdc7, 0xdc9, 0xdcb, 0xdce, 0xdd5, 0xdd5, 0xdd7, 0xdd7, 0xde0, 0xde5, 0xdf0, 0xdf1, 0xdf5, 0xe00, 0xe3b, 0xe3e, 0xe5c, 0xe80, 0xe83, 0xe83, 0xe85, 0xe86, 0xe89, 0xe89, 0xe8b, 0xe8c, 0xe8e, 0xe93, 0xe98, 0xe98, 0xea0, 0xea0, 0xea4, 0xea4, 0xea6, 0xea6, 0xea8, 0xea9, 0xeac, 0xeac, 0xeba, 0xeba, 0xebe, 0xebf, 0xec5, 0xec5, 0xec7, 0xec7, 0xece, 0xecf, 0xeda, 0xedb, 0xee0, 0xeff, 0xf48, 0xf48, 0xf6d, 0xf70, 0xf98, 0xf98, 0xfbd, 0xfbd, 0xfcd, 0xfcd, 0xfdb, 0xfff, 0x10c6, 0x10c6, 0x10c8, 0x10cc, 0x10ce, 0x10cf, 0x1249, 0x1249, 0x124e, 0x124f, 0x1257, 0x1257, 0x1259, 0x1259, 0x125e, 0x125f, 0x1289, 0x1289, 0x128e, 0x128f, 0x12b1, 0x12b1, 0x12b6, 0x12b7, 0x12bf, 0x12bf, 0x12c1, 0x12c1, 0x12c6, 0x12c7, 0x12d7, 0x12d7, 0x1311, 0x1311, 0x1316, 0x1317, 0x135b, 0x135c, 0x137d, 0x137f, 0x139a, 0x139f, 0x13f5, 0x13ff, 0x169d, 0x169f, 0x16f9, 0x16ff, 0x170d, 0x170d, 0x1715, 0x171f, 0x1737, 0x173f, 0x1754, 0x175f, 0x176d, 0x176d, 0x1771, 0x1771, 0x1774, 0x177f, 0x17de, 0x17df, 0x17ea, 0x17ef, 0x17fa, 0x17ff, 0x180f, 0x180f, 0x181a, 0x181f, 0x1878, 0x187f, 0x18ab, 0x18af, 0x18f6, 0x18ff, 0x191f, 0x191f, 0x192c, 0x192f, 0x193c, 0x193f, 0x1941, 0x1943, 0x196e, 0x196f, 0x1975, 0x197f, 0x19ac, 0x19af, 0x19ca, 0x19cf, 0x19db, 0x19dd, 0x1a1c, 0x1a1d, 0x1a5f, 0x1a5f, 0x1a7d, 0x1a7e, 0x1a8a, 0x1a8f, 0x1a9a, 0x1a9f, 0x1aae, 0x1aaf, 0x1abf, 0x1aff, 0x1b4c, 0x1b4f, 0x1b7d, 0x1b7f, 0x1bf4, 0x1bfb, 0x1c38, 0x1c3a, 0x1c4a, 0x1c4c, 0x1c80, 0x1cbf, 0x1cc8, 0x1ccf, 0x1cf7, 0x1cf7, 0x1cfa, 0x1cff, 0x1df6, 0x1dfb, 0x1f16, 0x1f17, 0x1f1e, 0x1f1f, 0x1f46, 0x1f47, 0x1f4e, 0x1f4f, 0x1f58, 0x1f58, 0x1f5a, 0x1f5a, 0x1f5c, 0x1f5c, 0x1f5e, 0x1f5e, 0x1f7e, 0x1f7f, 0x1fb5, 0x1fb5, 0x1fc5, 0x1fc5, 0x1fd4, 0x1fd5, 0x1fdc, 0x1fdc, 0x1ff0, 0x1ff1, 0x1ff5, 0x1ff5, 0x1fff, 0x1fff, 0x2065, 0x2065, 0x2072, 0x2073, 0x208f, 0x208f, 0x209d, 0x209f, 0x20be, 0x20cf, 0x20f1, 0x20ff, 0x218a, 0x218f, 0x23fb, 0x23ff, 0x2427, 0x243f, 0x244b, 0x245f, 0x2b74, 0x2b75, 0x2b96, 0x2b97, 0x2bba, 0x2bbc, 0x2bc9, 0x2bc9, 0x2bd2, 0x2bff, 0x2c2f, 0x2c2f, 0x2c5f, 0x2c5f, 0x2cf4, 0x2cf8, 0x2d26, 0x2d26, 0x2d28, 0x2d2c, 0x2d2e, 0x2d2f, 0x2d68, 0x2d6e, 0x2d71, 0x2d7e, 0x2d97, 0x2d9f, 0x2da7, 0x2da7, 0x2daf, 0x2daf, 0x2db7, 0x2db7, 0x2dbf, 0x2dbf, 0x2dc7, 0x2dc7, 0x2dcf, 0x2dcf, 0x2dd7, 0x2dd7, 0x2ddf, 0x2ddf, 0x2e43, 0x2e7f, 0x2e9a, 0x2e9a, 0x2ef4, 0x2eff, 0x2fd6, 0x2fef, 0x2ffc, 0x2fff, 0x3040, 0x3040, 0x3097, 0x3098, 0x3100, 0x3104, 0x312e, 0x3130, 0x318f, 0x318f, 0x31bb, 0x31bf, 0x31e4, 0x31ef, 0x321f, 0x321f, 0x32ff, 0x32ff, 0x4db6, 0x4dbf, 0x9fcd, 0x9fff, 0xa48d, 0xa48f, 0xa4c7, 0xa4cf, 0xa62c, 0xa63f, 0xa69e, 0xa69e, 0xa6f8, 0xa6ff, 0xa78f, 0xa78f, 0xa7ae, 0xa7af, 0xa7b2, 0xa7f6, 0xa82c, 0xa82f, 0xa83a, 0xa83f, 0xa878, 0xa87f, 0xa8c5, 0xa8cd, 0xa8da, 0xa8df, 0xa8fc, 0xa8ff, 0xa954, 0xa95e, 0xa97d, 0xa97f, 0xa9ce, 0xa9ce, 0xa9da, 0xa9dd, 0xa9ff, 0xa9ff, 0xaa37, 0xaa3f, 0xaa4e, 0xaa4f, 0xaa5a, 0xaa5b, 0xaac3, 0xaada, 0xaaf7, 0xab00, 0xab07, 0xab08, 0xab0f, 0xab10, 0xab17, 0xab1f, 0xab27, 0xab27, 0xab2f, 0xab2f, 0xab60, 0xab63, 0xab66, 0xabbf, 0xabee, 0xabef, 0xabfa, 0xabff, 0xd7a4, 0xd7af, 0xd7c7, 0xd7ca, 0xd7fc, 0xd7ff, 0xfa6e, 0xfa6f, 0xfada, 0xfaff, 0xfb07, 0xfb12, 0xfb18, 0xfb1c, 0xfb37, 0xfb37, 0xfb3d, 0xfb3d, 0xfb3f, 0xfb3f, 0xfb42, 0xfb42, 0xfb45, 0xfb45, 0xfbc2, 0xfbd2, 0xfd40, 0xfd4f, 0xfd90, 0xfd91, 0xfdc8, 0xfdef, 0xfdfe, 0xfdff, 0xfe1a, 0xfe1f, 0xfe2e, 0xfe2f, 0xfe53, 0xfe53, 0xfe67, 0xfe67, 0xfe6c, 0xfe6f, 0xfe75, 0xfe75, 0xfefd, 0xfefe, 0xff00, 0xff00, 0xffbf, 0xffc1, 0xffc8, 0xffc9, 0xffd0, 0xffd1, 0xffd8, 0xffd9, 0xffdd, 0xffdf, 0xffe7, 0xffe7, 0xffef, 0xfff8, 0xfffe, 0xffff, 0x1000c, 0x1000c, 0x10027, 0x10027, 0x1003b, 0x1003b, 0x1003e, 0x1003e, 0x1004e, 0x1004f, 0x1005e, 0x1007f, 0x100fb, 0x100ff, 0x10103, 0x10106, 0x10134, 0x10136, 0x1018d, 0x1018f, 0x1019c, 0x1019f, 0x101a1, 0x101cf, 0x101fe, 0x1027f, 0x1029d, 0x1029f, 0x102d1, 0x102df, 0x102fc, 0x102ff, 0x10324, 0x1032f, 0x1034b, 0x1034f, 0x1037b, 0x1037f, 0x1039e, 0x1039e, 0x103c4, 0x103c7, 0x103d6, 0x103ff, 0x1049e, 0x1049f, 0x104aa, 0x104ff, 0x10528, 0x1052f, 0x10564, 0x1056e, 0x10570, 0x105ff, 0x10737, 0x1073f, 0x10756, 0x1075f, 0x10768, 0x107ff, 0x10806, 0x10807, 0x10809, 0x10809, 0x10836, 0x10836, 0x10839, 0x1083b, 0x1083d, 0x1083e, 0x10856, 0x10856, 0x1089f, 0x108a6, 0x108b0, 0x108ff, 0x1091c, 0x1091e, 0x1093a, 0x1093e, 0x10940, 0x1097f, 0x109b8, 0x109bd, 0x109c0, 0x109ff, 0x10a04, 0x10a04, 0x10a07, 0x10a0b, 0x10a14, 0x10a14, 0x10a18, 0x10a18, 0x10a34, 0x10a37, 0x10a3b, 0x10a3e, 0x10a48, 0x10a4f, 0x10a59, 0x10a5f, 0x10aa0, 0x10abf, 0x10ae7, 0x10aea, 0x10af7, 0x10aff, 0x10b36, 0x10b38, 0x10b56, 0x10b57, 0x10b73, 0x10b77, 0x10b92, 0x10b98, 0x10b9d, 0x10ba8, 0x10bb0, 0x10bff, 0x10c49, 0x10e5f, 0x10e7f, 0x10fff, 0x1104e, 0x11051, 0x11070, 0x1107e, 0x110c2, 0x110cf, 0x110e9, 0x110ef, 0x110fa, 0x110ff, 0x11135, 0x11135, 0x11144, 0x1114f, 0x11177, 0x1117f, 0x111c9, 0x111cc, 0x111ce, 0x111cf, 0x111db, 0x111e0, 0x111f5, 0x111ff, 0x11212, 0x11212, 0x1123e, 0x112af, 0x112eb, 0x112ef, 0x112fa, 0x11300, 0x11304, 0x11304, 0x1130d, 0x1130e, 0x11311, 0x11312, 0x11329, 0x11329, 0x11331, 0x11331, 0x11334, 0x11334, 0x1133a, 0x1133b, 0x11345, 0x11346, 0x11349, 0x1134a, 0x1134e, 0x11356, 0x11358, 0x1135c, 0x11364, 0x11365, 0x1136d, 0x1136f, 0x11375, 0x1147f, 0x114c8, 0x114cf, 0x114da, 0x1157f, 0x115b6, 0x115b7, 0x115ca, 0x115ff, 0x11645, 0x1164f, 0x1165a, 0x1167f, 0x116b8, 0x116bf, 0x116ca, 0x1189f, 0x118f3, 0x118fe, 0x11900, 0x11abf, 0x11af9, 0x11fff, 0x12399, 0x123ff, 0x1246f, 0x1246f, 0x12475, 0x12fff, 0x1342f, 0x167ff, 0x16a39, 0x16a3f, 0x16a5f, 0x16a5f, 0x16a6a, 0x16a6d, 0x16a70, 0x16acf, 0x16aee, 0x16aef, 0x16af6, 0x16aff, 0x16b46, 0x16b4f, 0x16b5a, 0x16b5a, 0x16b62, 0x16b62, 0x16b78, 0x16b7c, 0x16b90, 0x16eff, 0x16f45, 0x16f4f, 0x16f7f, 0x16f8e, 0x16fa0, 0x1afff, 0x1b002, 0x1bbff, 0x1bc6b, 0x1bc6f, 0x1bc7d, 0x1bc7f, 0x1bc89, 0x1bc8f, 0x1bc9a, 0x1bc9b, 0x1bca4, 0x1cfff, 0x1d0f6, 0x1d0ff, 0x1d127, 0x1d128, 0x1d1de, 0x1d1ff, 0x1d246, 0x1d2ff, 0x1d357, 0x1d35f, 0x1d372, 0x1d3ff, 0x1d455, 0x1d455, 0x1d49d, 0x1d49d, 0x1d4a0, 0x1d4a1, 0x1d4a3, 0x1d4a4, 0x1d4a7, 0x1d4a8, 0x1d4ad, 0x1d4ad, 0x1d4ba, 0x1d4ba, 0x1d4bc, 0x1d4bc, 0x1d4c4, 0x1d4c4, 0x1d506, 0x1d506, 0x1d50b, 0x1d50c, 0x1d515, 0x1d515, 0x1d51d, 0x1d51d, 0x1d53a, 0x1d53a, 0x1d53f, 0x1d53f, 0x1d545, 0x1d545, 0x1d547, 0x1d549, 0x1d551, 0x1d551, 0x1d6a6, 0x1d6a7, 0x1d7cc, 0x1d7cd, 0x1d800, 0x1e7ff, 0x1e8c5, 0x1e8c6, 0x1e8d7, 0x1edff, 0x1ee04, 0x1ee04, 0x1ee20, 0x1ee20, 0x1ee23, 0x1ee23, 0x1ee25, 0x1ee26, 0x1ee28, 0x1ee28, 0x1ee33, 0x1ee33, 0x1ee38, 0x1ee38, 0x1ee3a, 0x1ee3a, 0x1ee3c, 0x1ee41, 0x1ee43, 0x1ee46, 0x1ee48, 0x1ee48, 0x1ee4a, 0x1ee4a, 0x1ee4c, 0x1ee4c, 0x1ee50, 0x1ee50, 0x1ee53, 0x1ee53, 0x1ee55, 0x1ee56, 0x1ee58, 0x1ee58, 0x1ee5a, 0x1ee5a, 0x1ee5c, 0x1ee5c, 0x1ee5e, 0x1ee5e, 0x1ee60, 0x1ee60, 0x1ee63, 0x1ee63, 0x1ee65, 0x1ee66, 0x1ee6b, 0x1ee6b, 0x1ee73, 0x1ee73, 0x1ee78, 0x1ee78, 0x1ee7d, 0x1ee7d, 0x1ee7f, 0x1ee7f, 0x1ee8a, 0x1ee8a, 0x1ee9c, 0x1eea0, 0x1eea4, 0x1eea4, 0x1eeaa, 0x1eeaa, 0x1eebc, 0x1eeef, 0x1eef2, 0x1efff, 0x1f02c, 0x1f02f, 0x1f094, 0x1f09f, 0x1f0af, 0x1f0b0, 0x1f0c0, 0x1f0c0, 0x1f0d0, 0x1f0d0, 0x1f0f6, 0x1f0ff, 0x1f10d, 0x1f10f, 0x1f12f, 0x1f12f, 0x1f16c, 0x1f16f, 0x1f19b, 0x1f1e5, 0x1f203, 0x1f20f, 0x1f23b, 0x1f23f, 0x1f249, 0x1f24f, 0x1f252, 0x1f2ff, 0x1f32d, 0x1f32f, 0x1f37e, 0x1f37f, 0x1f3cf, 0x1f3d3, 0x1f3f8, 0x1f3ff, 0x1f4ff, 0x1f4ff, 0x1f54b, 0x1f54f, 0x1f57a, 0x1f57a, 0x1f5a4, 0x1f5a4, 0x1f643, 0x1f644, 0x1f6d0, 0x1f6df, 0x1f6ed, 0x1f6ef, 0x1f6f4, 0x1f6ff, 0x1f774, 0x1f77f, 0x1f7d5, 0x1f7ff, 0x1f80c, 0x1f80f, 0x1f848, 0x1f84f, 0x1f85a, 0x1f85f, 0x1f888, 0x1f88f, 0x1f8ae, 0x1ffff, 0x2a6d7, 0x2a6ff, 0x2b735, 0x2b73f, 0x2b81e, 0x2f7ff, 0x2fa1e, 0xe0000, 0xe0002, 0xe001f, 0xe0080, 0xe00ff, 0xe01f0, 0xeffff, 0xffffe, 0xfffff, 0x10fffe, 0x10ffff }; UCP_FN(Cn) static const unichar ucp_Co_def[] = { 0xe000, 0xf8ff, 0xf0000, 0xffffd, 0x100000, 0x10fffd }; UCP_FN(Co) static const unichar ucp_Cs_def[] = { 0xd800, 0xdfff }; UCP_FN(Cs) static const unichar ucp_L_def[] = { 0x41, 0x5a, 0x61, 0x7a, 0xaa, 0xaa, 0xb5, 0xb5, 0xba, 0xba, 0xc0, 0xd6, 0xd8, 0xf6, 0xf8, 0x2c1, 0x2c6, 0x2d1, 0x2e0, 0x2e4, 0x2ec, 0x2ec, 0x2ee, 0x2ee, 0x370, 0x374, 0x376, 0x377, 0x37a, 0x37d, 0x37f, 0x37f, 0x386, 0x386, 0x388, 0x38a, 0x38c, 0x38c, 0x38e, 0x3a1, 0x3a3, 0x3f5, 0x3f7, 0x481, 0x48a, 0x52f, 0x531, 0x556, 0x559, 0x559, 0x561, 0x587, 0x5d0, 0x5ea, 0x5f0, 0x5f2, 0x620, 0x64a, 0x66e, 0x66f, 0x671, 0x6d3, 0x6d5, 0x6d5, 0x6e5, 0x6e6, 0x6ee, 0x6ef, 0x6fa, 0x6fc, 0x6ff, 0x6ff, 0x710, 0x710, 0x712, 0x72f, 0x74d, 0x7a5, 0x7b1, 0x7b1, 0x7ca, 0x7ea, 0x7f4, 0x7f5, 0x7fa, 0x7fa, 0x800, 0x815, 0x81a, 0x81a, 0x824, 0x824, 0x828, 0x828, 0x840, 0x858, 0x8a0, 0x8b2, 0x904, 0x939, 0x93d, 0x93d, 0x950, 0x950, 0x958, 0x961, 0x971, 0x980, 0x985, 0x98c, 0x98f, 0x990, 0x993, 0x9a8, 0x9aa, 0x9b0, 0x9b2, 0x9b2, 0x9b6, 0x9b9, 0x9bd, 0x9bd, 0x9ce, 0x9ce, 0x9dc, 0x9dd, 0x9df, 0x9e1, 0x9f0, 0x9f1, 0xa05, 0xa0a, 0xa0f, 0xa10, 0xa13, 0xa28, 0xa2a, 0xa30, 0xa32, 0xa33, 0xa35, 0xa36, 0xa38, 0xa39, 0xa59, 0xa5c, 0xa5e, 0xa5e, 0xa72, 0xa74, 0xa85, 0xa8d, 0xa8f, 0xa91, 0xa93, 0xaa8, 0xaaa, 0xab0, 0xab2, 0xab3, 0xab5, 0xab9, 0xabd, 0xabd, 0xad0, 0xad0, 0xae0, 0xae1, 0xb05, 0xb0c, 0xb0f, 0xb10, 0xb13, 0xb28, 0xb2a, 0xb30, 0xb32, 0xb33, 0xb35, 0xb39, 0xb3d, 0xb3d, 0xb5c, 0xb5d, 0xb5f, 0xb61, 0xb71, 0xb71, 0xb83, 0xb83, 0xb85, 0xb8a, 0xb8e, 0xb90, 0xb92, 0xb95, 0xb99, 0xb9a, 0xb9c, 0xb9c, 0xb9e, 0xb9f, 0xba3, 0xba4, 0xba8, 0xbaa, 0xbae, 0xbb9, 0xbd0, 0xbd0, 0xc05, 0xc0c, 0xc0e, 0xc10, 0xc12, 0xc28, 0xc2a, 0xc39, 0xc3d, 0xc3d, 0xc58, 0xc59, 0xc60, 0xc61, 0xc85, 0xc8c, 0xc8e, 0xc90, 0xc92, 0xca8, 0xcaa, 0xcb3, 0xcb5, 0xcb9, 0xcbd, 0xcbd, 0xcde, 0xcde, 0xce0, 0xce1, 0xcf1, 0xcf2, 0xd05, 0xd0c, 0xd0e, 0xd10, 0xd12, 0xd3a, 0xd3d, 0xd3d, 0xd4e, 0xd4e, 0xd60, 0xd61, 0xd7a, 0xd7f, 0xd85, 0xd96, 0xd9a, 0xdb1, 0xdb3, 0xdbb, 0xdbd, 0xdbd, 0xdc0, 0xdc6, 0xe01, 0xe30, 0xe32, 0xe33, 0xe40, 0xe46, 0xe81, 0xe82, 0xe84, 0xe84, 0xe87, 0xe88, 0xe8a, 0xe8a, 0xe8d, 0xe8d, 0xe94, 0xe97, 0xe99, 0xe9f, 0xea1, 0xea3, 0xea5, 0xea5, 0xea7, 0xea7, 0xeaa, 0xeab, 0xead, 0xeb0, 0xeb2, 0xeb3, 0xebd, 0xebd, 0xec0, 0xec4, 0xec6, 0xec6, 0xedc, 0xedf, 0xf00, 0xf00, 0xf40, 0xf47, 0xf49, 0xf6c, 0xf88, 0xf8c, 0x1000, 0x102a, 0x103f, 0x103f, 0x1050, 0x1055, 0x105a, 0x105d, 0x1061, 0x1061, 0x1065, 0x1066, 0x106e, 0x1070, 0x1075, 0x1081, 0x108e, 0x108e, 0x10a0, 0x10c5, 0x10c7, 0x10c7, 0x10cd, 0x10cd, 0x10d0, 0x10fa, 0x10fc, 0x1248, 0x124a, 0x124d, 0x1250, 0x1256, 0x1258, 0x1258, 0x125a, 0x125d, 0x1260, 0x1288, 0x128a, 0x128d, 0x1290, 0x12b0, 0x12b2, 0x12b5, 0x12b8, 0x12be, 0x12c0, 0x12c0, 0x12c2, 0x12c5, 0x12c8, 0x12d6, 0x12d8, 0x1310, 0x1312, 0x1315, 0x1318, 0x135a, 0x1380, 0x138f, 0x13a0, 0x13f4, 0x1401, 0x166c, 0x166f, 0x167f, 0x1681, 0x169a, 0x16a0, 0x16ea, 0x16f1, 0x16f8, 0x1700, 0x170c, 0x170e, 0x1711, 0x1720, 0x1731, 0x1740, 0x1751, 0x1760, 0x176c, 0x176e, 0x1770, 0x1780, 0x17b3, 0x17d7, 0x17d7, 0x17dc, 0x17dc, 0x1820, 0x1877, 0x1880, 0x18a8, 0x18aa, 0x18aa, 0x18b0, 0x18f5, 0x1900, 0x191e, 0x1950, 0x196d, 0x1970, 0x1974, 0x1980, 0x19ab, 0x19c1, 0x19c7, 0x1a00, 0x1a16, 0x1a20, 0x1a54, 0x1aa7, 0x1aa7, 0x1b05, 0x1b33, 0x1b45, 0x1b4b, 0x1b83, 0x1ba0, 0x1bae, 0x1baf, 0x1bba, 0x1be5, 0x1c00, 0x1c23, 0x1c4d, 0x1c4f, 0x1c5a, 0x1c7d, 0x1ce9, 0x1cec, 0x1cee, 0x1cf1, 0x1cf5, 0x1cf6, 0x1d00, 0x1dbf, 0x1e00, 0x1f15, 0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f57, 0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f7d, 0x1f80, 0x1fb4, 0x1fb6, 0x1fbc, 0x1fbe, 0x1fbe, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fcc, 0x1fd0, 0x1fd3, 0x1fd6, 0x1fdb, 0x1fe0, 0x1fec, 0x1ff2, 0x1ff4, 0x1ff6, 0x1ffc, 0x2071, 0x2071, 0x207f, 0x207f, 0x2090, 0x209c, 0x2102, 0x2102, 0x2107, 0x2107, 0x210a, 0x2113, 0x2115, 0x2115, 0x2119, 0x211d, 0x2124, 0x2124, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212d, 0x212f, 0x2139, 0x213c, 0x213f, 0x2145, 0x2149, 0x214e, 0x214e, 0x2183, 0x2184, 0x2c00, 0x2c2e, 0x2c30, 0x2c5e, 0x2c60, 0x2ce4, 0x2ceb, 0x2cee, 0x2cf2, 0x2cf3, 0x2d00, 0x2d25, 0x2d27, 0x2d27, 0x2d2d, 0x2d2d, 0x2d30, 0x2d67, 0x2d6f, 0x2d6f, 0x2d80, 0x2d96, 0x2da0, 0x2da6, 0x2da8, 0x2dae, 0x2db0, 0x2db6, 0x2db8, 0x2dbe, 0x2dc0, 0x2dc6, 0x2dc8, 0x2dce, 0x2dd0, 0x2dd6, 0x2dd8, 0x2dde, 0x2e2f, 0x2e2f, 0x3005, 0x3006, 0x3031, 0x3035, 0x303b, 0x303c, 0x3041, 0x3096, 0x309d, 0x309f, 0x30a1, 0x30fa, 0x30fc, 0x30ff, 0x3105, 0x312d, 0x3131, 0x318e, 0x31a0, 0x31ba, 0x31f0, 0x31ff, 0x3400, 0x4db5, 0x4e00, 0x9fcc, 0xa000, 0xa48c, 0xa4d0, 0xa4fd, 0xa500, 0xa60c, 0xa610, 0xa61f, 0xa62a, 0xa62b, 0xa640, 0xa66e, 0xa67f, 0xa69d, 0xa6a0, 0xa6e5, 0xa717, 0xa71f, 0xa722, 0xa788, 0xa78b, 0xa78e, 0xa790, 0xa7ad, 0xa7b0, 0xa7b1, 0xa7f7, 0xa801, 0xa803, 0xa805, 0xa807, 0xa80a, 0xa80c, 0xa822, 0xa840, 0xa873, 0xa882, 0xa8b3, 0xa8f2, 0xa8f7, 0xa8fb, 0xa8fb, 0xa90a, 0xa925, 0xa930, 0xa946, 0xa960, 0xa97c, 0xa984, 0xa9b2, 0xa9cf, 0xa9cf, 0xa9e0, 0xa9e4, 0xa9e6, 0xa9ef, 0xa9fa, 0xa9fe, 0xaa00, 0xaa28, 0xaa40, 0xaa42, 0xaa44, 0xaa4b, 0xaa60, 0xaa76, 0xaa7a, 0xaa7a, 0xaa7e, 0xaaaf, 0xaab1, 0xaab1, 0xaab5, 0xaab6, 0xaab9, 0xaabd, 0xaac0, 0xaac0, 0xaac2, 0xaac2, 0xaadb, 0xaadd, 0xaae0, 0xaaea, 0xaaf2, 0xaaf4, 0xab01, 0xab06, 0xab09, 0xab0e, 0xab11, 0xab16, 0xab20, 0xab26, 0xab28, 0xab2e, 0xab30, 0xab5a, 0xab5c, 0xab5f, 0xab64, 0xab65, 0xabc0, 0xabe2, 0xac00, 0xd7a3, 0xd7b0, 0xd7c6, 0xd7cb, 0xd7fb, 0xf900, 0xfa6d, 0xfa70, 0xfad9, 0xfb00, 0xfb06, 0xfb13, 0xfb17, 0xfb1d, 0xfb1d, 0xfb1f, 0xfb28, 0xfb2a, 0xfb36, 0xfb38, 0xfb3c, 0xfb3e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfb46, 0xfbb1, 0xfbd3, 0xfd3d, 0xfd50, 0xfd8f, 0xfd92, 0xfdc7, 0xfdf0, 0xfdfb, 0xfe70, 0xfe74, 0xfe76, 0xfefc, 0xff21, 0xff3a, 0xff41, 0xff5a, 0xff66, 0xffbe, 0xffc2, 0xffc7, 0xffca, 0xffcf, 0xffd2, 0xffd7, 0xffda, 0xffdc, 0x10000, 0x1000b, 0x1000d, 0x10026, 0x10028, 0x1003a, 0x1003c, 0x1003d, 0x1003f, 0x1004d, 0x10050, 0x1005d, 0x10080, 0x100fa, 0x10280, 0x1029c, 0x102a0, 0x102d0, 0x10300, 0x1031f, 0x10330, 0x10340, 0x10342, 0x10349, 0x10350, 0x10375, 0x10380, 0x1039d, 0x103a0, 0x103c3, 0x103c8, 0x103cf, 0x10400, 0x1049d, 0x10500, 0x10527, 0x10530, 0x10563, 0x10600, 0x10736, 0x10740, 0x10755, 0x10760, 0x10767, 0x10800, 0x10805, 0x10808, 0x10808, 0x1080a, 0x10835, 0x10837, 0x10838, 0x1083c, 0x1083c, 0x1083f, 0x10855, 0x10860, 0x10876, 0x10880, 0x1089e, 0x10900, 0x10915, 0x10920, 0x10939, 0x10980, 0x109b7, 0x109be, 0x109bf, 0x10a00, 0x10a00, 0x10a10, 0x10a13, 0x10a15, 0x10a17, 0x10a19, 0x10a33, 0x10a60, 0x10a7c, 0x10a80, 0x10a9c, 0x10ac0, 0x10ac7, 0x10ac9, 0x10ae4, 0x10b00, 0x10b35, 0x10b40, 0x10b55, 0x10b60, 0x10b72, 0x10b80, 0x10b91, 0x10c00, 0x10c48, 0x11003, 0x11037, 0x11083, 0x110af, 0x110d0, 0x110e8, 0x11103, 0x11126, 0x11150, 0x11172, 0x11176, 0x11176, 0x11183, 0x111b2, 0x111c1, 0x111c4, 0x111da, 0x111da, 0x11200, 0x11211, 0x11213, 0x1122b, 0x112b0, 0x112de, 0x11305, 0x1130c, 0x1130f, 0x11310, 0x11313, 0x11328, 0x1132a, 0x11330, 0x11332, 0x11333, 0x11335, 0x11339, 0x1133d, 0x1133d, 0x1135d, 0x11361, 0x11480, 0x114af, 0x114c4, 0x114c5, 0x114c7, 0x114c7, 0x11580, 0x115ae, 0x11600, 0x1162f, 0x11644, 0x11644, 0x11680, 0x116aa, 0x118a0, 0x118df, 0x118ff, 0x118ff, 0x11ac0, 0x11af8, 0x12000, 0x12398, 0x13000, 0x1342e, 0x16800, 0x16a38, 0x16a40, 0x16a5e, 0x16ad0, 0x16aed, 0x16b00, 0x16b2f, 0x16b40, 0x16b43, 0x16b63, 0x16b77, 0x16b7d, 0x16b8f, 0x16f00, 0x16f44, 0x16f50, 0x16f50, 0x16f93, 0x16f9f, 0x1b000, 0x1b001, 0x1bc00, 0x1bc6a, 0x1bc70, 0x1bc7c, 0x1bc80, 0x1bc88, 0x1bc90, 0x1bc99, 0x1d400, 0x1d454, 0x1d456, 0x1d49c, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4a9, 0x1d4ac, 0x1d4ae, 0x1d4b9, 0x1d4bb, 0x1d4bb, 0x1d4bd, 0x1d4c3, 0x1d4c5, 0x1d505, 0x1d507, 0x1d50a, 0x1d50d, 0x1d514, 0x1d516, 0x1d51c, 0x1d51e, 0x1d539, 0x1d53b, 0x1d53e, 0x1d540, 0x1d544, 0x1d546, 0x1d546, 0x1d54a, 0x1d550, 0x1d552, 0x1d6a5, 0x1d6a8, 0x1d6c0, 0x1d6c2, 0x1d6da, 0x1d6dc, 0x1d6fa, 0x1d6fc, 0x1d714, 0x1d716, 0x1d734, 0x1d736, 0x1d74e, 0x1d750, 0x1d76e, 0x1d770, 0x1d788, 0x1d78a, 0x1d7a8, 0x1d7aa, 0x1d7c2, 0x1d7c4, 0x1d7cb, 0x1e800, 0x1e8c4, 0x1ee00, 0x1ee03, 0x1ee05, 0x1ee1f, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee24, 0x1ee27, 0x1ee27, 0x1ee29, 0x1ee32, 0x1ee34, 0x1ee37, 0x1ee39, 0x1ee39, 0x1ee3b, 0x1ee3b, 0x1ee42, 0x1ee42, 0x1ee47, 0x1ee47, 0x1ee49, 0x1ee49, 0x1ee4b, 0x1ee4b, 0x1ee4d, 0x1ee4f, 0x1ee51, 0x1ee52, 0x1ee54, 0x1ee54, 0x1ee57, 0x1ee57, 0x1ee59, 0x1ee59, 0x1ee5b, 0x1ee5b, 0x1ee5d, 0x1ee5d, 0x1ee5f, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee64, 0x1ee67, 0x1ee6a, 0x1ee6c, 0x1ee72, 0x1ee74, 0x1ee77, 0x1ee79, 0x1ee7c, 0x1ee7e, 0x1ee7e, 0x1ee80, 0x1ee89, 0x1ee8b, 0x1ee9b, 0x1eea1, 0x1eea3, 0x1eea5, 0x1eea9, 0x1eeab, 0x1eebb, 0x20000, 0x2a6d6, 0x2a700, 0x2b734, 0x2b740, 0x2b81d, 0x2f800, 0x2fa1d }; UCP_FN(L) static const unichar ucp_L_and_def[] = { 0x41, 0x5a, 0x61, 0x7a, 0xb5, 0xb5, 0xc0, 0xd6, 0xd8, 0xf6, 0xf8, 0x1ba, 0x1bc, 0x1bf, 0x1c4, 0x293, 0x295, 0x2af, 0x370, 0x373, 0x376, 0x377, 0x37b, 0x37d, 0x37f, 0x37f, 0x386, 0x386, 0x388, 0x38a, 0x38c, 0x38c, 0x38e, 0x3a1, 0x3a3, 0x3f5, 0x3f7, 0x481, 0x48a, 0x52f, 0x531, 0x556, 0x561, 0x587, 0x10a0, 0x10c5, 0x10c7, 0x10c7, 0x10cd, 0x10cd, 0x1d00, 0x1d2b, 0x1d6b, 0x1d77, 0x1d79, 0x1d9a, 0x1e00, 0x1f15, 0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f57, 0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f7d, 0x1f80, 0x1fb4, 0x1fb6, 0x1fbc, 0x1fbe, 0x1fbe, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fcc, 0x1fd0, 0x1fd3, 0x1fd6, 0x1fdb, 0x1fe0, 0x1fec, 0x1ff2, 0x1ff4, 0x1ff6, 0x1ffc, 0x2102, 0x2102, 0x2107, 0x2107, 0x210a, 0x2113, 0x2115, 0x2115, 0x2119, 0x211d, 0x2124, 0x2124, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212d, 0x212f, 0x2134, 0x2139, 0x2139, 0x213c, 0x213f, 0x2145, 0x2149, 0x214e, 0x214e, 0x2183, 0x2184, 0x2c00, 0x2c2e, 0x2c30, 0x2c5e, 0x2c60, 0x2c7b, 0x2c7e, 0x2ce4, 0x2ceb, 0x2cee, 0x2cf2, 0x2cf3, 0x2d00, 0x2d25, 0x2d27, 0x2d27, 0x2d2d, 0x2d2d, 0xa640, 0xa66d, 0xa680, 0xa69b, 0xa722, 0xa76f, 0xa771, 0xa787, 0xa78b, 0xa78e, 0xa790, 0xa7ad, 0xa7b0, 0xa7b1, 0xa7fa, 0xa7fa, 0xab30, 0xab5a, 0xab64, 0xab65, 0xfb00, 0xfb06, 0xfb13, 0xfb17, 0xff21, 0xff3a, 0xff41, 0xff5a, 0x10400, 0x1044f, 0x118a0, 0x118df, 0x1d400, 0x1d454, 0x1d456, 0x1d49c, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4a9, 0x1d4ac, 0x1d4ae, 0x1d4b9, 0x1d4bb, 0x1d4bb, 0x1d4bd, 0x1d4c3, 0x1d4c5, 0x1d505, 0x1d507, 0x1d50a, 0x1d50d, 0x1d514, 0x1d516, 0x1d51c, 0x1d51e, 0x1d539, 0x1d53b, 0x1d53e, 0x1d540, 0x1d544, 0x1d546, 0x1d546, 0x1d54a, 0x1d550, 0x1d552, 0x1d6a5, 0x1d6a8, 0x1d6c0, 0x1d6c2, 0x1d6da, 0x1d6dc, 0x1d6fa, 0x1d6fc, 0x1d714, 0x1d716, 0x1d734, 0x1d736, 0x1d74e, 0x1d750, 0x1d76e, 0x1d770, 0x1d788, 0x1d78a, 0x1d7a8, 0x1d7aa, 0x1d7c2, 0x1d7c4, 0x1d7cb }; UCP_FN(L_and) static const unichar ucp_Ll_def[] = { 0x61, 0x7a, 0xb5, 0xb5, 0xdf, 0xf6, 0xf8, 0xff, 0x101, 0x101, 0x103, 0x103, 0x105, 0x105, 0x107, 0x107, 0x109, 0x109, 0x10b, 0x10b, 0x10d, 0x10d, 0x10f, 0x10f, 0x111, 0x111, 0x113, 0x113, 0x115, 0x115, 0x117, 0x117, 0x119, 0x119, 0x11b, 0x11b, 0x11d, 0x11d, 0x11f, 0x11f, 0x121, 0x121, 0x123, 0x123, 0x125, 0x125, 0x127, 0x127, 0x129, 0x129, 0x12b, 0x12b, 0x12d, 0x12d, 0x12f, 0x12f, 0x131, 0x131, 0x133, 0x133, 0x135, 0x135, 0x137, 0x138, 0x13a, 0x13a, 0x13c, 0x13c, 0x13e, 0x13e, 0x140, 0x140, 0x142, 0x142, 0x144, 0x144, 0x146, 0x146, 0x148, 0x149, 0x14b, 0x14b, 0x14d, 0x14d, 0x14f, 0x14f, 0x151, 0x151, 0x153, 0x153, 0x155, 0x155, 0x157, 0x157, 0x159, 0x159, 0x15b, 0x15b, 0x15d, 0x15d, 0x15f, 0x15f, 0x161, 0x161, 0x163, 0x163, 0x165, 0x165, 0x167, 0x167, 0x169, 0x169, 0x16b, 0x16b, 0x16d, 0x16d, 0x16f, 0x16f, 0x171, 0x171, 0x173, 0x173, 0x175, 0x175, 0x177, 0x177, 0x17a, 0x17a, 0x17c, 0x17c, 0x17e, 0x180, 0x183, 0x183, 0x185, 0x185, 0x188, 0x188, 0x18c, 0x18d, 0x192, 0x192, 0x195, 0x195, 0x199, 0x19b, 0x19e, 0x19e, 0x1a1, 0x1a1, 0x1a3, 0x1a3, 0x1a5, 0x1a5, 0x1a8, 0x1a8, 0x1aa, 0x1ab, 0x1ad, 0x1ad, 0x1b0, 0x1b0, 0x1b4, 0x1b4, 0x1b6, 0x1b6, 0x1b9, 0x1ba, 0x1bd, 0x1bf, 0x1c6, 0x1c6, 0x1c9, 0x1c9, 0x1cc, 0x1cc, 0x1ce, 0x1ce, 0x1d0, 0x1d0, 0x1d2, 0x1d2, 0x1d4, 0x1d4, 0x1d6, 0x1d6, 0x1d8, 0x1d8, 0x1da, 0x1da, 0x1dc, 0x1dd, 0x1df, 0x1df, 0x1e1, 0x1e1, 0x1e3, 0x1e3, 0x1e5, 0x1e5, 0x1e7, 0x1e7, 0x1e9, 0x1e9, 0x1eb, 0x1eb, 0x1ed, 0x1ed, 0x1ef, 0x1f0, 0x1f3, 0x1f3, 0x1f5, 0x1f5, 0x1f9, 0x1f9, 0x1fb, 0x1fb, 0x1fd, 0x1fd, 0x1ff, 0x1ff, 0x201, 0x201, 0x203, 0x203, 0x205, 0x205, 0x207, 0x207, 0x209, 0x209, 0x20b, 0x20b, 0x20d, 0x20d, 0x20f, 0x20f, 0x211, 0x211, 0x213, 0x213, 0x215, 0x215, 0x217, 0x217, 0x219, 0x219, 0x21b, 0x21b, 0x21d, 0x21d, 0x21f, 0x21f, 0x221, 0x221, 0x223, 0x223, 0x225, 0x225, 0x227, 0x227, 0x229, 0x229, 0x22b, 0x22b, 0x22d, 0x22d, 0x22f, 0x22f, 0x231, 0x231, 0x233, 0x239, 0x23c, 0x23c, 0x23f, 0x240, 0x242, 0x242, 0x247, 0x247, 0x249, 0x249, 0x24b, 0x24b, 0x24d, 0x24d, 0x24f, 0x293, 0x295, 0x2af, 0x371, 0x371, 0x373, 0x373, 0x377, 0x377, 0x37b, 0x37d, 0x390, 0x390, 0x3ac, 0x3ce, 0x3d0, 0x3d1, 0x3d5, 0x3d7, 0x3d9, 0x3d9, 0x3db, 0x3db, 0x3dd, 0x3dd, 0x3df, 0x3df, 0x3e1, 0x3e1, 0x3e3, 0x3e3, 0x3e5, 0x3e5, 0x3e7, 0x3e7, 0x3e9, 0x3e9, 0x3eb, 0x3eb, 0x3ed, 0x3ed, 0x3ef, 0x3f3, 0x3f5, 0x3f5, 0x3f8, 0x3f8, 0x3fb, 0x3fc, 0x430, 0x45f, 0x461, 0x461, 0x463, 0x463, 0x465, 0x465, 0x467, 0x467, 0x469, 0x469, 0x46b, 0x46b, 0x46d, 0x46d, 0x46f, 0x46f, 0x471, 0x471, 0x473, 0x473, 0x475, 0x475, 0x477, 0x477, 0x479, 0x479, 0x47b, 0x47b, 0x47d, 0x47d, 0x47f, 0x47f, 0x481, 0x481, 0x48b, 0x48b, 0x48d, 0x48d, 0x48f, 0x48f, 0x491, 0x491, 0x493, 0x493, 0x495, 0x495, 0x497, 0x497, 0x499, 0x499, 0x49b, 0x49b, 0x49d, 0x49d, 0x49f, 0x49f, 0x4a1, 0x4a1, 0x4a3, 0x4a3, 0x4a5, 0x4a5, 0x4a7, 0x4a7, 0x4a9, 0x4a9, 0x4ab, 0x4ab, 0x4ad, 0x4ad, 0x4af, 0x4af, 0x4b1, 0x4b1, 0x4b3, 0x4b3, 0x4b5, 0x4b5, 0x4b7, 0x4b7, 0x4b9, 0x4b9, 0x4bb, 0x4bb, 0x4bd, 0x4bd, 0x4bf, 0x4bf, 0x4c2, 0x4c2, 0x4c4, 0x4c4, 0x4c6, 0x4c6, 0x4c8, 0x4c8, 0x4ca, 0x4ca, 0x4cc, 0x4cc, 0x4ce, 0x4cf, 0x4d1, 0x4d1, 0x4d3, 0x4d3, 0x4d5, 0x4d5, 0x4d7, 0x4d7, 0x4d9, 0x4d9, 0x4db, 0x4db, 0x4dd, 0x4dd, 0x4df, 0x4df, 0x4e1, 0x4e1, 0x4e3, 0x4e3, 0x4e5, 0x4e5, 0x4e7, 0x4e7, 0x4e9, 0x4e9, 0x4eb, 0x4eb, 0x4ed, 0x4ed, 0x4ef, 0x4ef, 0x4f1, 0x4f1, 0x4f3, 0x4f3, 0x4f5, 0x4f5, 0x4f7, 0x4f7, 0x4f9, 0x4f9, 0x4fb, 0x4fb, 0x4fd, 0x4fd, 0x4ff, 0x4ff, 0x501, 0x501, 0x503, 0x503, 0x505, 0x505, 0x507, 0x507, 0x509, 0x509, 0x50b, 0x50b, 0x50d, 0x50d, 0x50f, 0x50f, 0x511, 0x511, 0x513, 0x513, 0x515, 0x515, 0x517, 0x517, 0x519, 0x519, 0x51b, 0x51b, 0x51d, 0x51d, 0x51f, 0x51f, 0x521, 0x521, 0x523, 0x523, 0x525, 0x525, 0x527, 0x527, 0x529, 0x529, 0x52b, 0x52b, 0x52d, 0x52d, 0x52f, 0x52f, 0x561, 0x587, 0x1d00, 0x1d2b, 0x1d6b, 0x1d77, 0x1d79, 0x1d9a, 0x1e01, 0x1e01, 0x1e03, 0x1e03, 0x1e05, 0x1e05, 0x1e07, 0x1e07, 0x1e09, 0x1e09, 0x1e0b, 0x1e0b, 0x1e0d, 0x1e0d, 0x1e0f, 0x1e0f, 0x1e11, 0x1e11, 0x1e13, 0x1e13, 0x1e15, 0x1e15, 0x1e17, 0x1e17, 0x1e19, 0x1e19, 0x1e1b, 0x1e1b, 0x1e1d, 0x1e1d, 0x1e1f, 0x1e1f, 0x1e21, 0x1e21, 0x1e23, 0x1e23, 0x1e25, 0x1e25, 0x1e27, 0x1e27, 0x1e29, 0x1e29, 0x1e2b, 0x1e2b, 0x1e2d, 0x1e2d, 0x1e2f, 0x1e2f, 0x1e31, 0x1e31, 0x1e33, 0x1e33, 0x1e35, 0x1e35, 0x1e37, 0x1e37, 0x1e39, 0x1e39, 0x1e3b, 0x1e3b, 0x1e3d, 0x1e3d, 0x1e3f, 0x1e3f, 0x1e41, 0x1e41, 0x1e43, 0x1e43, 0x1e45, 0x1e45, 0x1e47, 0x1e47, 0x1e49, 0x1e49, 0x1e4b, 0x1e4b, 0x1e4d, 0x1e4d, 0x1e4f, 0x1e4f, 0x1e51, 0x1e51, 0x1e53, 0x1e53, 0x1e55, 0x1e55, 0x1e57, 0x1e57, 0x1e59, 0x1e59, 0x1e5b, 0x1e5b, 0x1e5d, 0x1e5d, 0x1e5f, 0x1e5f, 0x1e61, 0x1e61, 0x1e63, 0x1e63, 0x1e65, 0x1e65, 0x1e67, 0x1e67, 0x1e69, 0x1e69, 0x1e6b, 0x1e6b, 0x1e6d, 0x1e6d, 0x1e6f, 0x1e6f, 0x1e71, 0x1e71, 0x1e73, 0x1e73, 0x1e75, 0x1e75, 0x1e77, 0x1e77, 0x1e79, 0x1e79, 0x1e7b, 0x1e7b, 0x1e7d, 0x1e7d, 0x1e7f, 0x1e7f, 0x1e81, 0x1e81, 0x1e83, 0x1e83, 0x1e85, 0x1e85, 0x1e87, 0x1e87, 0x1e89, 0x1e89, 0x1e8b, 0x1e8b, 0x1e8d, 0x1e8d, 0x1e8f, 0x1e8f, 0x1e91, 0x1e91, 0x1e93, 0x1e93, 0x1e95, 0x1e9d, 0x1e9f, 0x1e9f, 0x1ea1, 0x1ea1, 0x1ea3, 0x1ea3, 0x1ea5, 0x1ea5, 0x1ea7, 0x1ea7, 0x1ea9, 0x1ea9, 0x1eab, 0x1eab, 0x1ead, 0x1ead, 0x1eaf, 0x1eaf, 0x1eb1, 0x1eb1, 0x1eb3, 0x1eb3, 0x1eb5, 0x1eb5, 0x1eb7, 0x1eb7, 0x1eb9, 0x1eb9, 0x1ebb, 0x1ebb, 0x1ebd, 0x1ebd, 0x1ebf, 0x1ebf, 0x1ec1, 0x1ec1, 0x1ec3, 0x1ec3, 0x1ec5, 0x1ec5, 0x1ec7, 0x1ec7, 0x1ec9, 0x1ec9, 0x1ecb, 0x1ecb, 0x1ecd, 0x1ecd, 0x1ecf, 0x1ecf, 0x1ed1, 0x1ed1, 0x1ed3, 0x1ed3, 0x1ed5, 0x1ed5, 0x1ed7, 0x1ed7, 0x1ed9, 0x1ed9, 0x1edb, 0x1edb, 0x1edd, 0x1edd, 0x1edf, 0x1edf, 0x1ee1, 0x1ee1, 0x1ee3, 0x1ee3, 0x1ee5, 0x1ee5, 0x1ee7, 0x1ee7, 0x1ee9, 0x1ee9, 0x1eeb, 0x1eeb, 0x1eed, 0x1eed, 0x1eef, 0x1eef, 0x1ef1, 0x1ef1, 0x1ef3, 0x1ef3, 0x1ef5, 0x1ef5, 0x1ef7, 0x1ef7, 0x1ef9, 0x1ef9, 0x1efb, 0x1efb, 0x1efd, 0x1efd, 0x1eff, 0x1f07, 0x1f10, 0x1f15, 0x1f20, 0x1f27, 0x1f30, 0x1f37, 0x1f40, 0x1f45, 0x1f50, 0x1f57, 0x1f60, 0x1f67, 0x1f70, 0x1f7d, 0x1f80, 0x1f87, 0x1f90, 0x1f97, 0x1fa0, 0x1fa7, 0x1fb0, 0x1fb4, 0x1fb6, 0x1fb7, 0x1fbe, 0x1fbe, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fc7, 0x1fd0, 0x1fd3, 0x1fd6, 0x1fd7, 0x1fe0, 0x1fe7, 0x1ff2, 0x1ff4, 0x1ff6, 0x1ff7, 0x210a, 0x210a, 0x210e, 0x210f, 0x2113, 0x2113, 0x212f, 0x212f, 0x2134, 0x2134, 0x2139, 0x2139, 0x213c, 0x213d, 0x2146, 0x2149, 0x214e, 0x214e, 0x2184, 0x2184, 0x2c30, 0x2c5e, 0x2c61, 0x2c61, 0x2c65, 0x2c66, 0x2c68, 0x2c68, 0x2c6a, 0x2c6a, 0x2c6c, 0x2c6c, 0x2c71, 0x2c71, 0x2c73, 0x2c74, 0x2c76, 0x2c7b, 0x2c81, 0x2c81, 0x2c83, 0x2c83, 0x2c85, 0x2c85, 0x2c87, 0x2c87, 0x2c89, 0x2c89, 0x2c8b, 0x2c8b, 0x2c8d, 0x2c8d, 0x2c8f, 0x2c8f, 0x2c91, 0x2c91, 0x2c93, 0x2c93, 0x2c95, 0x2c95, 0x2c97, 0x2c97, 0x2c99, 0x2c99, 0x2c9b, 0x2c9b, 0x2c9d, 0x2c9d, 0x2c9f, 0x2c9f, 0x2ca1, 0x2ca1, 0x2ca3, 0x2ca3, 0x2ca5, 0x2ca5, 0x2ca7, 0x2ca7, 0x2ca9, 0x2ca9, 0x2cab, 0x2cab, 0x2cad, 0x2cad, 0x2caf, 0x2caf, 0x2cb1, 0x2cb1, 0x2cb3, 0x2cb3, 0x2cb5, 0x2cb5, 0x2cb7, 0x2cb7, 0x2cb9, 0x2cb9, 0x2cbb, 0x2cbb, 0x2cbd, 0x2cbd, 0x2cbf, 0x2cbf, 0x2cc1, 0x2cc1, 0x2cc3, 0x2cc3, 0x2cc5, 0x2cc5, 0x2cc7, 0x2cc7, 0x2cc9, 0x2cc9, 0x2ccb, 0x2ccb, 0x2ccd, 0x2ccd, 0x2ccf, 0x2ccf, 0x2cd1, 0x2cd1, 0x2cd3, 0x2cd3, 0x2cd5, 0x2cd5, 0x2cd7, 0x2cd7, 0x2cd9, 0x2cd9, 0x2cdb, 0x2cdb, 0x2cdd, 0x2cdd, 0x2cdf, 0x2cdf, 0x2ce1, 0x2ce1, 0x2ce3, 0x2ce4, 0x2cec, 0x2cec, 0x2cee, 0x2cee, 0x2cf3, 0x2cf3, 0x2d00, 0x2d25, 0x2d27, 0x2d27, 0x2d2d, 0x2d2d, 0xa641, 0xa641, 0xa643, 0xa643, 0xa645, 0xa645, 0xa647, 0xa647, 0xa649, 0xa649, 0xa64b, 0xa64b, 0xa64d, 0xa64d, 0xa64f, 0xa64f, 0xa651, 0xa651, 0xa653, 0xa653, 0xa655, 0xa655, 0xa657, 0xa657, 0xa659, 0xa659, 0xa65b, 0xa65b, 0xa65d, 0xa65d, 0xa65f, 0xa65f, 0xa661, 0xa661, 0xa663, 0xa663, 0xa665, 0xa665, 0xa667, 0xa667, 0xa669, 0xa669, 0xa66b, 0xa66b, 0xa66d, 0xa66d, 0xa681, 0xa681, 0xa683, 0xa683, 0xa685, 0xa685, 0xa687, 0xa687, 0xa689, 0xa689, 0xa68b, 0xa68b, 0xa68d, 0xa68d, 0xa68f, 0xa68f, 0xa691, 0xa691, 0xa693, 0xa693, 0xa695, 0xa695, 0xa697, 0xa697, 0xa699, 0xa699, 0xa69b, 0xa69b, 0xa723, 0xa723, 0xa725, 0xa725, 0xa727, 0xa727, 0xa729, 0xa729, 0xa72b, 0xa72b, 0xa72d, 0xa72d, 0xa72f, 0xa731, 0xa733, 0xa733, 0xa735, 0xa735, 0xa737, 0xa737, 0xa739, 0xa739, 0xa73b, 0xa73b, 0xa73d, 0xa73d, 0xa73f, 0xa73f, 0xa741, 0xa741, 0xa743, 0xa743, 0xa745, 0xa745, 0xa747, 0xa747, 0xa749, 0xa749, 0xa74b, 0xa74b, 0xa74d, 0xa74d, 0xa74f, 0xa74f, 0xa751, 0xa751, 0xa753, 0xa753, 0xa755, 0xa755, 0xa757, 0xa757, 0xa759, 0xa759, 0xa75b, 0xa75b, 0xa75d, 0xa75d, 0xa75f, 0xa75f, 0xa761, 0xa761, 0xa763, 0xa763, 0xa765, 0xa765, 0xa767, 0xa767, 0xa769, 0xa769, 0xa76b, 0xa76b, 0xa76d, 0xa76d, 0xa76f, 0xa76f, 0xa771, 0xa778, 0xa77a, 0xa77a, 0xa77c, 0xa77c, 0xa77f, 0xa77f, 0xa781, 0xa781, 0xa783, 0xa783, 0xa785, 0xa785, 0xa787, 0xa787, 0xa78c, 0xa78c, 0xa78e, 0xa78e, 0xa791, 0xa791, 0xa793, 0xa795, 0xa797, 0xa797, 0xa799, 0xa799, 0xa79b, 0xa79b, 0xa79d, 0xa79d, 0xa79f, 0xa79f, 0xa7a1, 0xa7a1, 0xa7a3, 0xa7a3, 0xa7a5, 0xa7a5, 0xa7a7, 0xa7a7, 0xa7a9, 0xa7a9, 0xa7fa, 0xa7fa, 0xab30, 0xab5a, 0xab64, 0xab65, 0xfb00, 0xfb06, 0xfb13, 0xfb17, 0xff41, 0xff5a, 0x10428, 0x1044f, 0x118c0, 0x118df, 0x1d41a, 0x1d433, 0x1d44e, 0x1d454, 0x1d456, 0x1d467, 0x1d482, 0x1d49b, 0x1d4b6, 0x1d4b9, 0x1d4bb, 0x1d4bb, 0x1d4bd, 0x1d4c3, 0x1d4c5, 0x1d4cf, 0x1d4ea, 0x1d503, 0x1d51e, 0x1d537, 0x1d552, 0x1d56b, 0x1d586, 0x1d59f, 0x1d5ba, 0x1d5d3, 0x1d5ee, 0x1d607, 0x1d622, 0x1d63b, 0x1d656, 0x1d66f, 0x1d68a, 0x1d6a5, 0x1d6c2, 0x1d6da, 0x1d6dc, 0x1d6e1, 0x1d6fc, 0x1d714, 0x1d716, 0x1d71b, 0x1d736, 0x1d74e, 0x1d750, 0x1d755, 0x1d770, 0x1d788, 0x1d78a, 0x1d78f, 0x1d7aa, 0x1d7c2, 0x1d7c4, 0x1d7c9, 0x1d7cb, 0x1d7cb }; UCP_FN(Ll) static const unichar ucp_Lm_def[] = { 0x2b0, 0x2c1, 0x2c6, 0x2d1, 0x2e0, 0x2e4, 0x2ec, 0x2ec, 0x2ee, 0x2ee, 0x374, 0x374, 0x37a, 0x37a, 0x559, 0x559, 0x640, 0x640, 0x6e5, 0x6e6, 0x7f4, 0x7f5, 0x7fa, 0x7fa, 0x81a, 0x81a, 0x824, 0x824, 0x828, 0x828, 0x971, 0x971, 0xe46, 0xe46, 0xec6, 0xec6, 0x10fc, 0x10fc, 0x17d7, 0x17d7, 0x1843, 0x1843, 0x1aa7, 0x1aa7, 0x1c78, 0x1c7d, 0x1d2c, 0x1d6a, 0x1d78, 0x1d78, 0x1d9b, 0x1dbf, 0x2071, 0x2071, 0x207f, 0x207f, 0x2090, 0x209c, 0x2c7c, 0x2c7d, 0x2d6f, 0x2d6f, 0x2e2f, 0x2e2f, 0x3005, 0x3005, 0x3031, 0x3035, 0x303b, 0x303b, 0x309d, 0x309e, 0x30fc, 0x30fe, 0xa015, 0xa015, 0xa4f8, 0xa4fd, 0xa60c, 0xa60c, 0xa67f, 0xa67f, 0xa69c, 0xa69d, 0xa717, 0xa71f, 0xa770, 0xa770, 0xa788, 0xa788, 0xa7f8, 0xa7f9, 0xa9cf, 0xa9cf, 0xa9e6, 0xa9e6, 0xaa70, 0xaa70, 0xaadd, 0xaadd, 0xaaf3, 0xaaf4, 0xab5c, 0xab5f, 0xff70, 0xff70, 0xff9e, 0xff9f, 0x16b40, 0x16b43, 0x16f93, 0x16f9f }; UCP_FN(Lm) static const unichar ucp_Lo_def[] = { 0xaa, 0xaa, 0xba, 0xba, 0x1bb, 0x1bb, 0x1c0, 0x1c3, 0x294, 0x294, 0x5d0, 0x5ea, 0x5f0, 0x5f2, 0x620, 0x63f, 0x641, 0x64a, 0x66e, 0x66f, 0x671, 0x6d3, 0x6d5, 0x6d5, 0x6ee, 0x6ef, 0x6fa, 0x6fc, 0x6ff, 0x6ff, 0x710, 0x710, 0x712, 0x72f, 0x74d, 0x7a5, 0x7b1, 0x7b1, 0x7ca, 0x7ea, 0x800, 0x815, 0x840, 0x858, 0x8a0, 0x8b2, 0x904, 0x939, 0x93d, 0x93d, 0x950, 0x950, 0x958, 0x961, 0x972, 0x980, 0x985, 0x98c, 0x98f, 0x990, 0x993, 0x9a8, 0x9aa, 0x9b0, 0x9b2, 0x9b2, 0x9b6, 0x9b9, 0x9bd, 0x9bd, 0x9ce, 0x9ce, 0x9dc, 0x9dd, 0x9df, 0x9e1, 0x9f0, 0x9f1, 0xa05, 0xa0a, 0xa0f, 0xa10, 0xa13, 0xa28, 0xa2a, 0xa30, 0xa32, 0xa33, 0xa35, 0xa36, 0xa38, 0xa39, 0xa59, 0xa5c, 0xa5e, 0xa5e, 0xa72, 0xa74, 0xa85, 0xa8d, 0xa8f, 0xa91, 0xa93, 0xaa8, 0xaaa, 0xab0, 0xab2, 0xab3, 0xab5, 0xab9, 0xabd, 0xabd, 0xad0, 0xad0, 0xae0, 0xae1, 0xb05, 0xb0c, 0xb0f, 0xb10, 0xb13, 0xb28, 0xb2a, 0xb30, 0xb32, 0xb33, 0xb35, 0xb39, 0xb3d, 0xb3d, 0xb5c, 0xb5d, 0xb5f, 0xb61, 0xb71, 0xb71, 0xb83, 0xb83, 0xb85, 0xb8a, 0xb8e, 0xb90, 0xb92, 0xb95, 0xb99, 0xb9a, 0xb9c, 0xb9c, 0xb9e, 0xb9f, 0xba3, 0xba4, 0xba8, 0xbaa, 0xbae, 0xbb9, 0xbd0, 0xbd0, 0xc05, 0xc0c, 0xc0e, 0xc10, 0xc12, 0xc28, 0xc2a, 0xc39, 0xc3d, 0xc3d, 0xc58, 0xc59, 0xc60, 0xc61, 0xc85, 0xc8c, 0xc8e, 0xc90, 0xc92, 0xca8, 0xcaa, 0xcb3, 0xcb5, 0xcb9, 0xcbd, 0xcbd, 0xcde, 0xcde, 0xce0, 0xce1, 0xcf1, 0xcf2, 0xd05, 0xd0c, 0xd0e, 0xd10, 0xd12, 0xd3a, 0xd3d, 0xd3d, 0xd4e, 0xd4e, 0xd60, 0xd61, 0xd7a, 0xd7f, 0xd85, 0xd96, 0xd9a, 0xdb1, 0xdb3, 0xdbb, 0xdbd, 0xdbd, 0xdc0, 0xdc6, 0xe01, 0xe30, 0xe32, 0xe33, 0xe40, 0xe45, 0xe81, 0xe82, 0xe84, 0xe84, 0xe87, 0xe88, 0xe8a, 0xe8a, 0xe8d, 0xe8d, 0xe94, 0xe97, 0xe99, 0xe9f, 0xea1, 0xea3, 0xea5, 0xea5, 0xea7, 0xea7, 0xeaa, 0xeab, 0xead, 0xeb0, 0xeb2, 0xeb3, 0xebd, 0xebd, 0xec0, 0xec4, 0xedc, 0xedf, 0xf00, 0xf00, 0xf40, 0xf47, 0xf49, 0xf6c, 0xf88, 0xf8c, 0x1000, 0x102a, 0x103f, 0x103f, 0x1050, 0x1055, 0x105a, 0x105d, 0x1061, 0x1061, 0x1065, 0x1066, 0x106e, 0x1070, 0x1075, 0x1081, 0x108e, 0x108e, 0x10d0, 0x10fa, 0x10fd, 0x1248, 0x124a, 0x124d, 0x1250, 0x1256, 0x1258, 0x1258, 0x125a, 0x125d, 0x1260, 0x1288, 0x128a, 0x128d, 0x1290, 0x12b0, 0x12b2, 0x12b5, 0x12b8, 0x12be, 0x12c0, 0x12c0, 0x12c2, 0x12c5, 0x12c8, 0x12d6, 0x12d8, 0x1310, 0x1312, 0x1315, 0x1318, 0x135a, 0x1380, 0x138f, 0x13a0, 0x13f4, 0x1401, 0x166c, 0x166f, 0x167f, 0x1681, 0x169a, 0x16a0, 0x16ea, 0x16f1, 0x16f8, 0x1700, 0x170c, 0x170e, 0x1711, 0x1720, 0x1731, 0x1740, 0x1751, 0x1760, 0x176c, 0x176e, 0x1770, 0x1780, 0x17b3, 0x17dc, 0x17dc, 0x1820, 0x1842, 0x1844, 0x1877, 0x1880, 0x18a8, 0x18aa, 0x18aa, 0x18b0, 0x18f5, 0x1900, 0x191e, 0x1950, 0x196d, 0x1970, 0x1974, 0x1980, 0x19ab, 0x19c1, 0x19c7, 0x1a00, 0x1a16, 0x1a20, 0x1a54, 0x1b05, 0x1b33, 0x1b45, 0x1b4b, 0x1b83, 0x1ba0, 0x1bae, 0x1baf, 0x1bba, 0x1be5, 0x1c00, 0x1c23, 0x1c4d, 0x1c4f, 0x1c5a, 0x1c77, 0x1ce9, 0x1cec, 0x1cee, 0x1cf1, 0x1cf5, 0x1cf6, 0x2135, 0x2138, 0x2d30, 0x2d67, 0x2d80, 0x2d96, 0x2da0, 0x2da6, 0x2da8, 0x2dae, 0x2db0, 0x2db6, 0x2db8, 0x2dbe, 0x2dc0, 0x2dc6, 0x2dc8, 0x2dce, 0x2dd0, 0x2dd6, 0x2dd8, 0x2dde, 0x3006, 0x3006, 0x303c, 0x303c, 0x3041, 0x3096, 0x309f, 0x309f, 0x30a1, 0x30fa, 0x30ff, 0x30ff, 0x3105, 0x312d, 0x3131, 0x318e, 0x31a0, 0x31ba, 0x31f0, 0x31ff, 0x3400, 0x4db5, 0x4e00, 0x9fcc, 0xa000, 0xa014, 0xa016, 0xa48c, 0xa4d0, 0xa4f7, 0xa500, 0xa60b, 0xa610, 0xa61f, 0xa62a, 0xa62b, 0xa66e, 0xa66e, 0xa6a0, 0xa6e5, 0xa7f7, 0xa7f7, 0xa7fb, 0xa801, 0xa803, 0xa805, 0xa807, 0xa80a, 0xa80c, 0xa822, 0xa840, 0xa873, 0xa882, 0xa8b3, 0xa8f2, 0xa8f7, 0xa8fb, 0xa8fb, 0xa90a, 0xa925, 0xa930, 0xa946, 0xa960, 0xa97c, 0xa984, 0xa9b2, 0xa9e0, 0xa9e4, 0xa9e7, 0xa9ef, 0xa9fa, 0xa9fe, 0xaa00, 0xaa28, 0xaa40, 0xaa42, 0xaa44, 0xaa4b, 0xaa60, 0xaa6f, 0xaa71, 0xaa76, 0xaa7a, 0xaa7a, 0xaa7e, 0xaaaf, 0xaab1, 0xaab1, 0xaab5, 0xaab6, 0xaab9, 0xaabd, 0xaac0, 0xaac0, 0xaac2, 0xaac2, 0xaadb, 0xaadc, 0xaae0, 0xaaea, 0xaaf2, 0xaaf2, 0xab01, 0xab06, 0xab09, 0xab0e, 0xab11, 0xab16, 0xab20, 0xab26, 0xab28, 0xab2e, 0xabc0, 0xabe2, 0xac00, 0xd7a3, 0xd7b0, 0xd7c6, 0xd7cb, 0xd7fb, 0xf900, 0xfa6d, 0xfa70, 0xfad9, 0xfb1d, 0xfb1d, 0xfb1f, 0xfb28, 0xfb2a, 0xfb36, 0xfb38, 0xfb3c, 0xfb3e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfb46, 0xfbb1, 0xfbd3, 0xfd3d, 0xfd50, 0xfd8f, 0xfd92, 0xfdc7, 0xfdf0, 0xfdfb, 0xfe70, 0xfe74, 0xfe76, 0xfefc, 0xff66, 0xff6f, 0xff71, 0xff9d, 0xffa0, 0xffbe, 0xffc2, 0xffc7, 0xffca, 0xffcf, 0xffd2, 0xffd7, 0xffda, 0xffdc, 0x10000, 0x1000b, 0x1000d, 0x10026, 0x10028, 0x1003a, 0x1003c, 0x1003d, 0x1003f, 0x1004d, 0x10050, 0x1005d, 0x10080, 0x100fa, 0x10280, 0x1029c, 0x102a0, 0x102d0, 0x10300, 0x1031f, 0x10330, 0x10340, 0x10342, 0x10349, 0x10350, 0x10375, 0x10380, 0x1039d, 0x103a0, 0x103c3, 0x103c8, 0x103cf, 0x10450, 0x1049d, 0x10500, 0x10527, 0x10530, 0x10563, 0x10600, 0x10736, 0x10740, 0x10755, 0x10760, 0x10767, 0x10800, 0x10805, 0x10808, 0x10808, 0x1080a, 0x10835, 0x10837, 0x10838, 0x1083c, 0x1083c, 0x1083f, 0x10855, 0x10860, 0x10876, 0x10880, 0x1089e, 0x10900, 0x10915, 0x10920, 0x10939, 0x10980, 0x109b7, 0x109be, 0x109bf, 0x10a00, 0x10a00, 0x10a10, 0x10a13, 0x10a15, 0x10a17, 0x10a19, 0x10a33, 0x10a60, 0x10a7c, 0x10a80, 0x10a9c, 0x10ac0, 0x10ac7, 0x10ac9, 0x10ae4, 0x10b00, 0x10b35, 0x10b40, 0x10b55, 0x10b60, 0x10b72, 0x10b80, 0x10b91, 0x10c00, 0x10c48, 0x11003, 0x11037, 0x11083, 0x110af, 0x110d0, 0x110e8, 0x11103, 0x11126, 0x11150, 0x11172, 0x11176, 0x11176, 0x11183, 0x111b2, 0x111c1, 0x111c4, 0x111da, 0x111da, 0x11200, 0x11211, 0x11213, 0x1122b, 0x112b0, 0x112de, 0x11305, 0x1130c, 0x1130f, 0x11310, 0x11313, 0x11328, 0x1132a, 0x11330, 0x11332, 0x11333, 0x11335, 0x11339, 0x1133d, 0x1133d, 0x1135d, 0x11361, 0x11480, 0x114af, 0x114c4, 0x114c5, 0x114c7, 0x114c7, 0x11580, 0x115ae, 0x11600, 0x1162f, 0x11644, 0x11644, 0x11680, 0x116aa, 0x118ff, 0x118ff, 0x11ac0, 0x11af8, 0x12000, 0x12398, 0x13000, 0x1342e, 0x16800, 0x16a38, 0x16a40, 0x16a5e, 0x16ad0, 0x16aed, 0x16b00, 0x16b2f, 0x16b63, 0x16b77, 0x16b7d, 0x16b8f, 0x16f00, 0x16f44, 0x16f50, 0x16f50, 0x1b000, 0x1b001, 0x1bc00, 0x1bc6a, 0x1bc70, 0x1bc7c, 0x1bc80, 0x1bc88, 0x1bc90, 0x1bc99, 0x1e800, 0x1e8c4, 0x1ee00, 0x1ee03, 0x1ee05, 0x1ee1f, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee24, 0x1ee27, 0x1ee27, 0x1ee29, 0x1ee32, 0x1ee34, 0x1ee37, 0x1ee39, 0x1ee39, 0x1ee3b, 0x1ee3b, 0x1ee42, 0x1ee42, 0x1ee47, 0x1ee47, 0x1ee49, 0x1ee49, 0x1ee4b, 0x1ee4b, 0x1ee4d, 0x1ee4f, 0x1ee51, 0x1ee52, 0x1ee54, 0x1ee54, 0x1ee57, 0x1ee57, 0x1ee59, 0x1ee59, 0x1ee5b, 0x1ee5b, 0x1ee5d, 0x1ee5d, 0x1ee5f, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee64, 0x1ee67, 0x1ee6a, 0x1ee6c, 0x1ee72, 0x1ee74, 0x1ee77, 0x1ee79, 0x1ee7c, 0x1ee7e, 0x1ee7e, 0x1ee80, 0x1ee89, 0x1ee8b, 0x1ee9b, 0x1eea1, 0x1eea3, 0x1eea5, 0x1eea9, 0x1eeab, 0x1eebb, 0x20000, 0x2a6d6, 0x2a700, 0x2b734, 0x2b740, 0x2b81d, 0x2f800, 0x2fa1d }; UCP_FN(Lo) static const unichar ucp_Lt_def[] = { 0x1c5, 0x1c5, 0x1c8, 0x1c8, 0x1cb, 0x1cb, 0x1f2, 0x1f2, 0x1f88, 0x1f8f, 0x1f98, 0x1f9f, 0x1fa8, 0x1faf, 0x1fbc, 0x1fbc, 0x1fcc, 0x1fcc, 0x1ffc, 0x1ffc }; UCP_FN(Lt) static const unichar ucp_Lu_def[] = { 0x41, 0x5a, 0xc0, 0xd6, 0xd8, 0xde, 0x100, 0x100, 0x102, 0x102, 0x104, 0x104, 0x106, 0x106, 0x108, 0x108, 0x10a, 0x10a, 0x10c, 0x10c, 0x10e, 0x10e, 0x110, 0x110, 0x112, 0x112, 0x114, 0x114, 0x116, 0x116, 0x118, 0x118, 0x11a, 0x11a, 0x11c, 0x11c, 0x11e, 0x11e, 0x120, 0x120, 0x122, 0x122, 0x124, 0x124, 0x126, 0x126, 0x128, 0x128, 0x12a, 0x12a, 0x12c, 0x12c, 0x12e, 0x12e, 0x130, 0x130, 0x132, 0x132, 0x134, 0x134, 0x136, 0x136, 0x139, 0x139, 0x13b, 0x13b, 0x13d, 0x13d, 0x13f, 0x13f, 0x141, 0x141, 0x143, 0x143, 0x145, 0x145, 0x147, 0x147, 0x14a, 0x14a, 0x14c, 0x14c, 0x14e, 0x14e, 0x150, 0x150, 0x152, 0x152, 0x154, 0x154, 0x156, 0x156, 0x158, 0x158, 0x15a, 0x15a, 0x15c, 0x15c, 0x15e, 0x15e, 0x160, 0x160, 0x162, 0x162, 0x164, 0x164, 0x166, 0x166, 0x168, 0x168, 0x16a, 0x16a, 0x16c, 0x16c, 0x16e, 0x16e, 0x170, 0x170, 0x172, 0x172, 0x174, 0x174, 0x176, 0x176, 0x178, 0x179, 0x17b, 0x17b, 0x17d, 0x17d, 0x181, 0x182, 0x184, 0x184, 0x186, 0x187, 0x189, 0x18b, 0x18e, 0x191, 0x193, 0x194, 0x196, 0x198, 0x19c, 0x19d, 0x19f, 0x1a0, 0x1a2, 0x1a2, 0x1a4, 0x1a4, 0x1a6, 0x1a7, 0x1a9, 0x1a9, 0x1ac, 0x1ac, 0x1ae, 0x1af, 0x1b1, 0x1b3, 0x1b5, 0x1b5, 0x1b7, 0x1b8, 0x1bc, 0x1bc, 0x1c4, 0x1c4, 0x1c7, 0x1c7, 0x1ca, 0x1ca, 0x1cd, 0x1cd, 0x1cf, 0x1cf, 0x1d1, 0x1d1, 0x1d3, 0x1d3, 0x1d5, 0x1d5, 0x1d7, 0x1d7, 0x1d9, 0x1d9, 0x1db, 0x1db, 0x1de, 0x1de, 0x1e0, 0x1e0, 0x1e2, 0x1e2, 0x1e4, 0x1e4, 0x1e6, 0x1e6, 0x1e8, 0x1e8, 0x1ea, 0x1ea, 0x1ec, 0x1ec, 0x1ee, 0x1ee, 0x1f1, 0x1f1, 0x1f4, 0x1f4, 0x1f6, 0x1f8, 0x1fa, 0x1fa, 0x1fc, 0x1fc, 0x1fe, 0x1fe, 0x200, 0x200, 0x202, 0x202, 0x204, 0x204, 0x206, 0x206, 0x208, 0x208, 0x20a, 0x20a, 0x20c, 0x20c, 0x20e, 0x20e, 0x210, 0x210, 0x212, 0x212, 0x214, 0x214, 0x216, 0x216, 0x218, 0x218, 0x21a, 0x21a, 0x21c, 0x21c, 0x21e, 0x21e, 0x220, 0x220, 0x222, 0x222, 0x224, 0x224, 0x226, 0x226, 0x228, 0x228, 0x22a, 0x22a, 0x22c, 0x22c, 0x22e, 0x22e, 0x230, 0x230, 0x232, 0x232, 0x23a, 0x23b, 0x23d, 0x23e, 0x241, 0x241, 0x243, 0x246, 0x248, 0x248, 0x24a, 0x24a, 0x24c, 0x24c, 0x24e, 0x24e, 0x370, 0x370, 0x372, 0x372, 0x376, 0x376, 0x37f, 0x37f, 0x386, 0x386, 0x388, 0x38a, 0x38c, 0x38c, 0x38e, 0x38f, 0x391, 0x3a1, 0x3a3, 0x3ab, 0x3cf, 0x3cf, 0x3d2, 0x3d4, 0x3d8, 0x3d8, 0x3da, 0x3da, 0x3dc, 0x3dc, 0x3de, 0x3de, 0x3e0, 0x3e0, 0x3e2, 0x3e2, 0x3e4, 0x3e4, 0x3e6, 0x3e6, 0x3e8, 0x3e8, 0x3ea, 0x3ea, 0x3ec, 0x3ec, 0x3ee, 0x3ee, 0x3f4, 0x3f4, 0x3f7, 0x3f7, 0x3f9, 0x3fa, 0x3fd, 0x42f, 0x460, 0x460, 0x462, 0x462, 0x464, 0x464, 0x466, 0x466, 0x468, 0x468, 0x46a, 0x46a, 0x46c, 0x46c, 0x46e, 0x46e, 0x470, 0x470, 0x472, 0x472, 0x474, 0x474, 0x476, 0x476, 0x478, 0x478, 0x47a, 0x47a, 0x47c, 0x47c, 0x47e, 0x47e, 0x480, 0x480, 0x48a, 0x48a, 0x48c, 0x48c, 0x48e, 0x48e, 0x490, 0x490, 0x492, 0x492, 0x494, 0x494, 0x496, 0x496, 0x498, 0x498, 0x49a, 0x49a, 0x49c, 0x49c, 0x49e, 0x49e, 0x4a0, 0x4a0, 0x4a2, 0x4a2, 0x4a4, 0x4a4, 0x4a6, 0x4a6, 0x4a8, 0x4a8, 0x4aa, 0x4aa, 0x4ac, 0x4ac, 0x4ae, 0x4ae, 0x4b0, 0x4b0, 0x4b2, 0x4b2, 0x4b4, 0x4b4, 0x4b6, 0x4b6, 0x4b8, 0x4b8, 0x4ba, 0x4ba, 0x4bc, 0x4bc, 0x4be, 0x4be, 0x4c0, 0x4c1, 0x4c3, 0x4c3, 0x4c5, 0x4c5, 0x4c7, 0x4c7, 0x4c9, 0x4c9, 0x4cb, 0x4cb, 0x4cd, 0x4cd, 0x4d0, 0x4d0, 0x4d2, 0x4d2, 0x4d4, 0x4d4, 0x4d6, 0x4d6, 0x4d8, 0x4d8, 0x4da, 0x4da, 0x4dc, 0x4dc, 0x4de, 0x4de, 0x4e0, 0x4e0, 0x4e2, 0x4e2, 0x4e4, 0x4e4, 0x4e6, 0x4e6, 0x4e8, 0x4e8, 0x4ea, 0x4ea, 0x4ec, 0x4ec, 0x4ee, 0x4ee, 0x4f0, 0x4f0, 0x4f2, 0x4f2, 0x4f4, 0x4f4, 0x4f6, 0x4f6, 0x4f8, 0x4f8, 0x4fa, 0x4fa, 0x4fc, 0x4fc, 0x4fe, 0x4fe, 0x500, 0x500, 0x502, 0x502, 0x504, 0x504, 0x506, 0x506, 0x508, 0x508, 0x50a, 0x50a, 0x50c, 0x50c, 0x50e, 0x50e, 0x510, 0x510, 0x512, 0x512, 0x514, 0x514, 0x516, 0x516, 0x518, 0x518, 0x51a, 0x51a, 0x51c, 0x51c, 0x51e, 0x51e, 0x520, 0x520, 0x522, 0x522, 0x524, 0x524, 0x526, 0x526, 0x528, 0x528, 0x52a, 0x52a, 0x52c, 0x52c, 0x52e, 0x52e, 0x531, 0x556, 0x10a0, 0x10c5, 0x10c7, 0x10c7, 0x10cd, 0x10cd, 0x1e00, 0x1e00, 0x1e02, 0x1e02, 0x1e04, 0x1e04, 0x1e06, 0x1e06, 0x1e08, 0x1e08, 0x1e0a, 0x1e0a, 0x1e0c, 0x1e0c, 0x1e0e, 0x1e0e, 0x1e10, 0x1e10, 0x1e12, 0x1e12, 0x1e14, 0x1e14, 0x1e16, 0x1e16, 0x1e18, 0x1e18, 0x1e1a, 0x1e1a, 0x1e1c, 0x1e1c, 0x1e1e, 0x1e1e, 0x1e20, 0x1e20, 0x1e22, 0x1e22, 0x1e24, 0x1e24, 0x1e26, 0x1e26, 0x1e28, 0x1e28, 0x1e2a, 0x1e2a, 0x1e2c, 0x1e2c, 0x1e2e, 0x1e2e, 0x1e30, 0x1e30, 0x1e32, 0x1e32, 0x1e34, 0x1e34, 0x1e36, 0x1e36, 0x1e38, 0x1e38, 0x1e3a, 0x1e3a, 0x1e3c, 0x1e3c, 0x1e3e, 0x1e3e, 0x1e40, 0x1e40, 0x1e42, 0x1e42, 0x1e44, 0x1e44, 0x1e46, 0x1e46, 0x1e48, 0x1e48, 0x1e4a, 0x1e4a, 0x1e4c, 0x1e4c, 0x1e4e, 0x1e4e, 0x1e50, 0x1e50, 0x1e52, 0x1e52, 0x1e54, 0x1e54, 0x1e56, 0x1e56, 0x1e58, 0x1e58, 0x1e5a, 0x1e5a, 0x1e5c, 0x1e5c, 0x1e5e, 0x1e5e, 0x1e60, 0x1e60, 0x1e62, 0x1e62, 0x1e64, 0x1e64, 0x1e66, 0x1e66, 0x1e68, 0x1e68, 0x1e6a, 0x1e6a, 0x1e6c, 0x1e6c, 0x1e6e, 0x1e6e, 0x1e70, 0x1e70, 0x1e72, 0x1e72, 0x1e74, 0x1e74, 0x1e76, 0x1e76, 0x1e78, 0x1e78, 0x1e7a, 0x1e7a, 0x1e7c, 0x1e7c, 0x1e7e, 0x1e7e, 0x1e80, 0x1e80, 0x1e82, 0x1e82, 0x1e84, 0x1e84, 0x1e86, 0x1e86, 0x1e88, 0x1e88, 0x1e8a, 0x1e8a, 0x1e8c, 0x1e8c, 0x1e8e, 0x1e8e, 0x1e90, 0x1e90, 0x1e92, 0x1e92, 0x1e94, 0x1e94, 0x1e9e, 0x1e9e, 0x1ea0, 0x1ea0, 0x1ea2, 0x1ea2, 0x1ea4, 0x1ea4, 0x1ea6, 0x1ea6, 0x1ea8, 0x1ea8, 0x1eaa, 0x1eaa, 0x1eac, 0x1eac, 0x1eae, 0x1eae, 0x1eb0, 0x1eb0, 0x1eb2, 0x1eb2, 0x1eb4, 0x1eb4, 0x1eb6, 0x1eb6, 0x1eb8, 0x1eb8, 0x1eba, 0x1eba, 0x1ebc, 0x1ebc, 0x1ebe, 0x1ebe, 0x1ec0, 0x1ec0, 0x1ec2, 0x1ec2, 0x1ec4, 0x1ec4, 0x1ec6, 0x1ec6, 0x1ec8, 0x1ec8, 0x1eca, 0x1eca, 0x1ecc, 0x1ecc, 0x1ece, 0x1ece, 0x1ed0, 0x1ed0, 0x1ed2, 0x1ed2, 0x1ed4, 0x1ed4, 0x1ed6, 0x1ed6, 0x1ed8, 0x1ed8, 0x1eda, 0x1eda, 0x1edc, 0x1edc, 0x1ede, 0x1ede, 0x1ee0, 0x1ee0, 0x1ee2, 0x1ee2, 0x1ee4, 0x1ee4, 0x1ee6, 0x1ee6, 0x1ee8, 0x1ee8, 0x1eea, 0x1eea, 0x1eec, 0x1eec, 0x1eee, 0x1eee, 0x1ef0, 0x1ef0, 0x1ef2, 0x1ef2, 0x1ef4, 0x1ef4, 0x1ef6, 0x1ef6, 0x1ef8, 0x1ef8, 0x1efa, 0x1efa, 0x1efc, 0x1efc, 0x1efe, 0x1efe, 0x1f08, 0x1f0f, 0x1f18, 0x1f1d, 0x1f28, 0x1f2f, 0x1f38, 0x1f3f, 0x1f48, 0x1f4d, 0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f5f, 0x1f68, 0x1f6f, 0x1fb8, 0x1fbb, 0x1fc8, 0x1fcb, 0x1fd8, 0x1fdb, 0x1fe8, 0x1fec, 0x1ff8, 0x1ffb, 0x2102, 0x2102, 0x2107, 0x2107, 0x210b, 0x210d, 0x2110, 0x2112, 0x2115, 0x2115, 0x2119, 0x211d, 0x2124, 0x2124, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212d, 0x2130, 0x2133, 0x213e, 0x213f, 0x2145, 0x2145, 0x2183, 0x2183, 0x2c00, 0x2c2e, 0x2c60, 0x2c60, 0x2c62, 0x2c64, 0x2c67, 0x2c67, 0x2c69, 0x2c69, 0x2c6b, 0x2c6b, 0x2c6d, 0x2c70, 0x2c72, 0x2c72, 0x2c75, 0x2c75, 0x2c7e, 0x2c80, 0x2c82, 0x2c82, 0x2c84, 0x2c84, 0x2c86, 0x2c86, 0x2c88, 0x2c88, 0x2c8a, 0x2c8a, 0x2c8c, 0x2c8c, 0x2c8e, 0x2c8e, 0x2c90, 0x2c90, 0x2c92, 0x2c92, 0x2c94, 0x2c94, 0x2c96, 0x2c96, 0x2c98, 0x2c98, 0x2c9a, 0x2c9a, 0x2c9c, 0x2c9c, 0x2c9e, 0x2c9e, 0x2ca0, 0x2ca0, 0x2ca2, 0x2ca2, 0x2ca4, 0x2ca4, 0x2ca6, 0x2ca6, 0x2ca8, 0x2ca8, 0x2caa, 0x2caa, 0x2cac, 0x2cac, 0x2cae, 0x2cae, 0x2cb0, 0x2cb0, 0x2cb2, 0x2cb2, 0x2cb4, 0x2cb4, 0x2cb6, 0x2cb6, 0x2cb8, 0x2cb8, 0x2cba, 0x2cba, 0x2cbc, 0x2cbc, 0x2cbe, 0x2cbe, 0x2cc0, 0x2cc0, 0x2cc2, 0x2cc2, 0x2cc4, 0x2cc4, 0x2cc6, 0x2cc6, 0x2cc8, 0x2cc8, 0x2cca, 0x2cca, 0x2ccc, 0x2ccc, 0x2cce, 0x2cce, 0x2cd0, 0x2cd0, 0x2cd2, 0x2cd2, 0x2cd4, 0x2cd4, 0x2cd6, 0x2cd6, 0x2cd8, 0x2cd8, 0x2cda, 0x2cda, 0x2cdc, 0x2cdc, 0x2cde, 0x2cde, 0x2ce0, 0x2ce0, 0x2ce2, 0x2ce2, 0x2ceb, 0x2ceb, 0x2ced, 0x2ced, 0x2cf2, 0x2cf2, 0xa640, 0xa640, 0xa642, 0xa642, 0xa644, 0xa644, 0xa646, 0xa646, 0xa648, 0xa648, 0xa64a, 0xa64a, 0xa64c, 0xa64c, 0xa64e, 0xa64e, 0xa650, 0xa650, 0xa652, 0xa652, 0xa654, 0xa654, 0xa656, 0xa656, 0xa658, 0xa658, 0xa65a, 0xa65a, 0xa65c, 0xa65c, 0xa65e, 0xa65e, 0xa660, 0xa660, 0xa662, 0xa662, 0xa664, 0xa664, 0xa666, 0xa666, 0xa668, 0xa668, 0xa66a, 0xa66a, 0xa66c, 0xa66c, 0xa680, 0xa680, 0xa682, 0xa682, 0xa684, 0xa684, 0xa686, 0xa686, 0xa688, 0xa688, 0xa68a, 0xa68a, 0xa68c, 0xa68c, 0xa68e, 0xa68e, 0xa690, 0xa690, 0xa692, 0xa692, 0xa694, 0xa694, 0xa696, 0xa696, 0xa698, 0xa698, 0xa69a, 0xa69a, 0xa722, 0xa722, 0xa724, 0xa724, 0xa726, 0xa726, 0xa728, 0xa728, 0xa72a, 0xa72a, 0xa72c, 0xa72c, 0xa72e, 0xa72e, 0xa732, 0xa732, 0xa734, 0xa734, 0xa736, 0xa736, 0xa738, 0xa738, 0xa73a, 0xa73a, 0xa73c, 0xa73c, 0xa73e, 0xa73e, 0xa740, 0xa740, 0xa742, 0xa742, 0xa744, 0xa744, 0xa746, 0xa746, 0xa748, 0xa748, 0xa74a, 0xa74a, 0xa74c, 0xa74c, 0xa74e, 0xa74e, 0xa750, 0xa750, 0xa752, 0xa752, 0xa754, 0xa754, 0xa756, 0xa756, 0xa758, 0xa758, 0xa75a, 0xa75a, 0xa75c, 0xa75c, 0xa75e, 0xa75e, 0xa760, 0xa760, 0xa762, 0xa762, 0xa764, 0xa764, 0xa766, 0xa766, 0xa768, 0xa768, 0xa76a, 0xa76a, 0xa76c, 0xa76c, 0xa76e, 0xa76e, 0xa779, 0xa779, 0xa77b, 0xa77b, 0xa77d, 0xa77e, 0xa780, 0xa780, 0xa782, 0xa782, 0xa784, 0xa784, 0xa786, 0xa786, 0xa78b, 0xa78b, 0xa78d, 0xa78d, 0xa790, 0xa790, 0xa792, 0xa792, 0xa796, 0xa796, 0xa798, 0xa798, 0xa79a, 0xa79a, 0xa79c, 0xa79c, 0xa79e, 0xa79e, 0xa7a0, 0xa7a0, 0xa7a2, 0xa7a2, 0xa7a4, 0xa7a4, 0xa7a6, 0xa7a6, 0xa7a8, 0xa7a8, 0xa7aa, 0xa7ad, 0xa7b0, 0xa7b1, 0xff21, 0xff3a, 0x10400, 0x10427, 0x118a0, 0x118bf, 0x1d400, 0x1d419, 0x1d434, 0x1d44d, 0x1d468, 0x1d481, 0x1d49c, 0x1d49c, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4a9, 0x1d4ac, 0x1d4ae, 0x1d4b5, 0x1d4d0, 0x1d4e9, 0x1d504, 0x1d505, 0x1d507, 0x1d50a, 0x1d50d, 0x1d514, 0x1d516, 0x1d51c, 0x1d538, 0x1d539, 0x1d53b, 0x1d53e, 0x1d540, 0x1d544, 0x1d546, 0x1d546, 0x1d54a, 0x1d550, 0x1d56c, 0x1d585, 0x1d5a0, 0x1d5b9, 0x1d5d4, 0x1d5ed, 0x1d608, 0x1d621, 0x1d63c, 0x1d655, 0x1d670, 0x1d689, 0x1d6a8, 0x1d6c0, 0x1d6e2, 0x1d6fa, 0x1d71c, 0x1d734, 0x1d756, 0x1d76e, 0x1d790, 0x1d7a8, 0x1d7ca, 0x1d7ca }; UCP_FN(Lu) static const unichar ucp_M_def[] = { 0x300, 0x36f, 0x483, 0x489, 0x591, 0x5bd, 0x5bf, 0x5bf, 0x5c1, 0x5c2, 0x5c4, 0x5c5, 0x5c7, 0x5c7, 0x610, 0x61a, 0x64b, 0x65f, 0x670, 0x670, 0x6d6, 0x6dc, 0x6df, 0x6e4, 0x6e7, 0x6e8, 0x6ea, 0x6ed, 0x711, 0x711, 0x730, 0x74a, 0x7a6, 0x7b0, 0x7eb, 0x7f3, 0x816, 0x819, 0x81b, 0x823, 0x825, 0x827, 0x829, 0x82d, 0x859, 0x85b, 0x8e4, 0x903, 0x93a, 0x93c, 0x93e, 0x94f, 0x951, 0x957, 0x962, 0x963, 0x981, 0x983, 0x9bc, 0x9bc, 0x9be, 0x9c4, 0x9c7, 0x9c8, 0x9cb, 0x9cd, 0x9d7, 0x9d7, 0x9e2, 0x9e3, 0xa01, 0xa03, 0xa3c, 0xa3c, 0xa3e, 0xa42, 0xa47, 0xa48, 0xa4b, 0xa4d, 0xa51, 0xa51, 0xa70, 0xa71, 0xa75, 0xa75, 0xa81, 0xa83, 0xabc, 0xabc, 0xabe, 0xac5, 0xac7, 0xac9, 0xacb, 0xacd, 0xae2, 0xae3, 0xb01, 0xb03, 0xb3c, 0xb3c, 0xb3e, 0xb44, 0xb47, 0xb48, 0xb4b, 0xb4d, 0xb56, 0xb57, 0xb62, 0xb63, 0xb82, 0xb82, 0xbbe, 0xbc2, 0xbc6, 0xbc8, 0xbca, 0xbcd, 0xbd7, 0xbd7, 0xc00, 0xc03, 0xc3e, 0xc44, 0xc46, 0xc48, 0xc4a, 0xc4d, 0xc55, 0xc56, 0xc62, 0xc63, 0xc81, 0xc83, 0xcbc, 0xcbc, 0xcbe, 0xcc4, 0xcc6, 0xcc8, 0xcca, 0xccd, 0xcd5, 0xcd6, 0xce2, 0xce3, 0xd01, 0xd03, 0xd3e, 0xd44, 0xd46, 0xd48, 0xd4a, 0xd4d, 0xd57, 0xd57, 0xd62, 0xd63, 0xd82, 0xd83, 0xdca, 0xdca, 0xdcf, 0xdd4, 0xdd6, 0xdd6, 0xdd8, 0xddf, 0xdf2, 0xdf3, 0xe31, 0xe31, 0xe34, 0xe3a, 0xe47, 0xe4e, 0xeb1, 0xeb1, 0xeb4, 0xeb9, 0xebb, 0xebc, 0xec8, 0xecd, 0xf18, 0xf19, 0xf35, 0xf35, 0xf37, 0xf37, 0xf39, 0xf39, 0xf3e, 0xf3f, 0xf71, 0xf84, 0xf86, 0xf87, 0xf8d, 0xf97, 0xf99, 0xfbc, 0xfc6, 0xfc6, 0x102b, 0x103e, 0x1056, 0x1059, 0x105e, 0x1060, 0x1062, 0x1064, 0x1067, 0x106d, 0x1071, 0x1074, 0x1082, 0x108d, 0x108f, 0x108f, 0x109a, 0x109d, 0x135d, 0x135f, 0x1712, 0x1714, 0x1732, 0x1734, 0x1752, 0x1753, 0x1772, 0x1773, 0x17b4, 0x17d3, 0x17dd, 0x17dd, 0x180b, 0x180d, 0x18a9, 0x18a9, 0x1920, 0x192b, 0x1930, 0x193b, 0x19b0, 0x19c0, 0x19c8, 0x19c9, 0x1a17, 0x1a1b, 0x1a55, 0x1a5e, 0x1a60, 0x1a7c, 0x1a7f, 0x1a7f, 0x1ab0, 0x1abe, 0x1b00, 0x1b04, 0x1b34, 0x1b44, 0x1b6b, 0x1b73, 0x1b80, 0x1b82, 0x1ba1, 0x1bad, 0x1be6, 0x1bf3, 0x1c24, 0x1c37, 0x1cd0, 0x1cd2, 0x1cd4, 0x1ce8, 0x1ced, 0x1ced, 0x1cf2, 0x1cf4, 0x1cf8, 0x1cf9, 0x1dc0, 0x1df5, 0x1dfc, 0x1dff, 0x20d0, 0x20f0, 0x2cef, 0x2cf1, 0x2d7f, 0x2d7f, 0x2de0, 0x2dff, 0x302a, 0x302f, 0x3099, 0x309a, 0xa66f, 0xa672, 0xa674, 0xa67d, 0xa69f, 0xa69f, 0xa6f0, 0xa6f1, 0xa802, 0xa802, 0xa806, 0xa806, 0xa80b, 0xa80b, 0xa823, 0xa827, 0xa880, 0xa881, 0xa8b4, 0xa8c4, 0xa8e0, 0xa8f1, 0xa926, 0xa92d, 0xa947, 0xa953, 0xa980, 0xa983, 0xa9b3, 0xa9c0, 0xa9e5, 0xa9e5, 0xaa29, 0xaa36, 0xaa43, 0xaa43, 0xaa4c, 0xaa4d, 0xaa7b, 0xaa7d, 0xaab0, 0xaab0, 0xaab2, 0xaab4, 0xaab7, 0xaab8, 0xaabe, 0xaabf, 0xaac1, 0xaac1, 0xaaeb, 0xaaef, 0xaaf5, 0xaaf6, 0xabe3, 0xabea, 0xabec, 0xabed, 0xfb1e, 0xfb1e, 0xfe00, 0xfe0f, 0xfe20, 0xfe2d, 0x101fd, 0x101fd, 0x102e0, 0x102e0, 0x10376, 0x1037a, 0x10a01, 0x10a03, 0x10a05, 0x10a06, 0x10a0c, 0x10a0f, 0x10a38, 0x10a3a, 0x10a3f, 0x10a3f, 0x10ae5, 0x10ae6, 0x11000, 0x11002, 0x11038, 0x11046, 0x1107f, 0x11082, 0x110b0, 0x110ba, 0x11100, 0x11102, 0x11127, 0x11134, 0x11173, 0x11173, 0x11180, 0x11182, 0x111b3, 0x111c0, 0x1122c, 0x11237, 0x112df, 0x112ea, 0x11301, 0x11303, 0x1133c, 0x1133c, 0x1133e, 0x11344, 0x11347, 0x11348, 0x1134b, 0x1134d, 0x11357, 0x11357, 0x11362, 0x11363, 0x11366, 0x1136c, 0x11370, 0x11374, 0x114b0, 0x114c3, 0x115af, 0x115b5, 0x115b8, 0x115c0, 0x11630, 0x11640, 0x116ab, 0x116b7, 0x16af0, 0x16af4, 0x16b30, 0x16b36, 0x16f51, 0x16f7e, 0x16f8f, 0x16f92, 0x1bc9d, 0x1bc9e, 0x1d165, 0x1d169, 0x1d16d, 0x1d172, 0x1d17b, 0x1d182, 0x1d185, 0x1d18b, 0x1d1aa, 0x1d1ad, 0x1d242, 0x1d244, 0x1e8d0, 0x1e8d6, 0xe0100, 0xe01ef }; UCP_FN(M) static const unichar ucp_Mc_def[] = { 0x903, 0x903, 0x93b, 0x93b, 0x93e, 0x940, 0x949, 0x94c, 0x94e, 0x94f, 0x982, 0x983, 0x9be, 0x9c0, 0x9c7, 0x9c8, 0x9cb, 0x9cc, 0x9d7, 0x9d7, 0xa03, 0xa03, 0xa3e, 0xa40, 0xa83, 0xa83, 0xabe, 0xac0, 0xac9, 0xac9, 0xacb, 0xacc, 0xb02, 0xb03, 0xb3e, 0xb3e, 0xb40, 0xb40, 0xb47, 0xb48, 0xb4b, 0xb4c, 0xb57, 0xb57, 0xbbe, 0xbbf, 0xbc1, 0xbc2, 0xbc6, 0xbc8, 0xbca, 0xbcc, 0xbd7, 0xbd7, 0xc01, 0xc03, 0xc41, 0xc44, 0xc82, 0xc83, 0xcbe, 0xcbe, 0xcc0, 0xcc4, 0xcc7, 0xcc8, 0xcca, 0xccb, 0xcd5, 0xcd6, 0xd02, 0xd03, 0xd3e, 0xd40, 0xd46, 0xd48, 0xd4a, 0xd4c, 0xd57, 0xd57, 0xd82, 0xd83, 0xdcf, 0xdd1, 0xdd8, 0xddf, 0xdf2, 0xdf3, 0xf3e, 0xf3f, 0xf7f, 0xf7f, 0x102b, 0x102c, 0x1031, 0x1031, 0x1038, 0x1038, 0x103b, 0x103c, 0x1056, 0x1057, 0x1062, 0x1064, 0x1067, 0x106d, 0x1083, 0x1084, 0x1087, 0x108c, 0x108f, 0x108f, 0x109a, 0x109c, 0x17b6, 0x17b6, 0x17be, 0x17c5, 0x17c7, 0x17c8, 0x1923, 0x1926, 0x1929, 0x192b, 0x1930, 0x1931, 0x1933, 0x1938, 0x19b0, 0x19c0, 0x19c8, 0x19c9, 0x1a19, 0x1a1a, 0x1a55, 0x1a55, 0x1a57, 0x1a57, 0x1a61, 0x1a61, 0x1a63, 0x1a64, 0x1a6d, 0x1a72, 0x1b04, 0x1b04, 0x1b35, 0x1b35, 0x1b3b, 0x1b3b, 0x1b3d, 0x1b41, 0x1b43, 0x1b44, 0x1b82, 0x1b82, 0x1ba1, 0x1ba1, 0x1ba6, 0x1ba7, 0x1baa, 0x1baa, 0x1be7, 0x1be7, 0x1bea, 0x1bec, 0x1bee, 0x1bee, 0x1bf2, 0x1bf3, 0x1c24, 0x1c2b, 0x1c34, 0x1c35, 0x1ce1, 0x1ce1, 0x1cf2, 0x1cf3, 0x302e, 0x302f, 0xa823, 0xa824, 0xa827, 0xa827, 0xa880, 0xa881, 0xa8b4, 0xa8c3, 0xa952, 0xa953, 0xa983, 0xa983, 0xa9b4, 0xa9b5, 0xa9ba, 0xa9bb, 0xa9bd, 0xa9c0, 0xaa2f, 0xaa30, 0xaa33, 0xaa34, 0xaa4d, 0xaa4d, 0xaa7b, 0xaa7b, 0xaa7d, 0xaa7d, 0xaaeb, 0xaaeb, 0xaaee, 0xaaef, 0xaaf5, 0xaaf5, 0xabe3, 0xabe4, 0xabe6, 0xabe7, 0xabe9, 0xabea, 0xabec, 0xabec, 0x11000, 0x11000, 0x11002, 0x11002, 0x11082, 0x11082, 0x110b0, 0x110b2, 0x110b7, 0x110b8, 0x1112c, 0x1112c, 0x11182, 0x11182, 0x111b3, 0x111b5, 0x111bf, 0x111c0, 0x1122c, 0x1122e, 0x11232, 0x11233, 0x11235, 0x11235, 0x112e0, 0x112e2, 0x11302, 0x11303, 0x1133e, 0x1133f, 0x11341, 0x11344, 0x11347, 0x11348, 0x1134b, 0x1134d, 0x11357, 0x11357, 0x11362, 0x11363, 0x114b0, 0x114b2, 0x114b9, 0x114b9, 0x114bb, 0x114be, 0x114c1, 0x114c1, 0x115af, 0x115b1, 0x115b8, 0x115bb, 0x115be, 0x115be, 0x11630, 0x11632, 0x1163b, 0x1163c, 0x1163e, 0x1163e, 0x116ac, 0x116ac, 0x116ae, 0x116af, 0x116b6, 0x116b6, 0x16f51, 0x16f7e, 0x1d165, 0x1d166, 0x1d16d, 0x1d172 }; UCP_FN(Mc) static const unichar ucp_Me_def[] = { 0x488, 0x489, 0x1abe, 0x1abe, 0x20dd, 0x20e0, 0x20e2, 0x20e4, 0xa670, 0xa672 }; UCP_FN(Me) static const unichar ucp_Mn_def[] = { 0x300, 0x36f, 0x483, 0x487, 0x591, 0x5bd, 0x5bf, 0x5bf, 0x5c1, 0x5c2, 0x5c4, 0x5c5, 0x5c7, 0x5c7, 0x610, 0x61a, 0x64b, 0x65f, 0x670, 0x670, 0x6d6, 0x6dc, 0x6df, 0x6e4, 0x6e7, 0x6e8, 0x6ea, 0x6ed, 0x711, 0x711, 0x730, 0x74a, 0x7a6, 0x7b0, 0x7eb, 0x7f3, 0x816, 0x819, 0x81b, 0x823, 0x825, 0x827, 0x829, 0x82d, 0x859, 0x85b, 0x8e4, 0x902, 0x93a, 0x93a, 0x93c, 0x93c, 0x941, 0x948, 0x94d, 0x94d, 0x951, 0x957, 0x962, 0x963, 0x981, 0x981, 0x9bc, 0x9bc, 0x9c1, 0x9c4, 0x9cd, 0x9cd, 0x9e2, 0x9e3, 0xa01, 0xa02, 0xa3c, 0xa3c, 0xa41, 0xa42, 0xa47, 0xa48, 0xa4b, 0xa4d, 0xa51, 0xa51, 0xa70, 0xa71, 0xa75, 0xa75, 0xa81, 0xa82, 0xabc, 0xabc, 0xac1, 0xac5, 0xac7, 0xac8, 0xacd, 0xacd, 0xae2, 0xae3, 0xb01, 0xb01, 0xb3c, 0xb3c, 0xb3f, 0xb3f, 0xb41, 0xb44, 0xb4d, 0xb4d, 0xb56, 0xb56, 0xb62, 0xb63, 0xb82, 0xb82, 0xbc0, 0xbc0, 0xbcd, 0xbcd, 0xc00, 0xc00, 0xc3e, 0xc40, 0xc46, 0xc48, 0xc4a, 0xc4d, 0xc55, 0xc56, 0xc62, 0xc63, 0xc81, 0xc81, 0xcbc, 0xcbc, 0xcbf, 0xcbf, 0xcc6, 0xcc6, 0xccc, 0xccd, 0xce2, 0xce3, 0xd01, 0xd01, 0xd41, 0xd44, 0xd4d, 0xd4d, 0xd62, 0xd63, 0xdca, 0xdca, 0xdd2, 0xdd4, 0xdd6, 0xdd6, 0xe31, 0xe31, 0xe34, 0xe3a, 0xe47, 0xe4e, 0xeb1, 0xeb1, 0xeb4, 0xeb9, 0xebb, 0xebc, 0xec8, 0xecd, 0xf18, 0xf19, 0xf35, 0xf35, 0xf37, 0xf37, 0xf39, 0xf39, 0xf71, 0xf7e, 0xf80, 0xf84, 0xf86, 0xf87, 0xf8d, 0xf97, 0xf99, 0xfbc, 0xfc6, 0xfc6, 0x102d, 0x1030, 0x1032, 0x1037, 0x1039, 0x103a, 0x103d, 0x103e, 0x1058, 0x1059, 0x105e, 0x1060, 0x1071, 0x1074, 0x1082, 0x1082, 0x1085, 0x1086, 0x108d, 0x108d, 0x109d, 0x109d, 0x135d, 0x135f, 0x1712, 0x1714, 0x1732, 0x1734, 0x1752, 0x1753, 0x1772, 0x1773, 0x17b4, 0x17b5, 0x17b7, 0x17bd, 0x17c6, 0x17c6, 0x17c9, 0x17d3, 0x17dd, 0x17dd, 0x180b, 0x180d, 0x18a9, 0x18a9, 0x1920, 0x1922, 0x1927, 0x1928, 0x1932, 0x1932, 0x1939, 0x193b, 0x1a17, 0x1a18, 0x1a1b, 0x1a1b, 0x1a56, 0x1a56, 0x1a58, 0x1a5e, 0x1a60, 0x1a60, 0x1a62, 0x1a62, 0x1a65, 0x1a6c, 0x1a73, 0x1a7c, 0x1a7f, 0x1a7f, 0x1ab0, 0x1abd, 0x1b00, 0x1b03, 0x1b34, 0x1b34, 0x1b36, 0x1b3a, 0x1b3c, 0x1b3c, 0x1b42, 0x1b42, 0x1b6b, 0x1b73, 0x1b80, 0x1b81, 0x1ba2, 0x1ba5, 0x1ba8, 0x1ba9, 0x1bab, 0x1bad, 0x1be6, 0x1be6, 0x1be8, 0x1be9, 0x1bed, 0x1bed, 0x1bef, 0x1bf1, 0x1c2c, 0x1c33, 0x1c36, 0x1c37, 0x1cd0, 0x1cd2, 0x1cd4, 0x1ce0, 0x1ce2, 0x1ce8, 0x1ced, 0x1ced, 0x1cf4, 0x1cf4, 0x1cf8, 0x1cf9, 0x1dc0, 0x1df5, 0x1dfc, 0x1dff, 0x20d0, 0x20dc, 0x20e1, 0x20e1, 0x20e5, 0x20f0, 0x2cef, 0x2cf1, 0x2d7f, 0x2d7f, 0x2de0, 0x2dff, 0x302a, 0x302d, 0x3099, 0x309a, 0xa66f, 0xa66f, 0xa674, 0xa67d, 0xa69f, 0xa69f, 0xa6f0, 0xa6f1, 0xa802, 0xa802, 0xa806, 0xa806, 0xa80b, 0xa80b, 0xa825, 0xa826, 0xa8c4, 0xa8c4, 0xa8e0, 0xa8f1, 0xa926, 0xa92d, 0xa947, 0xa951, 0xa980, 0xa982, 0xa9b3, 0xa9b3, 0xa9b6, 0xa9b9, 0xa9bc, 0xa9bc, 0xa9e5, 0xa9e5, 0xaa29, 0xaa2e, 0xaa31, 0xaa32, 0xaa35, 0xaa36, 0xaa43, 0xaa43, 0xaa4c, 0xaa4c, 0xaa7c, 0xaa7c, 0xaab0, 0xaab0, 0xaab2, 0xaab4, 0xaab7, 0xaab8, 0xaabe, 0xaabf, 0xaac1, 0xaac1, 0xaaec, 0xaaed, 0xaaf6, 0xaaf6, 0xabe5, 0xabe5, 0xabe8, 0xabe8, 0xabed, 0xabed, 0xfb1e, 0xfb1e, 0xfe00, 0xfe0f, 0xfe20, 0xfe2d, 0x101fd, 0x101fd, 0x102e0, 0x102e0, 0x10376, 0x1037a, 0x10a01, 0x10a03, 0x10a05, 0x10a06, 0x10a0c, 0x10a0f, 0x10a38, 0x10a3a, 0x10a3f, 0x10a3f, 0x10ae5, 0x10ae6, 0x11001, 0x11001, 0x11038, 0x11046, 0x1107f, 0x11081, 0x110b3, 0x110b6, 0x110b9, 0x110ba, 0x11100, 0x11102, 0x11127, 0x1112b, 0x1112d, 0x11134, 0x11173, 0x11173, 0x11180, 0x11181, 0x111b6, 0x111be, 0x1122f, 0x11231, 0x11234, 0x11234, 0x11236, 0x11237, 0x112df, 0x112df, 0x112e3, 0x112ea, 0x11301, 0x11301, 0x1133c, 0x1133c, 0x11340, 0x11340, 0x11366, 0x1136c, 0x11370, 0x11374, 0x114b3, 0x114b8, 0x114ba, 0x114ba, 0x114bf, 0x114c0, 0x114c2, 0x114c3, 0x115b2, 0x115b5, 0x115bc, 0x115bd, 0x115bf, 0x115c0, 0x11633, 0x1163a, 0x1163d, 0x1163d, 0x1163f, 0x11640, 0x116ab, 0x116ab, 0x116ad, 0x116ad, 0x116b0, 0x116b5, 0x116b7, 0x116b7, 0x16af0, 0x16af4, 0x16b30, 0x16b36, 0x16f8f, 0x16f92, 0x1bc9d, 0x1bc9e, 0x1d167, 0x1d169, 0x1d17b, 0x1d182, 0x1d185, 0x1d18b, 0x1d1aa, 0x1d1ad, 0x1d242, 0x1d244, 0x1e8d0, 0x1e8d6, 0xe0100, 0xe01ef }; UCP_FN(Mn) static const unichar ucp_N_def[] = { 0x30, 0x39, 0xb2, 0xb3, 0xb9, 0xb9, 0xbc, 0xbe, 0x660, 0x669, 0x6f0, 0x6f9, 0x7c0, 0x7c9, 0x966, 0x96f, 0x9e6, 0x9ef, 0x9f4, 0x9f9, 0xa66, 0xa6f, 0xae6, 0xaef, 0xb66, 0xb6f, 0xb72, 0xb77, 0xbe6, 0xbf2, 0xc66, 0xc6f, 0xc78, 0xc7e, 0xce6, 0xcef, 0xd66, 0xd75, 0xde6, 0xdef, 0xe50, 0xe59, 0xed0, 0xed9, 0xf20, 0xf33, 0x1040, 0x1049, 0x1090, 0x1099, 0x1369, 0x137c, 0x16ee, 0x16f0, 0x17e0, 0x17e9, 0x17f0, 0x17f9, 0x1810, 0x1819, 0x1946, 0x194f, 0x19d0, 0x19da, 0x1a80, 0x1a89, 0x1a90, 0x1a99, 0x1b50, 0x1b59, 0x1bb0, 0x1bb9, 0x1c40, 0x1c49, 0x1c50, 0x1c59, 0x2070, 0x2070, 0x2074, 0x2079, 0x2080, 0x2089, 0x2150, 0x2182, 0x2185, 0x2189, 0x2460, 0x249b, 0x24ea, 0x24ff, 0x2776, 0x2793, 0x2cfd, 0x2cfd, 0x3007, 0x3007, 0x3021, 0x3029, 0x3038, 0x303a, 0x3192, 0x3195, 0x3220, 0x3229, 0x3248, 0x324f, 0x3251, 0x325f, 0x3280, 0x3289, 0x32b1, 0x32bf, 0xa620, 0xa629, 0xa6e6, 0xa6ef, 0xa830, 0xa835, 0xa8d0, 0xa8d9, 0xa900, 0xa909, 0xa9d0, 0xa9d9, 0xa9f0, 0xa9f9, 0xaa50, 0xaa59, 0xabf0, 0xabf9, 0xff10, 0xff19, 0x10107, 0x10133, 0x10140, 0x10178, 0x1018a, 0x1018b, 0x102e1, 0x102fb, 0x10320, 0x10323, 0x10341, 0x10341, 0x1034a, 0x1034a, 0x103d1, 0x103d5, 0x104a0, 0x104a9, 0x10858, 0x1085f, 0x10879, 0x1087f, 0x108a7, 0x108af, 0x10916, 0x1091b, 0x10a40, 0x10a47, 0x10a7d, 0x10a7e, 0x10a9d, 0x10a9f, 0x10aeb, 0x10aef, 0x10b58, 0x10b5f, 0x10b78, 0x10b7f, 0x10ba9, 0x10baf, 0x10e60, 0x10e7e, 0x11052, 0x1106f, 0x110f0, 0x110f9, 0x11136, 0x1113f, 0x111d0, 0x111d9, 0x111e1, 0x111f4, 0x112f0, 0x112f9, 0x114d0, 0x114d9, 0x11650, 0x11659, 0x116c0, 0x116c9, 0x118e0, 0x118f2, 0x12400, 0x1246e, 0x16a60, 0x16a69, 0x16b50, 0x16b59, 0x16b5b, 0x16b61, 0x1d360, 0x1d371, 0x1d7ce, 0x1d7ff, 0x1e8c7, 0x1e8cf, 0x1f100, 0x1f10c }; UCP_FN(N) static const unichar ucp_Nd_def[] = { 0x30, 0x39, 0x660, 0x669, 0x6f0, 0x6f9, 0x7c0, 0x7c9, 0x966, 0x96f, 0x9e6, 0x9ef, 0xa66, 0xa6f, 0xae6, 0xaef, 0xb66, 0xb6f, 0xbe6, 0xbef, 0xc66, 0xc6f, 0xce6, 0xcef, 0xd66, 0xd6f, 0xde6, 0xdef, 0xe50, 0xe59, 0xed0, 0xed9, 0xf20, 0xf29, 0x1040, 0x1049, 0x1090, 0x1099, 0x17e0, 0x17e9, 0x1810, 0x1819, 0x1946, 0x194f, 0x19d0, 0x19d9, 0x1a80, 0x1a89, 0x1a90, 0x1a99, 0x1b50, 0x1b59, 0x1bb0, 0x1bb9, 0x1c40, 0x1c49, 0x1c50, 0x1c59, 0xa620, 0xa629, 0xa8d0, 0xa8d9, 0xa900, 0xa909, 0xa9d0, 0xa9d9, 0xa9f0, 0xa9f9, 0xaa50, 0xaa59, 0xabf0, 0xabf9, 0xff10, 0xff19, 0x104a0, 0x104a9, 0x11066, 0x1106f, 0x110f0, 0x110f9, 0x11136, 0x1113f, 0x111d0, 0x111d9, 0x112f0, 0x112f9, 0x114d0, 0x114d9, 0x11650, 0x11659, 0x116c0, 0x116c9, 0x118e0, 0x118e9, 0x16a60, 0x16a69, 0x16b50, 0x16b59, 0x1d7ce, 0x1d7ff }; UCP_FN(Nd) static const unichar ucp_Nl_def[] = { 0x16ee, 0x16f0, 0x2160, 0x2182, 0x2185, 0x2188, 0x3007, 0x3007, 0x3021, 0x3029, 0x3038, 0x303a, 0xa6e6, 0xa6ef, 0x10140, 0x10174, 0x10341, 0x10341, 0x1034a, 0x1034a, 0x103d1, 0x103d5, 0x12400, 0x1246e }; UCP_FN(Nl) static const unichar ucp_No_def[] = { 0xb2, 0xb3, 0xb9, 0xb9, 0xbc, 0xbe, 0x9f4, 0x9f9, 0xb72, 0xb77, 0xbf0, 0xbf2, 0xc78, 0xc7e, 0xd70, 0xd75, 0xf2a, 0xf33, 0x1369, 0x137c, 0x17f0, 0x17f9, 0x19da, 0x19da, 0x2070, 0x2070, 0x2074, 0x2079, 0x2080, 0x2089, 0x2150, 0x215f, 0x2189, 0x2189, 0x2460, 0x249b, 0x24ea, 0x24ff, 0x2776, 0x2793, 0x2cfd, 0x2cfd, 0x3192, 0x3195, 0x3220, 0x3229, 0x3248, 0x324f, 0x3251, 0x325f, 0x3280, 0x3289, 0x32b1, 0x32bf, 0xa830, 0xa835, 0x10107, 0x10133, 0x10175, 0x10178, 0x1018a, 0x1018b, 0x102e1, 0x102fb, 0x10320, 0x10323, 0x10858, 0x1085f, 0x10879, 0x1087f, 0x108a7, 0x108af, 0x10916, 0x1091b, 0x10a40, 0x10a47, 0x10a7d, 0x10a7e, 0x10a9d, 0x10a9f, 0x10aeb, 0x10aef, 0x10b58, 0x10b5f, 0x10b78, 0x10b7f, 0x10ba9, 0x10baf, 0x10e60, 0x10e7e, 0x11052, 0x11065, 0x111e1, 0x111f4, 0x118ea, 0x118f2, 0x16b5b, 0x16b61, 0x1d360, 0x1d371, 0x1e8c7, 0x1e8cf, 0x1f100, 0x1f10c }; UCP_FN(No) static const unichar ucp_P_def[] = { 0x21, 0x23, 0x25, 0x2a, 0x2c, 0x2f, 0x3a, 0x3b, 0x3f, 0x40, 0x5b, 0x5d, 0x5f, 0x5f, 0x7b, 0x7b, 0x7d, 0x7d, 0xa1, 0xa1, 0xa7, 0xa7, 0xab, 0xab, 0xb6, 0xb7, 0xbb, 0xbb, 0xbf, 0xbf, 0x37e, 0x37e, 0x387, 0x387, 0x55a, 0x55f, 0x589, 0x58a, 0x5be, 0x5be, 0x5c0, 0x5c0, 0x5c3, 0x5c3, 0x5c6, 0x5c6, 0x5f3, 0x5f4, 0x609, 0x60a, 0x60c, 0x60d, 0x61b, 0x61b, 0x61e, 0x61f, 0x66a, 0x66d, 0x6d4, 0x6d4, 0x700, 0x70d, 0x7f7, 0x7f9, 0x830, 0x83e, 0x85e, 0x85e, 0x964, 0x965, 0x970, 0x970, 0xaf0, 0xaf0, 0xdf4, 0xdf4, 0xe4f, 0xe4f, 0xe5a, 0xe5b, 0xf04, 0xf12, 0xf14, 0xf14, 0xf3a, 0xf3d, 0xf85, 0xf85, 0xfd0, 0xfd4, 0xfd9, 0xfda, 0x104a, 0x104f, 0x10fb, 0x10fb, 0x1360, 0x1368, 0x1400, 0x1400, 0x166d, 0x166e, 0x169b, 0x169c, 0x16eb, 0x16ed, 0x1735, 0x1736, 0x17d4, 0x17d6, 0x17d8, 0x17da, 0x1800, 0x180a, 0x1944, 0x1945, 0x1a1e, 0x1a1f, 0x1aa0, 0x1aa6, 0x1aa8, 0x1aad, 0x1b5a, 0x1b60, 0x1bfc, 0x1bff, 0x1c3b, 0x1c3f, 0x1c7e, 0x1c7f, 0x1cc0, 0x1cc7, 0x1cd3, 0x1cd3, 0x2010, 0x2027, 0x2030, 0x2043, 0x2045, 0x2051, 0x2053, 0x205e, 0x207d, 0x207e, 0x208d, 0x208e, 0x2308, 0x230b, 0x2329, 0x232a, 0x2768, 0x2775, 0x27c5, 0x27c6, 0x27e6, 0x27ef, 0x2983, 0x2998, 0x29d8, 0x29db, 0x29fc, 0x29fd, 0x2cf9, 0x2cfc, 0x2cfe, 0x2cff, 0x2d70, 0x2d70, 0x2e00, 0x2e2e, 0x2e30, 0x2e42, 0x3001, 0x3003, 0x3008, 0x3011, 0x3014, 0x301f, 0x3030, 0x3030, 0x303d, 0x303d, 0x30a0, 0x30a0, 0x30fb, 0x30fb, 0xa4fe, 0xa4ff, 0xa60d, 0xa60f, 0xa673, 0xa673, 0xa67e, 0xa67e, 0xa6f2, 0xa6f7, 0xa874, 0xa877, 0xa8ce, 0xa8cf, 0xa8f8, 0xa8fa, 0xa92e, 0xa92f, 0xa95f, 0xa95f, 0xa9c1, 0xa9cd, 0xa9de, 0xa9df, 0xaa5c, 0xaa5f, 0xaade, 0xaadf, 0xaaf0, 0xaaf1, 0xabeb, 0xabeb, 0xfd3e, 0xfd3f, 0xfe10, 0xfe19, 0xfe30, 0xfe52, 0xfe54, 0xfe61, 0xfe63, 0xfe63, 0xfe68, 0xfe68, 0xfe6a, 0xfe6b, 0xff01, 0xff03, 0xff05, 0xff0a, 0xff0c, 0xff0f, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3b, 0xff3d, 0xff3f, 0xff3f, 0xff5b, 0xff5b, 0xff5d, 0xff5d, 0xff5f, 0xff65, 0x10100, 0x10102, 0x1039f, 0x1039f, 0x103d0, 0x103d0, 0x1056f, 0x1056f, 0x10857, 0x10857, 0x1091f, 0x1091f, 0x1093f, 0x1093f, 0x10a50, 0x10a58, 0x10a7f, 0x10a7f, 0x10af0, 0x10af6, 0x10b39, 0x10b3f, 0x10b99, 0x10b9c, 0x11047, 0x1104d, 0x110bb, 0x110bc, 0x110be, 0x110c1, 0x11140, 0x11143, 0x11174, 0x11175, 0x111c5, 0x111c8, 0x111cd, 0x111cd, 0x11238, 0x1123d, 0x114c6, 0x114c6, 0x115c1, 0x115c9, 0x11641, 0x11643, 0x12470, 0x12474, 0x16a6e, 0x16a6f, 0x16af5, 0x16af5, 0x16b37, 0x16b3b, 0x16b44, 0x16b44, 0x1bc9f, 0x1bc9f }; UCP_FN(P) static const unichar ucp_Pc_def[] = { 0x5f, 0x5f, 0x203f, 0x2040, 0x2054, 0x2054, 0xfe33, 0xfe34, 0xfe4d, 0xfe4f, 0xff3f, 0xff3f }; UCP_FN(Pc) static const unichar ucp_Pd_def[] = { 0x2d, 0x2d, 0x58a, 0x58a, 0x5be, 0x5be, 0x1400, 0x1400, 0x1806, 0x1806, 0x2010, 0x2015, 0x2e17, 0x2e17, 0x2e1a, 0x2e1a, 0x2e3a, 0x2e3b, 0x2e40, 0x2e40, 0x301c, 0x301c, 0x3030, 0x3030, 0x30a0, 0x30a0, 0xfe31, 0xfe32, 0xfe58, 0xfe58, 0xfe63, 0xfe63, 0xff0d, 0xff0d }; UCP_FN(Pd) static const unichar ucp_Pe_def[] = { 0x29, 0x29, 0x5d, 0x5d, 0x7d, 0x7d, 0xf3b, 0xf3b, 0xf3d, 0xf3d, 0x169c, 0x169c, 0x2046, 0x2046, 0x207e, 0x207e, 0x208e, 0x208e, 0x2309, 0x2309, 0x230b, 0x230b, 0x232a, 0x232a, 0x2769, 0x2769, 0x276b, 0x276b, 0x276d, 0x276d, 0x276f, 0x276f, 0x2771, 0x2771, 0x2773, 0x2773, 0x2775, 0x2775, 0x27c6, 0x27c6, 0x27e7, 0x27e7, 0x27e9, 0x27e9, 0x27eb, 0x27eb, 0x27ed, 0x27ed, 0x27ef, 0x27ef, 0x2984, 0x2984, 0x2986, 0x2986, 0x2988, 0x2988, 0x298a, 0x298a, 0x298c, 0x298c, 0x298e, 0x298e, 0x2990, 0x2990, 0x2992, 0x2992, 0x2994, 0x2994, 0x2996, 0x2996, 0x2998, 0x2998, 0x29d9, 0x29d9, 0x29db, 0x29db, 0x29fd, 0x29fd, 0x2e23, 0x2e23, 0x2e25, 0x2e25, 0x2e27, 0x2e27, 0x2e29, 0x2e29, 0x3009, 0x3009, 0x300b, 0x300b, 0x300d, 0x300d, 0x300f, 0x300f, 0x3011, 0x3011, 0x3015, 0x3015, 0x3017, 0x3017, 0x3019, 0x3019, 0x301b, 0x301b, 0x301e, 0x301f, 0xfd3e, 0xfd3e, 0xfe18, 0xfe18, 0xfe36, 0xfe36, 0xfe38, 0xfe38, 0xfe3a, 0xfe3a, 0xfe3c, 0xfe3c, 0xfe3e, 0xfe3e, 0xfe40, 0xfe40, 0xfe42, 0xfe42, 0xfe44, 0xfe44, 0xfe48, 0xfe48, 0xfe5a, 0xfe5a, 0xfe5c, 0xfe5c, 0xfe5e, 0xfe5e, 0xff09, 0xff09, 0xff3d, 0xff3d, 0xff5d, 0xff5d, 0xff60, 0xff60, 0xff63, 0xff63 }; UCP_FN(Pe) static const unichar ucp_Pf_def[] = { 0xbb, 0xbb, 0x2019, 0x2019, 0x201d, 0x201d, 0x203a, 0x203a, 0x2e03, 0x2e03, 0x2e05, 0x2e05, 0x2e0a, 0x2e0a, 0x2e0d, 0x2e0d, 0x2e1d, 0x2e1d, 0x2e21, 0x2e21 }; UCP_FN(Pf) static const unichar ucp_Pi_def[] = { 0xab, 0xab, 0x2018, 0x2018, 0x201b, 0x201c, 0x201f, 0x201f, 0x2039, 0x2039, 0x2e02, 0x2e02, 0x2e04, 0x2e04, 0x2e09, 0x2e09, 0x2e0c, 0x2e0c, 0x2e1c, 0x2e1c, 0x2e20, 0x2e20 }; UCP_FN(Pi) static const unichar ucp_Po_def[] = { 0x21, 0x23, 0x25, 0x27, 0x2a, 0x2a, 0x2c, 0x2c, 0x2e, 0x2f, 0x3a, 0x3b, 0x3f, 0x40, 0x5c, 0x5c, 0xa1, 0xa1, 0xa7, 0xa7, 0xb6, 0xb7, 0xbf, 0xbf, 0x37e, 0x37e, 0x387, 0x387, 0x55a, 0x55f, 0x589, 0x589, 0x5c0, 0x5c0, 0x5c3, 0x5c3, 0x5c6, 0x5c6, 0x5f3, 0x5f4, 0x609, 0x60a, 0x60c, 0x60d, 0x61b, 0x61b, 0x61e, 0x61f, 0x66a, 0x66d, 0x6d4, 0x6d4, 0x700, 0x70d, 0x7f7, 0x7f9, 0x830, 0x83e, 0x85e, 0x85e, 0x964, 0x965, 0x970, 0x970, 0xaf0, 0xaf0, 0xdf4, 0xdf4, 0xe4f, 0xe4f, 0xe5a, 0xe5b, 0xf04, 0xf12, 0xf14, 0xf14, 0xf85, 0xf85, 0xfd0, 0xfd4, 0xfd9, 0xfda, 0x104a, 0x104f, 0x10fb, 0x10fb, 0x1360, 0x1368, 0x166d, 0x166e, 0x16eb, 0x16ed, 0x1735, 0x1736, 0x17d4, 0x17d6, 0x17d8, 0x17da, 0x1800, 0x1805, 0x1807, 0x180a, 0x1944, 0x1945, 0x1a1e, 0x1a1f, 0x1aa0, 0x1aa6, 0x1aa8, 0x1aad, 0x1b5a, 0x1b60, 0x1bfc, 0x1bff, 0x1c3b, 0x1c3f, 0x1c7e, 0x1c7f, 0x1cc0, 0x1cc7, 0x1cd3, 0x1cd3, 0x2016, 0x2017, 0x2020, 0x2027, 0x2030, 0x2038, 0x203b, 0x203e, 0x2041, 0x2043, 0x2047, 0x2051, 0x2053, 0x2053, 0x2055, 0x205e, 0x2cf9, 0x2cfc, 0x2cfe, 0x2cff, 0x2d70, 0x2d70, 0x2e00, 0x2e01, 0x2e06, 0x2e08, 0x2e0b, 0x2e0b, 0x2e0e, 0x2e16, 0x2e18, 0x2e19, 0x2e1b, 0x2e1b, 0x2e1e, 0x2e1f, 0x2e2a, 0x2e2e, 0x2e30, 0x2e39, 0x2e3c, 0x2e3f, 0x2e41, 0x2e41, 0x3001, 0x3003, 0x303d, 0x303d, 0x30fb, 0x30fb, 0xa4fe, 0xa4ff, 0xa60d, 0xa60f, 0xa673, 0xa673, 0xa67e, 0xa67e, 0xa6f2, 0xa6f7, 0xa874, 0xa877, 0xa8ce, 0xa8cf, 0xa8f8, 0xa8fa, 0xa92e, 0xa92f, 0xa95f, 0xa95f, 0xa9c1, 0xa9cd, 0xa9de, 0xa9df, 0xaa5c, 0xaa5f, 0xaade, 0xaadf, 0xaaf0, 0xaaf1, 0xabeb, 0xabeb, 0xfe10, 0xfe16, 0xfe19, 0xfe19, 0xfe30, 0xfe30, 0xfe45, 0xfe46, 0xfe49, 0xfe4c, 0xfe50, 0xfe52, 0xfe54, 0xfe57, 0xfe5f, 0xfe61, 0xfe68, 0xfe68, 0xfe6a, 0xfe6b, 0xff01, 0xff03, 0xff05, 0xff07, 0xff0a, 0xff0a, 0xff0c, 0xff0c, 0xff0e, 0xff0f, 0xff1a, 0xff1b, 0xff1f, 0xff20, 0xff3c, 0xff3c, 0xff61, 0xff61, 0xff64, 0xff65, 0x10100, 0x10102, 0x1039f, 0x1039f, 0x103d0, 0x103d0, 0x1056f, 0x1056f, 0x10857, 0x10857, 0x1091f, 0x1091f, 0x1093f, 0x1093f, 0x10a50, 0x10a58, 0x10a7f, 0x10a7f, 0x10af0, 0x10af6, 0x10b39, 0x10b3f, 0x10b99, 0x10b9c, 0x11047, 0x1104d, 0x110bb, 0x110bc, 0x110be, 0x110c1, 0x11140, 0x11143, 0x11174, 0x11175, 0x111c5, 0x111c8, 0x111cd, 0x111cd, 0x11238, 0x1123d, 0x114c6, 0x114c6, 0x115c1, 0x115c9, 0x11641, 0x11643, 0x12470, 0x12474, 0x16a6e, 0x16a6f, 0x16af5, 0x16af5, 0x16b37, 0x16b3b, 0x16b44, 0x16b44, 0x1bc9f, 0x1bc9f }; UCP_FN(Po) static const unichar ucp_Ps_def[] = { 0x28, 0x28, 0x5b, 0x5b, 0x7b, 0x7b, 0xf3a, 0xf3a, 0xf3c, 0xf3c, 0x169b, 0x169b, 0x201a, 0x201a, 0x201e, 0x201e, 0x2045, 0x2045, 0x207d, 0x207d, 0x208d, 0x208d, 0x2308, 0x2308, 0x230a, 0x230a, 0x2329, 0x2329, 0x2768, 0x2768, 0x276a, 0x276a, 0x276c, 0x276c, 0x276e, 0x276e, 0x2770, 0x2770, 0x2772, 0x2772, 0x2774, 0x2774, 0x27c5, 0x27c5, 0x27e6, 0x27e6, 0x27e8, 0x27e8, 0x27ea, 0x27ea, 0x27ec, 0x27ec, 0x27ee, 0x27ee, 0x2983, 0x2983, 0x2985, 0x2985, 0x2987, 0x2987, 0x2989, 0x2989, 0x298b, 0x298b, 0x298d, 0x298d, 0x298f, 0x298f, 0x2991, 0x2991, 0x2993, 0x2993, 0x2995, 0x2995, 0x2997, 0x2997, 0x29d8, 0x29d8, 0x29da, 0x29da, 0x29fc, 0x29fc, 0x2e22, 0x2e22, 0x2e24, 0x2e24, 0x2e26, 0x2e26, 0x2e28, 0x2e28, 0x2e42, 0x2e42, 0x3008, 0x3008, 0x300a, 0x300a, 0x300c, 0x300c, 0x300e, 0x300e, 0x3010, 0x3010, 0x3014, 0x3014, 0x3016, 0x3016, 0x3018, 0x3018, 0x301a, 0x301a, 0x301d, 0x301d, 0xfd3f, 0xfd3f, 0xfe17, 0xfe17, 0xfe35, 0xfe35, 0xfe37, 0xfe37, 0xfe39, 0xfe39, 0xfe3b, 0xfe3b, 0xfe3d, 0xfe3d, 0xfe3f, 0xfe3f, 0xfe41, 0xfe41, 0xfe43, 0xfe43, 0xfe47, 0xfe47, 0xfe59, 0xfe59, 0xfe5b, 0xfe5b, 0xfe5d, 0xfe5d, 0xff08, 0xff08, 0xff3b, 0xff3b, 0xff5b, 0xff5b, 0xff5f, 0xff5f, 0xff62, 0xff62 }; UCP_FN(Ps) static const unichar ucp_S_def[] = { 0x24, 0x24, 0x2b, 0x2b, 0x3c, 0x3e, 0x5e, 0x5e, 0x60, 0x60, 0x7c, 0x7c, 0x7e, 0x7e, 0xa2, 0xa6, 0xa8, 0xa9, 0xac, 0xac, 0xae, 0xb1, 0xb4, 0xb4, 0xb8, 0xb8, 0xd7, 0xd7, 0xf7, 0xf7, 0x2c2, 0x2c5, 0x2d2, 0x2df, 0x2e5, 0x2eb, 0x2ed, 0x2ed, 0x2ef, 0x2ff, 0x375, 0x375, 0x384, 0x385, 0x3f6, 0x3f6, 0x482, 0x482, 0x58d, 0x58f, 0x606, 0x608, 0x60b, 0x60b, 0x60e, 0x60f, 0x6de, 0x6de, 0x6e9, 0x6e9, 0x6fd, 0x6fe, 0x7f6, 0x7f6, 0x9f2, 0x9f3, 0x9fa, 0x9fb, 0xaf1, 0xaf1, 0xb70, 0xb70, 0xbf3, 0xbfa, 0xc7f, 0xc7f, 0xd79, 0xd79, 0xe3f, 0xe3f, 0xf01, 0xf03, 0xf13, 0xf13, 0xf15, 0xf17, 0xf1a, 0xf1f, 0xf34, 0xf34, 0xf36, 0xf36, 0xf38, 0xf38, 0xfbe, 0xfc5, 0xfc7, 0xfcc, 0xfce, 0xfcf, 0xfd5, 0xfd8, 0x109e, 0x109f, 0x1390, 0x1399, 0x17db, 0x17db, 0x1940, 0x1940, 0x19de, 0x19ff, 0x1b61, 0x1b6a, 0x1b74, 0x1b7c, 0x1fbd, 0x1fbd, 0x1fbf, 0x1fc1, 0x1fcd, 0x1fcf, 0x1fdd, 0x1fdf, 0x1fed, 0x1fef, 0x1ffd, 0x1ffe, 0x2044, 0x2044, 0x2052, 0x2052, 0x207a, 0x207c, 0x208a, 0x208c, 0x20a0, 0x20bd, 0x2100, 0x2101, 0x2103, 0x2106, 0x2108, 0x2109, 0x2114, 0x2114, 0x2116, 0x2118, 0x211e, 0x2123, 0x2125, 0x2125, 0x2127, 0x2127, 0x2129, 0x2129, 0x212e, 0x212e, 0x213a, 0x213b, 0x2140, 0x2144, 0x214a, 0x214d, 0x214f, 0x214f, 0x2190, 0x2307, 0x230c, 0x2328, 0x232b, 0x23fa, 0x2400, 0x2426, 0x2440, 0x244a, 0x249c, 0x24e9, 0x2500, 0x2767, 0x2794, 0x27c4, 0x27c7, 0x27e5, 0x27f0, 0x2982, 0x2999, 0x29d7, 0x29dc, 0x29fb, 0x29fe, 0x2b73, 0x2b76, 0x2b95, 0x2b98, 0x2bb9, 0x2bbd, 0x2bc8, 0x2bca, 0x2bd1, 0x2ce5, 0x2cea, 0x2e80, 0x2e99, 0x2e9b, 0x2ef3, 0x2f00, 0x2fd5, 0x2ff0, 0x2ffb, 0x3004, 0x3004, 0x3012, 0x3013, 0x3020, 0x3020, 0x3036, 0x3037, 0x303e, 0x303f, 0x309b, 0x309c, 0x3190, 0x3191, 0x3196, 0x319f, 0x31c0, 0x31e3, 0x3200, 0x321e, 0x322a, 0x3247, 0x3250, 0x3250, 0x3260, 0x327f, 0x328a, 0x32b0, 0x32c0, 0x32fe, 0x3300, 0x33ff, 0x4dc0, 0x4dff, 0xa490, 0xa4c6, 0xa700, 0xa716, 0xa720, 0xa721, 0xa789, 0xa78a, 0xa828, 0xa82b, 0xa836, 0xa839, 0xaa77, 0xaa79, 0xab5b, 0xab5b, 0xfb29, 0xfb29, 0xfbb2, 0xfbc1, 0xfdfc, 0xfdfd, 0xfe62, 0xfe62, 0xfe64, 0xfe66, 0xfe69, 0xfe69, 0xff04, 0xff04, 0xff0b, 0xff0b, 0xff1c, 0xff1e, 0xff3e, 0xff3e, 0xff40, 0xff40, 0xff5c, 0xff5c, 0xff5e, 0xff5e, 0xffe0, 0xffe6, 0xffe8, 0xffee, 0xfffc, 0xfffd, 0x10137, 0x1013f, 0x10179, 0x10189, 0x1018c, 0x1018c, 0x10190, 0x1019b, 0x101a0, 0x101a0, 0x101d0, 0x101fc, 0x10877, 0x10878, 0x10ac8, 0x10ac8, 0x16b3c, 0x16b3f, 0x16b45, 0x16b45, 0x1bc9c, 0x1bc9c, 0x1d000, 0x1d0f5, 0x1d100, 0x1d126, 0x1d129, 0x1d164, 0x1d16a, 0x1d16c, 0x1d183, 0x1d184, 0x1d18c, 0x1d1a9, 0x1d1ae, 0x1d1dd, 0x1d200, 0x1d241, 0x1d245, 0x1d245, 0x1d300, 0x1d356, 0x1d6c1, 0x1d6c1, 0x1d6db, 0x1d6db, 0x1d6fb, 0x1d6fb, 0x1d715, 0x1d715, 0x1d735, 0x1d735, 0x1d74f, 0x1d74f, 0x1d76f, 0x1d76f, 0x1d789, 0x1d789, 0x1d7a9, 0x1d7a9, 0x1d7c3, 0x1d7c3, 0x1eef0, 0x1eef1, 0x1f000, 0x1f02b, 0x1f030, 0x1f093, 0x1f0a0, 0x1f0ae, 0x1f0b1, 0x1f0bf, 0x1f0c1, 0x1f0cf, 0x1f0d1, 0x1f0f5, 0x1f110, 0x1f12e, 0x1f130, 0x1f16b, 0x1f170, 0x1f19a, 0x1f1e6, 0x1f202, 0x1f210, 0x1f23a, 0x1f240, 0x1f248, 0x1f250, 0x1f251, 0x1f300, 0x1f32c, 0x1f330, 0x1f37d, 0x1f380, 0x1f3ce, 0x1f3d4, 0x1f3f7, 0x1f400, 0x1f4fe, 0x1f500, 0x1f54a, 0x1f550, 0x1f579, 0x1f57b, 0x1f5a3, 0x1f5a5, 0x1f642, 0x1f645, 0x1f6cf, 0x1f6e0, 0x1f6ec, 0x1f6f0, 0x1f6f3, 0x1f700, 0x1f773, 0x1f780, 0x1f7d4, 0x1f800, 0x1f80b, 0x1f810, 0x1f847, 0x1f850, 0x1f859, 0x1f860, 0x1f887, 0x1f890, 0x1f8ad }; UCP_FN(S) static const unichar ucp_Sc_def[] = { 0x24, 0x24, 0xa2, 0xa5, 0x58f, 0x58f, 0x60b, 0x60b, 0x9f2, 0x9f3, 0x9fb, 0x9fb, 0xaf1, 0xaf1, 0xbf9, 0xbf9, 0xe3f, 0xe3f, 0x17db, 0x17db, 0x20a0, 0x20bd, 0xa838, 0xa838, 0xfdfc, 0xfdfc, 0xfe69, 0xfe69, 0xff04, 0xff04, 0xffe0, 0xffe1, 0xffe5, 0xffe6 }; UCP_FN(Sc) static const unichar ucp_Sk_def[] = { 0x5e, 0x5e, 0x60, 0x60, 0xa8, 0xa8, 0xaf, 0xaf, 0xb4, 0xb4, 0xb8, 0xb8, 0x2c2, 0x2c5, 0x2d2, 0x2df, 0x2e5, 0x2eb, 0x2ed, 0x2ed, 0x2ef, 0x2ff, 0x375, 0x375, 0x384, 0x385, 0x1fbd, 0x1fbd, 0x1fbf, 0x1fc1, 0x1fcd, 0x1fcf, 0x1fdd, 0x1fdf, 0x1fed, 0x1fef, 0x1ffd, 0x1ffe, 0x309b, 0x309c, 0xa700, 0xa716, 0xa720, 0xa721, 0xa789, 0xa78a, 0xab5b, 0xab5b, 0xfbb2, 0xfbc1, 0xff3e, 0xff3e, 0xff40, 0xff40, 0xffe3, 0xffe3 }; UCP_FN(Sk) static const unichar ucp_Sm_def[] = { 0x2b, 0x2b, 0x3c, 0x3e, 0x7c, 0x7c, 0x7e, 0x7e, 0xac, 0xac, 0xb1, 0xb1, 0xd7, 0xd7, 0xf7, 0xf7, 0x3f6, 0x3f6, 0x606, 0x608, 0x2044, 0x2044, 0x2052, 0x2052, 0x207a, 0x207c, 0x208a, 0x208c, 0x2118, 0x2118, 0x2140, 0x2144, 0x214b, 0x214b, 0x2190, 0x2194, 0x219a, 0x219b, 0x21a0, 0x21a0, 0x21a3, 0x21a3, 0x21a6, 0x21a6, 0x21ae, 0x21ae, 0x21ce, 0x21cf, 0x21d2, 0x21d2, 0x21d4, 0x21d4, 0x21f4, 0x22ff, 0x2320, 0x2321, 0x237c, 0x237c, 0x239b, 0x23b3, 0x23dc, 0x23e1, 0x25b7, 0x25b7, 0x25c1, 0x25c1, 0x25f8, 0x25ff, 0x266f, 0x266f, 0x27c0, 0x27c4, 0x27c7, 0x27e5, 0x27f0, 0x27ff, 0x2900, 0x2982, 0x2999, 0x29d7, 0x29dc, 0x29fb, 0x29fe, 0x2aff, 0x2b30, 0x2b44, 0x2b47, 0x2b4c, 0xfb29, 0xfb29, 0xfe62, 0xfe62, 0xfe64, 0xfe66, 0xff0b, 0xff0b, 0xff1c, 0xff1e, 0xff5c, 0xff5c, 0xff5e, 0xff5e, 0xffe2, 0xffe2, 0xffe9, 0xffec, 0x1d6c1, 0x1d6c1, 0x1d6db, 0x1d6db, 0x1d6fb, 0x1d6fb, 0x1d715, 0x1d715, 0x1d735, 0x1d735, 0x1d74f, 0x1d74f, 0x1d76f, 0x1d76f, 0x1d789, 0x1d789, 0x1d7a9, 0x1d7a9, 0x1d7c3, 0x1d7c3, 0x1eef0, 0x1eef1 }; UCP_FN(Sm) static const unichar ucp_So_def[] = { 0xa6, 0xa6, 0xa9, 0xa9, 0xae, 0xae, 0xb0, 0xb0, 0x482, 0x482, 0x58d, 0x58e, 0x60e, 0x60f, 0x6de, 0x6de, 0x6e9, 0x6e9, 0x6fd, 0x6fe, 0x7f6, 0x7f6, 0x9fa, 0x9fa, 0xb70, 0xb70, 0xbf3, 0xbf8, 0xbfa, 0xbfa, 0xc7f, 0xc7f, 0xd79, 0xd79, 0xf01, 0xf03, 0xf13, 0xf13, 0xf15, 0xf17, 0xf1a, 0xf1f, 0xf34, 0xf34, 0xf36, 0xf36, 0xf38, 0xf38, 0xfbe, 0xfc5, 0xfc7, 0xfcc, 0xfce, 0xfcf, 0xfd5, 0xfd8, 0x109e, 0x109f, 0x1390, 0x1399, 0x1940, 0x1940, 0x19de, 0x19ff, 0x1b61, 0x1b6a, 0x1b74, 0x1b7c, 0x2100, 0x2101, 0x2103, 0x2106, 0x2108, 0x2109, 0x2114, 0x2114, 0x2116, 0x2117, 0x211e, 0x2123, 0x2125, 0x2125, 0x2127, 0x2127, 0x2129, 0x2129, 0x212e, 0x212e, 0x213a, 0x213b, 0x214a, 0x214a, 0x214c, 0x214d, 0x214f, 0x214f, 0x2195, 0x2199, 0x219c, 0x219f, 0x21a1, 0x21a2, 0x21a4, 0x21a5, 0x21a7, 0x21ad, 0x21af, 0x21cd, 0x21d0, 0x21d1, 0x21d3, 0x21d3, 0x21d5, 0x21f3, 0x2300, 0x2307, 0x230c, 0x231f, 0x2322, 0x2328, 0x232b, 0x237b, 0x237d, 0x239a, 0x23b4, 0x23db, 0x23e2, 0x23fa, 0x2400, 0x2426, 0x2440, 0x244a, 0x249c, 0x24e9, 0x2500, 0x25b6, 0x25b8, 0x25c0, 0x25c2, 0x25f7, 0x2600, 0x266e, 0x2670, 0x2767, 0x2794, 0x27bf, 0x2800, 0x28ff, 0x2b00, 0x2b2f, 0x2b45, 0x2b46, 0x2b4d, 0x2b73, 0x2b76, 0x2b95, 0x2b98, 0x2bb9, 0x2bbd, 0x2bc8, 0x2bca, 0x2bd1, 0x2ce5, 0x2cea, 0x2e80, 0x2e99, 0x2e9b, 0x2ef3, 0x2f00, 0x2fd5, 0x2ff0, 0x2ffb, 0x3004, 0x3004, 0x3012, 0x3013, 0x3020, 0x3020, 0x3036, 0x3037, 0x303e, 0x303f, 0x3190, 0x3191, 0x3196, 0x319f, 0x31c0, 0x31e3, 0x3200, 0x321e, 0x322a, 0x3247, 0x3250, 0x3250, 0x3260, 0x327f, 0x328a, 0x32b0, 0x32c0, 0x32fe, 0x3300, 0x33ff, 0x4dc0, 0x4dff, 0xa490, 0xa4c6, 0xa828, 0xa82b, 0xa836, 0xa837, 0xa839, 0xa839, 0xaa77, 0xaa79, 0xfdfd, 0xfdfd, 0xffe4, 0xffe4, 0xffe8, 0xffe8, 0xffed, 0xffee, 0xfffc, 0xfffd, 0x10137, 0x1013f, 0x10179, 0x10189, 0x1018c, 0x1018c, 0x10190, 0x1019b, 0x101a0, 0x101a0, 0x101d0, 0x101fc, 0x10877, 0x10878, 0x10ac8, 0x10ac8, 0x16b3c, 0x16b3f, 0x16b45, 0x16b45, 0x1bc9c, 0x1bc9c, 0x1d000, 0x1d0f5, 0x1d100, 0x1d126, 0x1d129, 0x1d164, 0x1d16a, 0x1d16c, 0x1d183, 0x1d184, 0x1d18c, 0x1d1a9, 0x1d1ae, 0x1d1dd, 0x1d200, 0x1d241, 0x1d245, 0x1d245, 0x1d300, 0x1d356, 0x1f000, 0x1f02b, 0x1f030, 0x1f093, 0x1f0a0, 0x1f0ae, 0x1f0b1, 0x1f0bf, 0x1f0c1, 0x1f0cf, 0x1f0d1, 0x1f0f5, 0x1f110, 0x1f12e, 0x1f130, 0x1f16b, 0x1f170, 0x1f19a, 0x1f1e6, 0x1f202, 0x1f210, 0x1f23a, 0x1f240, 0x1f248, 0x1f250, 0x1f251, 0x1f300, 0x1f32c, 0x1f330, 0x1f37d, 0x1f380, 0x1f3ce, 0x1f3d4, 0x1f3f7, 0x1f400, 0x1f4fe, 0x1f500, 0x1f54a, 0x1f550, 0x1f579, 0x1f57b, 0x1f5a3, 0x1f5a5, 0x1f642, 0x1f645, 0x1f6cf, 0x1f6e0, 0x1f6ec, 0x1f6f0, 0x1f6f3, 0x1f700, 0x1f773, 0x1f780, 0x1f7d4, 0x1f800, 0x1f80b, 0x1f810, 0x1f847, 0x1f850, 0x1f859, 0x1f860, 0x1f887, 0x1f890, 0x1f8ad }; UCP_FN(So) static const unichar ucp_Xan_def[] = { 0x30, 0x39, 0x41, 0x5a, 0x61, 0x7a, 0xaa, 0xaa, 0xb2, 0xb3, 0xb5, 0xb5, 0xb9, 0xba, 0xbc, 0xbe, 0xc0, 0xd6, 0xd8, 0xf6, 0xf8, 0x2c1, 0x2c6, 0x2d1, 0x2e0, 0x2e4, 0x2ec, 0x2ec, 0x2ee, 0x2ee, 0x370, 0x374, 0x376, 0x377, 0x37a, 0x37d, 0x37f, 0x37f, 0x386, 0x386, 0x388, 0x38a, 0x38c, 0x38c, 0x38e, 0x3a1, 0x3a3, 0x3f5, 0x3f7, 0x481, 0x48a, 0x52f, 0x531, 0x556, 0x559, 0x559, 0x561, 0x587, 0x5d0, 0x5ea, 0x5f0, 0x5f2, 0x620, 0x64a, 0x660, 0x669, 0x66e, 0x66f, 0x671, 0x6d3, 0x6d5, 0x6d5, 0x6e5, 0x6e6, 0x6ee, 0x6fc, 0x6ff, 0x6ff, 0x710, 0x710, 0x712, 0x72f, 0x74d, 0x7a5, 0x7b1, 0x7b1, 0x7c0, 0x7ea, 0x7f4, 0x7f5, 0x7fa, 0x7fa, 0x800, 0x815, 0x81a, 0x81a, 0x824, 0x824, 0x828, 0x828, 0x840, 0x858, 0x8a0, 0x8b2, 0x904, 0x939, 0x93d, 0x93d, 0x950, 0x950, 0x958, 0x961, 0x966, 0x96f, 0x971, 0x980, 0x985, 0x98c, 0x98f, 0x990, 0x993, 0x9a8, 0x9aa, 0x9b0, 0x9b2, 0x9b2, 0x9b6, 0x9b9, 0x9bd, 0x9bd, 0x9ce, 0x9ce, 0x9dc, 0x9dd, 0x9df, 0x9e1, 0x9e6, 0x9f1, 0x9f4, 0x9f9, 0xa05, 0xa0a, 0xa0f, 0xa10, 0xa13, 0xa28, 0xa2a, 0xa30, 0xa32, 0xa33, 0xa35, 0xa36, 0xa38, 0xa39, 0xa59, 0xa5c, 0xa5e, 0xa5e, 0xa66, 0xa6f, 0xa72, 0xa74, 0xa85, 0xa8d, 0xa8f, 0xa91, 0xa93, 0xaa8, 0xaaa, 0xab0, 0xab2, 0xab3, 0xab5, 0xab9, 0xabd, 0xabd, 0xad0, 0xad0, 0xae0, 0xae1, 0xae6, 0xaef, 0xb05, 0xb0c, 0xb0f, 0xb10, 0xb13, 0xb28, 0xb2a, 0xb30, 0xb32, 0xb33, 0xb35, 0xb39, 0xb3d, 0xb3d, 0xb5c, 0xb5d, 0xb5f, 0xb61, 0xb66, 0xb6f, 0xb71, 0xb77, 0xb83, 0xb83, 0xb85, 0xb8a, 0xb8e, 0xb90, 0xb92, 0xb95, 0xb99, 0xb9a, 0xb9c, 0xb9c, 0xb9e, 0xb9f, 0xba3, 0xba4, 0xba8, 0xbaa, 0xbae, 0xbb9, 0xbd0, 0xbd0, 0xbe6, 0xbf2, 0xc05, 0xc0c, 0xc0e, 0xc10, 0xc12, 0xc28, 0xc2a, 0xc39, 0xc3d, 0xc3d, 0xc58, 0xc59, 0xc60, 0xc61, 0xc66, 0xc6f, 0xc78, 0xc7e, 0xc85, 0xc8c, 0xc8e, 0xc90, 0xc92, 0xca8, 0xcaa, 0xcb3, 0xcb5, 0xcb9, 0xcbd, 0xcbd, 0xcde, 0xcde, 0xce0, 0xce1, 0xce6, 0xcef, 0xcf1, 0xcf2, 0xd05, 0xd0c, 0xd0e, 0xd10, 0xd12, 0xd3a, 0xd3d, 0xd3d, 0xd4e, 0xd4e, 0xd60, 0xd61, 0xd66, 0xd75, 0xd7a, 0xd7f, 0xd85, 0xd96, 0xd9a, 0xdb1, 0xdb3, 0xdbb, 0xdbd, 0xdbd, 0xdc0, 0xdc6, 0xde6, 0xdef, 0xe01, 0xe30, 0xe32, 0xe33, 0xe40, 0xe46, 0xe50, 0xe59, 0xe81, 0xe82, 0xe84, 0xe84, 0xe87, 0xe88, 0xe8a, 0xe8a, 0xe8d, 0xe8d, 0xe94, 0xe97, 0xe99, 0xe9f, 0xea1, 0xea3, 0xea5, 0xea5, 0xea7, 0xea7, 0xeaa, 0xeab, 0xead, 0xeb0, 0xeb2, 0xeb3, 0xebd, 0xebd, 0xec0, 0xec4, 0xec6, 0xec6, 0xed0, 0xed9, 0xedc, 0xedf, 0xf00, 0xf00, 0xf20, 0xf33, 0xf40, 0xf47, 0xf49, 0xf6c, 0xf88, 0xf8c, 0x1000, 0x102a, 0x103f, 0x1049, 0x1050, 0x1055, 0x105a, 0x105d, 0x1061, 0x1061, 0x1065, 0x1066, 0x106e, 0x1070, 0x1075, 0x1081, 0x108e, 0x108e, 0x1090, 0x1099, 0x10a0, 0x10c5, 0x10c7, 0x10c7, 0x10cd, 0x10cd, 0x10d0, 0x10fa, 0x10fc, 0x1248, 0x124a, 0x124d, 0x1250, 0x1256, 0x1258, 0x1258, 0x125a, 0x125d, 0x1260, 0x1288, 0x128a, 0x128d, 0x1290, 0x12b0, 0x12b2, 0x12b5, 0x12b8, 0x12be, 0x12c0, 0x12c0, 0x12c2, 0x12c5, 0x12c8, 0x12d6, 0x12d8, 0x1310, 0x1312, 0x1315, 0x1318, 0x135a, 0x1369, 0x137c, 0x1380, 0x138f, 0x13a0, 0x13f4, 0x1401, 0x166c, 0x166f, 0x167f, 0x1681, 0x169a, 0x16a0, 0x16ea, 0x16ee, 0x16f8, 0x1700, 0x170c, 0x170e, 0x1711, 0x1720, 0x1731, 0x1740, 0x1751, 0x1760, 0x176c, 0x176e, 0x1770, 0x1780, 0x17b3, 0x17d7, 0x17d7, 0x17dc, 0x17dc, 0x17e0, 0x17e9, 0x17f0, 0x17f9, 0x1810, 0x1819, 0x1820, 0x1877, 0x1880, 0x18a8, 0x18aa, 0x18aa, 0x18b0, 0x18f5, 0x1900, 0x191e, 0x1946, 0x196d, 0x1970, 0x1974, 0x1980, 0x19ab, 0x19c1, 0x19c7, 0x19d0, 0x19da, 0x1a00, 0x1a16, 0x1a20, 0x1a54, 0x1a80, 0x1a89, 0x1a90, 0x1a99, 0x1aa7, 0x1aa7, 0x1b05, 0x1b33, 0x1b45, 0x1b4b, 0x1b50, 0x1b59, 0x1b83, 0x1ba0, 0x1bae, 0x1be5, 0x1c00, 0x1c23, 0x1c40, 0x1c49, 0x1c4d, 0x1c7d, 0x1ce9, 0x1cec, 0x1cee, 0x1cf1, 0x1cf5, 0x1cf6, 0x1d00, 0x1dbf, 0x1e00, 0x1f15, 0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f57, 0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f7d, 0x1f80, 0x1fb4, 0x1fb6, 0x1fbc, 0x1fbe, 0x1fbe, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fcc, 0x1fd0, 0x1fd3, 0x1fd6, 0x1fdb, 0x1fe0, 0x1fec, 0x1ff2, 0x1ff4, 0x1ff6, 0x1ffc, 0x2070, 0x2071, 0x2074, 0x2079, 0x207f, 0x2089, 0x2090, 0x209c, 0x2102, 0x2102, 0x2107, 0x2107, 0x210a, 0x2113, 0x2115, 0x2115, 0x2119, 0x211d, 0x2124, 0x2124, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212d, 0x212f, 0x2139, 0x213c, 0x213f, 0x2145, 0x2149, 0x214e, 0x214e, 0x2150, 0x2189, 0x2460, 0x249b, 0x24ea, 0x24ff, 0x2776, 0x2793, 0x2c00, 0x2c2e, 0x2c30, 0x2c5e, 0x2c60, 0x2ce4, 0x2ceb, 0x2cee, 0x2cf2, 0x2cf3, 0x2cfd, 0x2cfd, 0x2d00, 0x2d25, 0x2d27, 0x2d27, 0x2d2d, 0x2d2d, 0x2d30, 0x2d67, 0x2d6f, 0x2d6f, 0x2d80, 0x2d96, 0x2da0, 0x2da6, 0x2da8, 0x2dae, 0x2db0, 0x2db6, 0x2db8, 0x2dbe, 0x2dc0, 0x2dc6, 0x2dc8, 0x2dce, 0x2dd0, 0x2dd6, 0x2dd8, 0x2dde, 0x2e2f, 0x2e2f, 0x3005, 0x3007, 0x3021, 0x3029, 0x3031, 0x3035, 0x3038, 0x303c, 0x3041, 0x3096, 0x309d, 0x309f, 0x30a1, 0x30fa, 0x30fc, 0x30ff, 0x3105, 0x312d, 0x3131, 0x318e, 0x3192, 0x3195, 0x31a0, 0x31ba, 0x31f0, 0x31ff, 0x3220, 0x3229, 0x3248, 0x324f, 0x3251, 0x325f, 0x3280, 0x3289, 0x32b1, 0x32bf, 0x3400, 0x4db5, 0x4e00, 0x9fcc, 0xa000, 0xa48c, 0xa4d0, 0xa4fd, 0xa500, 0xa60c, 0xa610, 0xa62b, 0xa640, 0xa66e, 0xa67f, 0xa69d, 0xa6a0, 0xa6ef, 0xa717, 0xa71f, 0xa722, 0xa788, 0xa78b, 0xa78e, 0xa790, 0xa7ad, 0xa7b0, 0xa7b1, 0xa7f7, 0xa801, 0xa803, 0xa805, 0xa807, 0xa80a, 0xa80c, 0xa822, 0xa830, 0xa835, 0xa840, 0xa873, 0xa882, 0xa8b3, 0xa8d0, 0xa8d9, 0xa8f2, 0xa8f7, 0xa8fb, 0xa8fb, 0xa900, 0xa925, 0xa930, 0xa946, 0xa960, 0xa97c, 0xa984, 0xa9b2, 0xa9cf, 0xa9d9, 0xa9e0, 0xa9e4, 0xa9e6, 0xa9fe, 0xaa00, 0xaa28, 0xaa40, 0xaa42, 0xaa44, 0xaa4b, 0xaa50, 0xaa59, 0xaa60, 0xaa76, 0xaa7a, 0xaa7a, 0xaa7e, 0xaaaf, 0xaab1, 0xaab1, 0xaab5, 0xaab6, 0xaab9, 0xaabd, 0xaac0, 0xaac0, 0xaac2, 0xaac2, 0xaadb, 0xaadd, 0xaae0, 0xaaea, 0xaaf2, 0xaaf4, 0xab01, 0xab06, 0xab09, 0xab0e, 0xab11, 0xab16, 0xab20, 0xab26, 0xab28, 0xab2e, 0xab30, 0xab5a, 0xab5c, 0xab5f, 0xab64, 0xab65, 0xabc0, 0xabe2, 0xabf0, 0xabf9, 0xac00, 0xd7a3, 0xd7b0, 0xd7c6, 0xd7cb, 0xd7fb, 0xf900, 0xfa6d, 0xfa70, 0xfad9, 0xfb00, 0xfb06, 0xfb13, 0xfb17, 0xfb1d, 0xfb1d, 0xfb1f, 0xfb28, 0xfb2a, 0xfb36, 0xfb38, 0xfb3c, 0xfb3e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfb46, 0xfbb1, 0xfbd3, 0xfd3d, 0xfd50, 0xfd8f, 0xfd92, 0xfdc7, 0xfdf0, 0xfdfb, 0xfe70, 0xfe74, 0xfe76, 0xfefc, 0xff10, 0xff19, 0xff21, 0xff3a, 0xff41, 0xff5a, 0xff66, 0xffbe, 0xffc2, 0xffc7, 0xffca, 0xffcf, 0xffd2, 0xffd7, 0xffda, 0xffdc, 0x10000, 0x1000b, 0x1000d, 0x10026, 0x10028, 0x1003a, 0x1003c, 0x1003d, 0x1003f, 0x1004d, 0x10050, 0x1005d, 0x10080, 0x100fa, 0x10107, 0x10133, 0x10140, 0x10178, 0x1018a, 0x1018b, 0x10280, 0x1029c, 0x102a0, 0x102d0, 0x102e1, 0x102fb, 0x10300, 0x10323, 0x10330, 0x1034a, 0x10350, 0x10375, 0x10380, 0x1039d, 0x103a0, 0x103c3, 0x103c8, 0x103cf, 0x103d1, 0x103d5, 0x10400, 0x1049d, 0x104a0, 0x104a9, 0x10500, 0x10527, 0x10530, 0x10563, 0x10600, 0x10736, 0x10740, 0x10755, 0x10760, 0x10767, 0x10800, 0x10805, 0x10808, 0x10808, 0x1080a, 0x10835, 0x10837, 0x10838, 0x1083c, 0x1083c, 0x1083f, 0x10855, 0x10858, 0x10876, 0x10879, 0x1089e, 0x108a7, 0x108af, 0x10900, 0x1091b, 0x10920, 0x10939, 0x10980, 0x109b7, 0x109be, 0x109bf, 0x10a00, 0x10a00, 0x10a10, 0x10a13, 0x10a15, 0x10a17, 0x10a19, 0x10a33, 0x10a40, 0x10a47, 0x10a60, 0x10a7e, 0x10a80, 0x10a9f, 0x10ac0, 0x10ac7, 0x10ac9, 0x10ae4, 0x10aeb, 0x10aef, 0x10b00, 0x10b35, 0x10b40, 0x10b55, 0x10b58, 0x10b72, 0x10b78, 0x10b91, 0x10ba9, 0x10baf, 0x10c00, 0x10c48, 0x10e60, 0x10e7e, 0x11003, 0x11037, 0x11052, 0x1106f, 0x11083, 0x110af, 0x110d0, 0x110e8, 0x110f0, 0x110f9, 0x11103, 0x11126, 0x11136, 0x1113f, 0x11150, 0x11172, 0x11176, 0x11176, 0x11183, 0x111b2, 0x111c1, 0x111c4, 0x111d0, 0x111da, 0x111e1, 0x111f4, 0x11200, 0x11211, 0x11213, 0x1122b, 0x112b0, 0x112de, 0x112f0, 0x112f9, 0x11305, 0x1130c, 0x1130f, 0x11310, 0x11313, 0x11328, 0x1132a, 0x11330, 0x11332, 0x11333, 0x11335, 0x11339, 0x1133d, 0x1133d, 0x1135d, 0x11361, 0x11480, 0x114af, 0x114c4, 0x114c5, 0x114c7, 0x114c7, 0x114d0, 0x114d9, 0x11580, 0x115ae, 0x11600, 0x1162f, 0x11644, 0x11644, 0x11650, 0x11659, 0x11680, 0x116aa, 0x116c0, 0x116c9, 0x118a0, 0x118f2, 0x118ff, 0x118ff, 0x11ac0, 0x11af8, 0x12000, 0x12398, 0x12400, 0x1246e, 0x13000, 0x1342e, 0x16800, 0x16a38, 0x16a40, 0x16a5e, 0x16a60, 0x16a69, 0x16ad0, 0x16aed, 0x16b00, 0x16b2f, 0x16b40, 0x16b43, 0x16b50, 0x16b59, 0x16b5b, 0x16b61, 0x16b63, 0x16b77, 0x16b7d, 0x16b8f, 0x16f00, 0x16f44, 0x16f50, 0x16f50, 0x16f93, 0x16f9f, 0x1b000, 0x1b001, 0x1bc00, 0x1bc6a, 0x1bc70, 0x1bc7c, 0x1bc80, 0x1bc88, 0x1bc90, 0x1bc99, 0x1d360, 0x1d371, 0x1d400, 0x1d454, 0x1d456, 0x1d49c, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4a9, 0x1d4ac, 0x1d4ae, 0x1d4b9, 0x1d4bb, 0x1d4bb, 0x1d4bd, 0x1d4c3, 0x1d4c5, 0x1d505, 0x1d507, 0x1d50a, 0x1d50d, 0x1d514, 0x1d516, 0x1d51c, 0x1d51e, 0x1d539, 0x1d53b, 0x1d53e, 0x1d540, 0x1d544, 0x1d546, 0x1d546, 0x1d54a, 0x1d550, 0x1d552, 0x1d6a5, 0x1d6a8, 0x1d6c0, 0x1d6c2, 0x1d6da, 0x1d6dc, 0x1d6fa, 0x1d6fc, 0x1d714, 0x1d716, 0x1d734, 0x1d736, 0x1d74e, 0x1d750, 0x1d76e, 0x1d770, 0x1d788, 0x1d78a, 0x1d7a8, 0x1d7aa, 0x1d7c2, 0x1d7c4, 0x1d7cb, 0x1d7ce, 0x1d7ff, 0x1e800, 0x1e8c4, 0x1e8c7, 0x1e8cf, 0x1ee00, 0x1ee03, 0x1ee05, 0x1ee1f, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee24, 0x1ee27, 0x1ee27, 0x1ee29, 0x1ee32, 0x1ee34, 0x1ee37, 0x1ee39, 0x1ee39, 0x1ee3b, 0x1ee3b, 0x1ee42, 0x1ee42, 0x1ee47, 0x1ee47, 0x1ee49, 0x1ee49, 0x1ee4b, 0x1ee4b, 0x1ee4d, 0x1ee4f, 0x1ee51, 0x1ee52, 0x1ee54, 0x1ee54, 0x1ee57, 0x1ee57, 0x1ee59, 0x1ee59, 0x1ee5b, 0x1ee5b, 0x1ee5d, 0x1ee5d, 0x1ee5f, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee64, 0x1ee67, 0x1ee6a, 0x1ee6c, 0x1ee72, 0x1ee74, 0x1ee77, 0x1ee79, 0x1ee7c, 0x1ee7e, 0x1ee7e, 0x1ee80, 0x1ee89, 0x1ee8b, 0x1ee9b, 0x1eea1, 0x1eea3, 0x1eea5, 0x1eea9, 0x1eeab, 0x1eebb, 0x1f100, 0x1f10c, 0x20000, 0x2a6d6, 0x2a700, 0x2b734, 0x2b740, 0x2b81d, 0x2f800, 0x2fa1d }; UCP_FN(Xan) static const unichar ucp_Xps_def[] = { 0x9, 0xd, 0x20, 0x20, 0xa0, 0xa0, 0x1680, 0x1680, 0x2000, 0x200a, 0x2028, 0x2029, 0x202f, 0x202f, 0x205f, 0x205f, 0x3000, 0x3000 }; UCP_FN(Xps) static const unichar ucp_Xsp_def[] = { 0x9, 0xa, 0xc, 0xd, 0x20, 0x20, 0xa0, 0xa0, 0x1680, 0x1680, 0x2000, 0x200a, 0x2028, 0x2029, 0x202f, 0x202f, 0x205f, 0x205f, 0x3000, 0x3000 }; UCP_FN(Xsp) static const unichar ucp_Xwd_def[] = { 0x30, 0x39, 0x41, 0x5a, 0x5f, 0x5f, 0x61, 0x7a, 0xaa, 0xaa, 0xb2, 0xb3, 0xb5, 0xb5, 0xb9, 0xba, 0xbc, 0xbe, 0xc0, 0xd6, 0xd8, 0xf6, 0xf8, 0x2c1, 0x2c6, 0x2d1, 0x2e0, 0x2e4, 0x2ec, 0x2ec, 0x2ee, 0x2ee, 0x370, 0x374, 0x376, 0x377, 0x37a, 0x37d, 0x37f, 0x37f, 0x386, 0x386, 0x388, 0x38a, 0x38c, 0x38c, 0x38e, 0x3a1, 0x3a3, 0x3f5, 0x3f7, 0x481, 0x48a, 0x52f, 0x531, 0x556, 0x559, 0x559, 0x561, 0x587, 0x5d0, 0x5ea, 0x5f0, 0x5f2, 0x620, 0x64a, 0x660, 0x669, 0x66e, 0x66f, 0x671, 0x6d3, 0x6d5, 0x6d5, 0x6e5, 0x6e6, 0x6ee, 0x6fc, 0x6ff, 0x6ff, 0x710, 0x710, 0x712, 0x72f, 0x74d, 0x7a5, 0x7b1, 0x7b1, 0x7c0, 0x7ea, 0x7f4, 0x7f5, 0x7fa, 0x7fa, 0x800, 0x815, 0x81a, 0x81a, 0x824, 0x824, 0x828, 0x828, 0x840, 0x858, 0x8a0, 0x8b2, 0x904, 0x939, 0x93d, 0x93d, 0x950, 0x950, 0x958, 0x961, 0x966, 0x96f, 0x971, 0x980, 0x985, 0x98c, 0x98f, 0x990, 0x993, 0x9a8, 0x9aa, 0x9b0, 0x9b2, 0x9b2, 0x9b6, 0x9b9, 0x9bd, 0x9bd, 0x9ce, 0x9ce, 0x9dc, 0x9dd, 0x9df, 0x9e1, 0x9e6, 0x9f1, 0x9f4, 0x9f9, 0xa05, 0xa0a, 0xa0f, 0xa10, 0xa13, 0xa28, 0xa2a, 0xa30, 0xa32, 0xa33, 0xa35, 0xa36, 0xa38, 0xa39, 0xa59, 0xa5c, 0xa5e, 0xa5e, 0xa66, 0xa6f, 0xa72, 0xa74, 0xa85, 0xa8d, 0xa8f, 0xa91, 0xa93, 0xaa8, 0xaaa, 0xab0, 0xab2, 0xab3, 0xab5, 0xab9, 0xabd, 0xabd, 0xad0, 0xad0, 0xae0, 0xae1, 0xae6, 0xaef, 0xb05, 0xb0c, 0xb0f, 0xb10, 0xb13, 0xb28, 0xb2a, 0xb30, 0xb32, 0xb33, 0xb35, 0xb39, 0xb3d, 0xb3d, 0xb5c, 0xb5d, 0xb5f, 0xb61, 0xb66, 0xb6f, 0xb71, 0xb77, 0xb83, 0xb83, 0xb85, 0xb8a, 0xb8e, 0xb90, 0xb92, 0xb95, 0xb99, 0xb9a, 0xb9c, 0xb9c, 0xb9e, 0xb9f, 0xba3, 0xba4, 0xba8, 0xbaa, 0xbae, 0xbb9, 0xbd0, 0xbd0, 0xbe6, 0xbf2, 0xc05, 0xc0c, 0xc0e, 0xc10, 0xc12, 0xc28, 0xc2a, 0xc39, 0xc3d, 0xc3d, 0xc58, 0xc59, 0xc60, 0xc61, 0xc66, 0xc6f, 0xc78, 0xc7e, 0xc85, 0xc8c, 0xc8e, 0xc90, 0xc92, 0xca8, 0xcaa, 0xcb3, 0xcb5, 0xcb9, 0xcbd, 0xcbd, 0xcde, 0xcde, 0xce0, 0xce1, 0xce6, 0xcef, 0xcf1, 0xcf2, 0xd05, 0xd0c, 0xd0e, 0xd10, 0xd12, 0xd3a, 0xd3d, 0xd3d, 0xd4e, 0xd4e, 0xd60, 0xd61, 0xd66, 0xd75, 0xd7a, 0xd7f, 0xd85, 0xd96, 0xd9a, 0xdb1, 0xdb3, 0xdbb, 0xdbd, 0xdbd, 0xdc0, 0xdc6, 0xde6, 0xdef, 0xe01, 0xe30, 0xe32, 0xe33, 0xe40, 0xe46, 0xe50, 0xe59, 0xe81, 0xe82, 0xe84, 0xe84, 0xe87, 0xe88, 0xe8a, 0xe8a, 0xe8d, 0xe8d, 0xe94, 0xe97, 0xe99, 0xe9f, 0xea1, 0xea3, 0xea5, 0xea5, 0xea7, 0xea7, 0xeaa, 0xeab, 0xead, 0xeb0, 0xeb2, 0xeb3, 0xebd, 0xebd, 0xec0, 0xec4, 0xec6, 0xec6, 0xed0, 0xed9, 0xedc, 0xedf, 0xf00, 0xf00, 0xf20, 0xf33, 0xf40, 0xf47, 0xf49, 0xf6c, 0xf88, 0xf8c, 0x1000, 0x102a, 0x103f, 0x1049, 0x1050, 0x1055, 0x105a, 0x105d, 0x1061, 0x1061, 0x1065, 0x1066, 0x106e, 0x1070, 0x1075, 0x1081, 0x108e, 0x108e, 0x1090, 0x1099, 0x10a0, 0x10c5, 0x10c7, 0x10c7, 0x10cd, 0x10cd, 0x10d0, 0x10fa, 0x10fc, 0x1248, 0x124a, 0x124d, 0x1250, 0x1256, 0x1258, 0x1258, 0x125a, 0x125d, 0x1260, 0x1288, 0x128a, 0x128d, 0x1290, 0x12b0, 0x12b2, 0x12b5, 0x12b8, 0x12be, 0x12c0, 0x12c0, 0x12c2, 0x12c5, 0x12c8, 0x12d6, 0x12d8, 0x1310, 0x1312, 0x1315, 0x1318, 0x135a, 0x1369, 0x137c, 0x1380, 0x138f, 0x13a0, 0x13f4, 0x1401, 0x166c, 0x166f, 0x167f, 0x1681, 0x169a, 0x16a0, 0x16ea, 0x16ee, 0x16f8, 0x1700, 0x170c, 0x170e, 0x1711, 0x1720, 0x1731, 0x1740, 0x1751, 0x1760, 0x176c, 0x176e, 0x1770, 0x1780, 0x17b3, 0x17d7, 0x17d7, 0x17dc, 0x17dc, 0x17e0, 0x17e9, 0x17f0, 0x17f9, 0x1810, 0x1819, 0x1820, 0x1877, 0x1880, 0x18a8, 0x18aa, 0x18aa, 0x18b0, 0x18f5, 0x1900, 0x191e, 0x1946, 0x196d, 0x1970, 0x1974, 0x1980, 0x19ab, 0x19c1, 0x19c7, 0x19d0, 0x19da, 0x1a00, 0x1a16, 0x1a20, 0x1a54, 0x1a80, 0x1a89, 0x1a90, 0x1a99, 0x1aa7, 0x1aa7, 0x1b05, 0x1b33, 0x1b45, 0x1b4b, 0x1b50, 0x1b59, 0x1b83, 0x1ba0, 0x1bae, 0x1be5, 0x1c00, 0x1c23, 0x1c40, 0x1c49, 0x1c4d, 0x1c7d, 0x1ce9, 0x1cec, 0x1cee, 0x1cf1, 0x1cf5, 0x1cf6, 0x1d00, 0x1dbf, 0x1e00, 0x1f15, 0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f57, 0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f7d, 0x1f80, 0x1fb4, 0x1fb6, 0x1fbc, 0x1fbe, 0x1fbe, 0x1fc2, 0x1fc4, 0x1fc6, 0x1fcc, 0x1fd0, 0x1fd3, 0x1fd6, 0x1fdb, 0x1fe0, 0x1fec, 0x1ff2, 0x1ff4, 0x1ff6, 0x1ffc, 0x2070, 0x2071, 0x2074, 0x2079, 0x207f, 0x2089, 0x2090, 0x209c, 0x2102, 0x2102, 0x2107, 0x2107, 0x210a, 0x2113, 0x2115, 0x2115, 0x2119, 0x211d, 0x2124, 0x2124, 0x2126, 0x2126, 0x2128, 0x2128, 0x212a, 0x212d, 0x212f, 0x2139, 0x213c, 0x213f, 0x2145, 0x2149, 0x214e, 0x214e, 0x2150, 0x2189, 0x2460, 0x249b, 0x24ea, 0x24ff, 0x2776, 0x2793, 0x2c00, 0x2c2e, 0x2c30, 0x2c5e, 0x2c60, 0x2ce4, 0x2ceb, 0x2cee, 0x2cf2, 0x2cf3, 0x2cfd, 0x2cfd, 0x2d00, 0x2d25, 0x2d27, 0x2d27, 0x2d2d, 0x2d2d, 0x2d30, 0x2d67, 0x2d6f, 0x2d6f, 0x2d80, 0x2d96, 0x2da0, 0x2da6, 0x2da8, 0x2dae, 0x2db0, 0x2db6, 0x2db8, 0x2dbe, 0x2dc0, 0x2dc6, 0x2dc8, 0x2dce, 0x2dd0, 0x2dd6, 0x2dd8, 0x2dde, 0x2e2f, 0x2e2f, 0x3005, 0x3007, 0x3021, 0x3029, 0x3031, 0x3035, 0x3038, 0x303c, 0x3041, 0x3096, 0x309d, 0x309f, 0x30a1, 0x30fa, 0x30fc, 0x30ff, 0x3105, 0x312d, 0x3131, 0x318e, 0x3192, 0x3195, 0x31a0, 0x31ba, 0x31f0, 0x31ff, 0x3220, 0x3229, 0x3248, 0x324f, 0x3251, 0x325f, 0x3280, 0x3289, 0x32b1, 0x32bf, 0x3400, 0x4db5, 0x4e00, 0x9fcc, 0xa000, 0xa48c, 0xa4d0, 0xa4fd, 0xa500, 0xa60c, 0xa610, 0xa62b, 0xa640, 0xa66e, 0xa67f, 0xa69d, 0xa6a0, 0xa6ef, 0xa717, 0xa71f, 0xa722, 0xa788, 0xa78b, 0xa78e, 0xa790, 0xa7ad, 0xa7b0, 0xa7b1, 0xa7f7, 0xa801, 0xa803, 0xa805, 0xa807, 0xa80a, 0xa80c, 0xa822, 0xa830, 0xa835, 0xa840, 0xa873, 0xa882, 0xa8b3, 0xa8d0, 0xa8d9, 0xa8f2, 0xa8f7, 0xa8fb, 0xa8fb, 0xa900, 0xa925, 0xa930, 0xa946, 0xa960, 0xa97c, 0xa984, 0xa9b2, 0xa9cf, 0xa9d9, 0xa9e0, 0xa9e4, 0xa9e6, 0xa9fe, 0xaa00, 0xaa28, 0xaa40, 0xaa42, 0xaa44, 0xaa4b, 0xaa50, 0xaa59, 0xaa60, 0xaa76, 0xaa7a, 0xaa7a, 0xaa7e, 0xaaaf, 0xaab1, 0xaab1, 0xaab5, 0xaab6, 0xaab9, 0xaabd, 0xaac0, 0xaac0, 0xaac2, 0xaac2, 0xaadb, 0xaadd, 0xaae0, 0xaaea, 0xaaf2, 0xaaf4, 0xab01, 0xab06, 0xab09, 0xab0e, 0xab11, 0xab16, 0xab20, 0xab26, 0xab28, 0xab2e, 0xab30, 0xab5a, 0xab5c, 0xab5f, 0xab64, 0xab65, 0xabc0, 0xabe2, 0xabf0, 0xabf9, 0xac00, 0xd7a3, 0xd7b0, 0xd7c6, 0xd7cb, 0xd7fb, 0xf900, 0xfa6d, 0xfa70, 0xfad9, 0xfb00, 0xfb06, 0xfb13, 0xfb17, 0xfb1d, 0xfb1d, 0xfb1f, 0xfb28, 0xfb2a, 0xfb36, 0xfb38, 0xfb3c, 0xfb3e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfb46, 0xfbb1, 0xfbd3, 0xfd3d, 0xfd50, 0xfd8f, 0xfd92, 0xfdc7, 0xfdf0, 0xfdfb, 0xfe70, 0xfe74, 0xfe76, 0xfefc, 0xff10, 0xff19, 0xff21, 0xff3a, 0xff41, 0xff5a, 0xff66, 0xffbe, 0xffc2, 0xffc7, 0xffca, 0xffcf, 0xffd2, 0xffd7, 0xffda, 0xffdc, 0x10000, 0x1000b, 0x1000d, 0x10026, 0x10028, 0x1003a, 0x1003c, 0x1003d, 0x1003f, 0x1004d, 0x10050, 0x1005d, 0x10080, 0x100fa, 0x10107, 0x10133, 0x10140, 0x10178, 0x1018a, 0x1018b, 0x10280, 0x1029c, 0x102a0, 0x102d0, 0x102e1, 0x102fb, 0x10300, 0x10323, 0x10330, 0x1034a, 0x10350, 0x10375, 0x10380, 0x1039d, 0x103a0, 0x103c3, 0x103c8, 0x103cf, 0x103d1, 0x103d5, 0x10400, 0x1049d, 0x104a0, 0x104a9, 0x10500, 0x10527, 0x10530, 0x10563, 0x10600, 0x10736, 0x10740, 0x10755, 0x10760, 0x10767, 0x10800, 0x10805, 0x10808, 0x10808, 0x1080a, 0x10835, 0x10837, 0x10838, 0x1083c, 0x1083c, 0x1083f, 0x10855, 0x10858, 0x10876, 0x10879, 0x1089e, 0x108a7, 0x108af, 0x10900, 0x1091b, 0x10920, 0x10939, 0x10980, 0x109b7, 0x109be, 0x109bf, 0x10a00, 0x10a00, 0x10a10, 0x10a13, 0x10a15, 0x10a17, 0x10a19, 0x10a33, 0x10a40, 0x10a47, 0x10a60, 0x10a7e, 0x10a80, 0x10a9f, 0x10ac0, 0x10ac7, 0x10ac9, 0x10ae4, 0x10aeb, 0x10aef, 0x10b00, 0x10b35, 0x10b40, 0x10b55, 0x10b58, 0x10b72, 0x10b78, 0x10b91, 0x10ba9, 0x10baf, 0x10c00, 0x10c48, 0x10e60, 0x10e7e, 0x11003, 0x11037, 0x11052, 0x1106f, 0x11083, 0x110af, 0x110d0, 0x110e8, 0x110f0, 0x110f9, 0x11103, 0x11126, 0x11136, 0x1113f, 0x11150, 0x11172, 0x11176, 0x11176, 0x11183, 0x111b2, 0x111c1, 0x111c4, 0x111d0, 0x111da, 0x111e1, 0x111f4, 0x11200, 0x11211, 0x11213, 0x1122b, 0x112b0, 0x112de, 0x112f0, 0x112f9, 0x11305, 0x1130c, 0x1130f, 0x11310, 0x11313, 0x11328, 0x1132a, 0x11330, 0x11332, 0x11333, 0x11335, 0x11339, 0x1133d, 0x1133d, 0x1135d, 0x11361, 0x11480, 0x114af, 0x114c4, 0x114c5, 0x114c7, 0x114c7, 0x114d0, 0x114d9, 0x11580, 0x115ae, 0x11600, 0x1162f, 0x11644, 0x11644, 0x11650, 0x11659, 0x11680, 0x116aa, 0x116c0, 0x116c9, 0x118a0, 0x118f2, 0x118ff, 0x118ff, 0x11ac0, 0x11af8, 0x12000, 0x12398, 0x12400, 0x1246e, 0x13000, 0x1342e, 0x16800, 0x16a38, 0x16a40, 0x16a5e, 0x16a60, 0x16a69, 0x16ad0, 0x16aed, 0x16b00, 0x16b2f, 0x16b40, 0x16b43, 0x16b50, 0x16b59, 0x16b5b, 0x16b61, 0x16b63, 0x16b77, 0x16b7d, 0x16b8f, 0x16f00, 0x16f44, 0x16f50, 0x16f50, 0x16f93, 0x16f9f, 0x1b000, 0x1b001, 0x1bc00, 0x1bc6a, 0x1bc70, 0x1bc7c, 0x1bc80, 0x1bc88, 0x1bc90, 0x1bc99, 0x1d360, 0x1d371, 0x1d400, 0x1d454, 0x1d456, 0x1d49c, 0x1d49e, 0x1d49f, 0x1d4a2, 0x1d4a2, 0x1d4a5, 0x1d4a6, 0x1d4a9, 0x1d4ac, 0x1d4ae, 0x1d4b9, 0x1d4bb, 0x1d4bb, 0x1d4bd, 0x1d4c3, 0x1d4c5, 0x1d505, 0x1d507, 0x1d50a, 0x1d50d, 0x1d514, 0x1d516, 0x1d51c, 0x1d51e, 0x1d539, 0x1d53b, 0x1d53e, 0x1d540, 0x1d544, 0x1d546, 0x1d546, 0x1d54a, 0x1d550, 0x1d552, 0x1d6a5, 0x1d6a8, 0x1d6c0, 0x1d6c2, 0x1d6da, 0x1d6dc, 0x1d6fa, 0x1d6fc, 0x1d714, 0x1d716, 0x1d734, 0x1d736, 0x1d74e, 0x1d750, 0x1d76e, 0x1d770, 0x1d788, 0x1d78a, 0x1d7a8, 0x1d7aa, 0x1d7c2, 0x1d7c4, 0x1d7cb, 0x1d7ce, 0x1d7ff, 0x1e800, 0x1e8c4, 0x1e8c7, 0x1e8cf, 0x1ee00, 0x1ee03, 0x1ee05, 0x1ee1f, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee24, 0x1ee27, 0x1ee27, 0x1ee29, 0x1ee32, 0x1ee34, 0x1ee37, 0x1ee39, 0x1ee39, 0x1ee3b, 0x1ee3b, 0x1ee42, 0x1ee42, 0x1ee47, 0x1ee47, 0x1ee49, 0x1ee49, 0x1ee4b, 0x1ee4b, 0x1ee4d, 0x1ee4f, 0x1ee51, 0x1ee52, 0x1ee54, 0x1ee54, 0x1ee57, 0x1ee57, 0x1ee59, 0x1ee59, 0x1ee5b, 0x1ee5b, 0x1ee5d, 0x1ee5d, 0x1ee5f, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee64, 0x1ee67, 0x1ee6a, 0x1ee6c, 0x1ee72, 0x1ee74, 0x1ee77, 0x1ee79, 0x1ee7c, 0x1ee7e, 0x1ee7e, 0x1ee80, 0x1ee89, 0x1ee8b, 0x1ee9b, 0x1eea1, 0x1eea3, 0x1eea5, 0x1eea9, 0x1eeab, 0x1eebb, 0x1f100, 0x1f10c, 0x20000, 0x2a6d6, 0x2a700, 0x2b734, 0x2b740, 0x2b81d, 0x2f800, 0x2fa1d }; UCP_FN(Xwd) static const unichar ucp_Z_def[] = { 0x20, 0x20, 0xa0, 0xa0, 0x1680, 0x1680, 0x2000, 0x200a, 0x2028, 0x2029, 0x202f, 0x202f, 0x205f, 0x205f, 0x3000, 0x3000 }; UCP_FN(Z) static const unichar ucp_Zl_def[] = { 0x2028, 0x2028 }; UCP_FN(Zl) static const unichar ucp_Zp_def[] = { 0x2029, 0x2029 }; UCP_FN(Zp) static const unichar ucp_Zs_def[] = { 0x20, 0x20, 0xa0, 0xa0, 0x1680, 0x1680, 0x2000, 0x200a, 0x202f, 0x202f, 0x205f, 0x205f, 0x3000, 0x3000 }; UCP_FN(Zs) static const unichar ucp_Arabic_def[] = { 0x600, 0x604, 0x606, 0x60b, 0x60d, 0x61a, 0x61e, 0x61e, 0x620, 0x63f, 0x641, 0x64a, 0x656, 0x65f, 0x66a, 0x66f, 0x671, 0x6dc, 0x6de, 0x6ff, 0x750, 0x77f, 0x8a0, 0x8b2, 0x8e4, 0x8ff, 0xfb50, 0xfbc1, 0xfbd3, 0xfd3d, 0xfd50, 0xfd8f, 0xfd92, 0xfdc7, 0xfdf0, 0xfdfd, 0xfe70, 0xfe74, 0xfe76, 0xfefc, 0x10e60, 0x10e7e, 0x1ee00, 0x1ee03, 0x1ee05, 0x1ee1f, 0x1ee21, 0x1ee22, 0x1ee24, 0x1ee24, 0x1ee27, 0x1ee27, 0x1ee29, 0x1ee32, 0x1ee34, 0x1ee37, 0x1ee39, 0x1ee39, 0x1ee3b, 0x1ee3b, 0x1ee42, 0x1ee42, 0x1ee47, 0x1ee47, 0x1ee49, 0x1ee49, 0x1ee4b, 0x1ee4b, 0x1ee4d, 0x1ee4f, 0x1ee51, 0x1ee52, 0x1ee54, 0x1ee54, 0x1ee57, 0x1ee57, 0x1ee59, 0x1ee59, 0x1ee5b, 0x1ee5b, 0x1ee5d, 0x1ee5d, 0x1ee5f, 0x1ee5f, 0x1ee61, 0x1ee62, 0x1ee64, 0x1ee64, 0x1ee67, 0x1ee6a, 0x1ee6c, 0x1ee72, 0x1ee74, 0x1ee77, 0x1ee79, 0x1ee7c, 0x1ee7e, 0x1ee7e, 0x1ee80, 0x1ee89, 0x1ee8b, 0x1ee9b, 0x1eea1, 0x1eea3, 0x1eea5, 0x1eea9, 0x1eeab, 0x1eebb, 0x1eef0, 0x1eef1 }; UCP_FN(Arabic) static const unichar ucp_Armenian_def[] = { 0x531, 0x556, 0x559, 0x55f, 0x561, 0x587, 0x58a, 0x58a, 0x58d, 0x58f, 0xfb13, 0xfb17 }; UCP_FN(Armenian) static const unichar ucp_Avestan_def[] = { 0x10b00, 0x10b35, 0x10b39, 0x10b3f }; UCP_FN(Avestan) static const unichar ucp_Balinese_def[] = { 0x1b00, 0x1b4b, 0x1b50, 0x1b7c }; UCP_FN(Balinese) static const unichar ucp_Bamum_def[] = { 0xa6a0, 0xa6f7, 0x16800, 0x16a38 }; UCP_FN(Bamum) static const unichar ucp_Bassa_Vah_def[] = { 0x16ad0, 0x16aed, 0x16af0, 0x16af5 }; UCP_FN(Bassa_Vah) static const unichar ucp_Batak_def[] = { 0x1bc0, 0x1bf3, 0x1bfc, 0x1bff }; UCP_FN(Batak) static const unichar ucp_Bengali_def[] = { 0x980, 0x983, 0x985, 0x98c, 0x98f, 0x990, 0x993, 0x9a8, 0x9aa, 0x9b0, 0x9b2, 0x9b2, 0x9b6, 0x9b9, 0x9bc, 0x9c4, 0x9c7, 0x9c8, 0x9cb, 0x9ce, 0x9d7, 0x9d7, 0x9dc, 0x9dd, 0x9df, 0x9e3, 0x9e6, 0x9fb }; UCP_FN(Bengali) static const unichar ucp_Bopomofo_def[] = { 0x2ea, 0x2eb, 0x3105, 0x312d, 0x31a0, 0x31ba }; UCP_FN(Bopomofo) static const unichar ucp_Brahmi_def[] = { 0x11000, 0x1104d, 0x11052, 0x1106f, 0x1107f, 0x1107f }; UCP_FN(Brahmi) static const unichar ucp_Braille_def[] = { 0x2800, 0x28ff }; UCP_FN(Braille) static const unichar ucp_Buginese_def[] = { 0x1a00, 0x1a1b, 0x1a1e, 0x1a1f }; UCP_FN(Buginese) static const unichar ucp_Buhid_def[] = { 0x1740, 0x1753 }; UCP_FN(Buhid) static const unichar ucp_Canadian_Aboriginal_def[] = { 0x1400, 0x167f, 0x18b0, 0x18f5 }; UCP_FN(Canadian_Aboriginal) static const unichar ucp_Carian_def[] = { 0x102a0, 0x102d0 }; UCP_FN(Carian) static const unichar ucp_Caucasian_Albanian_def[] = { 0x10530, 0x10563, 0x1056f, 0x1056f }; UCP_FN(Caucasian_Albanian) static const unichar ucp_Chakma_def[] = { 0x11100, 0x11134, 0x11136, 0x11143 }; UCP_FN(Chakma) static const unichar ucp_Cham_def[] = { 0xaa00, 0xaa36, 0xaa40, 0xaa4d, 0xaa50, 0xaa59, 0xaa5c, 0xaa5f }; UCP_FN(Cham) static const unichar ucp_Cherokee_def[] = { 0x13a0, 0x13f4 }; UCP_FN(Cherokee) static const unichar ucp_Common_def[] = { 0x0, 0x40, 0x5b, 0x60, 0x7b, 0xa9, 0xab, 0xb9, 0xbb, 0xbf, 0xd7, 0xd7, 0xf7, 0xf7, 0x2b9, 0x2df, 0x2e5, 0x2e9, 0x2ec, 0x2ff, 0x374, 0x374, 0x378, 0x379, 0x37e, 0x37e, 0x380, 0x383, 0x385, 0x385, 0x387, 0x387, 0x38b, 0x38b, 0x38d, 0x38d, 0x3a2, 0x3a2, 0x530, 0x530, 0x557, 0x558, 0x560, 0x560, 0x588, 0x589, 0x58b, 0x58c, 0x590, 0x590, 0x5c8, 0x5cf, 0x5eb, 0x5ef, 0x5f5, 0x5ff, 0x605, 0x605, 0x60c, 0x60c, 0x61b, 0x61d, 0x61f, 0x61f, 0x640, 0x640, 0x660, 0x669, 0x6dd, 0x6dd, 0x70e, 0x70e, 0x74b, 0x74c, 0x7b2, 0x7bf, 0x7fb, 0x7ff, 0x82e, 0x82f, 0x83f, 0x83f, 0x85c, 0x85d, 0x85f, 0x89f, 0x8b3, 0x8e3, 0x964, 0x965, 0x984, 0x984, 0x98d, 0x98e, 0x991, 0x992, 0x9a9, 0x9a9, 0x9b1, 0x9b1, 0x9b3, 0x9b5, 0x9ba, 0x9bb, 0x9c5, 0x9c6, 0x9c9, 0x9ca, 0x9cf, 0x9d6, 0x9d8, 0x9db, 0x9de, 0x9de, 0x9e4, 0x9e5, 0x9fc, 0xa00, 0xa04, 0xa04, 0xa0b, 0xa0e, 0xa11, 0xa12, 0xa29, 0xa29, 0xa31, 0xa31, 0xa34, 0xa34, 0xa37, 0xa37, 0xa3a, 0xa3b, 0xa3d, 0xa3d, 0xa43, 0xa46, 0xa49, 0xa4a, 0xa4e, 0xa50, 0xa52, 0xa58, 0xa5d, 0xa5d, 0xa5f, 0xa65, 0xa76, 0xa80, 0xa84, 0xa84, 0xa8e, 0xa8e, 0xa92, 0xa92, 0xaa9, 0xaa9, 0xab1, 0xab1, 0xab4, 0xab4, 0xaba, 0xabb, 0xac6, 0xac6, 0xaca, 0xaca, 0xace, 0xacf, 0xad1, 0xadf, 0xae4, 0xae5, 0xaf2, 0xb00, 0xb04, 0xb04, 0xb0d, 0xb0e, 0xb11, 0xb12, 0xb29, 0xb29, 0xb31, 0xb31, 0xb34, 0xb34, 0xb3a, 0xb3b, 0xb45, 0xb46, 0xb49, 0xb4a, 0xb4e, 0xb55, 0xb58, 0xb5b, 0xb5e, 0xb5e, 0xb64, 0xb65, 0xb78, 0xb81, 0xb84, 0xb84, 0xb8b, 0xb8d, 0xb91, 0xb91, 0xb96, 0xb98, 0xb9b, 0xb9b, 0xb9d, 0xb9d, 0xba0, 0xba2, 0xba5, 0xba7, 0xbab, 0xbad, 0xbba, 0xbbd, 0xbc3, 0xbc5, 0xbc9, 0xbc9, 0xbce, 0xbcf, 0xbd1, 0xbd6, 0xbd8, 0xbe5, 0xbfb, 0xbff, 0xc04, 0xc04, 0xc0d, 0xc0d, 0xc11, 0xc11, 0xc29, 0xc29, 0xc3a, 0xc3c, 0xc45, 0xc45, 0xc49, 0xc49, 0xc4e, 0xc54, 0xc57, 0xc57, 0xc5a, 0xc5f, 0xc64, 0xc65, 0xc70, 0xc77, 0xc80, 0xc80, 0xc84, 0xc84, 0xc8d, 0xc8d, 0xc91, 0xc91, 0xca9, 0xca9, 0xcb4, 0xcb4, 0xcba, 0xcbb, 0xcc5, 0xcc5, 0xcc9, 0xcc9, 0xcce, 0xcd4, 0xcd7, 0xcdd, 0xcdf, 0xcdf, 0xce4, 0xce5, 0xcf0, 0xcf0, 0xcf3, 0xd00, 0xd04, 0xd04, 0xd0d, 0xd0d, 0xd11, 0xd11, 0xd3b, 0xd3c, 0xd45, 0xd45, 0xd49, 0xd49, 0xd4f, 0xd56, 0xd58, 0xd5f, 0xd64, 0xd65, 0xd76, 0xd78, 0xd80, 0xd81, 0xd84, 0xd84, 0xd97, 0xd99, 0xdb2, 0xdb2, 0xdbc, 0xdbc, 0xdbe, 0xdbf, 0xdc7, 0xdc9, 0xdcb, 0xdce, 0xdd5, 0xdd5, 0xdd7, 0xdd7, 0xde0, 0xde5, 0xdf0, 0xdf1, 0xdf5, 0xe00, 0xe3b, 0xe3f, 0xe5c, 0xe80, 0xe83, 0xe83, 0xe85, 0xe86, 0xe89, 0xe89, 0xe8b, 0xe8c, 0xe8e, 0xe93, 0xe98, 0xe98, 0xea0, 0xea0, 0xea4, 0xea4, 0xea6, 0xea6, 0xea8, 0xea9, 0xeac, 0xeac, 0xeba, 0xeba, 0xebe, 0xebf, 0xec5, 0xec5, 0xec7, 0xec7, 0xece, 0xecf, 0xeda, 0xedb, 0xee0, 0xeff, 0xf48, 0xf48, 0xf6d, 0xf70, 0xf98, 0xf98, 0xfbd, 0xfbd, 0xfcd, 0xfcd, 0xfd5, 0xfd8, 0xfdb, 0xfff, 0x10c6, 0x10c6, 0x10c8, 0x10cc, 0x10ce, 0x10cf, 0x10fb, 0x10fb, 0x1249, 0x1249, 0x124e, 0x124f, 0x1257, 0x1257, 0x1259, 0x1259, 0x125e, 0x125f, 0x1289, 0x1289, 0x128e, 0x128f, 0x12b1, 0x12b1, 0x12b6, 0x12b7, 0x12bf, 0x12bf, 0x12c1, 0x12c1, 0x12c6, 0x12c7, 0x12d7, 0x12d7, 0x1311, 0x1311, 0x1316, 0x1317, 0x135b, 0x135c, 0x137d, 0x137f, 0x139a, 0x139f, 0x13f5, 0x13ff, 0x169d, 0x169f, 0x16eb, 0x16ed, 0x16f9, 0x16ff, 0x170d, 0x170d, 0x1715, 0x171f, 0x1735, 0x173f, 0x1754, 0x175f, 0x176d, 0x176d, 0x1771, 0x1771, 0x1774, 0x177f, 0x17de, 0x17df, 0x17ea, 0x17ef, 0x17fa, 0x17ff, 0x1802, 0x1803, 0x1805, 0x1805, 0x180f, 0x180f, 0x181a, 0x181f, 0x1878, 0x187f, 0x18ab, 0x18af, 0x18f6, 0x18ff, 0x191f, 0x191f, 0x192c, 0x192f, 0x193c, 0x193f, 0x1941, 0x1943, 0x196e, 0x196f, 0x1975, 0x197f, 0x19ac, 0x19af, 0x19ca, 0x19cf, 0x19db, 0x19dd, 0x1a1c, 0x1a1d, 0x1a5f, 0x1a5f, 0x1a7d, 0x1a7e, 0x1a8a, 0x1a8f, 0x1a9a, 0x1a9f, 0x1aae, 0x1aaf, 0x1abf, 0x1aff, 0x1b4c, 0x1b4f, 0x1b7d, 0x1b7f, 0x1bf4, 0x1bfb, 0x1c38, 0x1c3a, 0x1c4a, 0x1c4c, 0x1c80, 0x1cbf, 0x1cc8, 0x1ccf, 0x1cd3, 0x1cd3, 0x1ce1, 0x1ce1, 0x1ce9, 0x1cec, 0x1cee, 0x1cf3, 0x1cf5, 0x1cf7, 0x1cfa, 0x1cff, 0x1df6, 0x1dfb, 0x1f16, 0x1f17, 0x1f1e, 0x1f1f, 0x1f46, 0x1f47, 0x1f4e, 0x1f4f, 0x1f58, 0x1f58, 0x1f5a, 0x1f5a, 0x1f5c, 0x1f5c, 0x1f5e, 0x1f5e, 0x1f7e, 0x1f7f, 0x1fb5, 0x1fb5, 0x1fc5, 0x1fc5, 0x1fd4, 0x1fd5, 0x1fdc, 0x1fdc, 0x1ff0, 0x1ff1, 0x1ff5, 0x1ff5, 0x1fff, 0x200b, 0x200e, 0x2070, 0x2072, 0x207e, 0x2080, 0x208f, 0x209d, 0x20cf, 0x20f1, 0x2125, 0x2127, 0x2129, 0x212c, 0x2131, 0x2133, 0x214d, 0x214f, 0x215f, 0x2189, 0x27ff, 0x2900, 0x2bff, 0x2c2f, 0x2c2f, 0x2c5f, 0x2c5f, 0x2cf4, 0x2cf8, 0x2d26, 0x2d26, 0x2d28, 0x2d2c, 0x2d2e, 0x2d2f, 0x2d68, 0x2d6e, 0x2d71, 0x2d7e, 0x2d97, 0x2d9f, 0x2da7, 0x2da7, 0x2daf, 0x2daf, 0x2db7, 0x2db7, 0x2dbf, 0x2dbf, 0x2dc7, 0x2dc7, 0x2dcf, 0x2dcf, 0x2dd7, 0x2dd7, 0x2ddf, 0x2ddf, 0x2e00, 0x2e7f, 0x2e9a, 0x2e9a, 0x2ef4, 0x2eff, 0x2fd6, 0x3004, 0x3006, 0x3006, 0x3008, 0x3020, 0x3030, 0x3037, 0x303c, 0x3040, 0x3097, 0x3098, 0x309b, 0x309c, 0x30a0, 0x30a0, 0x30fb, 0x30fc, 0x3100, 0x3104, 0x312e, 0x3130, 0x318f, 0x319f, 0x31bb, 0x31ef, 0x321f, 0x325f, 0x327f, 0x32cf, 0x32ff, 0x32ff, 0x3358, 0x33ff, 0x4db6, 0x4dff, 0x9fcd, 0x9fff, 0xa48d, 0xa48f, 0xa4c7, 0xa4cf, 0xa62c, 0xa63f, 0xa69e, 0xa69e, 0xa6f8, 0xa721, 0xa788, 0xa78a, 0xa78f, 0xa78f, 0xa7ae, 0xa7af, 0xa7b2, 0xa7f6, 0xa82c, 0xa83f, 0xa878, 0xa87f, 0xa8c5, 0xa8cd, 0xa8da, 0xa8df, 0xa8fc, 0xa8ff, 0xa92e, 0xa92e, 0xa954, 0xa95e, 0xa97d, 0xa97f, 0xa9ce, 0xa9cf, 0xa9da, 0xa9dd, 0xa9ff, 0xa9ff, 0xaa37, 0xaa3f, 0xaa4e, 0xaa4f, 0xaa5a, 0xaa5b, 0xaac3, 0xaada, 0xaaf7, 0xab00, 0xab07, 0xab08, 0xab0f, 0xab10, 0xab17, 0xab1f, 0xab27, 0xab27, 0xab2f, 0xab2f, 0xab5b, 0xab5b, 0xab60, 0xab63, 0xab66, 0xabbf, 0xabee, 0xabef, 0xabfa, 0xabff, 0xd7a4, 0xd7af, 0xd7c7, 0xd7ca, 0xd7fc, 0xf8ff, 0xfa6e, 0xfa6f, 0xfada, 0xfaff, 0xfb07, 0xfb12, 0xfb18, 0xfb1c, 0xfb37, 0xfb37, 0xfb3d, 0xfb3d, 0xfb3f, 0xfb3f, 0xfb42, 0xfb42, 0xfb45, 0xfb45, 0xfbc2, 0xfbd2, 0xfd3e, 0xfd4f, 0xfd90, 0xfd91, 0xfdc8, 0xfdef, 0xfdfe, 0xfdff, 0xfe10, 0xfe1f, 0xfe2e, 0xfe6f, 0xfe75, 0xfe75, 0xfefd, 0xff20, 0xff3b, 0xff40, 0xff5b, 0xff65, 0xff70, 0xff70, 0xff9e, 0xff9f, 0xffbf, 0xffc1, 0xffc8, 0xffc9, 0xffd0, 0xffd1, 0xffd8, 0xffd9, 0xffdd, 0xffff, 0x1000c, 0x1000c, 0x10027, 0x10027, 0x1003b, 0x1003b, 0x1003e, 0x1003e, 0x1004e, 0x1004f, 0x1005e, 0x1007f, 0x100fb, 0x1013f, 0x1018d, 0x1019f, 0x101a1, 0x101fc, 0x101fe, 0x1027f, 0x1029d, 0x1029f, 0x102d1, 0x102df, 0x102e1, 0x102ff, 0x10324, 0x1032f, 0x1034b, 0x1034f, 0x1037b, 0x1037f, 0x1039e, 0x1039e, 0x103c4, 0x103c7, 0x103d6, 0x103ff, 0x1049e, 0x1049f, 0x104aa, 0x104ff, 0x10528, 0x1052f, 0x10564, 0x1056e, 0x10570, 0x105ff, 0x10737, 0x1073f, 0x10756, 0x1075f, 0x10768, 0x107ff, 0x10806, 0x10807, 0x10809, 0x10809, 0x10836, 0x10836, 0x10839, 0x1083b, 0x1083d, 0x1083e, 0x10856, 0x10856, 0x1089f, 0x108a6, 0x108b0, 0x108ff, 0x1091c, 0x1091e, 0x1093a, 0x1093e, 0x10940, 0x1097f, 0x109b8, 0x109bd, 0x109c0, 0x109ff, 0x10a04, 0x10a04, 0x10a07, 0x10a0b, 0x10a14, 0x10a14, 0x10a18, 0x10a18, 0x10a34, 0x10a37, 0x10a3b, 0x10a3e, 0x10a48, 0x10a4f, 0x10a59, 0x10a5f, 0x10aa0, 0x10abf, 0x10ae7, 0x10aea, 0x10af7, 0x10aff, 0x10b36, 0x10b38, 0x10b56, 0x10b57, 0x10b73, 0x10b77, 0x10b92, 0x10b98, 0x10b9d, 0x10ba8, 0x10bb0, 0x10bff, 0x10c49, 0x10e5f, 0x10e7f, 0x10fff, 0x1104e, 0x11051, 0x11070, 0x1107e, 0x110c2, 0x110cf, 0x110e9, 0x110ef, 0x110fa, 0x110ff, 0x11135, 0x11135, 0x11144, 0x1114f, 0x11177, 0x1117f, 0x111c9, 0x111cc, 0x111ce, 0x111cf, 0x111db, 0x111e0, 0x111f5, 0x111ff, 0x11212, 0x11212, 0x1123e, 0x112af, 0x112eb, 0x112ef, 0x112fa, 0x11300, 0x11304, 0x11304, 0x1130d, 0x1130e, 0x11311, 0x11312, 0x11329, 0x11329, 0x11331, 0x11331, 0x11334, 0x11334, 0x1133a, 0x1133b, 0x11345, 0x11346, 0x11349, 0x1134a, 0x1134e, 0x11356, 0x11358, 0x1135c, 0x11364, 0x11365, 0x1136d, 0x1136f, 0x11375, 0x1147f, 0x114c8, 0x114cf, 0x114da, 0x1157f, 0x115b6, 0x115b7, 0x115ca, 0x115ff, 0x11645, 0x1164f, 0x1165a, 0x1167f, 0x116b8, 0x116bf, 0x116ca, 0x1189f, 0x118f3, 0x118fe, 0x11900, 0x11abf, 0x11af9, 0x11fff, 0x12399, 0x123ff, 0x1246f, 0x1246f, 0x12475, 0x12fff, 0x1342f, 0x167ff, 0x16a39, 0x16a3f, 0x16a5f, 0x16a5f, 0x16a6a, 0x16a6d, 0x16a70, 0x16acf, 0x16aee, 0x16aef, 0x16af6, 0x16aff, 0x16b46, 0x16b4f, 0x16b5a, 0x16b5a, 0x16b62, 0x16b62, 0x16b78, 0x16b7c, 0x16b90, 0x16eff, 0x16f45, 0x16f4f, 0x16f7f, 0x16f8e, 0x16fa0, 0x1afff, 0x1b002, 0x1bbff, 0x1bc6b, 0x1bc6f, 0x1bc7d, 0x1bc7f, 0x1bc89, 0x1bc8f, 0x1bc9a, 0x1bc9b, 0x1bca0, 0x1d166, 0x1d16a, 0x1d17a, 0x1d183, 0x1d184, 0x1d18c, 0x1d1a9, 0x1d1ae, 0x1d1ff, 0x1d246, 0x1e7ff, 0x1e8c5, 0x1e8c6, 0x1e8d7, 0x1edff, 0x1ee04, 0x1ee04, 0x1ee20, 0x1ee20, 0x1ee23, 0x1ee23, 0x1ee25, 0x1ee26, 0x1ee28, 0x1ee28, 0x1ee33, 0x1ee33, 0x1ee38, 0x1ee38, 0x1ee3a, 0x1ee3a, 0x1ee3c, 0x1ee41, 0x1ee43, 0x1ee46, 0x1ee48, 0x1ee48, 0x1ee4a, 0x1ee4a, 0x1ee4c, 0x1ee4c, 0x1ee50, 0x1ee50, 0x1ee53, 0x1ee53, 0x1ee55, 0x1ee56, 0x1ee58, 0x1ee58, 0x1ee5a, 0x1ee5a, 0x1ee5c, 0x1ee5c, 0x1ee5e, 0x1ee5e, 0x1ee60, 0x1ee60, 0x1ee63, 0x1ee63, 0x1ee65, 0x1ee66, 0x1ee6b, 0x1ee6b, 0x1ee73, 0x1ee73, 0x1ee78, 0x1ee78, 0x1ee7d, 0x1ee7d, 0x1ee7f, 0x1ee7f, 0x1ee8a, 0x1ee8a, 0x1ee9c, 0x1eea0, 0x1eea4, 0x1eea4, 0x1eeaa, 0x1eeaa, 0x1eebc, 0x1eeef, 0x1eef2, 0x1f1ff, 0x1f201, 0x1ffff, 0x2a6d7, 0x2a6ff, 0x2b735, 0x2b73f, 0x2b81e, 0x2f7ff, 0x2fa1e, 0xe00ff, 0xe01f0, 0x10ffff }; UCP_FN(Common) static const unichar ucp_Coptic_def[] = { 0x3e2, 0x3ef, 0x2c80, 0x2cf3, 0x2cf9, 0x2cff }; UCP_FN(Coptic) static const unichar ucp_Cuneiform_def[] = { 0x12000, 0x12398, 0x12400, 0x1246e, 0x12470, 0x12474 }; UCP_FN(Cuneiform) static const unichar ucp_Cypriot_def[] = { 0x10800, 0x10805, 0x10808, 0x10808, 0x1080a, 0x10835, 0x10837, 0x10838, 0x1083c, 0x1083c, 0x1083f, 0x1083f }; UCP_FN(Cypriot) static const unichar ucp_Cyrillic_def[] = { 0x400, 0x484, 0x487, 0x52f, 0x1d2b, 0x1d2b, 0x1d78, 0x1d78, 0x2de0, 0x2dff, 0xa640, 0xa69d, 0xa69f, 0xa69f }; UCP_FN(Cyrillic) static const unichar ucp_Deseret_def[] = { 0x10400, 0x1044f }; UCP_FN(Deseret) static const unichar ucp_Devanagari_def[] = { 0x900, 0x950, 0x953, 0x963, 0x966, 0x97f, 0xa8e0, 0xa8fb }; UCP_FN(Devanagari) static const unichar ucp_Duployan_def[] = { 0x1bc00, 0x1bc6a, 0x1bc70, 0x1bc7c, 0x1bc80, 0x1bc88, 0x1bc90, 0x1bc99, 0x1bc9c, 0x1bc9f }; UCP_FN(Duployan) static const unichar ucp_Egyptian_Hieroglyphs_def[] = { 0x13000, 0x1342e }; UCP_FN(Egyptian_Hieroglyphs) static const unichar ucp_Elbasan_def[] = { 0x10500, 0x10527 }; UCP_FN(Elbasan) static const unichar ucp_Ethiopic_def[] = { 0x1200, 0x1248, 0x124a, 0x124d, 0x1250, 0x1256, 0x1258, 0x1258, 0x125a, 0x125d, 0x1260, 0x1288, 0x128a, 0x128d, 0x1290, 0x12b0, 0x12b2, 0x12b5, 0x12b8, 0x12be, 0x12c0, 0x12c0, 0x12c2, 0x12c5, 0x12c8, 0x12d6, 0x12d8, 0x1310, 0x1312, 0x1315, 0x1318, 0x135a, 0x135d, 0x137c, 0x1380, 0x1399, 0x2d80, 0x2d96, 0x2da0, 0x2da6, 0x2da8, 0x2dae, 0x2db0, 0x2db6, 0x2db8, 0x2dbe, 0x2dc0, 0x2dc6, 0x2dc8, 0x2dce, 0x2dd0, 0x2dd6, 0x2dd8, 0x2dde, 0xab01, 0xab06, 0xab09, 0xab0e, 0xab11, 0xab16, 0xab20, 0xab26, 0xab28, 0xab2e }; UCP_FN(Ethiopic) static const unichar ucp_Georgian_def[] = { 0x10a0, 0x10c5, 0x10c7, 0x10c7, 0x10cd, 0x10cd, 0x10d0, 0x10fa, 0x10fc, 0x10ff, 0x2d00, 0x2d25, 0x2d27, 0x2d27, 0x2d2d, 0x2d2d }; UCP_FN(Georgian) static const unichar ucp_Glagolitic_def[] = { 0x2c00, 0x2c2e, 0x2c30, 0x2c5e }; UCP_FN(Glagolitic) static const unichar ucp_Gothic_def[] = { 0x10330, 0x1034a }; UCP_FN(Gothic) static const unichar ucp_Grantha_def[] = { 0x11301, 0x11303, 0x11305, 0x1130c, 0x1130f, 0x11310, 0x11313, 0x11328, 0x1132a, 0x11330, 0x11332, 0x11333, 0x11335, 0x11339, 0x1133c, 0x11344, 0x11347, 0x11348, 0x1134b, 0x1134d, 0x11357, 0x11357, 0x1135d, 0x11363, 0x11366, 0x1136c, 0x11370, 0x11374 }; UCP_FN(Grantha) static const unichar ucp_Greek_def[] = { 0x370, 0x373, 0x375, 0x377, 0x37a, 0x37d, 0x37f, 0x37f, 0x384, 0x384, 0x386, 0x386, 0x388, 0x38a, 0x38c, 0x38c, 0x38e, 0x3a1, 0x3a3, 0x3e1, 0x3f0, 0x3ff, 0x1d26, 0x1d2a, 0x1d5d, 0x1d61, 0x1d66, 0x1d6a, 0x1dbf, 0x1dbf, 0x1f00, 0x1f15, 0x1f18, 0x1f1d, 0x1f20, 0x1f45, 0x1f48, 0x1f4d, 0x1f50, 0x1f57, 0x1f59, 0x1f59, 0x1f5b, 0x1f5b, 0x1f5d, 0x1f5d, 0x1f5f, 0x1f7d, 0x1f80, 0x1fb4, 0x1fb6, 0x1fc4, 0x1fc6, 0x1fd3, 0x1fd6, 0x1fdb, 0x1fdd, 0x1fef, 0x1ff2, 0x1ff4, 0x1ff6, 0x1ffe, 0x2126, 0x2126, 0xab65, 0xab65, 0x10140, 0x1018c, 0x101a0, 0x101a0, 0x1d200, 0x1d245 }; UCP_FN(Greek) static const unichar ucp_Gujarati_def[] = { 0xa81, 0xa83, 0xa85, 0xa8d, 0xa8f, 0xa91, 0xa93, 0xaa8, 0xaaa, 0xab0, 0xab2, 0xab3, 0xab5, 0xab9, 0xabc, 0xac5, 0xac7, 0xac9, 0xacb, 0xacd, 0xad0, 0xad0, 0xae0, 0xae3, 0xae6, 0xaf1 }; UCP_FN(Gujarati) static const unichar ucp_Gurmukhi_def[] = { 0xa01, 0xa03, 0xa05, 0xa0a, 0xa0f, 0xa10, 0xa13, 0xa28, 0xa2a, 0xa30, 0xa32, 0xa33, 0xa35, 0xa36, 0xa38, 0xa39, 0xa3c, 0xa3c, 0xa3e, 0xa42, 0xa47, 0xa48, 0xa4b, 0xa4d, 0xa51, 0xa51, 0xa59, 0xa5c, 0xa5e, 0xa5e, 0xa66, 0xa75 }; UCP_FN(Gurmukhi) static const unichar ucp_Han_def[] = { 0x2e80, 0x2e99, 0x2e9b, 0x2ef3, 0x2f00, 0x2fd5, 0x3005, 0x3005, 0x3007, 0x3007, 0x3021, 0x3029, 0x3038, 0x303b, 0x3400, 0x4db5, 0x4e00, 0x9fcc, 0xf900, 0xfa6d, 0xfa70, 0xfad9, 0x20000, 0x2a6d6, 0x2a700, 0x2b734, 0x2b740, 0x2b81d, 0x2f800, 0x2fa1d }; UCP_FN(Han) static const unichar ucp_Hangul_def[] = { 0x1100, 0x11ff, 0x302e, 0x302f, 0x3131, 0x318e, 0x3200, 0x321e, 0x3260, 0x327e, 0xa960, 0xa97c, 0xac00, 0xd7a3, 0xd7b0, 0xd7c6, 0xd7cb, 0xd7fb, 0xffa0, 0xffbe, 0xffc2, 0xffc7, 0xffca, 0xffcf, 0xffd2, 0xffd7, 0xffda, 0xffdc }; UCP_FN(Hangul) static const unichar ucp_Hanunoo_def[] = { 0x1720, 0x1734 }; UCP_FN(Hanunoo) static const unichar ucp_Hebrew_def[] = { 0x591, 0x5c7, 0x5d0, 0x5ea, 0x5f0, 0x5f4, 0xfb1d, 0xfb36, 0xfb38, 0xfb3c, 0xfb3e, 0xfb3e, 0xfb40, 0xfb41, 0xfb43, 0xfb44, 0xfb46, 0xfb4f }; UCP_FN(Hebrew) static const unichar ucp_Hiragana_def[] = { 0x3041, 0x3096, 0x309d, 0x309f, 0x1b001, 0x1b001, 0x1f200, 0x1f200 }; UCP_FN(Hiragana) static const unichar ucp_Imperial_Aramaic_def[] = { 0x10840, 0x10855, 0x10857, 0x1085f }; UCP_FN(Imperial_Aramaic) static const unichar ucp_Inherited_def[] = { 0x300, 0x36f, 0x485, 0x486, 0x64b, 0x655, 0x670, 0x670, 0x951, 0x952, 0x1ab0, 0x1abe, 0x1cd0, 0x1cd2, 0x1cd4, 0x1ce0, 0x1ce2, 0x1ce8, 0x1ced, 0x1ced, 0x1cf4, 0x1cf4, 0x1cf8, 0x1cf9, 0x1dc0, 0x1df5, 0x1dfc, 0x1dff, 0x200c, 0x200d, 0x20d0, 0x20f0, 0x302a, 0x302d, 0x3099, 0x309a, 0xfe00, 0xfe0f, 0xfe20, 0xfe2d, 0x101fd, 0x101fd, 0x102e0, 0x102e0, 0x1d167, 0x1d169, 0x1d17b, 0x1d182, 0x1d185, 0x1d18b, 0x1d1aa, 0x1d1ad, 0xe0100, 0xe01ef }; UCP_FN(Inherited) static const unichar ucp_Inscriptional_Pahlavi_def[] = { 0x10b60, 0x10b72, 0x10b78, 0x10b7f }; UCP_FN(Inscriptional_Pahlavi) static const unichar ucp_Inscriptional_Parthian_def[] = { 0x10b40, 0x10b55, 0x10b58, 0x10b5f }; UCP_FN(Inscriptional_Parthian) static const unichar ucp_Javanese_def[] = { 0xa980, 0xa9cd, 0xa9d0, 0xa9d9, 0xa9de, 0xa9df }; UCP_FN(Javanese) static const unichar ucp_Kaithi_def[] = { 0x11080, 0x110c1 }; UCP_FN(Kaithi) static const unichar ucp_Kannada_def[] = { 0xc81, 0xc83, 0xc85, 0xc8c, 0xc8e, 0xc90, 0xc92, 0xca8, 0xcaa, 0xcb3, 0xcb5, 0xcb9, 0xcbc, 0xcc4, 0xcc6, 0xcc8, 0xcca, 0xccd, 0xcd5, 0xcd6, 0xcde, 0xcde, 0xce0, 0xce3, 0xce6, 0xcef, 0xcf1, 0xcf2 }; UCP_FN(Kannada) static const unichar ucp_Katakana_def[] = { 0x30a1, 0x30fa, 0x30fd, 0x30ff, 0x31f0, 0x31ff, 0x32d0, 0x32fe, 0x3300, 0x3357, 0xff66, 0xff6f, 0xff71, 0xff9d, 0x1b000, 0x1b000 }; UCP_FN(Katakana) static const unichar ucp_Kayah_Li_def[] = { 0xa900, 0xa92d, 0xa92f, 0xa92f }; UCP_FN(Kayah_Li) static const unichar ucp_Kharoshthi_def[] = { 0x10a00, 0x10a03, 0x10a05, 0x10a06, 0x10a0c, 0x10a13, 0x10a15, 0x10a17, 0x10a19, 0x10a33, 0x10a38, 0x10a3a, 0x10a3f, 0x10a47, 0x10a50, 0x10a58 }; UCP_FN(Kharoshthi) static const unichar ucp_Khmer_def[] = { 0x1780, 0x17dd, 0x17e0, 0x17e9, 0x17f0, 0x17f9, 0x19e0, 0x19ff }; UCP_FN(Khmer) static const unichar ucp_Khojki_def[] = { 0x11200, 0x11211, 0x11213, 0x1123d }; UCP_FN(Khojki) static const unichar ucp_Khudawadi_def[] = { 0x112b0, 0x112ea, 0x112f0, 0x112f9 }; UCP_FN(Khudawadi) static const unichar ucp_Lao_def[] = { 0xe81, 0xe82, 0xe84, 0xe84, 0xe87, 0xe88, 0xe8a, 0xe8a, 0xe8d, 0xe8d, 0xe94, 0xe97, 0xe99, 0xe9f, 0xea1, 0xea3, 0xea5, 0xea5, 0xea7, 0xea7, 0xeaa, 0xeab, 0xead, 0xeb9, 0xebb, 0xebd, 0xec0, 0xec4, 0xec6, 0xec6, 0xec8, 0xecd, 0xed0, 0xed9, 0xedc, 0xedf }; UCP_FN(Lao) static const unichar ucp_Latin_def[] = { 0x41, 0x5a, 0x61, 0x7a, 0xaa, 0xaa, 0xba, 0xba, 0xc0, 0xd6, 0xd8, 0xf6, 0xf8, 0x2b8, 0x2e0, 0x2e4, 0x1d00, 0x1d25, 0x1d2c, 0x1d5c, 0x1d62, 0x1d65, 0x1d6b, 0x1d77, 0x1d79, 0x1dbe, 0x1e00, 0x1eff, 0x2071, 0x2071, 0x207f, 0x207f, 0x2090, 0x209c, 0x212a, 0x212b, 0x2132, 0x2132, 0x214e, 0x214e, 0x2160, 0x2188, 0x2c60, 0x2c7f, 0xa722, 0xa787, 0xa78b, 0xa78e, 0xa790, 0xa7ad, 0xa7b0, 0xa7b1, 0xa7f7, 0xa7ff, 0xab30, 0xab5a, 0xab5c, 0xab5f, 0xab64, 0xab64, 0xfb00, 0xfb06, 0xff21, 0xff3a, 0xff41, 0xff5a }; UCP_FN(Latin) static const unichar ucp_Lepcha_def[] = { 0x1c00, 0x1c37, 0x1c3b, 0x1c49, 0x1c4d, 0x1c4f }; UCP_FN(Lepcha) static const unichar ucp_Limbu_def[] = { 0x1900, 0x191e, 0x1920, 0x192b, 0x1930, 0x193b, 0x1940, 0x1940, 0x1944, 0x194f }; UCP_FN(Limbu) static const unichar ucp_Linear_A_def[] = { 0x10600, 0x10736, 0x10740, 0x10755, 0x10760, 0x10767 }; UCP_FN(Linear_A) static const unichar ucp_Linear_B_def[] = { 0x10000, 0x1000b, 0x1000d, 0x10026, 0x10028, 0x1003a, 0x1003c, 0x1003d, 0x1003f, 0x1004d, 0x10050, 0x1005d, 0x10080, 0x100fa }; UCP_FN(Linear_B) static const unichar ucp_Lisu_def[] = { 0xa4d0, 0xa4ff }; UCP_FN(Lisu) static const unichar ucp_Lycian_def[] = { 0x10280, 0x1029c }; UCP_FN(Lycian) static const unichar ucp_Lydian_def[] = { 0x10920, 0x10939, 0x1093f, 0x1093f }; UCP_FN(Lydian) static const unichar ucp_Mahajani_def[] = { 0x11150, 0x11176 }; UCP_FN(Mahajani) static const unichar ucp_Malayalam_def[] = { 0xd01, 0xd03, 0xd05, 0xd0c, 0xd0e, 0xd10, 0xd12, 0xd3a, 0xd3d, 0xd44, 0xd46, 0xd48, 0xd4a, 0xd4e, 0xd57, 0xd57, 0xd60, 0xd63, 0xd66, 0xd75, 0xd79, 0xd7f }; UCP_FN(Malayalam) static const unichar ucp_Mandaic_def[] = { 0x840, 0x85b, 0x85e, 0x85e }; UCP_FN(Mandaic) static const unichar ucp_Manichaean_def[] = { 0x10ac0, 0x10ae6, 0x10aeb, 0x10af6 }; UCP_FN(Manichaean) static const unichar ucp_Meetei_Mayek_def[] = { 0xaae0, 0xaaf6, 0xabc0, 0xabed, 0xabf0, 0xabf9 }; UCP_FN(Meetei_Mayek) static const unichar ucp_Mende_Kikakui_def[] = { 0x1e800, 0x1e8c4, 0x1e8c7, 0x1e8d6 }; UCP_FN(Mende_Kikakui) static const unichar ucp_Meroitic_Cursive_def[] = { 0x109a0, 0x109b7, 0x109be, 0x109bf }; UCP_FN(Meroitic_Cursive) static const unichar ucp_Meroitic_Hieroglyphs_def[] = { 0x10980, 0x1099f }; UCP_FN(Meroitic_Hieroglyphs) static const unichar ucp_Miao_def[] = { 0x16f00, 0x16f44, 0x16f50, 0x16f7e, 0x16f8f, 0x16f9f }; UCP_FN(Miao) static const unichar ucp_Modi_def[] = { 0x11600, 0x11644, 0x11650, 0x11659 }; UCP_FN(Modi) static const unichar ucp_Mongolian_def[] = { 0x1800, 0x1801, 0x1804, 0x1804, 0x1806, 0x180e, 0x1810, 0x1819, 0x1820, 0x1877, 0x1880, 0x18aa }; UCP_FN(Mongolian) static const unichar ucp_Mro_def[] = { 0x16a40, 0x16a5e, 0x16a60, 0x16a69, 0x16a6e, 0x16a6f }; UCP_FN(Mro) static const unichar ucp_Myanmar_def[] = { 0x1000, 0x109f, 0xa9e0, 0xa9fe, 0xaa60, 0xaa7f }; UCP_FN(Myanmar) static const unichar ucp_Nabataean_def[] = { 0x10880, 0x1089e, 0x108a7, 0x108af }; UCP_FN(Nabataean) static const unichar ucp_New_Tai_Lue_def[] = { 0x1980, 0x19ab, 0x19b0, 0x19c9, 0x19d0, 0x19da, 0x19de, 0x19df }; UCP_FN(New_Tai_Lue) static const unichar ucp_Nko_def[] = { 0x7c0, 0x7fa }; UCP_FN(Nko) static const unichar ucp_Ogham_def[] = { 0x1680, 0x169c }; UCP_FN(Ogham) static const unichar ucp_Ol_Chiki_def[] = { 0x1c50, 0x1c7f }; UCP_FN(Ol_Chiki) static const unichar ucp_Old_Italic_def[] = { 0x10300, 0x10323 }; UCP_FN(Old_Italic) static const unichar ucp_Old_North_Arabian_def[] = { 0x10a80, 0x10a9f }; UCP_FN(Old_North_Arabian) static const unichar ucp_Old_Permic_def[] = { 0x10350, 0x1037a }; UCP_FN(Old_Permic) static const unichar ucp_Old_Persian_def[] = { 0x103a0, 0x103c3, 0x103c8, 0x103d5 }; UCP_FN(Old_Persian) static const unichar ucp_Old_South_Arabian_def[] = { 0x10a60, 0x10a7f }; UCP_FN(Old_South_Arabian) static const unichar ucp_Old_Turkic_def[] = { 0x10c00, 0x10c48 }; UCP_FN(Old_Turkic) static const unichar ucp_Oriya_def[] = { 0xb01, 0xb03, 0xb05, 0xb0c, 0xb0f, 0xb10, 0xb13, 0xb28, 0xb2a, 0xb30, 0xb32, 0xb33, 0xb35, 0xb39, 0xb3c, 0xb44, 0xb47, 0xb48, 0xb4b, 0xb4d, 0xb56, 0xb57, 0xb5c, 0xb5d, 0xb5f, 0xb63, 0xb66, 0xb77 }; UCP_FN(Oriya) static const unichar ucp_Osmanya_def[] = { 0x10480, 0x1049d, 0x104a0, 0x104a9 }; UCP_FN(Osmanya) static const unichar ucp_Pahawh_Hmong_def[] = { 0x16b00, 0x16b45, 0x16b50, 0x16b59, 0x16b5b, 0x16b61, 0x16b63, 0x16b77, 0x16b7d, 0x16b8f }; UCP_FN(Pahawh_Hmong) static const unichar ucp_Palmyrene_def[] = { 0x10860, 0x1087f }; UCP_FN(Palmyrene) static const unichar ucp_Pau_Cin_Hau_def[] = { 0x11ac0, 0x11af8 }; UCP_FN(Pau_Cin_Hau) static const unichar ucp_Phags_Pa_def[] = { 0xa840, 0xa877 }; UCP_FN(Phags_Pa) static const unichar ucp_Phoenician_def[] = { 0x10900, 0x1091b, 0x1091f, 0x1091f }; UCP_FN(Phoenician) static const unichar ucp_Psalter_Pahlavi_def[] = { 0x10b80, 0x10b91, 0x10b99, 0x10b9c, 0x10ba9, 0x10baf }; UCP_FN(Psalter_Pahlavi) static const unichar ucp_Rejang_def[] = { 0xa930, 0xa953, 0xa95f, 0xa95f }; UCP_FN(Rejang) static const unichar ucp_Runic_def[] = { 0x16a0, 0x16ea, 0x16ee, 0x16f8 }; UCP_FN(Runic) static const unichar ucp_Samaritan_def[] = { 0x800, 0x82d, 0x830, 0x83e }; UCP_FN(Samaritan) static const unichar ucp_Saurashtra_def[] = { 0xa880, 0xa8c4, 0xa8ce, 0xa8d9 }; UCP_FN(Saurashtra) static const unichar ucp_Sharada_def[] = { 0x11180, 0x111c8, 0x111cd, 0x111cd, 0x111d0, 0x111da }; UCP_FN(Sharada) static const unichar ucp_Shavian_def[] = { 0x10450, 0x1047f }; UCP_FN(Shavian) static const unichar ucp_Siddham_def[] = { 0x11580, 0x115b5, 0x115b8, 0x115c9 }; UCP_FN(Siddham) static const unichar ucp_Sinhala_def[] = { 0xd82, 0xd83, 0xd85, 0xd96, 0xd9a, 0xdb1, 0xdb3, 0xdbb, 0xdbd, 0xdbd, 0xdc0, 0xdc6, 0xdca, 0xdca, 0xdcf, 0xdd4, 0xdd6, 0xdd6, 0xdd8, 0xddf, 0xde6, 0xdef, 0xdf2, 0xdf4, 0x111e1, 0x111f4 }; UCP_FN(Sinhala) static const unichar ucp_Sora_Sompeng_def[] = { 0x110d0, 0x110e8, 0x110f0, 0x110f9 }; UCP_FN(Sora_Sompeng) static const unichar ucp_Sundanese_def[] = { 0x1b80, 0x1bbf, 0x1cc0, 0x1cc7 }; UCP_FN(Sundanese) static const unichar ucp_Syloti_Nagri_def[] = { 0xa800, 0xa82b }; UCP_FN(Syloti_Nagri) static const unichar ucp_Syriac_def[] = { 0x700, 0x70d, 0x70f, 0x74a, 0x74d, 0x74f }; UCP_FN(Syriac) static const unichar ucp_Tagalog_def[] = { 0x1700, 0x170c, 0x170e, 0x1714 }; UCP_FN(Tagalog) static const unichar ucp_Tagbanwa_def[] = { 0x1760, 0x176c, 0x176e, 0x1770, 0x1772, 0x1773 }; UCP_FN(Tagbanwa) static const unichar ucp_Tai_Le_def[] = { 0x1950, 0x196d, 0x1970, 0x1974 }; UCP_FN(Tai_Le) static const unichar ucp_Tai_Tham_def[] = { 0x1a20, 0x1a5e, 0x1a60, 0x1a7c, 0x1a7f, 0x1a89, 0x1a90, 0x1a99, 0x1aa0, 0x1aad }; UCP_FN(Tai_Tham) static const unichar ucp_Tai_Viet_def[] = { 0xaa80, 0xaac2, 0xaadb, 0xaadf }; UCP_FN(Tai_Viet) static const unichar ucp_Takri_def[] = { 0x11680, 0x116b7, 0x116c0, 0x116c9 }; UCP_FN(Takri) static const unichar ucp_Tamil_def[] = { 0xb82, 0xb83, 0xb85, 0xb8a, 0xb8e, 0xb90, 0xb92, 0xb95, 0xb99, 0xb9a, 0xb9c, 0xb9c, 0xb9e, 0xb9f, 0xba3, 0xba4, 0xba8, 0xbaa, 0xbae, 0xbb9, 0xbbe, 0xbc2, 0xbc6, 0xbc8, 0xbca, 0xbcd, 0xbd0, 0xbd0, 0xbd7, 0xbd7, 0xbe6, 0xbfa }; UCP_FN(Tamil) static const unichar ucp_Telugu_def[] = { 0xc00, 0xc03, 0xc05, 0xc0c, 0xc0e, 0xc10, 0xc12, 0xc28, 0xc2a, 0xc39, 0xc3d, 0xc44, 0xc46, 0xc48, 0xc4a, 0xc4d, 0xc55, 0xc56, 0xc58, 0xc59, 0xc60, 0xc63, 0xc66, 0xc6f, 0xc78, 0xc7f }; UCP_FN(Telugu) static const unichar ucp_Thaana_def[] = { 0x780, 0x7b1 }; UCP_FN(Thaana) static const unichar ucp_Thai_def[] = { 0xe01, 0xe3a, 0xe40, 0xe5b }; UCP_FN(Thai) static const unichar ucp_Tibetan_def[] = { 0xf00, 0xf47, 0xf49, 0xf6c, 0xf71, 0xf97, 0xf99, 0xfbc, 0xfbe, 0xfcc, 0xfce, 0xfd4, 0xfd9, 0xfda }; UCP_FN(Tibetan) static const unichar ucp_Tifinagh_def[] = { 0x2d30, 0x2d67, 0x2d6f, 0x2d70, 0x2d7f, 0x2d7f }; UCP_FN(Tifinagh) static const unichar ucp_Tirhuta_def[] = { 0x11480, 0x114c7, 0x114d0, 0x114d9 }; UCP_FN(Tirhuta) static const unichar ucp_Ugaritic_def[] = { 0x10380, 0x1039d, 0x1039f, 0x1039f }; UCP_FN(Ugaritic) static const unichar ucp_Vai_def[] = { 0xa500, 0xa62b }; UCP_FN(Vai) static const unichar ucp_Warang_Citi_def[] = { 0x118a0, 0x118f2, 0x118ff, 0x118ff }; UCP_FN(Warang_Citi) static const unichar ucp_Yi_def[] = { 0xa000, 0xa48c, 0xa490, 0xa4c6 }; UCP_FN(Yi) static const unicase ucp_caseless_def[] = { {0x41, 0x61}, {0x42, 0x62}, {0x43, 0x63}, {0x44, 0x64}, {0x45, 0x65}, {0x46, 0x66}, {0x47, 0x67}, {0x48, 0x68}, {0x49, 0x69}, {0x4a, 0x6a}, {0x4b, 0x6b}, {0x4b, 0x212a}, {0x4c, 0x6c}, {0x4d, 0x6d}, {0x4e, 0x6e}, {0x4f, 0x6f}, {0x50, 0x70}, {0x51, 0x71}, {0x52, 0x72}, {0x53, 0x73}, {0x53, 0x17f}, {0x54, 0x74}, {0x55, 0x75}, {0x56, 0x76}, {0x57, 0x77}, {0x58, 0x78}, {0x59, 0x79}, {0x5a, 0x7a}, {0x61, 0x41}, {0x62, 0x42}, {0x63, 0x43}, {0x64, 0x44}, {0x65, 0x45}, {0x66, 0x46}, {0x67, 0x47}, {0x68, 0x48}, {0x69, 0x49}, {0x6a, 0x4a}, {0x6b, 0x4b}, {0x6b, 0x212a}, {0x6c, 0x4c}, {0x6d, 0x4d}, {0x6e, 0x4e}, {0x6f, 0x4f}, {0x70, 0x50}, {0x71, 0x51}, {0x72, 0x52}, {0x73, 0x53}, {0x73, 0x17f}, {0x74, 0x54}, {0x75, 0x55}, {0x76, 0x56}, {0x77, 0x57}, {0x78, 0x58}, {0x79, 0x59}, {0x7a, 0x5a}, {0xb5, 0x39c}, {0xb5, 0x3bc}, {0xc0, 0xe0}, {0xc1, 0xe1}, {0xc2, 0xe2}, {0xc3, 0xe3}, {0xc4, 0xe4}, {0xc5, 0xe5}, {0xc5, 0x212b}, {0xc6, 0xe6}, {0xc7, 0xe7}, {0xc8, 0xe8}, {0xc9, 0xe9}, {0xca, 0xea}, {0xcb, 0xeb}, {0xcc, 0xec}, {0xcd, 0xed}, {0xce, 0xee}, {0xcf, 0xef}, {0xd0, 0xf0}, {0xd1, 0xf1}, {0xd2, 0xf2}, {0xd3, 0xf3}, {0xd4, 0xf4}, {0xd5, 0xf5}, {0xd6, 0xf6}, {0xd8, 0xf8}, {0xd9, 0xf9}, {0xda, 0xfa}, {0xdb, 0xfb}, {0xdc, 0xfc}, {0xdd, 0xfd}, {0xde, 0xfe}, {0xdf, 0x1e9e}, {0xe0, 0xc0}, {0xe1, 0xc1}, {0xe2, 0xc2}, {0xe3, 0xc3}, {0xe4, 0xc4}, {0xe5, 0xc5}, {0xe5, 0x212b}, {0xe6, 0xc6}, {0xe7, 0xc7}, {0xe8, 0xc8}, {0xe9, 0xc9}, {0xea, 0xca}, {0xeb, 0xcb}, {0xec, 0xcc}, {0xed, 0xcd}, {0xee, 0xce}, {0xef, 0xcf}, {0xf0, 0xd0}, {0xf1, 0xd1}, {0xf2, 0xd2}, {0xf3, 0xd3}, {0xf4, 0xd4}, {0xf5, 0xd5}, {0xf6, 0xd6}, {0xf8, 0xd8}, {0xf9, 0xd9}, {0xfa, 0xda}, {0xfb, 0xdb}, {0xfc, 0xdc}, {0xfd, 0xdd}, {0xfe, 0xde}, {0xff, 0x178}, {0x100, 0x101}, {0x101, 0x100}, {0x102, 0x103}, {0x103, 0x102}, {0x104, 0x105}, {0x105, 0x104}, {0x106, 0x107}, {0x107, 0x106}, {0x108, 0x109}, {0x109, 0x108}, {0x10a, 0x10b}, {0x10b, 0x10a}, {0x10c, 0x10d}, {0x10d, 0x10c}, {0x10e, 0x10f}, {0x10f, 0x10e}, {0x110, 0x111}, {0x111, 0x110}, {0x112, 0x113}, {0x113, 0x112}, {0x114, 0x115}, {0x115, 0x114}, {0x116, 0x117}, {0x117, 0x116}, {0x118, 0x119}, {0x119, 0x118}, {0x11a, 0x11b}, {0x11b, 0x11a}, {0x11c, 0x11d}, {0x11d, 0x11c}, {0x11e, 0x11f}, {0x11f, 0x11e}, {0x120, 0x121}, {0x121, 0x120}, {0x122, 0x123}, {0x123, 0x122}, {0x124, 0x125}, {0x125, 0x124}, {0x126, 0x127}, {0x127, 0x126}, {0x128, 0x129}, {0x129, 0x128}, {0x12a, 0x12b}, {0x12b, 0x12a}, {0x12c, 0x12d}, {0x12d, 0x12c}, {0x12e, 0x12f}, {0x12f, 0x12e}, {0x132, 0x133}, {0x133, 0x132}, {0x134, 0x135}, {0x135, 0x134}, {0x136, 0x137}, {0x137, 0x136}, {0x139, 0x13a}, {0x13a, 0x139}, {0x13b, 0x13c}, {0x13c, 0x13b}, {0x13d, 0x13e}, {0x13e, 0x13d}, {0x13f, 0x140}, {0x140, 0x13f}, {0x141, 0x142}, {0x142, 0x141}, {0x143, 0x144}, {0x144, 0x143}, {0x145, 0x146}, {0x146, 0x145}, {0x147, 0x148}, {0x148, 0x147}, {0x14a, 0x14b}, {0x14b, 0x14a}, {0x14c, 0x14d}, {0x14d, 0x14c}, {0x14e, 0x14f}, {0x14f, 0x14e}, {0x150, 0x151}, {0x151, 0x150}, {0x152, 0x153}, {0x153, 0x152}, {0x154, 0x155}, {0x155, 0x154}, {0x156, 0x157}, {0x157, 0x156}, {0x158, 0x159}, {0x159, 0x158}, {0x15a, 0x15b}, {0x15b, 0x15a}, {0x15c, 0x15d}, {0x15d, 0x15c}, {0x15e, 0x15f}, {0x15f, 0x15e}, {0x160, 0x161}, {0x161, 0x160}, {0x162, 0x163}, {0x163, 0x162}, {0x164, 0x165}, {0x165, 0x164}, {0x166, 0x167}, {0x167, 0x166}, {0x168, 0x169}, {0x169, 0x168}, {0x16a, 0x16b}, {0x16b, 0x16a}, {0x16c, 0x16d}, {0x16d, 0x16c}, {0x16e, 0x16f}, {0x16f, 0x16e}, {0x170, 0x171}, {0x171, 0x170}, {0x172, 0x173}, {0x173, 0x172}, {0x174, 0x175}, {0x175, 0x174}, {0x176, 0x177}, {0x177, 0x176}, {0x178, 0xff}, {0x179, 0x17a}, {0x17a, 0x179}, {0x17b, 0x17c}, {0x17c, 0x17b}, {0x17d, 0x17e}, {0x17e, 0x17d}, {0x17f, 0x53}, {0x17f, 0x73}, {0x180, 0x243}, {0x181, 0x253}, {0x182, 0x183}, {0x183, 0x182}, {0x184, 0x185}, {0x185, 0x184}, {0x186, 0x254}, {0x187, 0x188}, {0x188, 0x187}, {0x189, 0x256}, {0x18a, 0x257}, {0x18b, 0x18c}, {0x18c, 0x18b}, {0x18e, 0x1dd}, {0x18f, 0x259}, {0x190, 0x25b}, {0x191, 0x192}, {0x192, 0x191}, {0x193, 0x260}, {0x194, 0x263}, {0x195, 0x1f6}, {0x196, 0x269}, {0x197, 0x268}, {0x198, 0x199}, {0x199, 0x198}, {0x19a, 0x23d}, {0x19c, 0x26f}, {0x19d, 0x272}, {0x19e, 0x220}, {0x19f, 0x275}, {0x1a0, 0x1a1}, {0x1a1, 0x1a0}, {0x1a2, 0x1a3}, {0x1a3, 0x1a2}, {0x1a4, 0x1a5}, {0x1a5, 0x1a4}, {0x1a6, 0x280}, {0x1a7, 0x1a8}, {0x1a8, 0x1a7}, {0x1a9, 0x283}, {0x1ac, 0x1ad}, {0x1ad, 0x1ac}, {0x1ae, 0x288}, {0x1af, 0x1b0}, {0x1b0, 0x1af}, {0x1b1, 0x28a}, {0x1b2, 0x28b}, {0x1b3, 0x1b4}, {0x1b4, 0x1b3}, {0x1b5, 0x1b6}, {0x1b6, 0x1b5}, {0x1b7, 0x292}, {0x1b8, 0x1b9}, {0x1b9, 0x1b8}, {0x1bc, 0x1bd}, {0x1bd, 0x1bc}, {0x1bf, 0x1f7}, {0x1c4, 0x1c5}, {0x1c4, 0x1c6}, {0x1c5, 0x1c4}, {0x1c5, 0x1c6}, {0x1c6, 0x1c4}, {0x1c6, 0x1c5}, {0x1c7, 0x1c8}, {0x1c7, 0x1c9}, {0x1c8, 0x1c7}, {0x1c8, 0x1c9}, {0x1c9, 0x1c7}, {0x1c9, 0x1c8}, {0x1ca, 0x1cb}, {0x1ca, 0x1cc}, {0x1cb, 0x1ca}, {0x1cb, 0x1cc}, {0x1cc, 0x1ca}, {0x1cc, 0x1cb}, {0x1cd, 0x1ce}, {0x1ce, 0x1cd}, {0x1cf, 0x1d0}, {0x1d0, 0x1cf}, {0x1d1, 0x1d2}, {0x1d2, 0x1d1}, {0x1d3, 0x1d4}, {0x1d4, 0x1d3}, {0x1d5, 0x1d6}, {0x1d6, 0x1d5}, {0x1d7, 0x1d8}, {0x1d8, 0x1d7}, {0x1d9, 0x1da}, {0x1da, 0x1d9}, {0x1db, 0x1dc}, {0x1dc, 0x1db}, {0x1dd, 0x18e}, {0x1de, 0x1df}, {0x1df, 0x1de}, {0x1e0, 0x1e1}, {0x1e1, 0x1e0}, {0x1e2, 0x1e3}, {0x1e3, 0x1e2}, {0x1e4, 0x1e5}, {0x1e5, 0x1e4}, {0x1e6, 0x1e7}, {0x1e7, 0x1e6}, {0x1e8, 0x1e9}, {0x1e9, 0x1e8}, {0x1ea, 0x1eb}, {0x1eb, 0x1ea}, {0x1ec, 0x1ed}, {0x1ed, 0x1ec}, {0x1ee, 0x1ef}, {0x1ef, 0x1ee}, {0x1f1, 0x1f2}, {0x1f1, 0x1f3}, {0x1f2, 0x1f1}, {0x1f2, 0x1f3}, {0x1f3, 0x1f1}, {0x1f3, 0x1f2}, {0x1f4, 0x1f5}, {0x1f5, 0x1f4}, {0x1f6, 0x195}, {0x1f7, 0x1bf}, {0x1f8, 0x1f9}, {0x1f9, 0x1f8}, {0x1fa, 0x1fb}, {0x1fb, 0x1fa}, {0x1fc, 0x1fd}, {0x1fd, 0x1fc}, {0x1fe, 0x1ff}, {0x1ff, 0x1fe}, {0x200, 0x201}, {0x201, 0x200}, {0x202, 0x203}, {0x203, 0x202}, {0x204, 0x205}, {0x205, 0x204}, {0x206, 0x207}, {0x207, 0x206}, {0x208, 0x209}, {0x209, 0x208}, {0x20a, 0x20b}, {0x20b, 0x20a}, {0x20c, 0x20d}, {0x20d, 0x20c}, {0x20e, 0x20f}, {0x20f, 0x20e}, {0x210, 0x211}, {0x211, 0x210}, {0x212, 0x213}, {0x213, 0x212}, {0x214, 0x215}, {0x215, 0x214}, {0x216, 0x217}, {0x217, 0x216}, {0x218, 0x219}, {0x219, 0x218}, {0x21a, 0x21b}, {0x21b, 0x21a}, {0x21c, 0x21d}, {0x21d, 0x21c}, {0x21e, 0x21f}, {0x21f, 0x21e}, {0x220, 0x19e}, {0x222, 0x223}, {0x223, 0x222}, {0x224, 0x225}, {0x225, 0x224}, {0x226, 0x227}, {0x227, 0x226}, {0x228, 0x229}, {0x229, 0x228}, {0x22a, 0x22b}, {0x22b, 0x22a}, {0x22c, 0x22d}, {0x22d, 0x22c}, {0x22e, 0x22f}, {0x22f, 0x22e}, {0x230, 0x231}, {0x231, 0x230}, {0x232, 0x233}, {0x233, 0x232}, {0x23a, 0x2c65}, {0x23b, 0x23c}, {0x23c, 0x23b}, {0x23d, 0x19a}, {0x23e, 0x2c66}, {0x23f, 0x2c7e}, {0x240, 0x2c7f}, {0x241, 0x242}, {0x242, 0x241}, {0x243, 0x180}, {0x244, 0x289}, {0x245, 0x28c}, {0x246, 0x247}, {0x247, 0x246}, {0x248, 0x249}, {0x249, 0x248}, {0x24a, 0x24b}, {0x24b, 0x24a}, {0x24c, 0x24d}, {0x24d, 0x24c}, {0x24e, 0x24f}, {0x24f, 0x24e}, {0x250, 0x2c6f}, {0x251, 0x2c6d}, {0x252, 0x2c70}, {0x253, 0x181}, {0x254, 0x186}, {0x256, 0x189}, {0x257, 0x18a}, {0x259, 0x18f}, {0x25b, 0x190}, {0x25c, 0xa7ab}, {0x260, 0x193}, {0x261, 0xa7ac}, {0x263, 0x194}, {0x265, 0xa78d}, {0x266, 0xa7aa}, {0x268, 0x197}, {0x269, 0x196}, {0x26b, 0x2c62}, {0x26c, 0xa7ad}, {0x26f, 0x19c}, {0x271, 0x2c6e}, {0x272, 0x19d}, {0x275, 0x19f}, {0x27d, 0x2c64}, {0x280, 0x1a6}, {0x283, 0x1a9}, {0x287, 0xa7b1}, {0x288, 0x1ae}, {0x289, 0x244}, {0x28a, 0x1b1}, {0x28b, 0x1b2}, {0x28c, 0x245}, {0x292, 0x1b7}, {0x29e, 0xa7b0}, {0x345, 0x399}, {0x345, 0x3b9}, {0x345, 0x1fbe}, {0x370, 0x371}, {0x371, 0x370}, {0x372, 0x373}, {0x373, 0x372}, {0x376, 0x377}, {0x377, 0x376}, {0x37b, 0x3fd}, {0x37c, 0x3fe}, {0x37d, 0x3ff}, {0x37f, 0x3f3}, {0x386, 0x3ac}, {0x388, 0x3ad}, {0x389, 0x3ae}, {0x38a, 0x3af}, {0x38c, 0x3cc}, {0x38e, 0x3cd}, {0x38f, 0x3ce}, {0x391, 0x3b1}, {0x392, 0x3b2}, {0x392, 0x3d0}, {0x393, 0x3b3}, {0x394, 0x3b4}, {0x395, 0x3b5}, {0x395, 0x3f5}, {0x396, 0x3b6}, {0x397, 0x3b7}, {0x398, 0x3b8}, {0x398, 0x3d1}, {0x398, 0x3f4}, {0x399, 0x345}, {0x399, 0x3b9}, {0x399, 0x1fbe}, {0x39a, 0x3ba}, {0x39a, 0x3f0}, {0x39b, 0x3bb}, {0x39c, 0xb5}, {0x39c, 0x3bc}, {0x39d, 0x3bd}, {0x39e, 0x3be}, {0x39f, 0x3bf}, {0x3a0, 0x3c0}, {0x3a0, 0x3d6}, {0x3a1, 0x3c1}, {0x3a1, 0x3f1}, {0x3a3, 0x3c2}, {0x3a3, 0x3c3}, {0x3a4, 0x3c4}, {0x3a5, 0x3c5}, {0x3a6, 0x3c6}, {0x3a6, 0x3d5}, {0x3a7, 0x3c7}, {0x3a8, 0x3c8}, {0x3a9, 0x3c9}, {0x3a9, 0x2126}, {0x3aa, 0x3ca}, {0x3ab, 0x3cb}, {0x3ac, 0x386}, {0x3ad, 0x388}, {0x3ae, 0x389}, {0x3af, 0x38a}, {0x3b1, 0x391}, {0x3b2, 0x392}, {0x3b2, 0x3d0}, {0x3b3, 0x393}, {0x3b4, 0x394}, {0x3b5, 0x395}, {0x3b5, 0x3f5}, {0x3b6, 0x396}, {0x3b7, 0x397}, {0x3b8, 0x398}, {0x3b8, 0x3d1}, {0x3b8, 0x3f4}, {0x3b9, 0x345}, {0x3b9, 0x399}, {0x3b9, 0x1fbe}, {0x3ba, 0x39a}, {0x3ba, 0x3f0}, {0x3bb, 0x39b}, {0x3bc, 0xb5}, {0x3bc, 0x39c}, {0x3bd, 0x39d}, {0x3be, 0x39e}, {0x3bf, 0x39f}, {0x3c0, 0x3a0}, {0x3c0, 0x3d6}, {0x3c1, 0x3a1}, {0x3c1, 0x3f1}, {0x3c2, 0x3a3}, {0x3c2, 0x3c3}, {0x3c3, 0x3a3}, {0x3c3, 0x3c2}, {0x3c4, 0x3a4}, {0x3c5, 0x3a5}, {0x3c6, 0x3a6}, {0x3c6, 0x3d5}, {0x3c7, 0x3a7}, {0x3c8, 0x3a8}, {0x3c9, 0x3a9}, {0x3c9, 0x2126}, {0x3ca, 0x3aa}, {0x3cb, 0x3ab}, {0x3cc, 0x38c}, {0x3cd, 0x38e}, {0x3ce, 0x38f}, {0x3cf, 0x3d7}, {0x3d0, 0x392}, {0x3d0, 0x3b2}, {0x3d1, 0x398}, {0x3d1, 0x3b8}, {0x3d1, 0x3f4}, {0x3d5, 0x3a6}, {0x3d5, 0x3c6}, {0x3d6, 0x3a0}, {0x3d6, 0x3c0}, {0x3d7, 0x3cf}, {0x3d8, 0x3d9}, {0x3d9, 0x3d8}, {0x3da, 0x3db}, {0x3db, 0x3da}, {0x3dc, 0x3dd}, {0x3dd, 0x3dc}, {0x3de, 0x3df}, {0x3df, 0x3de}, {0x3e0, 0x3e1}, {0x3e1, 0x3e0}, {0x3e2, 0x3e3}, {0x3e3, 0x3e2}, {0x3e4, 0x3e5}, {0x3e5, 0x3e4}, {0x3e6, 0x3e7}, {0x3e7, 0x3e6}, {0x3e8, 0x3e9}, {0x3e9, 0x3e8}, {0x3ea, 0x3eb}, {0x3eb, 0x3ea}, {0x3ec, 0x3ed}, {0x3ed, 0x3ec}, {0x3ee, 0x3ef}, {0x3ef, 0x3ee}, {0x3f0, 0x39a}, {0x3f0, 0x3ba}, {0x3f1, 0x3a1}, {0x3f1, 0x3c1}, {0x3f2, 0x3f9}, {0x3f3, 0x37f}, {0x3f4, 0x398}, {0x3f4, 0x3b8}, {0x3f4, 0x3d1}, {0x3f5, 0x395}, {0x3f5, 0x3b5}, {0x3f7, 0x3f8}, {0x3f8, 0x3f7}, {0x3f9, 0x3f2}, {0x3fa, 0x3fb}, {0x3fb, 0x3fa}, {0x3fd, 0x37b}, {0x3fe, 0x37c}, {0x3ff, 0x37d}, {0x400, 0x450}, {0x401, 0x451}, {0x402, 0x452}, {0x403, 0x453}, {0x404, 0x454}, {0x405, 0x455}, {0x406, 0x456}, {0x407, 0x457}, {0x408, 0x458}, {0x409, 0x459}, {0x40a, 0x45a}, {0x40b, 0x45b}, {0x40c, 0x45c}, {0x40d, 0x45d}, {0x40e, 0x45e}, {0x40f, 0x45f}, {0x410, 0x430}, {0x411, 0x431}, {0x412, 0x432}, {0x413, 0x433}, {0x414, 0x434}, {0x415, 0x435}, {0x416, 0x436}, {0x417, 0x437}, {0x418, 0x438}, {0x419, 0x439}, {0x41a, 0x43a}, {0x41b, 0x43b}, {0x41c, 0x43c}, {0x41d, 0x43d}, {0x41e, 0x43e}, {0x41f, 0x43f}, {0x420, 0x440}, {0x421, 0x441}, {0x422, 0x442}, {0x423, 0x443}, {0x424, 0x444}, {0x425, 0x445}, {0x426, 0x446}, {0x427, 0x447}, {0x428, 0x448}, {0x429, 0x449}, {0x42a, 0x44a}, {0x42b, 0x44b}, {0x42c, 0x44c}, {0x42d, 0x44d}, {0x42e, 0x44e}, {0x42f, 0x44f}, {0x430, 0x410}, {0x431, 0x411}, {0x432, 0x412}, {0x433, 0x413}, {0x434, 0x414}, {0x435, 0x415}, {0x436, 0x416}, {0x437, 0x417}, {0x438, 0x418}, {0x439, 0x419}, {0x43a, 0x41a}, {0x43b, 0x41b}, {0x43c, 0x41c}, {0x43d, 0x41d}, {0x43e, 0x41e}, {0x43f, 0x41f}, {0x440, 0x420}, {0x441, 0x421}, {0x442, 0x422}, {0x443, 0x423}, {0x444, 0x424}, {0x445, 0x425}, {0x446, 0x426}, {0x447, 0x427}, {0x448, 0x428}, {0x449, 0x429}, {0x44a, 0x42a}, {0x44b, 0x42b}, {0x44c, 0x42c}, {0x44d, 0x42d}, {0x44e, 0x42e}, {0x44f, 0x42f}, {0x450, 0x400}, {0x451, 0x401}, {0x452, 0x402}, {0x453, 0x403}, {0x454, 0x404}, {0x455, 0x405}, {0x456, 0x406}, {0x457, 0x407}, {0x458, 0x408}, {0x459, 0x409}, {0x45a, 0x40a}, {0x45b, 0x40b}, {0x45c, 0x40c}, {0x45d, 0x40d}, {0x45e, 0x40e}, {0x45f, 0x40f}, {0x460, 0x461}, {0x461, 0x460}, {0x462, 0x463}, {0x463, 0x462}, {0x464, 0x465}, {0x465, 0x464}, {0x466, 0x467}, {0x467, 0x466}, {0x468, 0x469}, {0x469, 0x468}, {0x46a, 0x46b}, {0x46b, 0x46a}, {0x46c, 0x46d}, {0x46d, 0x46c}, {0x46e, 0x46f}, {0x46f, 0x46e}, {0x470, 0x471}, {0x471, 0x470}, {0x472, 0x473}, {0x473, 0x472}, {0x474, 0x475}, {0x475, 0x474}, {0x476, 0x477}, {0x477, 0x476}, {0x478, 0x479}, {0x479, 0x478}, {0x47a, 0x47b}, {0x47b, 0x47a}, {0x47c, 0x47d}, {0x47d, 0x47c}, {0x47e, 0x47f}, {0x47f, 0x47e}, {0x480, 0x481}, {0x481, 0x480}, {0x48a, 0x48b}, {0x48b, 0x48a}, {0x48c, 0x48d}, {0x48d, 0x48c}, {0x48e, 0x48f}, {0x48f, 0x48e}, {0x490, 0x491}, {0x491, 0x490}, {0x492, 0x493}, {0x493, 0x492}, {0x494, 0x495}, {0x495, 0x494}, {0x496, 0x497}, {0x497, 0x496}, {0x498, 0x499}, {0x499, 0x498}, {0x49a, 0x49b}, {0x49b, 0x49a}, {0x49c, 0x49d}, {0x49d, 0x49c}, {0x49e, 0x49f}, {0x49f, 0x49e}, {0x4a0, 0x4a1}, {0x4a1, 0x4a0}, {0x4a2, 0x4a3}, {0x4a3, 0x4a2}, {0x4a4, 0x4a5}, {0x4a5, 0x4a4}, {0x4a6, 0x4a7}, {0x4a7, 0x4a6}, {0x4a8, 0x4a9}, {0x4a9, 0x4a8}, {0x4aa, 0x4ab}, {0x4ab, 0x4aa}, {0x4ac, 0x4ad}, {0x4ad, 0x4ac}, {0x4ae, 0x4af}, {0x4af, 0x4ae}, {0x4b0, 0x4b1}, {0x4b1, 0x4b0}, {0x4b2, 0x4b3}, {0x4b3, 0x4b2}, {0x4b4, 0x4b5}, {0x4b5, 0x4b4}, {0x4b6, 0x4b7}, {0x4b7, 0x4b6}, {0x4b8, 0x4b9}, {0x4b9, 0x4b8}, {0x4ba, 0x4bb}, {0x4bb, 0x4ba}, {0x4bc, 0x4bd}, {0x4bd, 0x4bc}, {0x4be, 0x4bf}, {0x4bf, 0x4be}, {0x4c0, 0x4cf}, {0x4c1, 0x4c2}, {0x4c2, 0x4c1}, {0x4c3, 0x4c4}, {0x4c4, 0x4c3}, {0x4c5, 0x4c6}, {0x4c6, 0x4c5}, {0x4c7, 0x4c8}, {0x4c8, 0x4c7}, {0x4c9, 0x4ca}, {0x4ca, 0x4c9}, {0x4cb, 0x4cc}, {0x4cc, 0x4cb}, {0x4cd, 0x4ce}, {0x4ce, 0x4cd}, {0x4cf, 0x4c0}, {0x4d0, 0x4d1}, {0x4d1, 0x4d0}, {0x4d2, 0x4d3}, {0x4d3, 0x4d2}, {0x4d4, 0x4d5}, {0x4d5, 0x4d4}, {0x4d6, 0x4d7}, {0x4d7, 0x4d6}, {0x4d8, 0x4d9}, {0x4d9, 0x4d8}, {0x4da, 0x4db}, {0x4db, 0x4da}, {0x4dc, 0x4dd}, {0x4dd, 0x4dc}, {0x4de, 0x4df}, {0x4df, 0x4de}, {0x4e0, 0x4e1}, {0x4e1, 0x4e0}, {0x4e2, 0x4e3}, {0x4e3, 0x4e2}, {0x4e4, 0x4e5}, {0x4e5, 0x4e4}, {0x4e6, 0x4e7}, {0x4e7, 0x4e6}, {0x4e8, 0x4e9}, {0x4e9, 0x4e8}, {0x4ea, 0x4eb}, {0x4eb, 0x4ea}, {0x4ec, 0x4ed}, {0x4ed, 0x4ec}, {0x4ee, 0x4ef}, {0x4ef, 0x4ee}, {0x4f0, 0x4f1}, {0x4f1, 0x4f0}, {0x4f2, 0x4f3}, {0x4f3, 0x4f2}, {0x4f4, 0x4f5}, {0x4f5, 0x4f4}, {0x4f6, 0x4f7}, {0x4f7, 0x4f6}, {0x4f8, 0x4f9}, {0x4f9, 0x4f8}, {0x4fa, 0x4fb}, {0x4fb, 0x4fa}, {0x4fc, 0x4fd}, {0x4fd, 0x4fc}, {0x4fe, 0x4ff}, {0x4ff, 0x4fe}, {0x500, 0x501}, {0x501, 0x500}, {0x502, 0x503}, {0x503, 0x502}, {0x504, 0x505}, {0x505, 0x504}, {0x506, 0x507}, {0x507, 0x506}, {0x508, 0x509}, {0x509, 0x508}, {0x50a, 0x50b}, {0x50b, 0x50a}, {0x50c, 0x50d}, {0x50d, 0x50c}, {0x50e, 0x50f}, {0x50f, 0x50e}, {0x510, 0x511}, {0x511, 0x510}, {0x512, 0x513}, {0x513, 0x512}, {0x514, 0x515}, {0x515, 0x514}, {0x516, 0x517}, {0x517, 0x516}, {0x518, 0x519}, {0x519, 0x518}, {0x51a, 0x51b}, {0x51b, 0x51a}, {0x51c, 0x51d}, {0x51d, 0x51c}, {0x51e, 0x51f}, {0x51f, 0x51e}, {0x520, 0x521}, {0x521, 0x520}, {0x522, 0x523}, {0x523, 0x522}, {0x524, 0x525}, {0x525, 0x524}, {0x526, 0x527}, {0x527, 0x526}, {0x528, 0x529}, {0x529, 0x528}, {0x52a, 0x52b}, {0x52b, 0x52a}, {0x52c, 0x52d}, {0x52d, 0x52c}, {0x52e, 0x52f}, {0x52f, 0x52e}, {0x531, 0x561}, {0x532, 0x562}, {0x533, 0x563}, {0x534, 0x564}, {0x535, 0x565}, {0x536, 0x566}, {0x537, 0x567}, {0x538, 0x568}, {0x539, 0x569}, {0x53a, 0x56a}, {0x53b, 0x56b}, {0x53c, 0x56c}, {0x53d, 0x56d}, {0x53e, 0x56e}, {0x53f, 0x56f}, {0x540, 0x570}, {0x541, 0x571}, {0x542, 0x572}, {0x543, 0x573}, {0x544, 0x574}, {0x545, 0x575}, {0x546, 0x576}, {0x547, 0x577}, {0x548, 0x578}, {0x549, 0x579}, {0x54a, 0x57a}, {0x54b, 0x57b}, {0x54c, 0x57c}, {0x54d, 0x57d}, {0x54e, 0x57e}, {0x54f, 0x57f}, {0x550, 0x580}, {0x551, 0x581}, {0x552, 0x582}, {0x553, 0x583}, {0x554, 0x584}, {0x555, 0x585}, {0x556, 0x586}, {0x561, 0x531}, {0x562, 0x532}, {0x563, 0x533}, {0x564, 0x534}, {0x565, 0x535}, {0x566, 0x536}, {0x567, 0x537}, {0x568, 0x538}, {0x569, 0x539}, {0x56a, 0x53a}, {0x56b, 0x53b}, {0x56c, 0x53c}, {0x56d, 0x53d}, {0x56e, 0x53e}, {0x56f, 0x53f}, {0x570, 0x540}, {0x571, 0x541}, {0x572, 0x542}, {0x573, 0x543}, {0x574, 0x544}, {0x575, 0x545}, {0x576, 0x546}, {0x577, 0x547}, {0x578, 0x548}, {0x579, 0x549}, {0x57a, 0x54a}, {0x57b, 0x54b}, {0x57c, 0x54c}, {0x57d, 0x54d}, {0x57e, 0x54e}, {0x57f, 0x54f}, {0x580, 0x550}, {0x581, 0x551}, {0x582, 0x552}, {0x583, 0x553}, {0x584, 0x554}, {0x585, 0x555}, {0x586, 0x556}, {0x10a0, 0x2d00}, {0x10a1, 0x2d01}, {0x10a2, 0x2d02}, {0x10a3, 0x2d03}, {0x10a4, 0x2d04}, {0x10a5, 0x2d05}, {0x10a6, 0x2d06}, {0x10a7, 0x2d07}, {0x10a8, 0x2d08}, {0x10a9, 0x2d09}, {0x10aa, 0x2d0a}, {0x10ab, 0x2d0b}, {0x10ac, 0x2d0c}, {0x10ad, 0x2d0d}, {0x10ae, 0x2d0e}, {0x10af, 0x2d0f}, {0x10b0, 0x2d10}, {0x10b1, 0x2d11}, {0x10b2, 0x2d12}, {0x10b3, 0x2d13}, {0x10b4, 0x2d14}, {0x10b5, 0x2d15}, {0x10b6, 0x2d16}, {0x10b7, 0x2d17}, {0x10b8, 0x2d18}, {0x10b9, 0x2d19}, {0x10ba, 0x2d1a}, {0x10bb, 0x2d1b}, {0x10bc, 0x2d1c}, {0x10bd, 0x2d1d}, {0x10be, 0x2d1e}, {0x10bf, 0x2d1f}, {0x10c0, 0x2d20}, {0x10c1, 0x2d21}, {0x10c2, 0x2d22}, {0x10c3, 0x2d23}, {0x10c4, 0x2d24}, {0x10c5, 0x2d25}, {0x10c7, 0x2d27}, {0x10cd, 0x2d2d}, {0x1d79, 0xa77d}, {0x1d7d, 0x2c63}, {0x1e00, 0x1e01}, {0x1e01, 0x1e00}, {0x1e02, 0x1e03}, {0x1e03, 0x1e02}, {0x1e04, 0x1e05}, {0x1e05, 0x1e04}, {0x1e06, 0x1e07}, {0x1e07, 0x1e06}, {0x1e08, 0x1e09}, {0x1e09, 0x1e08}, {0x1e0a, 0x1e0b}, {0x1e0b, 0x1e0a}, {0x1e0c, 0x1e0d}, {0x1e0d, 0x1e0c}, {0x1e0e, 0x1e0f}, {0x1e0f, 0x1e0e}, {0x1e10, 0x1e11}, {0x1e11, 0x1e10}, {0x1e12, 0x1e13}, {0x1e13, 0x1e12}, {0x1e14, 0x1e15}, {0x1e15, 0x1e14}, {0x1e16, 0x1e17}, {0x1e17, 0x1e16}, {0x1e18, 0x1e19}, {0x1e19, 0x1e18}, {0x1e1a, 0x1e1b}, {0x1e1b, 0x1e1a}, {0x1e1c, 0x1e1d}, {0x1e1d, 0x1e1c}, {0x1e1e, 0x1e1f}, {0x1e1f, 0x1e1e}, {0x1e20, 0x1e21}, {0x1e21, 0x1e20}, {0x1e22, 0x1e23}, {0x1e23, 0x1e22}, {0x1e24, 0x1e25}, {0x1e25, 0x1e24}, {0x1e26, 0x1e27}, {0x1e27, 0x1e26}, {0x1e28, 0x1e29}, {0x1e29, 0x1e28}, {0x1e2a, 0x1e2b}, {0x1e2b, 0x1e2a}, {0x1e2c, 0x1e2d}, {0x1e2d, 0x1e2c}, {0x1e2e, 0x1e2f}, {0x1e2f, 0x1e2e}, {0x1e30, 0x1e31}, {0x1e31, 0x1e30}, {0x1e32, 0x1e33}, {0x1e33, 0x1e32}, {0x1e34, 0x1e35}, {0x1e35, 0x1e34}, {0x1e36, 0x1e37}, {0x1e37, 0x1e36}, {0x1e38, 0x1e39}, {0x1e39, 0x1e38}, {0x1e3a, 0x1e3b}, {0x1e3b, 0x1e3a}, {0x1e3c, 0x1e3d}, {0x1e3d, 0x1e3c}, {0x1e3e, 0x1e3f}, {0x1e3f, 0x1e3e}, {0x1e40, 0x1e41}, {0x1e41, 0x1e40}, {0x1e42, 0x1e43}, {0x1e43, 0x1e42}, {0x1e44, 0x1e45}, {0x1e45, 0x1e44}, {0x1e46, 0x1e47}, {0x1e47, 0x1e46}, {0x1e48, 0x1e49}, {0x1e49, 0x1e48}, {0x1e4a, 0x1e4b}, {0x1e4b, 0x1e4a}, {0x1e4c, 0x1e4d}, {0x1e4d, 0x1e4c}, {0x1e4e, 0x1e4f}, {0x1e4f, 0x1e4e}, {0x1e50, 0x1e51}, {0x1e51, 0x1e50}, {0x1e52, 0x1e53}, {0x1e53, 0x1e52}, {0x1e54, 0x1e55}, {0x1e55, 0x1e54}, {0x1e56, 0x1e57}, {0x1e57, 0x1e56}, {0x1e58, 0x1e59}, {0x1e59, 0x1e58}, {0x1e5a, 0x1e5b}, {0x1e5b, 0x1e5a}, {0x1e5c, 0x1e5d}, {0x1e5d, 0x1e5c}, {0x1e5e, 0x1e5f}, {0x1e5f, 0x1e5e}, {0x1e60, 0x1e61}, {0x1e60, 0x1e9b}, {0x1e61, 0x1e60}, {0x1e61, 0x1e9b}, {0x1e62, 0x1e63}, {0x1e63, 0x1e62}, {0x1e64, 0x1e65}, {0x1e65, 0x1e64}, {0x1e66, 0x1e67}, {0x1e67, 0x1e66}, {0x1e68, 0x1e69}, {0x1e69, 0x1e68}, {0x1e6a, 0x1e6b}, {0x1e6b, 0x1e6a}, {0x1e6c, 0x1e6d}, {0x1e6d, 0x1e6c}, {0x1e6e, 0x1e6f}, {0x1e6f, 0x1e6e}, {0x1e70, 0x1e71}, {0x1e71, 0x1e70}, {0x1e72, 0x1e73}, {0x1e73, 0x1e72}, {0x1e74, 0x1e75}, {0x1e75, 0x1e74}, {0x1e76, 0x1e77}, {0x1e77, 0x1e76}, {0x1e78, 0x1e79}, {0x1e79, 0x1e78}, {0x1e7a, 0x1e7b}, {0x1e7b, 0x1e7a}, {0x1e7c, 0x1e7d}, {0x1e7d, 0x1e7c}, {0x1e7e, 0x1e7f}, {0x1e7f, 0x1e7e}, {0x1e80, 0x1e81}, {0x1e81, 0x1e80}, {0x1e82, 0x1e83}, {0x1e83, 0x1e82}, {0x1e84, 0x1e85}, {0x1e85, 0x1e84}, {0x1e86, 0x1e87}, {0x1e87, 0x1e86}, {0x1e88, 0x1e89}, {0x1e89, 0x1e88}, {0x1e8a, 0x1e8b}, {0x1e8b, 0x1e8a}, {0x1e8c, 0x1e8d}, {0x1e8d, 0x1e8c}, {0x1e8e, 0x1e8f}, {0x1e8f, 0x1e8e}, {0x1e90, 0x1e91}, {0x1e91, 0x1e90}, {0x1e92, 0x1e93}, {0x1e93, 0x1e92}, {0x1e94, 0x1e95}, {0x1e95, 0x1e94}, {0x1e9b, 0x1e60}, {0x1e9b, 0x1e61}, {0x1e9e, 0xdf}, {0x1ea0, 0x1ea1}, {0x1ea1, 0x1ea0}, {0x1ea2, 0x1ea3}, {0x1ea3, 0x1ea2}, {0x1ea4, 0x1ea5}, {0x1ea5, 0x1ea4}, {0x1ea6, 0x1ea7}, {0x1ea7, 0x1ea6}, {0x1ea8, 0x1ea9}, {0x1ea9, 0x1ea8}, {0x1eaa, 0x1eab}, {0x1eab, 0x1eaa}, {0x1eac, 0x1ead}, {0x1ead, 0x1eac}, {0x1eae, 0x1eaf}, {0x1eaf, 0x1eae}, {0x1eb0, 0x1eb1}, {0x1eb1, 0x1eb0}, {0x1eb2, 0x1eb3}, {0x1eb3, 0x1eb2}, {0x1eb4, 0x1eb5}, {0x1eb5, 0x1eb4}, {0x1eb6, 0x1eb7}, {0x1eb7, 0x1eb6}, {0x1eb8, 0x1eb9}, {0x1eb9, 0x1eb8}, {0x1eba, 0x1ebb}, {0x1ebb, 0x1eba}, {0x1ebc, 0x1ebd}, {0x1ebd, 0x1ebc}, {0x1ebe, 0x1ebf}, {0x1ebf, 0x1ebe}, {0x1ec0, 0x1ec1}, {0x1ec1, 0x1ec0}, {0x1ec2, 0x1ec3}, {0x1ec3, 0x1ec2}, {0x1ec4, 0x1ec5}, {0x1ec5, 0x1ec4}, {0x1ec6, 0x1ec7}, {0x1ec7, 0x1ec6}, {0x1ec8, 0x1ec9}, {0x1ec9, 0x1ec8}, {0x1eca, 0x1ecb}, {0x1ecb, 0x1eca}, {0x1ecc, 0x1ecd}, {0x1ecd, 0x1ecc}, {0x1ece, 0x1ecf}, {0x1ecf, 0x1ece}, {0x1ed0, 0x1ed1}, {0x1ed1, 0x1ed0}, {0x1ed2, 0x1ed3}, {0x1ed3, 0x1ed2}, {0x1ed4, 0x1ed5}, {0x1ed5, 0x1ed4}, {0x1ed6, 0x1ed7}, {0x1ed7, 0x1ed6}, {0x1ed8, 0x1ed9}, {0x1ed9, 0x1ed8}, {0x1eda, 0x1edb}, {0x1edb, 0x1eda}, {0x1edc, 0x1edd}, {0x1edd, 0x1edc}, {0x1ede, 0x1edf}, {0x1edf, 0x1ede}, {0x1ee0, 0x1ee1}, {0x1ee1, 0x1ee0}, {0x1ee2, 0x1ee3}, {0x1ee3, 0x1ee2}, {0x1ee4, 0x1ee5}, {0x1ee5, 0x1ee4}, {0x1ee6, 0x1ee7}, {0x1ee7, 0x1ee6}, {0x1ee8, 0x1ee9}, {0x1ee9, 0x1ee8}, {0x1eea, 0x1eeb}, {0x1eeb, 0x1eea}, {0x1eec, 0x1eed}, {0x1eed, 0x1eec}, {0x1eee, 0x1eef}, {0x1eef, 0x1eee}, {0x1ef0, 0x1ef1}, {0x1ef1, 0x1ef0}, {0x1ef2, 0x1ef3}, {0x1ef3, 0x1ef2}, {0x1ef4, 0x1ef5}, {0x1ef5, 0x1ef4}, {0x1ef6, 0x1ef7}, {0x1ef7, 0x1ef6}, {0x1ef8, 0x1ef9}, {0x1ef9, 0x1ef8}, {0x1efa, 0x1efb}, {0x1efb, 0x1efa}, {0x1efc, 0x1efd}, {0x1efd, 0x1efc}, {0x1efe, 0x1eff}, {0x1eff, 0x1efe}, {0x1f00, 0x1f08}, {0x1f01, 0x1f09}, {0x1f02, 0x1f0a}, {0x1f03, 0x1f0b}, {0x1f04, 0x1f0c}, {0x1f05, 0x1f0d}, {0x1f06, 0x1f0e}, {0x1f07, 0x1f0f}, {0x1f08, 0x1f00}, {0x1f09, 0x1f01}, {0x1f0a, 0x1f02}, {0x1f0b, 0x1f03}, {0x1f0c, 0x1f04}, {0x1f0d, 0x1f05}, {0x1f0e, 0x1f06}, {0x1f0f, 0x1f07}, {0x1f10, 0x1f18}, {0x1f11, 0x1f19}, {0x1f12, 0x1f1a}, {0x1f13, 0x1f1b}, {0x1f14, 0x1f1c}, {0x1f15, 0x1f1d}, {0x1f18, 0x1f10}, {0x1f19, 0x1f11}, {0x1f1a, 0x1f12}, {0x1f1b, 0x1f13}, {0x1f1c, 0x1f14}, {0x1f1d, 0x1f15}, {0x1f20, 0x1f28}, {0x1f21, 0x1f29}, {0x1f22, 0x1f2a}, {0x1f23, 0x1f2b}, {0x1f24, 0x1f2c}, {0x1f25, 0x1f2d}, {0x1f26, 0x1f2e}, {0x1f27, 0x1f2f}, {0x1f28, 0x1f20}, {0x1f29, 0x1f21}, {0x1f2a, 0x1f22}, {0x1f2b, 0x1f23}, {0x1f2c, 0x1f24}, {0x1f2d, 0x1f25}, {0x1f2e, 0x1f26}, {0x1f2f, 0x1f27}, {0x1f30, 0x1f38}, {0x1f31, 0x1f39}, {0x1f32, 0x1f3a}, {0x1f33, 0x1f3b}, {0x1f34, 0x1f3c}, {0x1f35, 0x1f3d}, {0x1f36, 0x1f3e}, {0x1f37, 0x1f3f}, {0x1f38, 0x1f30}, {0x1f39, 0x1f31}, {0x1f3a, 0x1f32}, {0x1f3b, 0x1f33}, {0x1f3c, 0x1f34}, {0x1f3d, 0x1f35}, {0x1f3e, 0x1f36}, {0x1f3f, 0x1f37}, {0x1f40, 0x1f48}, {0x1f41, 0x1f49}, {0x1f42, 0x1f4a}, {0x1f43, 0x1f4b}, {0x1f44, 0x1f4c}, {0x1f45, 0x1f4d}, {0x1f48, 0x1f40}, {0x1f49, 0x1f41}, {0x1f4a, 0x1f42}, {0x1f4b, 0x1f43}, {0x1f4c, 0x1f44}, {0x1f4d, 0x1f45}, {0x1f51, 0x1f59}, {0x1f53, 0x1f5b}, {0x1f55, 0x1f5d}, {0x1f57, 0x1f5f}, {0x1f59, 0x1f51}, {0x1f5b, 0x1f53}, {0x1f5d, 0x1f55}, {0x1f5f, 0x1f57}, {0x1f60, 0x1f68}, {0x1f61, 0x1f69}, {0x1f62, 0x1f6a}, {0x1f63, 0x1f6b}, {0x1f64, 0x1f6c}, {0x1f65, 0x1f6d}, {0x1f66, 0x1f6e}, {0x1f67, 0x1f6f}, {0x1f68, 0x1f60}, {0x1f69, 0x1f61}, {0x1f6a, 0x1f62}, {0x1f6b, 0x1f63}, {0x1f6c, 0x1f64}, {0x1f6d, 0x1f65}, {0x1f6e, 0x1f66}, {0x1f6f, 0x1f67}, {0x1f70, 0x1fba}, {0x1f71, 0x1fbb}, {0x1f72, 0x1fc8}, {0x1f73, 0x1fc9}, {0x1f74, 0x1fca}, {0x1f75, 0x1fcb}, {0x1f76, 0x1fda}, {0x1f77, 0x1fdb}, {0x1f78, 0x1ff8}, {0x1f79, 0x1ff9}, {0x1f7a, 0x1fea}, {0x1f7b, 0x1feb}, {0x1f7c, 0x1ffa}, {0x1f7d, 0x1ffb}, {0x1f80, 0x1f88}, {0x1f81, 0x1f89}, {0x1f82, 0x1f8a}, {0x1f83, 0x1f8b}, {0x1f84, 0x1f8c}, {0x1f85, 0x1f8d}, {0x1f86, 0x1f8e}, {0x1f87, 0x1f8f}, {0x1f88, 0x1f80}, {0x1f89, 0x1f81}, {0x1f8a, 0x1f82}, {0x1f8b, 0x1f83}, {0x1f8c, 0x1f84}, {0x1f8d, 0x1f85}, {0x1f8e, 0x1f86}, {0x1f8f, 0x1f87}, {0x1f90, 0x1f98}, {0x1f91, 0x1f99}, {0x1f92, 0x1f9a}, {0x1f93, 0x1f9b}, {0x1f94, 0x1f9c}, {0x1f95, 0x1f9d}, {0x1f96, 0x1f9e}, {0x1f97, 0x1f9f}, {0x1f98, 0x1f90}, {0x1f99, 0x1f91}, {0x1f9a, 0x1f92}, {0x1f9b, 0x1f93}, {0x1f9c, 0x1f94}, {0x1f9d, 0x1f95}, {0x1f9e, 0x1f96}, {0x1f9f, 0x1f97}, {0x1fa0, 0x1fa8}, {0x1fa1, 0x1fa9}, {0x1fa2, 0x1faa}, {0x1fa3, 0x1fab}, {0x1fa4, 0x1fac}, {0x1fa5, 0x1fad}, {0x1fa6, 0x1fae}, {0x1fa7, 0x1faf}, {0x1fa8, 0x1fa0}, {0x1fa9, 0x1fa1}, {0x1faa, 0x1fa2}, {0x1fab, 0x1fa3}, {0x1fac, 0x1fa4}, {0x1fad, 0x1fa5}, {0x1fae, 0x1fa6}, {0x1faf, 0x1fa7}, {0x1fb0, 0x1fb8}, {0x1fb1, 0x1fb9}, {0x1fb3, 0x1fbc}, {0x1fb8, 0x1fb0}, {0x1fb9, 0x1fb1}, {0x1fba, 0x1f70}, {0x1fbb, 0x1f71}, {0x1fbc, 0x1fb3}, {0x1fbe, 0x345}, {0x1fbe, 0x399}, {0x1fbe, 0x3b9}, {0x1fc3, 0x1fcc}, {0x1fc8, 0x1f72}, {0x1fc9, 0x1f73}, {0x1fca, 0x1f74}, {0x1fcb, 0x1f75}, {0x1fcc, 0x1fc3}, {0x1fd0, 0x1fd8}, {0x1fd1, 0x1fd9}, {0x1fd8, 0x1fd0}, {0x1fd9, 0x1fd1}, {0x1fda, 0x1f76}, {0x1fdb, 0x1f77}, {0x1fe0, 0x1fe8}, {0x1fe1, 0x1fe9}, {0x1fe5, 0x1fec}, {0x1fe8, 0x1fe0}, {0x1fe9, 0x1fe1}, {0x1fea, 0x1f7a}, {0x1feb, 0x1f7b}, {0x1fec, 0x1fe5}, {0x1ff3, 0x1ffc}, {0x1ff8, 0x1f78}, {0x1ff9, 0x1f79}, {0x1ffa, 0x1f7c}, {0x1ffb, 0x1f7d}, {0x1ffc, 0x1ff3}, {0x2126, 0x3a9}, {0x2126, 0x3c9}, {0x212a, 0x4b}, {0x212a, 0x6b}, {0x212b, 0xc5}, {0x212b, 0xe5}, {0x2132, 0x214e}, {0x214e, 0x2132}, {0x2160, 0x2170}, {0x2161, 0x2171}, {0x2162, 0x2172}, {0x2163, 0x2173}, {0x2164, 0x2174}, {0x2165, 0x2175}, {0x2166, 0x2176}, {0x2167, 0x2177}, {0x2168, 0x2178}, {0x2169, 0x2179}, {0x216a, 0x217a}, {0x216b, 0x217b}, {0x216c, 0x217c}, {0x216d, 0x217d}, {0x216e, 0x217e}, {0x216f, 0x217f}, {0x2170, 0x2160}, {0x2171, 0x2161}, {0x2172, 0x2162}, {0x2173, 0x2163}, {0x2174, 0x2164}, {0x2175, 0x2165}, {0x2176, 0x2166}, {0x2177, 0x2167}, {0x2178, 0x2168}, {0x2179, 0x2169}, {0x217a, 0x216a}, {0x217b, 0x216b}, {0x217c, 0x216c}, {0x217d, 0x216d}, {0x217e, 0x216e}, {0x217f, 0x216f}, {0x2183, 0x2184}, {0x2184, 0x2183}, {0x24b6, 0x24d0}, {0x24b7, 0x24d1}, {0x24b8, 0x24d2}, {0x24b9, 0x24d3}, {0x24ba, 0x24d4}, {0x24bb, 0x24d5}, {0x24bc, 0x24d6}, {0x24bd, 0x24d7}, {0x24be, 0x24d8}, {0x24bf, 0x24d9}, {0x24c0, 0x24da}, {0x24c1, 0x24db}, {0x24c2, 0x24dc}, {0x24c3, 0x24dd}, {0x24c4, 0x24de}, {0x24c5, 0x24df}, {0x24c6, 0x24e0}, {0x24c7, 0x24e1}, {0x24c8, 0x24e2}, {0x24c9, 0x24e3}, {0x24ca, 0x24e4}, {0x24cb, 0x24e5}, {0x24cc, 0x24e6}, {0x24cd, 0x24e7}, {0x24ce, 0x24e8}, {0x24cf, 0x24e9}, {0x24d0, 0x24b6}, {0x24d1, 0x24b7}, {0x24d2, 0x24b8}, {0x24d3, 0x24b9}, {0x24d4, 0x24ba}, {0x24d5, 0x24bb}, {0x24d6, 0x24bc}, {0x24d7, 0x24bd}, {0x24d8, 0x24be}, {0x24d9, 0x24bf}, {0x24da, 0x24c0}, {0x24db, 0x24c1}, {0x24dc, 0x24c2}, {0x24dd, 0x24c3}, {0x24de, 0x24c4}, {0x24df, 0x24c5}, {0x24e0, 0x24c6}, {0x24e1, 0x24c7}, {0x24e2, 0x24c8}, {0x24e3, 0x24c9}, {0x24e4, 0x24ca}, {0x24e5, 0x24cb}, {0x24e6, 0x24cc}, {0x24e7, 0x24cd}, {0x24e8, 0x24ce}, {0x24e9, 0x24cf}, {0x2c00, 0x2c30}, {0x2c01, 0x2c31}, {0x2c02, 0x2c32}, {0x2c03, 0x2c33}, {0x2c04, 0x2c34}, {0x2c05, 0x2c35}, {0x2c06, 0x2c36}, {0x2c07, 0x2c37}, {0x2c08, 0x2c38}, {0x2c09, 0x2c39}, {0x2c0a, 0x2c3a}, {0x2c0b, 0x2c3b}, {0x2c0c, 0x2c3c}, {0x2c0d, 0x2c3d}, {0x2c0e, 0x2c3e}, {0x2c0f, 0x2c3f}, {0x2c10, 0x2c40}, {0x2c11, 0x2c41}, {0x2c12, 0x2c42}, {0x2c13, 0x2c43}, {0x2c14, 0x2c44}, {0x2c15, 0x2c45}, {0x2c16, 0x2c46}, {0x2c17, 0x2c47}, {0x2c18, 0x2c48}, {0x2c19, 0x2c49}, {0x2c1a, 0x2c4a}, {0x2c1b, 0x2c4b}, {0x2c1c, 0x2c4c}, {0x2c1d, 0x2c4d}, {0x2c1e, 0x2c4e}, {0x2c1f, 0x2c4f}, {0x2c20, 0x2c50}, {0x2c21, 0x2c51}, {0x2c22, 0x2c52}, {0x2c23, 0x2c53}, {0x2c24, 0x2c54}, {0x2c25, 0x2c55}, {0x2c26, 0x2c56}, {0x2c27, 0x2c57}, {0x2c28, 0x2c58}, {0x2c29, 0x2c59}, {0x2c2a, 0x2c5a}, {0x2c2b, 0x2c5b}, {0x2c2c, 0x2c5c}, {0x2c2d, 0x2c5d}, {0x2c2e, 0x2c5e}, {0x2c30, 0x2c00}, {0x2c31, 0x2c01}, {0x2c32, 0x2c02}, {0x2c33, 0x2c03}, {0x2c34, 0x2c04}, {0x2c35, 0x2c05}, {0x2c36, 0x2c06}, {0x2c37, 0x2c07}, {0x2c38, 0x2c08}, {0x2c39, 0x2c09}, {0x2c3a, 0x2c0a}, {0x2c3b, 0x2c0b}, {0x2c3c, 0x2c0c}, {0x2c3d, 0x2c0d}, {0x2c3e, 0x2c0e}, {0x2c3f, 0x2c0f}, {0x2c40, 0x2c10}, {0x2c41, 0x2c11}, {0x2c42, 0x2c12}, {0x2c43, 0x2c13}, {0x2c44, 0x2c14}, {0x2c45, 0x2c15}, {0x2c46, 0x2c16}, {0x2c47, 0x2c17}, {0x2c48, 0x2c18}, {0x2c49, 0x2c19}, {0x2c4a, 0x2c1a}, {0x2c4b, 0x2c1b}, {0x2c4c, 0x2c1c}, {0x2c4d, 0x2c1d}, {0x2c4e, 0x2c1e}, {0x2c4f, 0x2c1f}, {0x2c50, 0x2c20}, {0x2c51, 0x2c21}, {0x2c52, 0x2c22}, {0x2c53, 0x2c23}, {0x2c54, 0x2c24}, {0x2c55, 0x2c25}, {0x2c56, 0x2c26}, {0x2c57, 0x2c27}, {0x2c58, 0x2c28}, {0x2c59, 0x2c29}, {0x2c5a, 0x2c2a}, {0x2c5b, 0x2c2b}, {0x2c5c, 0x2c2c}, {0x2c5d, 0x2c2d}, {0x2c5e, 0x2c2e}, {0x2c60, 0x2c61}, {0x2c61, 0x2c60}, {0x2c62, 0x26b}, {0x2c63, 0x1d7d}, {0x2c64, 0x27d}, {0x2c65, 0x23a}, {0x2c66, 0x23e}, {0x2c67, 0x2c68}, {0x2c68, 0x2c67}, {0x2c69, 0x2c6a}, {0x2c6a, 0x2c69}, {0x2c6b, 0x2c6c}, {0x2c6c, 0x2c6b}, {0x2c6d, 0x251}, {0x2c6e, 0x271}, {0x2c6f, 0x250}, {0x2c70, 0x252}, {0x2c72, 0x2c73}, {0x2c73, 0x2c72}, {0x2c75, 0x2c76}, {0x2c76, 0x2c75}, {0x2c7e, 0x23f}, {0x2c7f, 0x240}, {0x2c80, 0x2c81}, {0x2c81, 0x2c80}, {0x2c82, 0x2c83}, {0x2c83, 0x2c82}, {0x2c84, 0x2c85}, {0x2c85, 0x2c84}, {0x2c86, 0x2c87}, {0x2c87, 0x2c86}, {0x2c88, 0x2c89}, {0x2c89, 0x2c88}, {0x2c8a, 0x2c8b}, {0x2c8b, 0x2c8a}, {0x2c8c, 0x2c8d}, {0x2c8d, 0x2c8c}, {0x2c8e, 0x2c8f}, {0x2c8f, 0x2c8e}, {0x2c90, 0x2c91}, {0x2c91, 0x2c90}, {0x2c92, 0x2c93}, {0x2c93, 0x2c92}, {0x2c94, 0x2c95}, {0x2c95, 0x2c94}, {0x2c96, 0x2c97}, {0x2c97, 0x2c96}, {0x2c98, 0x2c99}, {0x2c99, 0x2c98}, {0x2c9a, 0x2c9b}, {0x2c9b, 0x2c9a}, {0x2c9c, 0x2c9d}, {0x2c9d, 0x2c9c}, {0x2c9e, 0x2c9f}, {0x2c9f, 0x2c9e}, {0x2ca0, 0x2ca1}, {0x2ca1, 0x2ca0}, {0x2ca2, 0x2ca3}, {0x2ca3, 0x2ca2}, {0x2ca4, 0x2ca5}, {0x2ca5, 0x2ca4}, {0x2ca6, 0x2ca7}, {0x2ca7, 0x2ca6}, {0x2ca8, 0x2ca9}, {0x2ca9, 0x2ca8}, {0x2caa, 0x2cab}, {0x2cab, 0x2caa}, {0x2cac, 0x2cad}, {0x2cad, 0x2cac}, {0x2cae, 0x2caf}, {0x2caf, 0x2cae}, {0x2cb0, 0x2cb1}, {0x2cb1, 0x2cb0}, {0x2cb2, 0x2cb3}, {0x2cb3, 0x2cb2}, {0x2cb4, 0x2cb5}, {0x2cb5, 0x2cb4}, {0x2cb6, 0x2cb7}, {0x2cb7, 0x2cb6}, {0x2cb8, 0x2cb9}, {0x2cb9, 0x2cb8}, {0x2cba, 0x2cbb}, {0x2cbb, 0x2cba}, {0x2cbc, 0x2cbd}, {0x2cbd, 0x2cbc}, {0x2cbe, 0x2cbf}, {0x2cbf, 0x2cbe}, {0x2cc0, 0x2cc1}, {0x2cc1, 0x2cc0}, {0x2cc2, 0x2cc3}, {0x2cc3, 0x2cc2}, {0x2cc4, 0x2cc5}, {0x2cc5, 0x2cc4}, {0x2cc6, 0x2cc7}, {0x2cc7, 0x2cc6}, {0x2cc8, 0x2cc9}, {0x2cc9, 0x2cc8}, {0x2cca, 0x2ccb}, {0x2ccb, 0x2cca}, {0x2ccc, 0x2ccd}, {0x2ccd, 0x2ccc}, {0x2cce, 0x2ccf}, {0x2ccf, 0x2cce}, {0x2cd0, 0x2cd1}, {0x2cd1, 0x2cd0}, {0x2cd2, 0x2cd3}, {0x2cd3, 0x2cd2}, {0x2cd4, 0x2cd5}, {0x2cd5, 0x2cd4}, {0x2cd6, 0x2cd7}, {0x2cd7, 0x2cd6}, {0x2cd8, 0x2cd9}, {0x2cd9, 0x2cd8}, {0x2cda, 0x2cdb}, {0x2cdb, 0x2cda}, {0x2cdc, 0x2cdd}, {0x2cdd, 0x2cdc}, {0x2cde, 0x2cdf}, {0x2cdf, 0x2cde}, {0x2ce0, 0x2ce1}, {0x2ce1, 0x2ce0}, {0x2ce2, 0x2ce3}, {0x2ce3, 0x2ce2}, {0x2ceb, 0x2cec}, {0x2cec, 0x2ceb}, {0x2ced, 0x2cee}, {0x2cee, 0x2ced}, {0x2cf2, 0x2cf3}, {0x2cf3, 0x2cf2}, {0x2d00, 0x10a0}, {0x2d01, 0x10a1}, {0x2d02, 0x10a2}, {0x2d03, 0x10a3}, {0x2d04, 0x10a4}, {0x2d05, 0x10a5}, {0x2d06, 0x10a6}, {0x2d07, 0x10a7}, {0x2d08, 0x10a8}, {0x2d09, 0x10a9}, {0x2d0a, 0x10aa}, {0x2d0b, 0x10ab}, {0x2d0c, 0x10ac}, {0x2d0d, 0x10ad}, {0x2d0e, 0x10ae}, {0x2d0f, 0x10af}, {0x2d10, 0x10b0}, {0x2d11, 0x10b1}, {0x2d12, 0x10b2}, {0x2d13, 0x10b3}, {0x2d14, 0x10b4}, {0x2d15, 0x10b5}, {0x2d16, 0x10b6}, {0x2d17, 0x10b7}, {0x2d18, 0x10b8}, {0x2d19, 0x10b9}, {0x2d1a, 0x10ba}, {0x2d1b, 0x10bb}, {0x2d1c, 0x10bc}, {0x2d1d, 0x10bd}, {0x2d1e, 0x10be}, {0x2d1f, 0x10bf}, {0x2d20, 0x10c0}, {0x2d21, 0x10c1}, {0x2d22, 0x10c2}, {0x2d23, 0x10c3}, {0x2d24, 0x10c4}, {0x2d25, 0x10c5}, {0x2d27, 0x10c7}, {0x2d2d, 0x10cd}, {0xa640, 0xa641}, {0xa641, 0xa640}, {0xa642, 0xa643}, {0xa643, 0xa642}, {0xa644, 0xa645}, {0xa645, 0xa644}, {0xa646, 0xa647}, {0xa647, 0xa646}, {0xa648, 0xa649}, {0xa649, 0xa648}, {0xa64a, 0xa64b}, {0xa64b, 0xa64a}, {0xa64c, 0xa64d}, {0xa64d, 0xa64c}, {0xa64e, 0xa64f}, {0xa64f, 0xa64e}, {0xa650, 0xa651}, {0xa651, 0xa650}, {0xa652, 0xa653}, {0xa653, 0xa652}, {0xa654, 0xa655}, {0xa655, 0xa654}, {0xa656, 0xa657}, {0xa657, 0xa656}, {0xa658, 0xa659}, {0xa659, 0xa658}, {0xa65a, 0xa65b}, {0xa65b, 0xa65a}, {0xa65c, 0xa65d}, {0xa65d, 0xa65c}, {0xa65e, 0xa65f}, {0xa65f, 0xa65e}, {0xa660, 0xa661}, {0xa661, 0xa660}, {0xa662, 0xa663}, {0xa663, 0xa662}, {0xa664, 0xa665}, {0xa665, 0xa664}, {0xa666, 0xa667}, {0xa667, 0xa666}, {0xa668, 0xa669}, {0xa669, 0xa668}, {0xa66a, 0xa66b}, {0xa66b, 0xa66a}, {0xa66c, 0xa66d}, {0xa66d, 0xa66c}, {0xa680, 0xa681}, {0xa681, 0xa680}, {0xa682, 0xa683}, {0xa683, 0xa682}, {0xa684, 0xa685}, {0xa685, 0xa684}, {0xa686, 0xa687}, {0xa687, 0xa686}, {0xa688, 0xa689}, {0xa689, 0xa688}, {0xa68a, 0xa68b}, {0xa68b, 0xa68a}, {0xa68c, 0xa68d}, {0xa68d, 0xa68c}, {0xa68e, 0xa68f}, {0xa68f, 0xa68e}, {0xa690, 0xa691}, {0xa691, 0xa690}, {0xa692, 0xa693}, {0xa693, 0xa692}, {0xa694, 0xa695}, {0xa695, 0xa694}, {0xa696, 0xa697}, {0xa697, 0xa696}, {0xa698, 0xa699}, {0xa699, 0xa698}, {0xa69a, 0xa69b}, {0xa69b, 0xa69a}, {0xa722, 0xa723}, {0xa723, 0xa722}, {0xa724, 0xa725}, {0xa725, 0xa724}, {0xa726, 0xa727}, {0xa727, 0xa726}, {0xa728, 0xa729}, {0xa729, 0xa728}, {0xa72a, 0xa72b}, {0xa72b, 0xa72a}, {0xa72c, 0xa72d}, {0xa72d, 0xa72c}, {0xa72e, 0xa72f}, {0xa72f, 0xa72e}, {0xa732, 0xa733}, {0xa733, 0xa732}, {0xa734, 0xa735}, {0xa735, 0xa734}, {0xa736, 0xa737}, {0xa737, 0xa736}, {0xa738, 0xa739}, {0xa739, 0xa738}, {0xa73a, 0xa73b}, {0xa73b, 0xa73a}, {0xa73c, 0xa73d}, {0xa73d, 0xa73c}, {0xa73e, 0xa73f}, {0xa73f, 0xa73e}, {0xa740, 0xa741}, {0xa741, 0xa740}, {0xa742, 0xa743}, {0xa743, 0xa742}, {0xa744, 0xa745}, {0xa745, 0xa744}, {0xa746, 0xa747}, {0xa747, 0xa746}, {0xa748, 0xa749}, {0xa749, 0xa748}, {0xa74a, 0xa74b}, {0xa74b, 0xa74a}, {0xa74c, 0xa74d}, {0xa74d, 0xa74c}, {0xa74e, 0xa74f}, {0xa74f, 0xa74e}, {0xa750, 0xa751}, {0xa751, 0xa750}, {0xa752, 0xa753}, {0xa753, 0xa752}, {0xa754, 0xa755}, {0xa755, 0xa754}, {0xa756, 0xa757}, {0xa757, 0xa756}, {0xa758, 0xa759}, {0xa759, 0xa758}, {0xa75a, 0xa75b}, {0xa75b, 0xa75a}, {0xa75c, 0xa75d}, {0xa75d, 0xa75c}, {0xa75e, 0xa75f}, {0xa75f, 0xa75e}, {0xa760, 0xa761}, {0xa761, 0xa760}, {0xa762, 0xa763}, {0xa763, 0xa762}, {0xa764, 0xa765}, {0xa765, 0xa764}, {0xa766, 0xa767}, {0xa767, 0xa766}, {0xa768, 0xa769}, {0xa769, 0xa768}, {0xa76a, 0xa76b}, {0xa76b, 0xa76a}, {0xa76c, 0xa76d}, {0xa76d, 0xa76c}, {0xa76e, 0xa76f}, {0xa76f, 0xa76e}, {0xa779, 0xa77a}, {0xa77a, 0xa779}, {0xa77b, 0xa77c}, {0xa77c, 0xa77b}, {0xa77d, 0x1d79}, {0xa77e, 0xa77f}, {0xa77f, 0xa77e}, {0xa780, 0xa781}, {0xa781, 0xa780}, {0xa782, 0xa783}, {0xa783, 0xa782}, {0xa784, 0xa785}, {0xa785, 0xa784}, {0xa786, 0xa787}, {0xa787, 0xa786}, {0xa78b, 0xa78c}, {0xa78c, 0xa78b}, {0xa78d, 0x265}, {0xa790, 0xa791}, {0xa791, 0xa790}, {0xa792, 0xa793}, {0xa793, 0xa792}, {0xa796, 0xa797}, {0xa797, 0xa796}, {0xa798, 0xa799}, {0xa799, 0xa798}, {0xa79a, 0xa79b}, {0xa79b, 0xa79a}, {0xa79c, 0xa79d}, {0xa79d, 0xa79c}, {0xa79e, 0xa79f}, {0xa79f, 0xa79e}, {0xa7a0, 0xa7a1}, {0xa7a1, 0xa7a0}, {0xa7a2, 0xa7a3}, {0xa7a3, 0xa7a2}, {0xa7a4, 0xa7a5}, {0xa7a5, 0xa7a4}, {0xa7a6, 0xa7a7}, {0xa7a7, 0xa7a6}, {0xa7a8, 0xa7a9}, {0xa7a9, 0xa7a8}, {0xa7aa, 0x266}, {0xa7ab, 0x25c}, {0xa7ac, 0x261}, {0xa7ad, 0x26c}, {0xa7b0, 0x29e}, {0xa7b1, 0x287}, {0xff21, 0xff41}, {0xff22, 0xff42}, {0xff23, 0xff43}, {0xff24, 0xff44}, {0xff25, 0xff45}, {0xff26, 0xff46}, {0xff27, 0xff47}, {0xff28, 0xff48}, {0xff29, 0xff49}, {0xff2a, 0xff4a}, {0xff2b, 0xff4b}, {0xff2c, 0xff4c}, {0xff2d, 0xff4d}, {0xff2e, 0xff4e}, {0xff2f, 0xff4f}, {0xff30, 0xff50}, {0xff31, 0xff51}, {0xff32, 0xff52}, {0xff33, 0xff53}, {0xff34, 0xff54}, {0xff35, 0xff55}, {0xff36, 0xff56}, {0xff37, 0xff57}, {0xff38, 0xff58}, {0xff39, 0xff59}, {0xff3a, 0xff5a}, {0xff41, 0xff21}, {0xff42, 0xff22}, {0xff43, 0xff23}, {0xff44, 0xff24}, {0xff45, 0xff25}, {0xff46, 0xff26}, {0xff47, 0xff27}, {0xff48, 0xff28}, {0xff49, 0xff29}, {0xff4a, 0xff2a}, {0xff4b, 0xff2b}, {0xff4c, 0xff2c}, {0xff4d, 0xff2d}, {0xff4e, 0xff2e}, {0xff4f, 0xff2f}, {0xff50, 0xff30}, {0xff51, 0xff31}, {0xff52, 0xff32}, {0xff53, 0xff33}, {0xff54, 0xff34}, {0xff55, 0xff35}, {0xff56, 0xff36}, {0xff57, 0xff37}, {0xff58, 0xff38}, {0xff59, 0xff39}, {0xff5a, 0xff3a}, {0x10400, 0x10428}, {0x10401, 0x10429}, {0x10402, 0x1042a}, {0x10403, 0x1042b}, {0x10404, 0x1042c}, {0x10405, 0x1042d}, {0x10406, 0x1042e}, {0x10407, 0x1042f}, {0x10408, 0x10430}, {0x10409, 0x10431}, {0x1040a, 0x10432}, {0x1040b, 0x10433}, {0x1040c, 0x10434}, {0x1040d, 0x10435}, {0x1040e, 0x10436}, {0x1040f, 0x10437}, {0x10410, 0x10438}, {0x10411, 0x10439}, {0x10412, 0x1043a}, {0x10413, 0x1043b}, {0x10414, 0x1043c}, {0x10415, 0x1043d}, {0x10416, 0x1043e}, {0x10417, 0x1043f}, {0x10418, 0x10440}, {0x10419, 0x10441}, {0x1041a, 0x10442}, {0x1041b, 0x10443}, {0x1041c, 0x10444}, {0x1041d, 0x10445}, {0x1041e, 0x10446}, {0x1041f, 0x10447}, {0x10420, 0x10448}, {0x10421, 0x10449}, {0x10422, 0x1044a}, {0x10423, 0x1044b}, {0x10424, 0x1044c}, {0x10425, 0x1044d}, {0x10426, 0x1044e}, {0x10427, 0x1044f}, {0x10428, 0x10400}, {0x10429, 0x10401}, {0x1042a, 0x10402}, {0x1042b, 0x10403}, {0x1042c, 0x10404}, {0x1042d, 0x10405}, {0x1042e, 0x10406}, {0x1042f, 0x10407}, {0x10430, 0x10408}, {0x10431, 0x10409}, {0x10432, 0x1040a}, {0x10433, 0x1040b}, {0x10434, 0x1040c}, {0x10435, 0x1040d}, {0x10436, 0x1040e}, {0x10437, 0x1040f}, {0x10438, 0x10410}, {0x10439, 0x10411}, {0x1043a, 0x10412}, {0x1043b, 0x10413}, {0x1043c, 0x10414}, {0x1043d, 0x10415}, {0x1043e, 0x10416}, {0x1043f, 0x10417}, {0x10440, 0x10418}, {0x10441, 0x10419}, {0x10442, 0x1041a}, {0x10443, 0x1041b}, {0x10444, 0x1041c}, {0x10445, 0x1041d}, {0x10446, 0x1041e}, {0x10447, 0x1041f}, {0x10448, 0x10420}, {0x10449, 0x10421}, {0x1044a, 0x10422}, {0x1044b, 0x10423}, {0x1044c, 0x10424}, {0x1044d, 0x10425}, {0x1044e, 0x10426}, {0x1044f, 0x10427}, {0x118a0, 0x118c0}, {0x118a1, 0x118c1}, {0x118a2, 0x118c2}, {0x118a3, 0x118c3}, {0x118a4, 0x118c4}, {0x118a5, 0x118c5}, {0x118a6, 0x118c6}, {0x118a7, 0x118c7}, {0x118a8, 0x118c8}, {0x118a9, 0x118c9}, {0x118aa, 0x118ca}, {0x118ab, 0x118cb}, {0x118ac, 0x118cc}, {0x118ad, 0x118cd}, {0x118ae, 0x118ce}, {0x118af, 0x118cf}, {0x118b0, 0x118d0}, {0x118b1, 0x118d1}, {0x118b2, 0x118d2}, {0x118b3, 0x118d3}, {0x118b4, 0x118d4}, {0x118b5, 0x118d5}, {0x118b6, 0x118d6}, {0x118b7, 0x118d7}, {0x118b8, 0x118d8}, {0x118b9, 0x118d9}, {0x118ba, 0x118da}, {0x118bb, 0x118db}, {0x118bc, 0x118dc}, {0x118bd, 0x118dd}, {0x118be, 0x118de}, {0x118bf, 0x118df}, {0x118c0, 0x118a0}, {0x118c1, 0x118a1}, {0x118c2, 0x118a2}, {0x118c3, 0x118a3}, {0x118c4, 0x118a4}, {0x118c5, 0x118a5}, {0x118c6, 0x118a6}, {0x118c7, 0x118a7}, {0x118c8, 0x118a8}, {0x118c9, 0x118a9}, {0x118ca, 0x118aa}, {0x118cb, 0x118ab}, {0x118cc, 0x118ac}, {0x118cd, 0x118ad}, {0x118ce, 0x118ae}, {0x118cf, 0x118af}, {0x118d0, 0x118b0}, {0x118d1, 0x118b1}, {0x118d2, 0x118b2}, {0x118d3, 0x118b3}, {0x118d4, 0x118b4}, {0x118d5, 0x118b5}, {0x118d6, 0x118b6}, {0x118d7, 0x118b7}, {0x118d8, 0x118b8}, {0x118d9, 0x118b9}, {0x118da, 0x118ba}, {0x118db, 0x118bb}, {0x118dc, 0x118bc}, {0x118dd, 0x118bd}, {0x118de, 0x118be}, {0x118df, 0x118bf}, }; #endif // UCP_TABLE_DEFINE_FN } // namespace ue2 #endif hyperscan-4.4.1/src/parser/ConstComponentVisitor.h0000644000175000017500000001646513055426554023100 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Visitor base class for working with the component tree. */ #ifndef CONSTCOMPONENTVISITOR_H #define CONSTCOMPONENTVISITOR_H namespace ue2 { class AsciiComponentClass; class Component; class ComponentAlternation; class ComponentAssertion; class ComponentAtomicGroup; class ComponentBackReference; class ComponentBoundary; class ComponentByte; class ComponentCondReference; class ComponentClass; class ComponentEmpty; class ComponentEUS; class ComponentRepeat; class ComponentSequence; class ComponentWordBoundary; class UTF8ComponentClass; /** * \brief Visitor base class for traversing an immutable component tree. * * Our approach to implementing the visitor pattern for traversing the * Component tree for a pattern. This version operates on an immutable tree; * use \ref ComponentVisitor if you need to make changes to components during * traversal. */ class ConstComponentVisitor { public: virtual ~ConstComponentVisitor(); virtual void pre(const AsciiComponentClass &c) = 0; virtual void pre(const ComponentAlternation &c) = 0; virtual void pre(const ComponentAssertion &c) = 0; virtual void pre(const ComponentAtomicGroup &c) = 0; virtual void pre(const ComponentBackReference &c) = 0; virtual void pre(const ComponentBoundary &c) = 0; virtual void pre(const ComponentByte &c) = 0; virtual void pre(const ComponentCondReference &c) = 0; virtual void pre(const ComponentEmpty &c) = 0; virtual void pre(const ComponentEUS &c) = 0; virtual void pre(const ComponentRepeat &c) = 0; virtual void pre(const ComponentSequence &c) = 0; virtual void pre(const ComponentWordBoundary &c) = 0; virtual void pre(const UTF8ComponentClass &c) = 0; virtual void during(const AsciiComponentClass &c) = 0; virtual void during(const ComponentAlternation &c) = 0; virtual void during(const ComponentAssertion &c) = 0; virtual void during(const ComponentAtomicGroup &c) = 0; virtual void during(const ComponentBackReference &c) = 0; virtual void during(const ComponentBoundary &c) = 0; virtual void during(const ComponentByte &c) = 0; virtual void during(const ComponentCondReference &c) = 0; virtual void during(const ComponentEmpty &c) = 0; virtual void during(const ComponentEUS &c) = 0; virtual void during(const ComponentRepeat &c) = 0; virtual void during(const ComponentSequence &c) = 0; virtual void during(const ComponentWordBoundary &c) = 0; virtual void during(const UTF8ComponentClass &c) = 0; virtual void post(const AsciiComponentClass &c) = 0; virtual void post(const ComponentAlternation &c) = 0; virtual void post(const ComponentAssertion &c) = 0; virtual void post(const ComponentAtomicGroup &c) = 0; virtual void post(const ComponentBackReference &c) = 0; virtual void post(const ComponentBoundary &c) = 0; virtual void post(const ComponentByte &c) = 0; virtual void post(const ComponentCondReference &c) = 0; virtual void post(const ComponentEmpty &c) = 0; virtual void post(const ComponentEUS &c) = 0; virtual void post(const ComponentRepeat &c) = 0; virtual void post(const ComponentSequence &c) = 0; virtual void post(const ComponentWordBoundary &c) = 0; virtual void post(const UTF8ComponentClass &c) = 0; }; /** * \brief Concrete subclass of ConstComponentVisitor with default behaviour, * allowing you to just implement the member functions you need. */ class DefaultConstComponentVisitor : public ConstComponentVisitor { public: DefaultConstComponentVisitor(); ~DefaultConstComponentVisitor() override; void pre(const AsciiComponentClass &c) override; void pre(const ComponentAlternation &c) override; void pre(const ComponentAssertion &c) override; void pre(const ComponentAtomicGroup &c) override; void pre(const ComponentBackReference &c) override; void pre(const ComponentBoundary &c) override; void pre(const ComponentByte &c) override; void pre(const ComponentCondReference &c) override; void pre(const ComponentEmpty &c) override; void pre(const ComponentEUS &c) override; void pre(const ComponentRepeat &c) override; void pre(const ComponentSequence &c) override; void pre(const ComponentWordBoundary &c) override; void pre(const UTF8ComponentClass &c) override; void during(const AsciiComponentClass &c) override; void during(const ComponentAlternation &c) override; void during(const ComponentAssertion &c) override; void during(const ComponentAtomicGroup &c) override; void during(const ComponentBackReference &c) override; void during(const ComponentBoundary &c) override; void during(const ComponentByte &c) override; void during(const ComponentCondReference &c) override; void during(const ComponentEmpty &c) override; void during(const ComponentEUS &c) override; void during(const ComponentRepeat &c) override; void during(const ComponentSequence &c) override; void during(const ComponentWordBoundary &c) override; void during(const UTF8ComponentClass &c) override; void post(const AsciiComponentClass &c) override; void post(const ComponentAlternation &c) override; void post(const ComponentAssertion &c) override; void post(const ComponentAtomicGroup &c) override; void post(const ComponentBackReference &c) override; void post(const ComponentBoundary &c) override; void post(const ComponentByte &c) override; void post(const ComponentCondReference &c) override; void post(const ComponentEmpty &c) override; void post(const ComponentEUS &c) override; void post(const ComponentRepeat &c) override; void post(const ComponentSequence &c) override; void post(const ComponentWordBoundary &c) override; void post(const UTF8ComponentClass &c) override; }; } // namespace ue2 #endif // CONSTCOMPONENTVISITOR_H hyperscan-4.4.1/src/parser/ComponentEUS.h0000644000175000017500000000557513055426554021066 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Extended Unicode sequences (\\X) */ #ifndef _RE_COMPONENTEXTENDEDUNICODESEQUENCE_H_ #define _RE_COMPONENTEXTENDEDUNICODESEQUENCE_H_ #include "Component.h" namespace ue2 { struct ParseMode; class ComponentEUS : public Component { friend class DumpVisitor; friend class UnsupportedVisitor; public: ComponentEUS(u32 loc, const ParseMode &mode); ~ComponentEUS() override; ComponentEUS *clone() const override; Component *accept(ComponentVisitor &v) override { Component *c = v.visit(this); v.post(this); return c; } void accept(ConstComponentVisitor &v) const override { v.pre(*this); v.during(*this); v.post(*this); } std::vector first() const override; std::vector last() const override; bool empty() const override { return false; } void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &, const std::vector &) override { // all follow set construction is handled by firsts/lasts return; } private: u32 loc; bool utf8; Position position; ComponentEUS(const ComponentEUS &other) : Component(other), loc(other.loc), utf8(other.utf8), position(other.position) {} }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/parse_error.cpp0000644000175000017500000000366013055426554021416 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Parse/Compile exceptions. */ #include "parse_error.h" #include namespace ue2 { // this is just to get these out of the .h to avoid weak vtables ParseError::~ParseError() {} LocatedParseError::~LocatedParseError() {} void LocatedParseError::locate(size_t offset) { std::ostringstream str; str << reason << " at index " << offset << "."; reason = str.str(); } } hyperscan-4.4.1/src/parser/Utf8ComponentClass.cpp0000644000175000017500000011205113055426554022565 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Character class in UTF-8 mode. */ #include "Utf8ComponentClass.h" #include "buildstate.h" #include "Parser.h" #include "parse_error.h" #include "position.h" #include "position_info.h" #include "nfagraph/ng_builder.h" #include "util/compare.h" #include "util/unicode_def.h" #include #include "ucp_table.h" using namespace std; namespace ue2 { PredefinedClass translateForUcpMode(PredefinedClass in, const ParseMode &mode) { /* Note: the mapping used here for mapping posix character classes * matches the observed behaviour of PCRE (lower and upper going to \p{L} * is not documented by pcre). * * Note: this mapping is quite different from both of the mappings * recommended in the unicode regex tech report (TR-18) appendix C */ switch (in) { case CLASS_ALNUM: return CLASS_UCP_XAN; case CLASS_ALPHA: return CLASS_UCP_L; case CLASS_BLANK: return CLASS_HORZ; case CLASS_DIGIT: return CLASS_UCP_ND; case CLASS_GRAPH: return CLASS_XGRAPH; case CLASS_LOWER: if (mode.caseless) { /* we also pick up uppercase titlecase and others */ return CLASS_UCP_L; } else { return CLASS_UCP_LL; } case CLASS_PRINT: return CLASS_XPRINT; case CLASS_PUNCT: return CLASS_XPUNCT; case CLASS_SPACE: return CLASS_UCP_XPS; case CLASS_UPPER: if (mode.caseless) { /* we also pick up lowercase titlecase and others */ return CLASS_UCP_L; } else { return CLASS_UCP_LU; } case CLASS_WORD: return CLASS_UCP_XWD; default: return in; } } CodePointSet getPredefinedCodePointSet(PredefinedClass c, const ParseMode &mode) { /* TODO: support properly PCRE_UCP mode and non PCRE_UCP mode */ switch (c) { case CLASS_ANY: if (mode.dotall) { return CodePointSet(CodePointSet::interval(0, MAX_UNICODE)); } else { CodePointSet rv; rv.set('\n'); rv.flip(); return rv; } case CLASS_XGRAPH: { CodePointSet rv; rv = getUcpZ(); rv |= getUcpC(); rv.flip(); // most of Cf, except for ... CodePointSet cf = getUcpCf(); cf.unset(0x061c); cf.unset(0x180e); cf.unsetRange(0x2066, 0x2069); rv |= cf; return rv; } case CLASS_XPRINT: { // Same as graph, plus everything with the Zs property. CodePointSet rv = getPredefinedCodePointSet(CLASS_XGRAPH, mode); rv |= getUcpZs(); rv.set(0x180e); // Also included in this class by PCRE 8.38. return rv; } case CLASS_XPUNCT: { // Everything with the P (punctuation) property, plus code points in S // (symbols) that are < 128. CodePointSet rv = getUcpP(); CodePointSet symbols = getUcpS(); symbols.unsetRange(128, MAX_UNICODE); rv |= symbols; return rv; } case CLASS_HORZ: { CodePointSet rv; rv.set(0x0009); /* Horizontal tab */ rv.set(0x0020); /* Space */ rv.set(0x00A0); /* Non-break space */ rv.set(0x1680); /* Ogham space mark */ rv.set(0x180E); /* Mongolian vowel separator */ rv.set(0x2000); /* En quad */ rv.set(0x2001); /* Em quad */ rv.set(0x2002); /* En space */ rv.set(0x2003); /* Em space */ rv.set(0x2004); /* Three-per-em space */ rv.set(0x2005); /* Four-per-em space */ rv.set(0x2006); /* Six-per-em space */ rv.set(0x2007); /* Figure space */ rv.set(0x2008); /* Punctuation space */ rv.set(0x2009); /* Thin space */ rv.set(0x200A); /* Hair space */ rv.set(0x202F); /* Narrow no-break space */ rv.set(0x205F); /* Medium mathematical space */ rv.set(0x3000); /* Ideographic space */ return rv; } case CLASS_VERT: { CodePointSet rv; rv.set(0x000A); /* Linefeed */ rv.set(0x000B); /* Vertical tab */ rv.set(0x000C); /* Formfeed */ rv.set(0x000D); /* Carriage return */ rv.set(0x0085); /* Next line */ rv.set(0x2028); /* Line separator */ rv.set(0x2029); /* Paragraph separator */ return rv; } case CLASS_UCP_XPS: case CLASS_UCP_XSP: { CodePointSet rv; rv.set(0x0009); /* Horizontal tab */ rv.set(0x0020); /* Space */ rv.set(0x00A0); /* Non-break space */ rv.set(0x1680); /* Ogham space mark */ rv.set(0x180E); /* Mongolian vowel separator */ rv.set(0x2000); /* En quad */ rv.set(0x2001); /* Em quad */ rv.set(0x2002); /* En space */ rv.set(0x2003); /* Em space */ rv.set(0x2004); /* Three-per-em space */ rv.set(0x2005); /* Four-per-em space */ rv.set(0x2006); /* Six-per-em space */ rv.set(0x2007); /* Figure space */ rv.set(0x2008); /* Punctuation space */ rv.set(0x2009); /* Thin space */ rv.set(0x200A); /* Hair space */ rv.set(0x202F); /* Narrow no-break space */ rv.set(0x205F); /* Medium mathematical space */ rv.set(0x3000); /* Ideographic space */ rv.set(0x000A); /* Linefeed */ rv.set(0x000B); /* Vertical tab */ rv.set(0x000C); /* Formfeed */ rv.set(0x000D); /* Carriage return */ rv.set(0x0085); /* Next line */ rv.set(0x2028); /* Line separator */ rv.set(0x2029); /* Paragraph separator */ return rv; } case CLASS_UCP_C: return getUcpC(); case CLASS_UCP_CC: return getUcpCc(); case CLASS_UCP_CF: return getUcpCf(); case CLASS_UCP_CN: return getUcpCn(); case CLASS_UCP_CO: return getUcpCo(); case CLASS_UCP_CS: return getUcpCs(); case CLASS_UCP_L: return getUcpL(); case CLASS_UCP_L_AND: return getUcpL_and(); case CLASS_UCP_LL: return getUcpLl(); case CLASS_UCP_LM: return getUcpLm(); case CLASS_UCP_LO: return getUcpLo(); case CLASS_UCP_LT: return getUcpLt(); case CLASS_UCP_LU: return getUcpLu(); case CLASS_UCP_M: return getUcpM(); case CLASS_UCP_MC: return getUcpMc(); case CLASS_UCP_ME: return getUcpMe(); case CLASS_UCP_MN: return getUcpMn(); case CLASS_UCP_N: return getUcpN(); case CLASS_UCP_ND: return getUcpNd(); case CLASS_UCP_NL: return getUcpNl(); case CLASS_UCP_NO: return getUcpNo(); case CLASS_UCP_P: return getUcpP(); case CLASS_UCP_PC: return getUcpPc(); case CLASS_UCP_PD: return getUcpPd(); case CLASS_UCP_PE: return getUcpPe(); case CLASS_UCP_PF: return getUcpPf(); case CLASS_UCP_PI: return getUcpPi(); case CLASS_UCP_PO: return getUcpPo(); case CLASS_UCP_PS: return getUcpPs(); case CLASS_UCP_S: return getUcpS(); case CLASS_UCP_SC: return getUcpSc(); case CLASS_UCP_SK: return getUcpSk(); case CLASS_UCP_SM: return getUcpSm(); case CLASS_UCP_SO: return getUcpSo(); case CLASS_UCP_XAN: return getUcpXan(); case CLASS_UCP_XWD: return getUcpXwd(); case CLASS_UCP_Z: return getUcpZ(); case CLASS_UCP_ZL: return getUcpZl(); case CLASS_UCP_ZP: return getUcpZp(); case CLASS_UCP_ZS: return getUcpZs(); case CLASS_SCRIPT_ARABIC: return getUcpArabic(); case CLASS_SCRIPT_ARMENIAN: return getUcpArmenian(); case CLASS_SCRIPT_AVESTAN: return getUcpAvestan(); case CLASS_SCRIPT_BALINESE: return getUcpBalinese(); case CLASS_SCRIPT_BAMUM: return getUcpBamum(); case CLASS_SCRIPT_BATAK: return getUcpBatak(); case CLASS_SCRIPT_BENGALI: return getUcpBengali(); case CLASS_SCRIPT_BOPOMOFO: return getUcpBopomofo(); case CLASS_SCRIPT_BRAHMI: return getUcpBrahmi(); case CLASS_SCRIPT_BRAILLE: return getUcpBraille(); case CLASS_SCRIPT_BUGINESE: return getUcpBuginese(); case CLASS_SCRIPT_BUHID: return getUcpBuhid(); case CLASS_SCRIPT_CANADIAN_ABORIGINAL: return getUcpCanadian_Aboriginal(); case CLASS_SCRIPT_CARIAN: return getUcpCarian(); case CLASS_SCRIPT_CHAM: return getUcpCham(); case CLASS_SCRIPT_CHEROKEE: return getUcpCherokee(); case CLASS_SCRIPT_COMMON: return getUcpCommon(); case CLASS_SCRIPT_COPTIC: return getUcpCoptic(); case CLASS_SCRIPT_CUNEIFORM: return getUcpCuneiform(); case CLASS_SCRIPT_CYPRIOT: return getUcpCypriot(); case CLASS_SCRIPT_CYRILLIC: return getUcpCyrillic(); case CLASS_SCRIPT_DESERET: return getUcpDeseret(); case CLASS_SCRIPT_DEVANAGARI: return getUcpDevanagari(); case CLASS_SCRIPT_EGYPTIAN_HIEROGLYPHS: return getUcpEgyptian_Hieroglyphs(); case CLASS_SCRIPT_ETHIOPIC: return getUcpEthiopic(); case CLASS_SCRIPT_GEORGIAN: return getUcpGeorgian(); case CLASS_SCRIPT_GLAGOLITIC: return getUcpGlagolitic(); case CLASS_SCRIPT_GOTHIC: return getUcpGothic(); case CLASS_SCRIPT_GREEK: return getUcpGreek(); case CLASS_SCRIPT_GUJARATI: return getUcpGujarati(); case CLASS_SCRIPT_GURMUKHI: return getUcpGurmukhi(); case CLASS_SCRIPT_HAN: return getUcpHan(); case CLASS_SCRIPT_HANGUL: return getUcpHangul(); case CLASS_SCRIPT_HANUNOO: return getUcpHanunoo(); case CLASS_SCRIPT_HEBREW: return getUcpHebrew(); case CLASS_SCRIPT_HIRAGANA: return getUcpHiragana(); case CLASS_SCRIPT_IMPERIAL_ARAMAIC: return getUcpImperial_Aramaic(); case CLASS_SCRIPT_INHERITED: return getUcpInherited(); case CLASS_SCRIPT_INSCRIPTIONAL_PAHLAVI: return getUcpInscriptional_Pahlavi(); case CLASS_SCRIPT_INSCRIPTIONAL_PARTHIAN: return getUcpInscriptional_Parthian(); case CLASS_SCRIPT_JAVANESE: return getUcpJavanese(); case CLASS_SCRIPT_KAITHI: return getUcpKaithi(); case CLASS_SCRIPT_KANNADA: return getUcpKannada(); case CLASS_SCRIPT_KATAKANA: return getUcpKatakana(); case CLASS_SCRIPT_KAYAH_LI: return getUcpKayah_Li(); case CLASS_SCRIPT_KHAROSHTHI: return getUcpKharoshthi(); case CLASS_SCRIPT_KHMER: return getUcpKhmer(); case CLASS_SCRIPT_LAO: return getUcpLao(); case CLASS_SCRIPT_LATIN: return getUcpLatin(); case CLASS_SCRIPT_LEPCHA: return getUcpLepcha(); case CLASS_SCRIPT_LIMBU: return getUcpLimbu(); case CLASS_SCRIPT_LINEAR_B: return getUcpLinear_B(); case CLASS_SCRIPT_LISU: return getUcpLisu(); case CLASS_SCRIPT_LYCIAN: return getUcpLycian(); case CLASS_SCRIPT_LYDIAN: return getUcpLydian(); case CLASS_SCRIPT_MALAYALAM: return getUcpMalayalam(); case CLASS_SCRIPT_MANDAIC: return getUcpMandaic(); case CLASS_SCRIPT_MEETEI_MAYEK: return getUcpMeetei_Mayek(); case CLASS_SCRIPT_MONGOLIAN: return getUcpMongolian(); case CLASS_SCRIPT_MYANMAR: return getUcpMyanmar(); case CLASS_SCRIPT_NEW_TAI_LUE: return getUcpNew_Tai_Lue(); case CLASS_SCRIPT_NKO: return getUcpNko(); case CLASS_SCRIPT_OGHAM: return getUcpOgham(); case CLASS_SCRIPT_OL_CHIKI: return getUcpOl_Chiki(); case CLASS_SCRIPT_OLD_ITALIC: return getUcpOld_Italic(); case CLASS_SCRIPT_OLD_PERSIAN: return getUcpOld_Persian(); case CLASS_SCRIPT_OLD_SOUTH_ARABIAN: return getUcpOld_South_Arabian(); case CLASS_SCRIPT_OLD_TURKIC: return getUcpOld_Turkic(); case CLASS_SCRIPT_ORIYA: return getUcpOriya(); case CLASS_SCRIPT_OSMANYA: return getUcpOsmanya(); case CLASS_SCRIPT_PHAGS_PA: return getUcpPhags_Pa(); case CLASS_SCRIPT_PHOENICIAN: return getUcpPhoenician(); case CLASS_SCRIPT_REJANG: return getUcpRejang(); case CLASS_SCRIPT_RUNIC: return getUcpRunic(); case CLASS_SCRIPT_SAMARITAN: return getUcpSamaritan(); case CLASS_SCRIPT_SAURASHTRA: return getUcpSaurashtra(); case CLASS_SCRIPT_SHAVIAN: return getUcpShavian(); case CLASS_SCRIPT_SINHALA: return getUcpSinhala(); case CLASS_SCRIPT_SUNDANESE: return getUcpSundanese(); case CLASS_SCRIPT_SYLOTI_NAGRI: return getUcpSyloti_Nagri(); case CLASS_SCRIPT_SYRIAC: return getUcpSyriac(); case CLASS_SCRIPT_TAGALOG: return getUcpTagalog(); case CLASS_SCRIPT_TAGBANWA: return getUcpTagbanwa(); case CLASS_SCRIPT_TAI_LE: return getUcpTai_Le(); case CLASS_SCRIPT_TAI_THAM: return getUcpTai_Tham(); case CLASS_SCRIPT_TAI_VIET: return getUcpTai_Viet(); case CLASS_SCRIPT_TAMIL: return getUcpTamil(); case CLASS_SCRIPT_TELUGU: return getUcpTelugu(); case CLASS_SCRIPT_THAANA: return getUcpThaana(); case CLASS_SCRIPT_THAI: return getUcpThai(); case CLASS_SCRIPT_TIBETAN: return getUcpTibetan(); case CLASS_SCRIPT_TIFINAGH: return getUcpTifinagh(); case CLASS_SCRIPT_UGARITIC: return getUcpUgaritic(); case CLASS_SCRIPT_VAI: return getUcpVai(); case CLASS_SCRIPT_YI: return getUcpYi(); case CLASS_UCP_ANY: return CodePointSet(CodePointSet::interval(0, MAX_UNICODE)); default: { /* currently uses ascii defns */ CharReach cr = getPredefinedCharReach(c, mode); CodePointSet rv; for (u32 i = cr.find_first(); i != CharReach::npos; i = cr.find_next(i)) { rv.set(i); } return rv; } } } UTF8ComponentClass::UTF8ComponentClass(const ParseMode &mode_in) : ComponentClass(mode_in), single_pos( GlushkovBuildState::POS_UNINITIALIZED), one_dot_trailer( GlushkovBuildState::POS_UNINITIALIZED), two_dot_trailer( GlushkovBuildState::POS_UNINITIALIZED), three_dot_trailer( GlushkovBuildState::POS_UNINITIALIZED), two_char_dot_head( GlushkovBuildState::POS_UNINITIALIZED), three_char_dot_head(GlushkovBuildState::POS_UNINITIALIZED), four_char_dot_head( GlushkovBuildState::POS_UNINITIALIZED) { assert(mode.utf8); } UTF8ComponentClass *UTF8ComponentClass::clone() const { return new UTF8ComponentClass(*this); } bool UTF8ComponentClass::class_empty(void) const { assert(finalized); return cps.none(); } void UTF8ComponentClass::createRange(unichar to) { assert(range_start != INVALID_UNICODE); unichar from = range_start; if (from > to) { throw LocatedParseError("Range out of order in character class"); } in_cand_range = false; CodePointSet ncps; ncps.setRange(from, to); if (mode.caseless) { make_caseless(&ncps); } cps |= ncps; range_start = INVALID_UNICODE; } void UTF8ComponentClass::add(PredefinedClass c, bool negative) { if (in_cand_range) { // can't form a range here throw LocatedParseError("Invalid range in character class"); } if (mode.ucp) { c = translateForUcpMode(c, mode); } // caselessness is handled inside this call - don't apply make_caseless // to the result CodePointSet pcps = getPredefinedCodePointSet(c, mode); if (negative) { pcps.flip(); } cps |= pcps; range_start = INVALID_UNICODE; in_cand_range = false; } void UTF8ComponentClass::add(unichar c) { DEBUG_PRINTF("adding \\x%08x\n", c); if (c > MAX_UNICODE) { // too big! throw LocatedParseError("Hexadecimal value is greater than \\x10FFFF"); } if (in_cand_range) { createRange(c); return; } CodePointSet ncps; ncps.set(c); if (mode.caseless) { make_caseless(&ncps); } cps |= ncps; range_start = c; } void UTF8ComponentClass::finalize() { if (finalized) { return; } // Handle unclosed ranges, like '[a-]' and '[a-\Q\E]' -- in these cases the // dash is a literal dash. if (in_cand_range) { cps.set('-'); in_cand_range = false; } if (m_negate) { cps.flip(); } finalized = true; } Position UTF8ComponentClass::getHead(NFABuilder &builder, u8 first_byte) { map::const_iterator it = heads.find(first_byte); if (it != heads.end()) { return it->second; } Position head = builder.makePositions(1); assert(heads.find(first_byte) == heads.end()); builder.addCharReach(head, CharReach(first_byte)); /* no report id as head can not be directly wired to accept */ heads[first_byte] = head; return head; } void UTF8ComponentClass::ensureDotTrailer(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); if (one_dot_trailer != GlushkovBuildState::POS_UNINITIALIZED) { return; } one_dot_trailer = builder.makePositions(1); builder.setNodeReportID(one_dot_trailer, 0); builder.addCharReach(one_dot_trailer, CharReach(0x80, 0xbf)); tails.insert(one_dot_trailer); } void UTF8ComponentClass::ensureTwoDotTrailer(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); if (two_dot_trailer != GlushkovBuildState::POS_UNINITIALIZED) { return; } ensureDotTrailer(bs); two_dot_trailer = builder.makePositions(1); builder.addCharReach(two_dot_trailer, CharReach(0x80, 0xbf)); bs.addSuccessor(two_dot_trailer, one_dot_trailer); } void UTF8ComponentClass::ensureThreeDotTrailer(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); if (three_dot_trailer != GlushkovBuildState::POS_UNINITIALIZED) { return; } ensureTwoDotTrailer(bs); three_dot_trailer = builder.makePositions(1); builder.addCharReach(three_dot_trailer, CharReach(0x80, 0xbf)); bs.addSuccessor(three_dot_trailer, two_dot_trailer); } void UTF8ComponentClass::buildOneByte(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); for (CodePointSet::const_iterator it = cps.begin(); it != cps.end(); ++it) { unichar b = lower(*it); unichar e = upper(*it) + 1; if (b >= UTF_2CHAR_MIN) { continue; } DEBUG_PRINTF("building vertices for [%u, %u)\n", b, e); if (single_pos == GlushkovBuildState::POS_UNINITIALIZED) { single_pos = builder.makePositions(1); builder.setNodeReportID(single_pos, 0 /* offset adj */); tails.insert(single_pos); } CharReach cr(b, MIN(e, UTF_2CHAR_MIN) - 1); builder.addCharReach(single_pos, cr); } } void UTF8ComponentClass::addToTail(GlushkovBuildState &bs, map &finals, Position prev, unichar b, unichar e) { NFABuilder &builder = bs.getBuilder(); Position tail; if (finals.find(prev) == finals.end()) { tail = builder.makePositions(1); builder.setNodeReportID(tail, 0 /* offset adj */); bs.addSuccessor(prev, tail); finals[prev] = tail; tails.insert(tail); } else { tail = finals[prev]; } u8 bb = makeContByte(b); u8 ee = makeContByte(e - 1); builder.addCharReach(tail, CharReach(bb, ee)); } void UTF8ComponentClass::buildTwoByte(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); map finals; for (auto it = cps.begin(); it != cps.end(); ++it) { unichar b = lower(*it); unichar e = upper(*it) + 1; b = MAX(b, UTF_2CHAR_MIN); e = MIN(e, UTF_3CHAR_MIN); if (b >= e) { continue; /* we're done here */ } /* raise b to the start of the next tail byte boundary */ if (b & UTF_CONT_BYTE_VALUE_MASK) { unichar bb = MIN(e, ROUNDUP_N(b, UTF_CONT_BYTE_RANGE)); u8 first_byte = UTF_TWO_BYTE_HEADER | (b >> UTF_CONT_SHIFT); assert(first_byte > 0xc1 && first_byte <= 0xdf); Position head = getHead(builder, first_byte); addToTail(bs, finals, head, b, bb); b = bb; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* lower e to the end of a tail byte boundary */ if (e & UTF_CONT_BYTE_VALUE_MASK) { unichar ee = e & ~UTF_CONT_BYTE_VALUE_MASK; assert(ee >= b); u8 first_byte = UTF_TWO_BYTE_HEADER | (ee >> UTF_CONT_SHIFT); assert(first_byte > 0xc1 && first_byte <= 0xdf); Position head = getHead(builder, first_byte); addToTail(bs, finals, head, ee, e); e = ee; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* middle section just goes to a common full vertex */ ensureDotTrailer(bs); if (two_char_dot_head == GlushkovBuildState::POS_UNINITIALIZED) { two_char_dot_head = builder.makePositions(1); bs.addSuccessor(two_char_dot_head, one_dot_trailer); } u8 min_first_byte = UTF_TWO_BYTE_HEADER | (b >> UTF_CONT_SHIFT); u8 max_first_byte = UTF_TWO_BYTE_HEADER | ((e - 1) >> UTF_CONT_SHIFT); assert(min_first_byte > 0xc1 && min_first_byte <= 0xdf); assert(max_first_byte > 0xc1 && max_first_byte <= 0xdf); builder.addCharReach(two_char_dot_head, CharReach(min_first_byte, max_first_byte)); } } static Position getMid(GlushkovBuildState &bs, map > &mids, const Position &prev, u8 byte_val) { NFABuilder &builder = bs.getBuilder(); map &by_byte = mids[prev]; map::const_iterator it = by_byte.find(byte_val); if (it != by_byte.end()) { return it->second; } Position mid = builder.makePositions(1); builder.addCharReach(mid, CharReach(byte_val)); bs.addSuccessor(prev, mid); /* no report id as mid can not be directly wired to accept */ by_byte[byte_val] = mid; return mid; } void UTF8ComponentClass::buildThreeByte(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); map > mids; map finals; for (auto it = cps.begin(); it != cps.end(); ++it) { unichar b = lower(*it); unichar e = upper(*it) + 1; b = MAX(b, UTF_3CHAR_MIN); e = MIN(e, UTF_4CHAR_MIN); if (b >= e) { continue; /* we're done here */ } /* raise b to the start of the next tail byte boundary */ if (b & UTF_CONT_BYTE_VALUE_MASK) { unichar bb = MIN(e, ROUNDUP_N(b, UTF_CONT_BYTE_RANGE)); u8 first_byte = UTF_THREE_BYTE_HEADER | (b >> (2 * UTF_CONT_SHIFT)); assert(first_byte >= 0xe0 && first_byte <= 0xef); Position head = getHead(builder, first_byte); u8 second_byte = makeContByte(b >> UTF_CONT_SHIFT); Position mid = getMid(bs, mids, head, second_byte); addToTail(bs, finals, mid, b, bb); b = bb; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* lower e to the end of a tail byte boundary */ if (e & UTF_CONT_BYTE_VALUE_MASK) { unichar ee = e & ~UTF_CONT_BYTE_VALUE_MASK; assert(ee >= b); u8 first_byte = UTF_THREE_BYTE_HEADER | (ee >> (2 * UTF_CONT_SHIFT)); assert(first_byte >= 0xe0 && first_byte <= 0xef); Position head = getHead(builder, first_byte); u8 second_byte = makeContByte(ee >> UTF_CONT_SHIFT); Position mid = getMid(bs, mids, head, second_byte); addToTail(bs, finals, mid, ee, e); e = ee; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* from here on in the last byte is always full */ ensureDotTrailer(bs); /* raise b to the start of the next mid byte boundary */ if (b & ((1 << (2 * UTF_CONT_SHIFT)) - 1)) { unichar bb = MIN(e, ROUNDUP_N(b, 1 << (2 * UTF_CONT_SHIFT))); u8 first_byte = UTF_THREE_BYTE_HEADER | (b >> (2 * UTF_CONT_SHIFT)); Position head = getHead(builder, first_byte); Position mid = builder.makePositions(1); bs.addSuccessor(head, mid); bs.addSuccessor(mid, one_dot_trailer); /* no report id as mid can not be directly wired to accept, * not adding to mids as we are completely filling its downstream */ u8 second_min = makeContByte(b >> UTF_CONT_SHIFT); u8 second_max = makeContByte((bb - 1) >> UTF_CONT_SHIFT); builder.addCharReach(mid, CharReach(second_min, second_max)); b = bb; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* lower e to the end of a mid byte boundary */ if (e & ((1 << (2 * UTF_CONT_SHIFT)) - 1)) { unichar ee = e & ~((1 << (2 * UTF_CONT_SHIFT)) - 1); assert(ee >= b); u8 first_byte = UTF_THREE_BYTE_HEADER | (ee >> (2 * UTF_CONT_SHIFT)); Position head = getHead(builder, first_byte); Position mid = builder.makePositions(1); bs.addSuccessor(head, mid); bs.addSuccessor(mid, one_dot_trailer); /* no report id as mid can not be directly wired to accept, * not adding to mids as we are completely filling its downstream */ u8 second_min = makeContByte(ee >> UTF_CONT_SHIFT); u8 second_max = makeContByte((e - 1) >> UTF_CONT_SHIFT); builder.addCharReach(mid, CharReach(second_min, second_max)); e = ee; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* now we just have to wire head to a common dot trailer */ ensureTwoDotTrailer(bs); if (three_char_dot_head == GlushkovBuildState::POS_UNINITIALIZED) { three_char_dot_head = builder.makePositions(1); bs.addSuccessor(three_char_dot_head, two_dot_trailer); } u8 min_first_byte = UTF_THREE_BYTE_HEADER | (b >> (2 * UTF_CONT_SHIFT)); u8 max_first_byte = UTF_THREE_BYTE_HEADER | ((e - 1) >> (2 * UTF_CONT_SHIFT)); assert(min_first_byte > 0xdf && min_first_byte <= 0xef); assert(max_first_byte > 0xdf && max_first_byte <= 0xef); builder.addCharReach(three_char_dot_head, CharReach(min_first_byte, max_first_byte)); } } static u8 makeFirstByteOfFour(unichar raw) { u8 first_byte = UTF_FOUR_BYTE_HEADER | (raw >> (3 * UTF_CONT_SHIFT)); assert(first_byte > 0xef && first_byte <= 0xf7); return first_byte; } static bool isTwoContAligned(unichar raw) { return !(raw & ((1 << (2 * UTF_CONT_SHIFT)) - 1)); } static bool isThreeContAligned(unichar raw) { return !(raw & ((1 << (3 * UTF_CONT_SHIFT)) - 1)); } void UTF8ComponentClass::buildFourByte(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); map > mids; map finals; for (auto it = cps.begin(); it != cps.end(); ++it) { unichar b = lower(*it); unichar e = upper(*it) + 1; b = MAX(b, UTF_4CHAR_MIN); e = MIN(e, MAX_UNICODE + 1); if (b >= e) { continue; } /* raise b to the start of the next tail byte boundary */ if (b & UTF_CONT_BYTE_VALUE_MASK) { unichar bb = MIN(e, ROUNDUP_N(b, UTF_CONT_BYTE_RANGE)); u8 first_byte = makeFirstByteOfFour(b); Position head = getHead(builder, first_byte); u8 second_byte = makeContByte(b >> (2 * UTF_CONT_SHIFT)); Position mid1 = getMid(bs, mids, head, second_byte); u8 third_byte = makeContByte(b >> UTF_CONT_SHIFT); Position mid2 = getMid(bs, mids, mid1, third_byte); addToTail(bs, finals, mid2, b, bb); b = bb; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* lower e to the end of a tail byte boundary */ if (e & UTF_CONT_BYTE_VALUE_MASK) { unichar ee = e & ~UTF_CONT_BYTE_VALUE_MASK; assert(ee >= b); u8 first_byte = makeFirstByteOfFour(ee); Position head = getHead(builder, first_byte); u8 second_byte = makeContByte(ee >> (2 * UTF_CONT_SHIFT)); Position mid1 = getMid(bs, mids, head, second_byte); u8 third_byte = makeContByte(ee >> UTF_CONT_SHIFT); Position mid2 = getMid(bs, mids, mid1, third_byte); addToTail(bs, finals, mid2, ee, e); e = ee; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* from here on in the last byte is always full */ ensureDotTrailer(bs); /* raise b to the start of the next mid byte boundary */ if (!isTwoContAligned(b)) { unichar bb = MIN(e, ROUNDUP_N(b, 1 << (2 * UTF_CONT_SHIFT))); u8 first_byte = makeFirstByteOfFour(b); Position head = getHead(builder, first_byte); u8 second_byte = makeContByte(b >> (2 * UTF_CONT_SHIFT)); Position mid1 = getMid(bs, mids, head, second_byte); Position mid2 = builder.makePositions(1); bs.addSuccessor(mid1, mid2); bs.addSuccessor(mid2, one_dot_trailer); /* no report id as mid can not be directly wired to accept, * not adding to mids as we are completely filling its downstream */ u8 byte_min = makeContByte(b >> UTF_CONT_SHIFT); u8 byte_max = makeContByte((bb - 1) >> UTF_CONT_SHIFT); builder.addCharReach(mid2, CharReach(byte_min, byte_max)); b = bb; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* lower e to the end of a mid byte boundary */ if (!isTwoContAligned(e)) { unichar ee = e & ~((1 << (2 * UTF_CONT_SHIFT)) - 1); assert(ee >= b); u8 first_byte = makeFirstByteOfFour(ee); Position head = getHead(builder, first_byte); u8 second_byte = makeContByte(ee >> (2 * UTF_CONT_SHIFT)); Position mid1 = getMid(bs, mids, head, second_byte); Position mid2 = builder.makePositions(1); bs.addSuccessor(mid1, mid2); bs.addSuccessor(mid2, one_dot_trailer); /* no report id as mid can not be directly wired to accept, * not adding to mids as we are completely filling its downstream */ u8 byte_min = makeContByte(ee >> UTF_CONT_SHIFT); u8 byte_max = makeContByte((e - 1) >> UTF_CONT_SHIFT); builder.addCharReach(mid2, CharReach(byte_min, byte_max)); e = ee; } if (b == e) { continue; /* we're done here */ } assert(b < e); ensureTwoDotTrailer(bs); /* raise b to the next byte boundary */ if (!isThreeContAligned(b)) { unichar bb = MIN(e, ROUNDUP_N(b, 1 << (3 * UTF_CONT_SHIFT))); u8 first_byte = makeFirstByteOfFour(b); Position head = getHead(builder, first_byte); Position mid1 = builder.makePositions(1); bs.addSuccessor(head, mid1); bs.addSuccessor(mid1, two_dot_trailer); /* no report id as mid can not be directly wired to accept, * not adding to mids as we are completely filling its downstream */ u8 byte_min = makeContByte(b >> (2 * UTF_CONT_SHIFT)); u8 byte_max = makeContByte((bb - 1) >> (2 * UTF_CONT_SHIFT)); builder.addCharReach(mid1, CharReach(byte_min, byte_max)); b = bb; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* lower e to the next byte boundary */ if (!isThreeContAligned(e)) { unichar ee = e & ~((1 << (3 * UTF_CONT_SHIFT)) - 1); assert(ee >= b); u8 first_byte = makeFirstByteOfFour(ee); Position head = getHead(builder, first_byte); Position mid1 = builder.makePositions(1); bs.addSuccessor(head, mid1); bs.addSuccessor(mid1, two_dot_trailer); /* no report id as mid can not be directly wired to accept, * not adding to mids as we are completely filling its downstream */ u8 byte_min = makeContByte(ee >> (2 * UTF_CONT_SHIFT)); u8 byte_max = makeContByte((e - 1) >> (2 * UTF_CONT_SHIFT)); builder.addCharReach(mid1, CharReach(byte_min, byte_max)); e = ee; } if (b == e) { continue; /* we're done here */ } assert(b < e); /* now we just have to wire head to a common dot trailer */ ensureThreeDotTrailer(bs); if (four_char_dot_head == GlushkovBuildState::POS_UNINITIALIZED) { four_char_dot_head = builder.makePositions(1); bs.addSuccessor(four_char_dot_head, three_dot_trailer); } u8 min_first_byte = makeFirstByteOfFour(b); u8 max_first_byte = makeFirstByteOfFour(e - 1); builder.addCharReach(four_char_dot_head, CharReach(min_first_byte, max_first_byte)); } } void UTF8ComponentClass::notePositions(GlushkovBuildState &bs) { // We should always be finalized by now. assert(finalized); // An empty class is a special case; this would be generated by something // like /[\s\S]/8, which can never match. We treat these like we do the non // UTF-8 version: add a vertex with empty reach (to ensure we create a // connected graph) and pick it up later on. if (class_empty()) { DEBUG_PRINTF("empty class!\n"); assert(single_pos == GlushkovBuildState::POS_UNINITIALIZED); NFABuilder &builder = bs.getBuilder(); single_pos = builder.makePositions(1); builder.setNodeReportID(single_pos, 0 /* offset adj */); builder.addCharReach(single_pos, CharReach()); tails.insert(single_pos); return; } buildOneByte(bs); buildTwoByte(bs); buildThreeByte(bs); buildFourByte(bs); } void UTF8ComponentClass::buildFollowSet(GlushkovBuildState &, const vector &) { /* states are wired in notePositions as all belong to this component. */ } vector UTF8ComponentClass::first(void) const { vector rv; if (single_pos != GlushkovBuildState::POS_UNINITIALIZED) { rv.push_back(single_pos); } if (two_char_dot_head != GlushkovBuildState::POS_UNINITIALIZED) { rv.push_back(two_char_dot_head); } if (three_char_dot_head != GlushkovBuildState::POS_UNINITIALIZED) { rv.push_back(three_char_dot_head); } if (four_char_dot_head != GlushkovBuildState::POS_UNINITIALIZED) { rv.push_back(four_char_dot_head); } for (auto it = heads.begin(); it != heads.end(); ++it) { rv.push_back(it->second); } return rv; } vector UTF8ComponentClass::last(void) const { vector rv; rv.insert(rv.end(), tails.begin(), tails.end()); return rv; } } // namespace ue2 hyperscan-4.4.1/src/parser/parser_util.cpp0000644000175000017500000000370313055426554021422 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Utilities (currently just ParseMode constructor) */ #include "hs.h" #include "Parser.h" #include "ue2common.h" namespace ue2 { ParseMode::ParseMode(u32 hs_flags) : caseless(hs_flags & HS_FLAG_CASELESS), dotall(hs_flags & HS_FLAG_DOTALL), ignore_space(false), multiline(hs_flags & HS_FLAG_MULTILINE), ucp(hs_flags & HS_FLAG_UCP), utf8(hs_flags & HS_FLAG_UTF8) {} } // namespace ue2 hyperscan-4.4.1/src/parser/check_refs.cpp0000644000175000017500000001041613055426554021164 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Component tree analysis that checks that references (such as * back-refs, conditionals) have valid referents. */ #include "check_refs.h" #include "ComponentBackReference.h" #include "ComponentCondReference.h" #include "ConstComponentVisitor.h" #include "parse_error.h" #include "util/container.h" #include "util/ue2_containers.h" #include using namespace std; namespace ue2 { /** * \brief Visitor that checks the validity of references against a known list * of indices and labels. */ class ReferenceVisitor: public DefaultConstComponentVisitor { private: const size_t num_ids; const flat_set &names; public: ReferenceVisitor(size_t num_groups, const flat_set &targets) : num_ids(num_groups), names(targets) {} ~ReferenceVisitor() override; void invalid_index(const char *component, unsigned id) { assert(component); ostringstream str; str << "Invalid " << component << " to expression " << id << "."; throw ParseError(str.str()); } void invalid_label(const char *component, const std::string &label) { assert(component); ostringstream str; str << "Invalid " << component << " to label '" << label << "'."; throw ParseError(str.str()); } using DefaultConstComponentVisitor::pre; void pre(const ComponentBackReference &c) override { if (c.ref_id) { if (c.ref_id >= num_ids) { invalid_index("back reference", c.ref_id); } } else { if (!contains(names, c.name)) { invalid_label("back reference", c.name); } } } void pre(const ComponentCondReference &c) override { switch (c.kind) { case ComponentCondReference::CONDITION_NUMBER: if (c.ref_id >= num_ids) { invalid_index("conditional reference", c.ref_id); } break; case ComponentCondReference::CONDITION_NAME: if (c.ref_name == "DEFINE") { // The string "DEFINE" is a special "always false" condition // used to define subroutines. break; } if (!contains(names, c.ref_name)) { invalid_label("conditional reference", c.ref_name); } break; case ComponentCondReference::CONDITION_ASSERTION: break; } } }; // Out-of-line destructor to silence weak vtable warnings. ReferenceVisitor::~ReferenceVisitor() {} void checkReferences(const Component &root, unsigned int groupIndices, const ue2::flat_set &groupNames) { ReferenceVisitor vis(groupIndices, groupNames); root.accept(vis); } } // namespace ue2 hyperscan-4.4.1/src/parser/unsupported.h0000644000175000017500000000362713055426554021133 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Checks component trees for unsupported components. */ #ifndef PARSER_UNSUPPORTED_H_ #define PARSER_UNSUPPORTED_H_ #include "parse_error.h" namespace ue2 { class Component; /** \brief Throws a ParseError if this component tree contains an unsupported * Component. */ void checkUnsupported(const Component &root); } // namespace #endif // PARSER_UNSUPPORTED_H_ hyperscan-4.4.1/src/parser/buildstate.cpp0000644000175000017500000004320113055426554021226 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Glushkov construction. */ #include "buildstate.h" #include "position.h" #include "position_dump.h" #include "position_info.h" #include "parse_error.h" #include "hs_internal.h" #include "ue2common.h" #include "nfagraph/ng_builder.h" #include "util/charreach.h" #include "util/container.h" #include "util/make_unique.h" #include "util/ue2_containers.h" #include #include #include #include #include #if defined(DEBUG) || defined(DUMP_SUPPORT) #include #include #endif using namespace std; namespace ue2 { /** \brief Represents an uninitialized state. */ const Position GlushkovBuildState::POS_UNINITIALIZED = numeric_limits::max(); /** \brief Represents an epsilon transition in the firsts of a component. */ const Position GlushkovBuildState::POS_EPSILON = numeric_limits::max() - 1; GlushkovBuildState::~GlushkovBuildState() { } namespace /* anonymous */ { class CheckPositionFlags { public: explicit CheckPositionFlags(int fl) : flags(fl) {} bool operator()(const PositionInfo &p) const { return (p.flags & flags) == flags; } private: int flags; }; class CheckUnflaggedEpsilon { public: bool operator()(const PositionInfo &p) const { return p.pos == GlushkovBuildState::POS_EPSILON && p.flags == 0; } }; /** \brief Concrete impl of the GlushkovBuildState interface. */ class GlushkovBuildStateImpl : public GlushkovBuildState { public: GlushkovBuildStateImpl(NFABuilder &b, bool prefilter); /** \brief Returns a reference to the NFABuilder being used. */ NFABuilder &getBuilder() override { return builder; } /** \brief Returns a const reference to the NFABuilder being used. */ const NFABuilder &getBuilder() const override { return builder; } /** \brief Wire up the lasts of one component to the firsts of another. */ void connectRegions(const vector &lasts, const vector &firsts) override; /** \brief Wire the lasts of the main sequence to accepts. */ void connectAccepts(const vector &lasts) override; /** \brief Wire up a single last to a list of firsts. */ void connectSuccessors(const PositionInfo &last, vector firsts); /** Wire up a pair of positions. */ void addSuccessor(Position from, Position to) override; /** \brief Clone the vertex properties and edges of all vertices between * two positions. */ void cloneFollowSet(Position from, Position to, unsigned offset) override; /** \brief Build the prioritised list of edges out of our successor map. */ void buildEdges() override; /** Construct an edge, called internally by \ref buildEdges. */ void buildEdge(Position from, const PositionInfo &to); Position startState; Position startDotstarState; Position acceptState; Position acceptEodState; Position acceptNlEodState; Position acceptNlState; NFABuilder &builder; //!< \brief builder for the NFAGraph bool doPrefilter; //!< \brief we're building a prefiltering pattern /** \brief Map storing successors for each position. */ map> successors; }; } // namespace GlushkovBuildStateImpl::GlushkovBuildStateImpl(NFABuilder &b, bool prefilter) : startState(b.getStart()), startDotstarState(b.getStartDotStar()), acceptState(b.getAccept()), acceptEodState(b.getAcceptEOD()), acceptNlEodState(POS_UNINITIALIZED), acceptNlState(POS_UNINITIALIZED), builder(b), doPrefilter(prefilter) { // Our special nodes need special relationships. vector lasts, firsts; // start->startDs and startDs self-loop. lasts.push_back(startState); lasts.push_back(startDotstarState); firsts.push_back(startDotstarState); connectRegions(lasts, firsts); // accept to acceptEod edges already wired // XXX: a small hack to support vacuous NFAs: give start and startDs an // initial report ID. builder.setNodeReportID(startState, 0); builder.setNodeReportID(startDotstarState, 0); } static void checkEmbeddedEndAnchor(const PositionInfo &from, const vector &firsts) { if (!(from.flags & POS_FLAG_ONLY_ENDS)) { return; } for (const auto &first : firsts) { if (first.pos != GlushkovBuildStateImpl::POS_EPSILON) { /* can make it through the parse tree */ throw ParseError("Embedded end anchors not supported."); } } } // Wire up the lasts of one component to the firsts of another void GlushkovBuildStateImpl::connectRegions(const vector &lasts, const vector &firsts) { for (const auto &last : lasts) { checkEmbeddedEndAnchor(last, firsts); connectSuccessors(last, firsts); } } static void filterEdges(const GlushkovBuildStateImpl &bs, const PositionInfo &from, vector &tolist) { if (from.pos == bs.startDotstarState) { // If we're connecting from start-dotstar, remove all caret flavoured // positions. CheckPositionFlags check(POS_FLAG_NOFLOAT); tolist.erase(remove_if(tolist.begin(), tolist.end(), check), tolist.end()); if (from.flags & POS_FLAG_NOFLOAT) { tolist.clear(); } } else if (from.pos == bs.startState) { // If we're connecting from start, we should remove any epsilons that // aren't caret flavoured. CheckUnflaggedEpsilon check; tolist.erase(remove_if(tolist.begin(), tolist.end(), check), tolist.end()); CheckPositionFlags check2(POS_FLAG_MUST_FLOAT | POS_FLAG_NOFLOAT); tolist.erase(remove_if(tolist.begin(), tolist.end(), check2), tolist.end()); } if (bs.builder.getAssertFlag(from.pos) & POS_FLAG_MULTILINE_START) { // If we have a (mildly boneheaded) pattern like /^$/m, we're right up // against the edge of what we can do without true assertion support. // Here we have an evil hack to prevent us plugging the \n generated by // the caret right into acceptEod (which is in the firsts of the // dollar). /* This is due to the 'interesting quirk' that multiline ^ does not * not match a newline at the end of buffer. */ DEBUG_PRINTF("multiline start - no eod\n"); tolist.erase(remove(tolist.begin(), tolist.end(), bs.acceptEodState), tolist.end()); } } static Position makeNewlineAssertPos(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); Position newline = builder.makePositions(1); builder.addCharReach(newline, CharReach('\n')); builder.setAssertFlag(newline, POS_FLAG_FIDDLE_ACCEPT); builder.setNodeReportID(newline, -1); return newline; } static void generateAccepts(GlushkovBuildStateImpl &bs, const PositionInfo &from, vector *tolist) { NFABuilder &builder = bs.getBuilder(); u32 flags = from.flags; bool require_eod = flags & POS_FLAG_WIRE_EOD; bool require_nl_eod = flags & POS_FLAG_WIRE_NL_EOD && !(flags & POS_FLAG_NO_NL_EOD); bool require_nl_accept = (flags & POS_FLAG_WIRE_NL_ACCEPT) && !(flags & POS_FLAG_NO_NL_ACCEPT); bool require_accept = !(flags & POS_FLAG_ONLY_ENDS); if (require_eod) { tolist->push_back(bs.acceptEodState); } if (require_nl_accept) { if (bs.acceptNlState == GlushkovBuildState::POS_UNINITIALIZED) { Position newline = makeNewlineAssertPos(bs); bs.addSuccessor(newline, builder.getAccept()); bs.acceptNlState = newline; } tolist->push_back(bs.acceptNlState); } if (require_nl_eod) { if (bs.acceptNlEodState == GlushkovBuildState::POS_UNINITIALIZED) { Position newline = makeNewlineAssertPos(bs); bs.addSuccessor(newline, builder.getAcceptEOD()); bs.acceptNlEodState = newline; } tolist->push_back(bs.acceptNlEodState); } if (require_accept) { tolist->push_back(bs.acceptState); } } void GlushkovBuildStateImpl::connectAccepts(const vector &lasts) { for (const auto &last : lasts) { vector accepts; generateAccepts(*this, last, &accepts); connectSuccessors(last, accepts); } } #if defined(DEBUG) || defined(DUMP_SUPPORT) static UNUSED string dumpCaptures(const PositionInfo &p) { ostringstream oss; if (p.flags & POS_FLAG_NOFLOAT) { oss << ""; } if (p.flags & POS_FLAG_MUST_FLOAT) { oss << ""; } if (p.flags & POS_FLAG_FIDDLE_ACCEPT) { oss << ""; } if (p.flags & POS_FLAG_ONLY_ENDS) { oss << ""; } if (p.flags & POS_FLAG_NO_NL_EOD) { oss << ""; } if (p.flags & POS_FLAG_NO_NL_ACCEPT) { oss << ""; } return oss.str(); } #endif // DEBUG || DUMP_SUPPORT void GlushkovBuildStateImpl::connectSuccessors(const PositionInfo &from, vector tolist) { /* note: tolist maybe modified for our own internal use -> not a reference */ assert(from.pos != POS_EPSILON); assert(from.pos != POS_UNINITIALIZED); assert(find(tolist.begin(), tolist.end(), POS_UNINITIALIZED) == tolist.end()); DEBUG_PRINTF("FROM = %u%s TO = %s\n", from.pos, dumpCaptures(from).c_str(), dumpPositions(tolist.begin(), tolist.end()).c_str()); /* prevent creation of edges with invalid assertions */ filterEdges(*this, from, tolist); if (from.flags & POS_FLAG_FIDDLE_ACCEPT) { auto accept = find(tolist.begin(), tolist.end(), acceptState); if (accept != tolist.end()) { DEBUG_PRINTF("accept through -1 offset-adjusting dot\n"); Position fakedot = builder.makePositions(1); builder.addCharReach(fakedot, CharReach(0x00, 0xff)); builder.setNodeReportID(fakedot, -1); addSuccessor(fakedot, acceptState); *accept = fakedot; } else { // We might lead to accept via an assertion vertex, so we add the // offset adj to this vertex itself. Used for cases like /^\B/m, // which should match only at 0 for '\n'. builder.setNodeReportID(from.pos, -1); } assert(find(tolist.begin(), tolist.end(), acceptState) == tolist.end()); } auto &succ = successors[from.pos]; DEBUG_PRINTF("connect %u -> %s\n", from.pos, dumpPositions(tolist.begin(), tolist.end()).c_str()); DEBUG_PRINTF("%u curr succ: %s\n", from.pos, dumpPositions(begin(succ), end(succ)).c_str()); for (const auto &to : tolist) { if (to.pos != POS_EPSILON) { succ.insert(to); } } DEBUG_PRINTF("%u succ: %s\n", from.pos, dumpPositions(begin(succ), end(succ)).c_str()); } void GlushkovBuildStateImpl::addSuccessor(Position from, Position to) { DEBUG_PRINTF("connect %u -> %u\n", from, to); assert(from != POS_EPSILON && from != POS_UNINITIALIZED); assert(to != POS_EPSILON && to != POS_UNINITIALIZED); auto &succ = successors[from]; succ.insert(to); DEBUG_PRINTF("%u succ: %s\n", from, dumpPositions(begin(succ), end(succ)).c_str()); } void GlushkovBuildStateImpl::cloneFollowSet(Position first, Position last, unsigned offset) { assert(first <= last); // Clone vertex properties (reachability, etc) builder.cloneRegion(first, last, offset); /* Clone the successors of all the positions between first and last * inclusive, producing a new set of positions starting at (first + * offset). */ for (Position i = first; i <= last; i++) { // This should be a new position. assert(successors[i + offset].empty()); for (const PositionInfo &to : successors[i]) { if (to.pos >= first && to.pos <= last) { PositionInfo clone(to); clone.pos += offset; DEBUG_PRINTF("clone: %u -> %u\n", i + offset, clone.pos); successors[i + offset].insert(clone); } else { // There shouldn't be any stray edges leading out of this // region! assert(0); } } } } void GlushkovBuildStateImpl::buildEdge(Position from, const PositionInfo &to) { // Guard against embedded anchors if (to == startState) { /* can make it through the parse tree */ throw ParseError("Embedded start anchors not supported."); } assert(to.pos != POS_UNINITIALIZED); assert(to.pos != POS_EPSILON); if (builder.hasEdge(from, to.pos)) { return; } builder.addEdge(from, to.pos); } void GlushkovBuildStateImpl::buildEdges() { // Create all the edges and track which vertices are asserts which need to // be removed later. for (const auto &m : successors) { const Position from = m.first; for (const auto &to : m.second) { buildEdge(from, to); } } } // Construct a usable GlushkovBuildState for the outside world. unique_ptr makeGlushkovBuildState(NFABuilder &b, bool prefilter) { return ue2::make_unique(b, prefilter); } // free functions for utility use /** \brief Eliminate lower-priority duplicate PositionInfo entries. * * Scans through a list of positions and retains only the highest priority * version of a given (position, flags) entry. */ void cleanupPositions(vector &a) { ue2::unordered_set> seen; // track dupes vector out; out.reserve(a.size()); // output should be close to input in size. for (const auto &p : a) { if (seen.emplace(p.pos, p.flags).second) { out.push_back(p); // first encounter } } DEBUG_PRINTF("in %zu; out %zu\n", a.size(), out.size()); a.swap(out); } static vector::iterator replaceElemWithSequence(vector &dest, vector::iterator &victim, const vector &replacement) { auto past = dest.erase(victim); size_t d = distance(dest.begin(), past) + replacement.size(); dest.insert(past, replacement.begin(), replacement.end()); /* recalc past as iterator may have been invalidated */ return dest.begin() + d; } /** \brief Replace all epsilons with the given positions. * * Replace epsilons in a firsts list with another given firsts list. Note: the * firsts lists must come from disjoint sets of components. If no epsilons are * in the first firsts list the source is appended to the end. */ void replaceEpsilons(vector &target, const vector &source) { auto found = find(target.begin(), target.end(), GlushkovBuildState::POS_EPSILON); if (found == target.end()) { // no epsilons to replace, push on to the end target.insert(target.end(), source.begin(), source.end()); return; } while (found != target.end()) { checkEmbeddedEndAnchor(*found, source); // replace this epsilon with a copy of source with the same flags vector newsource(source); for (auto &pos : newsource) { pos.flags |= found->flags; } found = replaceElemWithSequence(target, found, newsource); // find the next epsilon found = find(found, target.end(), GlushkovBuildState::POS_EPSILON); } cleanupPositions(target); } #ifdef DUMP_SUPPORT void dump(ostream &os, const PositionInfo &p) { if (p.pos == GlushkovBuildState::POS_EPSILON) { os << "epsilon"; } else { os << p.pos; } os << dumpCaptures(p); } #endif // DUMP_SUPPORT } // namespace ue2 hyperscan-4.4.1/src/parser/ComponentCondReference.cpp0000644000175000017500000001245213055426554023457 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Conditional reference. */ #include "ComponentCondReference.h" #include "ComponentAlternation.h" #include "ComponentAssertion.h" #include "parse_error.h" #include "position_info.h" #include #include #include using namespace std; namespace ue2 { ComponentCondReference::ComponentCondReference(unsigned ref) : kind(CONDITION_NUMBER), ref_id(ref), hasBothBranches(false) {} ComponentCondReference::ComponentCondReference(const string &name) : kind(CONDITION_NAME), ref_id(0), ref_name(name), hasBothBranches(false) {} ComponentCondReference::ComponentCondReference(unique_ptr c) : kind(CONDITION_ASSERTION), ref_id(0), assertion(move(c)), hasBothBranches(false) {} ComponentCondReference::~ComponentCondReference() {} ComponentCondReference::ComponentCondReference( const ComponentCondReference &other) : ComponentSequence(other), kind(other.kind), ref_id(other.ref_id), ref_name(other.ref_name), hasBothBranches(other.hasBothBranches) { if (kind == CONDITION_ASSERTION) { assert(other.assertion); assertion.reset(other.assertion->clone()); } else { assert(!other.assertion); } } ComponentCondReference *ComponentCondReference::clone() const { return new ComponentCondReference(*this); } Component *ComponentCondReference::accept(ComponentVisitor &v) { Component *c = v.visit(this); if (c != this) { v.post(this); return c; } if (kind == CONDITION_ASSERTION) { Component *a = assertion.get(); c = assertion->accept(v); if (c != a) { assertion.reset(c); } } for (auto i = children.begin(), e = children.end(); i != e; ++i) { Component *child = i->get(); c = (*i)->accept(v); if (c != child) { // Child has been replaced (new Component pointer) or we've been // instructed to delete it (null). i->reset(c); } } // Remove deleted children. children.erase(remove(children.begin(), children.end(), nullptr), children.end()); v.post(this); return this; } void ComponentCondReference::accept(ConstComponentVisitor &v) const { v.pre(*this); if (kind == CONDITION_ASSERTION) { assertion->accept(v); v.during(*this); // FIXME: a good idea? } for (auto i = children.begin(), e = children.end(); i != e; ++i) { (*i)->accept(v); if (i + 1 != e) { v.during(*this); } } v.post(*this); } void ComponentCondReference::addAlternation() { if (alternation) { if (ref_name == "DEFINE") { throw LocatedParseError("DEFINE conditional group with more than " "one branch"); } if (alternation->numBranches() >= 2) { throw LocatedParseError("Conditional with more than two branches"); } } hasBothBranches = true; ComponentSequence::addAlternation(); } vector ComponentCondReference::first() const { assert(0); return vector(); } vector ComponentCondReference::last() const { assert(0); return vector(); } bool ComponentCondReference::empty() const { return true; } void ComponentCondReference::notePositions(GlushkovBuildState &) { assert(0); } void ComponentCondReference::buildFollowSet(GlushkovBuildState &, const vector &) { assert(0); } bool ComponentCondReference::repeatable() const { // If this assertion has no children (it's an empty sequence, like that // produced by '(?!)') then PCRE would throw a "nothing to repeat" error. // So we do as well. return !children.empty(); } } // namespace ue2 hyperscan-4.4.1/src/parser/AsciiComponentClass.cpp0000644000175000017500000001132313055426554022767 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Character classes and their mnemonics. */ #include "AsciiComponentClass.h" #include "Utf8ComponentClass.h" #include "buildstate.h" #include "parse_error.h" #include "position.h" #include "position_info.h" #include "nfagraph/ng_builder.h" #include "util/charreach_util.h" using namespace std; namespace ue2 { AsciiComponentClass::AsciiComponentClass(const ParseMode &mode_in) : ComponentClass(mode_in), position(GlushkovBuildState::POS_UNINITIALIZED) { assert(!mode.utf8); } AsciiComponentClass *AsciiComponentClass::clone() const { return new AsciiComponentClass(*this); } bool AsciiComponentClass::class_empty(void) const { assert(finalized); return cr.none(); } void AsciiComponentClass::createRange(unichar to) { assert(range_start <= 0xff); unsigned char from = (u8)range_start; if (from > to) { throw LocatedParseError("Range out of order in character class"); } in_cand_range = false; CharReach ncr(from, to); if (mode.caseless) { make_caseless(&ncr); } cr |= ncr; range_start = INVALID_UNICODE; } void AsciiComponentClass::notePositions(GlushkovBuildState &bs) { // We should always be finalized by now. assert(finalized); NFABuilder &builder = bs.getBuilder(); position = builder.makePositions(1); builder.addCharReach(position, cr); builder.setNodeReportID(position, 0 /* offset adj */); recordPosBounds(position, position + 1); } void AsciiComponentClass::buildFollowSet(GlushkovBuildState &, const vector &) { // all follow set construction is handled by firsts/lasts } void AsciiComponentClass::add(PredefinedClass c, bool negative) { if (in_cand_range) { // can't form a range here throw LocatedParseError("Invalid range in character class"); } DEBUG_PRINTF("getting %u %s\n", (u32)c, negative ? "^" : ""); if (mode.ucp) { c = translateForUcpMode(c, mode); } // Note: caselessness is handled by getPredefinedCharReach. CharReach pcr = getPredefinedCharReach(c, mode); if (negative) { pcr.flip(); } cr |= pcr; range_start = INVALID_UNICODE; in_cand_range = false; } void AsciiComponentClass::add(unichar c) { DEBUG_PRINTF("adding \\x%02x\n", c); if (c > 0xff) { // too big! throw LocatedParseError("Hexadecimal value is greater than \\xFF"); } if (in_cand_range) { createRange(c); return; } CharReach ncr(c, c); if (mode.caseless) { make_caseless(&ncr); } cr |= ncr; range_start = c; } void AsciiComponentClass::finalize() { if (finalized) { return; } // Handle unclosed ranges, like '[a-]' and '[a-\Q\E]' -- in these cases the // dash is a literal dash. if (in_cand_range) { cr.set('-'); in_cand_range = false; } if (m_negate) { cr.flip(); } finalized = true; } vector AsciiComponentClass::first(void) const { return vector(1, PositionInfo(position)); } vector AsciiComponentClass::last(void) const { return vector(1, PositionInfo(position)); } } // namespace ue2 hyperscan-4.4.1/src/parser/Parser.rl0000644000175000017500000023027013055426554020161 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Parser code (generated with Ragel from Parser.rl). */ #include "config.h" /* Parser.cpp is a built source, may not be in same dir as parser files */ #include "parser/check_refs.h" #include "parser/ComponentAlternation.h" #include "parser/ComponentAssertion.h" #include "parser/ComponentAtomicGroup.h" #include "parser/ComponentBackReference.h" #include "parser/ComponentBoundary.h" #include "parser/ComponentByte.h" #include "parser/ComponentClass.h" #include "parser/ComponentCondReference.h" #include "parser/ComponentEmpty.h" #include "parser/ComponentEUS.h" #include "parser/Component.h" #include "parser/ComponentRepeat.h" #include "parser/ComponentSequence.h" #include "parser/ComponentWordBoundary.h" #include "parser/parse_error.h" #include "parser/Parser.h" #include "ue2common.h" #include "util/compare.h" #include "util/make_unique.h" #include "util/ue2_containers.h" #include "util/unicode_def.h" #include "util/verify_types.h" #include #include #include #include #include #include #include #include using namespace std; namespace ue2 { #define PUSH_SEQUENCE do {\ sequences.push_back(ExprState(currentSeq, (size_t)(ts - ptr), \ mode)); \ } while(0) #define POP_SEQUENCE do {\ currentSeq = sequences.back().seq; \ mode = sequences.back().mode; \ sequences.pop_back(); \ } while(0) namespace { /** \brief Structure representing current state as we're parsing (current * sequence, current options). Stored in the 'sequences' vector. */ struct ExprState { ExprState(ComponentSequence *seq_in, size_t offset, const ParseMode &mode_in) : seq(seq_in), seqOffset(offset), mode(mode_in) {} ComponentSequence *seq; //!< current sequence size_t seqOffset; //!< offset seq was entered, for error reporting ParseMode mode; //!< current mode flags }; } // namespace static unsigned parseAsDecimal(unsigned oct) { // The input was parsed as octal, but should have been parsed as decimal. // Deconstruct the octal number and reconstruct into decimal unsigned ret = 0; unsigned multiplier = 1; while (oct) { ret += (oct & 0x7) * multiplier; oct >>= 3; multiplier *= 10; } return ret; } /** \brief Maximum value for a positive integer. We use INT_MAX, as that's what * PCRE uses. */ static constexpr u32 MAX_NUMBER = INT_MAX; static void pushDec(u32 *acc, u8 raw_digit) { assert(raw_digit >= '0' && raw_digit <= '9'); u32 digit_val = raw_digit - '0'; // Ensure that we don't overflow. u64a val = ((u64a)*acc * 10) + digit_val; if (val > MAX_NUMBER) { throw LocatedParseError("Number is too big"); } *acc = verify_u32(val); } static void pushOct(u32 *acc, u8 raw_digit) { assert(raw_digit >= '0' && raw_digit <= '7'); u32 digit_val = raw_digit - '0'; // Ensure that we don't overflow. u64a val = ((u64a)*acc * 8) + digit_val; if (val > MAX_NUMBER) { throw LocatedParseError("Number is too big"); } *acc = verify_u32(val); } static void throwInvalidRepeat(void) { throw LocatedParseError("Invalid repeat"); } static void throwInvalidUtf8(void) { throw ParseError("Expression is not valid UTF-8."); } /** * Adds the given child component to the parent sequence, returning a pointer * to the new (child) "current sequence". */ static ComponentSequence *enterSequence(ComponentSequence *parent, unique_ptr child) { assert(parent); assert(child); ComponentSequence *seq = child.get(); parent->addComponent(move(child)); return seq; } static void addLiteral(ComponentSequence *currentSeq, unsigned char c, const ParseMode &mode) { if (mode.utf8 && mode.caseless) { /* leverage ComponentClass to generate the vertices */ auto cc = getComponentClass(mode); assert(cc); cc->add(c); cc->finalize(); currentSeq->addComponent(move(cc)); } else { currentSeq->addComponent(getLiteralComponentClass(c, mode.caseless)); } } static void addEscaped(ComponentSequence *currentSeq, unichar accum, const ParseMode &mode, const char *err_msg) { if (mode.utf8) { /* leverage ComponentClass to generate the vertices */ auto cc = getComponentClass(mode); assert(cc); cc->add(accum); cc->finalize(); currentSeq->addComponent(move(cc)); } else { if (accum > 255) { throw LocatedParseError(err_msg); } addLiteral(currentSeq, (unsigned char)accum, mode); } } static void addEscapedOctal(ComponentSequence *currentSeq, unichar accum, const ParseMode &mode) { addEscaped(currentSeq, accum, mode, "Octal value is greater than \\377"); } static void addEscapedHex(ComponentSequence *currentSeq, unichar accum, const ParseMode &mode) { addEscaped(currentSeq, accum, mode, "Hexadecimal value is greater than \\xFF"); } #define SLASH_C_ERROR "\\c must be followed by an ASCII character" static u8 decodeCtrl(u8 raw) { if (raw & 0x80) { throw LocatedParseError(SLASH_C_ERROR); } return mytoupper(raw) ^ 0x40; } static unichar readUtf8CodePoint2c(const u8 *ts) { assert(ts[0] >= 0xc0 && ts[0] < 0xe0); assert(ts[1] >= 0x80 && ts[1] < 0xc0); unichar val = ts[0] & 0x1f; val <<= 6; val |= ts[1] & 0x3f; DEBUG_PRINTF("utf8 %02hhx %02hhx ->\\x{%x}\n", ts[0], ts[1], val); return val; } static unichar readUtf8CodePoint3c(const u8 *ts) { assert(ts[0] >= 0xe0 && ts[0] < 0xf0); assert(ts[1] >= 0x80 && ts[1] < 0xc0); assert(ts[2] >= 0x80 && ts[2] < 0xc0); unichar val = ts[0] & 0x0f; val <<= 6; val |= ts[1] & 0x3f; val <<= 6; val |= ts[2] & 0x3f; DEBUG_PRINTF("utf8 %02hhx %02hhx %02hhx ->\\x{%x}\n", ts[0], ts[1], ts[2], val); return val; } static unichar readUtf8CodePoint4c(const u8 *ts) { assert(ts[0] >= 0xf0 && ts[0] < 0xf8); assert(ts[1] >= 0x80 && ts[1] < 0xc0); assert(ts[2] >= 0x80 && ts[2] < 0xc0); assert(ts[3] >= 0x80 && ts[3] < 0xc0); unichar val = ts[0] & 0x07; val <<= 6; val |= ts[1] & 0x3f; val <<= 6; val |= ts[2] & 0x3f; val <<= 6; val |= ts[3] & 0x3f; DEBUG_PRINTF("utf8 %02hhx %02hhx %02hhx %02hhx ->\\x{%x}\n", ts[0], ts[1], ts[2], ts[3], val); return val; } %%{ machine regex; alphtype unsigned char; action throwUnsupportedEscape { ostringstream str; str << "'\\" << (char)*(ts + 1) << "' at index " << ts - ptr << " not supported in a character class."; throw ParseError(str.str()); } action unsupportedProperty { throw LocatedParseError("Character property not supported"); } action clearLabel { label.clear();} action appendLabelCharacter { label.push_back(fc);} action clearOctAccumulator { octAccumulator = 0;} action clearAccumulator { accumulator = 0;} action setOctAccumulator { octAccumulator = 0; pushOct(&octAccumulator, fc); } action setDecAccumulator { accumulator = 0; pushDec(&accumulator, fc); } action clearNM { repeatN = 0; repeatM = 0; } action appendN { pushDec(&repeatN, fc); } action appendM { pushDec(&repeatM, fc); } action appendAccumulatorOctDigit { pushOct(&octAccumulator, fc); } action appendAccumulatorDecDigit { pushDec(&accumulator, fc); } action appendAccumulatorHexDigit { accumulator *= 16; accumulator += fc - '0'; } action appendAccumulatorHexL { accumulator *= 16; accumulator += 10 + fc - 'a'; } action appendAccumulatorHexU { accumulator *= 16; accumulator += 10 + fc - 'A'; } # enter a comment group, where we just scan for a close paren. action enterComment { inComment = true; fgoto readComment; } # enter an extended mode comment, where we just scan for a newline. action enterNewlineTerminatedComment { inComment = true; fgoto readNewlineTerminatedComment; } # enter a CAPTURING group ( e.g. '(blah)' ) action enterCapturingGroup { PUSH_SEQUENCE; auto seq = ue2::make_unique(); seq->setCaptureIndex(groupIndex++); currentSeq = enterSequence(currentSeq, move(seq)); } # enter a NAMED CAPTURING group ( e.g. (?'blah) ) action enterNamedGroup { assert(!label.empty()); // should be guaranteed by machine char c = *label.begin(); if (c >= '0' && c <= '9') { throw LocatedParseError("Group name cannot begin with a digit"); } if (!groupNames.insert(label).second) { throw LocatedParseError("Two named subpatterns use the name '" + label + "'"); } PUSH_SEQUENCE; auto seq = ue2::make_unique(); seq->setCaptureIndex(groupIndex++); seq->setCaptureName(label); currentSeq = enterSequence(currentSeq, move(seq)); } # enter a NON-CAPTURING group where we're modifying flags # ( e.g. '(?i:blah)' ). Standard non-capturing groups use this path # as well. action enterModifiedGroup { PUSH_SEQUENCE; mode = newMode; currentSeq = enterSequence(currentSeq, ue2::make_unique()); } action exitGroup { if (sequences.empty()) { throw LocatedParseError("Unmatched parentheses"); } currentSeq->finalize(); POP_SEQUENCE; } action enterZWLookAhead { PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(ComponentAssertion::LOOKAHEAD, ComponentAssertion::POS)); } action enterZWNegLookAhead { PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(ComponentAssertion::LOOKAHEAD, ComponentAssertion::NEG)); } action enterZWLookBehind { PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(ComponentAssertion::LOOKBEHIND, ComponentAssertion::POS)); } action enterZWNegLookBehind { PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(ComponentAssertion::LOOKBEHIND, ComponentAssertion::NEG)); } action enterEmbeddedCode { throw LocatedParseError("Embedded code is not supported"); } action enterConditionUnsupported { throw LocatedParseError("Conditional subpattern unsupported"); } action enterReferenceUnsupported { throw LocatedParseError("Subpattern reference unsupported"); } action enterNumberedConditionalRef { if (accumulator == 0) { throw LocatedParseError("Numbered reference cannot be zero"); } PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(accumulator)); } action enterNamedConditionalRef { PUSH_SEQUENCE; assert(!label.empty()); currentSeq = enterSequence(currentSeq, ue2::make_unique(label)); } action enterAtomicGroup { PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique()); } action eatClass { assert(!currentCls); assert(!inCharClass); // not reentrant currentCls = getComponentClass(mode); inCharClass = true; inCharClassEarly = true; currentClsBegin = ts; fgoto readClass; } action resetModifiers { newMode = mode; } action applyModifiers { mode = newMode; currentSeq->addComponent(ue2::make_unique()); } action modifyMatchPositive { switch (fc) { case 'i': newMode.caseless = true; break; case 'm': newMode.multiline = true; break; case 's': newMode.dotall = true; break; case 'x': newMode.ignore_space = true; break; default: assert(0); // this action only called for [imsx] break; } } action modifyMatchNegative { switch (fc) { case 'i': newMode.caseless = false; break; case 'm': newMode.multiline = false; break; case 's': newMode.dotall = false; break; case 'x': newMode.ignore_space = false; break; default: assert(0); // this action only called for [imsx] break; } } action is_utf8 { mode.utf8 } action is_ignore_space { mode.ignore_space } action is_early_charclass { inCharClassEarly } action addNumberedBackRef { if (accumulator == 0) { throw LocatedParseError("Numbered reference cannot be zero"); } currentSeq->addComponent(ue2::make_unique(accumulator)); } action addNegativeNumberedBackRef { // Accumulator is a negative offset. if (accumulator == 0) { throw LocatedParseError("Numbered reference cannot be zero"); } if (accumulator >= groupIndex) { throw LocatedParseError("Invalid reference"); } unsigned idx = groupIndex - accumulator; currentSeq->addComponent(ue2::make_unique(idx)); } action addNamedBackRef { currentSeq->addComponent(ue2::make_unique(label)); } escapedOctal0 = '\\0' @clearOctAccumulator [0-7]{0,2} $appendAccumulatorOctDigit; escapedOctal2 = '\\' [1-7] $setOctAccumulator [0-7]{1,2} $appendAccumulatorOctDigit; escapedOctal2c = '\\' [1-7] $setOctAccumulator [0-7]{0,2} $appendAccumulatorOctDigit; backRefIdSingle = [1-7] $setDecAccumulator; backRefId = [1-9] $setDecAccumulator [0-9]+ $appendAccumulatorDecDigit; escapedHex = '\\x' @clearAccumulator ([0-9] $appendAccumulatorHexDigit | [a-f] $appendAccumulatorHexL | [A-F] $appendAccumulatorHexU){0,2}; escapedCtrl = '\\c' any?; escapedUnsupported = '\\' [NluLU]; repeatNM1 = '\{' @clearNM [0-9]+ $appendN ('}' @{repeatM = repeatN;} | ',' '\}' @{repeatM = ComponentRepeat::NoLimit;} | ',' [0-9]+ $appendM '}'); backReferenceG = '\\g' @clearAccumulator [0-9]{1,3} $appendAccumulatorDecDigit; backReferenceGNegative = '\\g-' @clearAccumulator [0-9]{1,3} $appendAccumulatorDecDigit; backReferenceGBracket = '\\g{' @clearAccumulator [0-9]{1,3} $appendAccumulatorDecDigit '}'; backReferenceGBracket2 = '\\g{-' @clearAccumulator [0-9]{1,3} $appendAccumulatorDecDigit '}'; backReferenceGBracketName = '\\g{' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '}'; backReferenceKBracketName = '\\k{' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '}'; backReferenceKBracketName2 = '\\k<' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '>'; backReferenceKBracketName3 = '\\k\'' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '\''; backReferenceP = '(?P=' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter ')'; namedGroup1 = '(?<' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '>'; namedGroup2 = '(?\'' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '\''; namedGroup3 = '(?P<' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '>'; namedConditionalRef1 = '(?(<' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '>)'; namedConditionalRef2 = '(?(\'' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter '\')'; namedConditionalRef3 = '(?(' @clearLabel [A-Za-z0-9_]+ $appendLabelCharacter ')'; numberedSubExpression = '(?' [+\-]? [0-9]+ ')'; namedSubExpression = '(?' ('&'|'P>') [A-Za-z0-9_]+ ')'; positiveMatchModifiers = [imsx]+ $modifyMatchPositive; negativeMatchModifiers = '-' [imsx]+ $modifyMatchNegative; matchModifiers = positiveMatchModifiers ? negativeMatchModifiers ?; utf8_cont = 0x80..0xbf; utf8_2c = 0xc0..0xdf utf8_cont; utf8_3c = 0xe0..0xef utf8_cont utf8_cont; utf8_4c = 0xf0..0xf7 utf8_cont utf8_cont utf8_cont; hi_byte = 0x80..0xff; whitespace = [\t\n\v\f\r ]; ############################################################# # Trivial parser to read Perl 5.10+ control verbs, introduced # by '(*'. ############################################################# readVerb := |* 'UTF8)' => { if (ts != ptr + 2) { throw LocatedParseError("(*UTF8) must be at start of " "expression, encountered"); } mode.utf8 = true; globalMode.utf8 = true; /* once you unicode, you can't stop */ ucp_start_p = te; /* (*UCP) can appear after us */ fret; }; 'UCP)' => { if (ts != ucp_start_p + 2) { throw LocatedParseError("(*UCP) must be at start of " "expression, encountered"); } mode.ucp = true; globalMode.ucp = true; /* once you unicode, you can't stop */ fret; }; 'UTF16)' => { throw LocatedParseError("(*UTF16) not supported"); }; any => { throw LocatedParseError("Unknown control verb"); }; *|; ############################################################# # Parser to read UCP ############################################################# readUCP := |* 'C' => { currentCls->add(CLASS_UCP_C, negated); fret; }; 'Cc' => { currentCls->add(CLASS_UCP_CC, negated); fret; }; 'Cf' => { currentCls->add(CLASS_UCP_CF, negated); fret; }; 'Cn' => { currentCls->add(CLASS_UCP_CN, negated); fret; }; 'Co' => { currentCls->add(CLASS_UCP_CO, negated); fret; }; 'Cs' => { currentCls->add(CLASS_UCP_CS, negated); fret; }; 'L' => { currentCls->add(CLASS_UCP_L, negated); fret; }; 'Ll' => { currentCls->add(CLASS_UCP_LL, negated); fret; }; 'Lm' => { currentCls->add(CLASS_UCP_LM, negated); fret; }; 'Lo' => { currentCls->add(CLASS_UCP_LO, negated); fret; }; 'Lt' => { currentCls->add(CLASS_UCP_LT, negated); fret; }; 'Lu' => { currentCls->add(CLASS_UCP_LU, negated); fret; }; 'L&' => { currentCls->add(CLASS_UCP_L_AND, negated); fret; }; 'M' => { currentCls->add(CLASS_UCP_M, negated); fret; }; 'Mc' => { currentCls->add(CLASS_UCP_MC, negated); fret; }; 'Me' => { currentCls->add(CLASS_UCP_ME, negated); fret; }; 'Mn' => { currentCls->add(CLASS_UCP_MN, negated); fret; }; 'N' => { currentCls->add(CLASS_UCP_N, negated); fret; }; 'Nd' => { currentCls->add(CLASS_UCP_ND, negated); fret; }; 'Nl' => { currentCls->add(CLASS_UCP_NL, negated); fret; }; 'No' => { currentCls->add(CLASS_UCP_NO, negated); fret; }; 'P' => { currentCls->add(CLASS_UCP_P, negated); fret; }; 'Pc' => { currentCls->add(CLASS_UCP_PC, negated); fret; }; 'Pd' => { currentCls->add(CLASS_UCP_PD, negated); fret; }; 'Pe' => { currentCls->add(CLASS_UCP_PE, negated); fret; }; 'Pf' => { currentCls->add(CLASS_UCP_PF, negated); fret; }; 'Pi' => { currentCls->add(CLASS_UCP_PI, negated); fret; }; 'Po' => { currentCls->add(CLASS_UCP_PO, negated); fret; }; 'Ps' => { currentCls->add(CLASS_UCP_PS, negated); fret; }; 'S' => { currentCls->add(CLASS_UCP_S, negated); fret; }; 'Sc' => { currentCls->add(CLASS_UCP_SC, negated); fret; }; 'Sk' => { currentCls->add(CLASS_UCP_SK, negated); fret; }; 'Sm' => { currentCls->add(CLASS_UCP_SM, negated); fret; }; 'So' => { currentCls->add(CLASS_UCP_SO, negated); fret; }; 'Z' => { currentCls->add(CLASS_UCP_Z, negated); fret; }; 'Zl' => { currentCls->add(CLASS_UCP_ZL, negated); fret; }; 'Zp' => { currentCls->add(CLASS_UCP_ZP, negated); fret; }; 'Zs' => { currentCls->add(CLASS_UCP_ZS, negated); fret; }; 'Xan' => { currentCls->add(CLASS_UCP_XAN, negated); fret; }; 'Xps' => { currentCls->add(CLASS_UCP_XPS, negated); fret; }; 'Xsp' => { currentCls->add(CLASS_UCP_XSP, negated); fret; }; 'Xwd' => { currentCls->add(CLASS_UCP_XWD, negated); fret; }; 'Arabic' => { currentCls->add(CLASS_SCRIPT_ARABIC, negated); fret; }; 'Armenian' => { currentCls->add(CLASS_SCRIPT_ARMENIAN, negated); fret; }; 'Avestan' => { currentCls->add(CLASS_SCRIPT_AVESTAN, negated); fret; }; 'Balinese' => { currentCls->add(CLASS_SCRIPT_BALINESE, negated); fret; }; 'Bamum' => { currentCls->add(CLASS_SCRIPT_BAMUM, negated); fret; }; 'Batak' => { currentCls->add(CLASS_SCRIPT_BATAK, negated); fret; }; 'Bengali' => { currentCls->add(CLASS_SCRIPT_BENGALI, negated); fret; }; 'Bopomofo' => { currentCls->add(CLASS_SCRIPT_BOPOMOFO, negated); fret; }; 'Brahmi' => { currentCls->add(CLASS_SCRIPT_BRAHMI, negated); fret; }; 'Braille' => { currentCls->add(CLASS_SCRIPT_BRAILLE, negated); fret; }; 'Buginese' => { currentCls->add(CLASS_SCRIPT_BUGINESE, negated); fret; }; 'Buhid' => { currentCls->add(CLASS_SCRIPT_BUHID, negated); fret; }; 'Canadian_Aboriginal' => { currentCls->add(CLASS_SCRIPT_CANADIAN_ABORIGINAL, negated); fret; }; 'Carian' => { currentCls->add(CLASS_SCRIPT_CARIAN, negated); fret; }; 'Cham' => { currentCls->add(CLASS_SCRIPT_CHAM, negated); fret; }; 'Cherokee' => { currentCls->add(CLASS_SCRIPT_CHEROKEE, negated); fret; }; 'Common' => { currentCls->add(CLASS_SCRIPT_COMMON, negated); fret; }; 'Coptic' => { currentCls->add(CLASS_SCRIPT_COPTIC, negated); fret; }; 'Cuneiform' => { currentCls->add(CLASS_SCRIPT_CUNEIFORM, negated); fret; }; 'Cypriot' => { currentCls->add(CLASS_SCRIPT_CYPRIOT, negated); fret; }; 'Cyrillic' => { currentCls->add(CLASS_SCRIPT_CYRILLIC, negated); fret; }; 'Deseret' => { currentCls->add(CLASS_SCRIPT_DESERET, negated); fret; }; 'Devanagari' => { currentCls->add(CLASS_SCRIPT_DEVANAGARI, negated); fret; }; 'Egyptian_Hieroglyphs' => { currentCls->add(CLASS_SCRIPT_EGYPTIAN_HIEROGLYPHS, negated); fret; }; 'Ethiopic' => { currentCls->add(CLASS_SCRIPT_ETHIOPIC, negated); fret; }; 'Georgian' => { currentCls->add(CLASS_SCRIPT_GEORGIAN, negated); fret; }; 'Glagolitic' => { currentCls->add(CLASS_SCRIPT_GLAGOLITIC, negated); fret; }; 'Gothic' => { currentCls->add(CLASS_SCRIPT_GOTHIC, negated); fret; }; 'Greek' => { currentCls->add(CLASS_SCRIPT_GREEK, negated); fret; }; 'Gujarati' => { currentCls->add(CLASS_SCRIPT_GUJARATI, negated); fret; }; 'Gurmukhi' => { currentCls->add(CLASS_SCRIPT_GURMUKHI, negated); fret; }; 'Han' => { currentCls->add(CLASS_SCRIPT_HAN, negated); fret; }; 'Hangul' => { currentCls->add(CLASS_SCRIPT_HANGUL, negated); fret; }; 'Hanunoo' => { currentCls->add(CLASS_SCRIPT_HANUNOO, negated); fret; }; 'Hebrew' => { currentCls->add(CLASS_SCRIPT_HEBREW, negated); fret; }; 'Hiragana' => { currentCls->add(CLASS_SCRIPT_HIRAGANA, negated); fret; }; 'Imperial_Aramaic' => { currentCls->add(CLASS_SCRIPT_IMPERIAL_ARAMAIC, negated); fret; }; 'Inherited' => { currentCls->add(CLASS_SCRIPT_INHERITED, negated); fret; }; 'Inscriptional_Pahlavi' => { currentCls->add(CLASS_SCRIPT_INSCRIPTIONAL_PAHLAVI, negated); fret; }; 'Inscriptional_Parthian' => { currentCls->add(CLASS_SCRIPT_INSCRIPTIONAL_PARTHIAN, negated); fret; }; 'Javanese' => { currentCls->add(CLASS_SCRIPT_JAVANESE, negated); fret; }; 'Kaithi' => { currentCls->add(CLASS_SCRIPT_KAITHI, negated); fret; }; 'Kannada' => { currentCls->add(CLASS_SCRIPT_KANNADA, negated); fret; }; 'Katakana' => { currentCls->add(CLASS_SCRIPT_KATAKANA, negated); fret; }; 'Kayah_Li' => { currentCls->add(CLASS_SCRIPT_KAYAH_LI, negated); fret; }; 'Kharoshthi' => { currentCls->add(CLASS_SCRIPT_KHAROSHTHI, negated); fret; }; 'Khmer' => { currentCls->add(CLASS_SCRIPT_KHMER, negated); fret; }; 'Lao' => { currentCls->add(CLASS_SCRIPT_LAO, negated); fret; }; 'Latin' => { currentCls->add(CLASS_SCRIPT_LATIN, negated); fret; }; 'Lepcha' => { currentCls->add(CLASS_SCRIPT_LEPCHA, negated); fret; }; 'Limbu' => { currentCls->add(CLASS_SCRIPT_LIMBU, negated); fret; }; 'Linear_B' => { currentCls->add(CLASS_SCRIPT_LINEAR_B, negated); fret; }; 'Lisu' => { currentCls->add(CLASS_SCRIPT_LISU, negated); fret; }; 'Lycian' => { currentCls->add(CLASS_SCRIPT_LYCIAN, negated); fret; }; 'Lydian' => { currentCls->add(CLASS_SCRIPT_LYDIAN, negated); fret; }; 'Malayalam' => { currentCls->add(CLASS_SCRIPT_MALAYALAM, negated); fret; }; 'Mandaic' => { currentCls->add(CLASS_SCRIPT_MANDAIC, negated); fret; }; 'Meetei_Mayek' => { currentCls->add(CLASS_SCRIPT_MEETEI_MAYEK, negated); fret; }; 'Mongolian' => { currentCls->add(CLASS_SCRIPT_MONGOLIAN, negated); fret; }; 'Myanmar' => { currentCls->add(CLASS_SCRIPT_MYANMAR, negated); fret; }; 'New_Tai_Lue' => { currentCls->add(CLASS_SCRIPT_NEW_TAI_LUE, negated); fret; }; 'Nko' => { currentCls->add(CLASS_SCRIPT_NKO, negated); fret; }; 'Ogham' => { currentCls->add(CLASS_SCRIPT_OGHAM, negated); fret; }; 'Ol_Chiki' => { currentCls->add(CLASS_SCRIPT_OL_CHIKI, negated); fret; }; 'Old_Italic' => { currentCls->add(CLASS_SCRIPT_OLD_ITALIC, negated); fret; }; 'Old_Persian' => { currentCls->add(CLASS_SCRIPT_OLD_PERSIAN, negated); fret; }; 'Old_South_Arabian' => { currentCls->add(CLASS_SCRIPT_OLD_SOUTH_ARABIAN, negated); fret; }; 'Old_Turkic' => { currentCls->add(CLASS_SCRIPT_OLD_TURKIC, negated); fret; }; 'Oriya' => { currentCls->add(CLASS_SCRIPT_ORIYA, negated); fret; }; 'Osmanya' => { currentCls->add(CLASS_SCRIPT_OSMANYA, negated); fret; }; 'Phags_Pa' => { currentCls->add(CLASS_SCRIPT_PHAGS_PA, negated); fret; }; 'Phoenician' => { currentCls->add(CLASS_SCRIPT_PHOENICIAN, negated); fret; }; 'Rejang' => { currentCls->add(CLASS_SCRIPT_REJANG, negated); fret; }; 'Runic' => { currentCls->add(CLASS_SCRIPT_RUNIC, negated); fret; }; 'Samaritan' => { currentCls->add(CLASS_SCRIPT_SAMARITAN, negated); fret; }; 'Saurashtra' => { currentCls->add(CLASS_SCRIPT_SAURASHTRA, negated); fret; }; 'Shavian' => { currentCls->add(CLASS_SCRIPT_SHAVIAN, negated); fret; }; 'Sinhala' => { currentCls->add(CLASS_SCRIPT_SINHALA, negated); fret; }; 'Sundanese' => { currentCls->add(CLASS_SCRIPT_SUNDANESE, negated); fret; }; 'Syloti_Nagri' => { currentCls->add(CLASS_SCRIPT_SYLOTI_NAGRI, negated); fret; }; 'Syriac' => { currentCls->add(CLASS_SCRIPT_SYRIAC, negated); fret; }; 'Tagalog' => { currentCls->add(CLASS_SCRIPT_TAGALOG, negated); fret; }; 'Tagbanwa' => { currentCls->add(CLASS_SCRIPT_TAGBANWA, negated); fret; }; 'Tai_Le' => { currentCls->add(CLASS_SCRIPT_TAI_LE, negated); fret; }; 'Tai_Tham' => { currentCls->add(CLASS_SCRIPT_TAI_THAM, negated); fret; }; 'Tai_Viet' => { currentCls->add(CLASS_SCRIPT_TAI_VIET, negated); fret; }; 'Tamil' => { currentCls->add(CLASS_SCRIPT_TAMIL, negated); fret; }; 'Telugu' => { currentCls->add(CLASS_SCRIPT_TELUGU, negated); fret; }; 'Thaana' => { currentCls->add(CLASS_SCRIPT_THAANA, negated); fret; }; 'Thai' => { currentCls->add(CLASS_SCRIPT_THAI, negated); fret; }; 'Tibetan' => { currentCls->add(CLASS_SCRIPT_TIBETAN, negated); fret; }; 'Tifinagh' => { currentCls->add(CLASS_SCRIPT_TIFINAGH, negated); fret; }; 'Ugaritic' => { currentCls->add(CLASS_SCRIPT_UGARITIC, negated); fret; }; 'Vai' => { currentCls->add(CLASS_SCRIPT_VAI, negated); fret; }; 'Yi' => { currentCls->add(CLASS_SCRIPT_YI, negated); fret; }; 'Any' => { currentCls->add(CLASS_UCP_ANY, negated); fret; }; any => { throw LocatedParseError("Unknown property"); }; *|; readBracedUCP := ('{' ('^' ${ negated = !negated; }) ? ([^^] ${ fhold; fcall readUCP; }) '}' ${ if (!inCharClass) { // not inside [..] currentCls->finalize(); currentSeq->addComponent(move(currentCls)); } fret; }) $^{ throw LocatedParseError("Malformed property"); }; readUCPSingle := |* 'C' => { currentCls->add(CLASS_UCP_C, negated); if (!inCharClass) { currentCls->finalize(); currentSeq->addComponent(move(currentCls)); } fret; }; 'L' => { currentCls->add(CLASS_UCP_L, negated); if (!inCharClass) { currentCls->finalize(); currentSeq->addComponent(move(currentCls)); } fret; }; 'M' => { currentCls->add(CLASS_UCP_M, negated); if (!inCharClass) { currentCls->finalize(); currentSeq->addComponent(move(currentCls)); } fret; }; 'N' => { currentCls->add(CLASS_UCP_N, negated); if (!inCharClass) { currentCls->finalize(); currentSeq->addComponent(move(currentCls)); } fret; }; 'P' => { currentCls->add(CLASS_UCP_P, negated); if (!inCharClass) { currentCls->finalize(); currentSeq->addComponent(move(currentCls)); } fret; }; 'S' => { currentCls->add(CLASS_UCP_S, negated); if (!inCharClass) { currentCls->finalize(); currentSeq->addComponent(move(currentCls)); } fret; }; 'Z' => { currentCls->add(CLASS_UCP_Z, negated); if (!inCharClass) { currentCls->finalize(); currentSeq->addComponent(move(currentCls)); } fret; }; any => { throw LocatedParseError("Unknown property"); }; *|; charClassGuts := |* # We don't support POSIX collating elements (neither does PCRE # or Perl). These look like [.ch.] or [=ch=]. '\[\.' ( '\\]' | [^\]] )* '\.\]' | '\[=' ( '\\]' | [^\]] )* '=\]' => { throw LocatedParseError("Unsupported POSIX collating " "element"); }; # Named sets # Adding these may cause the charclass to close, hence the # finalized check - UE-2276 '[:alnum:]' => { currentCls->add(CLASS_ALNUM, false); }; '[:^alnum:]' => { currentCls->add(CLASS_ALNUM, true); }; '[:alpha:]' => { currentCls->add(CLASS_ALPHA, false); }; '[:^alpha:]' => { currentCls->add(CLASS_ALPHA, true); }; '[:ascii:]' => { currentCls->add(CLASS_ASCII, false); }; '[:^ascii:]' => { currentCls->add(CLASS_ASCII, true); }; '[:blank:]' => { currentCls->add(CLASS_BLANK, false); }; '[:^blank:]' => { currentCls->add(CLASS_BLANK, true); }; '[:cntrl:]' => { currentCls->add(CLASS_CNTRL, false); }; '[:^cntrl:]' => { currentCls->add(CLASS_CNTRL, true); }; '[:digit:]' => { currentCls->add(CLASS_DIGIT, false); }; '[:^digit:]' => { currentCls->add(CLASS_DIGIT, true); }; '[:graph:]' => { currentCls->add(CLASS_GRAPH, false); }; '[:^graph:]' => { currentCls->add(CLASS_GRAPH, true); }; '[:lower:]' => { currentCls->add(CLASS_LOWER, false); }; '[:^lower:]' => { currentCls->add(CLASS_LOWER, true); }; '[:print:]' => { currentCls->add(CLASS_PRINT, false); }; '[:^print:]' => { currentCls->add(CLASS_PRINT, true); }; '[:punct:]' => { currentCls->add(CLASS_PUNCT, false); }; '[:^punct:]' => { currentCls->add(CLASS_PUNCT, true); }; # Posix SPACE covers 9, 10, 11, 12, 13, 32 '[:space:]' => { currentCls->add(CLASS_SPACE, false); }; '[:^space:]' => { currentCls->add(CLASS_SPACE, true); }; '[:upper:]' => { currentCls->add(CLASS_UPPER, false); }; '[:^upper:]' => { currentCls->add(CLASS_UPPER, true); }; '[:word:]' => { currentCls->add(CLASS_WORD, false); }; '[:^word:]' => { currentCls->add(CLASS_WORD, true); }; '[:xdigit:]' => { currentCls->add(CLASS_XDIGIT, false); }; '[:^xdigit:]' => { currentCls->add(CLASS_XDIGIT, true); }; # Anything else between "[:" and ":]" is an invalid POSIX class. # Note that "\]" counts as a literal char here. '\[:' ( '\\]' | [^\]] )* ':\]' => { throw LocatedParseError("Invalid POSIX named class"); }; '\\Q' => { fcall readQuotedClass; }; '\\E' => { /*noop*/}; # Backspace (this is only valid for \b in char classes) '\\b' => { currentCls->add('\x08'); }; # Tab '\\t' => { currentCls->add('\x09'); }; # Newline '\\n' => { currentCls->add('\x0a'); }; # Carriage return '\\r' => { currentCls->add('\x0d'); }; # Form feed '\\f' => { currentCls->add('\x0c'); }; # Bell '\\a' => { currentCls->add('\x07'); }; # Escape '\\e' => { currentCls->add('\x1b'); }; # Horizontal whitespace '\\h' => { currentCls->add(CLASS_HORZ, false); }; # Not horizontal whitespace '\\H' => { currentCls->add(CLASS_HORZ, true); }; # Vertical whitespace '\\v' => { currentCls->add(CLASS_VERT, false); }; # Not vertical whitespace '\\V' => { currentCls->add(CLASS_VERT, true); }; '\\p{' => { negated = false; fhold; fcall readBracedUCP; }; '\\p' any => { negated = false; fhold; fcall readUCPSingle; }; '\\P{' => { negated = true; fhold; fcall readBracedUCP; }; '\\P'any => { negated = true; fhold; fcall readUCPSingle; }; '\\P' => { throw LocatedParseError("Malformed property"); }; '\\p' => { throw LocatedParseError("Malformed property"); }; # Octal escapedOctal0 => { currentCls->add(octAccumulator); }; escapedOctal2c => { currentCls->add(octAccumulator); }; '\\o{' [0-7]+ '}' => { string oct((const char *)ts + 3, te - ts - 4); long int val = strtol(oct.c_str(), nullptr, 8); if ((!mode.utf8 && val > 255) || val > MAX_UNICODE) { throw LocatedParseError("Value in \\o{...} sequence is too large"); } currentCls->add((unichar)val); }; # And for when it goes wrong '\\o' => { throw LocatedParseError("Value in \\o{...} sequence is non-octal or missing braces"); }; # Hex escapedHex => { currentCls->add(accumulator); }; # not a back-ref, not octal, just PCRE madness '\\' [89] => { // whatever we found here currentCls->add(*(ts + 1)); }; # Unicode Hex '\\x{' xdigit+ '}' => { string hex((const char *)ts + 3, te - ts - 4); long int val = strtol(hex.c_str(), nullptr, 16); if (val > MAX_UNICODE) { throw LocatedParseError("Value in \\x{...} sequence is too large"); } currentCls->add((unichar)val); }; # And for when it goes wrong '\\x{' => { throw LocatedParseError("Value in \\x{...} sequence is non-hex or missing }"); }; # Control characters escapedCtrl => { if (te - ts < 3) { assert(te - ts == 2); throw LocatedParseError(SLASH_C_ERROR); } else { assert(te - ts == 3); currentCls->add(decodeCtrl(ts[2])); } }; # Word character '\\w' => { currentCls->add(CLASS_WORD, false); }; # Non word character '\\W' => { currentCls->add(CLASS_WORD, true); }; # Whitespace character (except VT) '\\s' => { currentCls->add(CLASS_SPACE, false); }; # Non whitespace character '\\S' => { currentCls->add(CLASS_SPACE, true); }; # Digit character '\\d' => { currentCls->add(CLASS_DIGIT, false); }; # Non digit character '\\D' => { currentCls->add(CLASS_DIGIT, true); }; '\-' => { currentCls->addDash(); }; # A bunch of unsupported (for now) escapes escapedUnsupported - '\\X' => throwUnsupportedEscape; # PCRE appears to discard escaped g in a char class (a backref bug?) '\\g' => throwUnsupportedEscape; # the too-hard basket: UE-944, UE-1134, UE-1157 # many escaped single char literals shold be benign, but PCRE # breaks with them when adding to ranges, so unless they have # defined special meaning in a char-class we reject them to be # safe. '\\' alpha => throwUnsupportedEscape; '\\' any => { // add the literal char currentCls->add(*(ts + 1)); }; #unicode chars utf8_2c when is_utf8 => { assert(mode.utf8); currentCls->add(readUtf8CodePoint2c(ts)); }; utf8_3c when is_utf8 => { assert(mode.utf8); currentCls->add(readUtf8CodePoint3c(ts)); }; utf8_4c when is_utf8 => { assert(mode.utf8); currentCls->add(readUtf8CodePoint4c(ts)); }; hi_byte when is_utf8 => { assert(mode.utf8); throwInvalidUtf8(); }; # Literal character (any - ']') => { currentCls->add(*ts); }; ']' => { currentCls->finalize(); currentSeq->addComponent(move(currentCls)); inCharClass = false; fgoto main; }; *|; ############################################################# # Parser to read stuff from a character class ############################################################# readClass := |* # A caret at the beginning of the class means that the rest of the # class is negated. '\^' when is_early_charclass => { if (currentCls->isNegated()) { // Already seen a caret; the second one is not a meta-character. inCharClassEarly = false; fhold; fgoto charClassGuts; } else { currentCls->negate(); // Note: we cannot switch off inCharClassEarly here, as /[^]]/ // needs to use the right square bracket path below. } }; # A right square bracket before anything "real" is interpreted as a # literal right square bracket. ']' when is_early_charclass => { currentCls->add(']'); inCharClassEarly = false; }; # if we hit a quote before anything "real", handle it '\\Q' => { fcall readQuotedClass; }; '\\E' => { /*noop*/}; # time for the real work to happen any => { inCharClassEarly = false; fhold; fgoto charClassGuts; }; *|; ############################################################# # Parser to read a quoted literal ############################################################# readQuotedLiteral := |* # Escape sequence '\\E' => { fgoto main; }; # Literal character any => { addLiteral(currentSeq, *ts, mode); }; *|; ############################################################# # Parser to read a quoted class ############################################################# readQuotedClass := |* # Escape sequence '\\E' => { fret; }; # Literal character any => { currentCls->add(*ts); inCharClassEarly = false; }; *|; ############################################################# # Parser to read (and ignore) a comment block ############################################################# readComment := |* # Right paren '\)' => { inComment = false; fgoto main; }; # absolutely everything gets ignored until we see a right # paren any; *|; ############################################################# # Parser to read (and ignore) a newline-terminated comment # block ############################################################# readNewlineTerminatedComment := |* '\n' => { inComment = false; fgoto main; }; # absolutely everything gets ignored until we see a # newline any; *|; ############################################################# # Parser for standard components ############################################################# main := |* ############################################################# # Standard components ############################################################# # Begin capturing group (non-capturing handled further down) '\(' => enterCapturingGroup; # End group '\)' => exitGroup; # Mark alternation '\|' => { currentSeq->addAlternation(); }; # POSIX named elements should only be used inside a class. Note # that we need to be able to reject /[:\]:]/ here. '\[:' ( '\\]' | [^\]] )* ':\]' => { throw LocatedParseError("POSIX named classes are only " "supported inside a class"); }; # We don't support POSIX collating elements (neither does PCRE # or Perl). These look like [.ch.] or [=ch=]. '\[\.' ( '\\]' | [^\]] )* '\.\]' | '\[=' ( '\\]' | [^\]] )* '=\]' => { throw LocatedParseError("Unsupported POSIX collating " "element"); }; # Begin eating characters for class '\[' => eatClass; # Begin quoted literal '\\Q' => { fgoto readQuotedLiteral; }; # An \E that is not preceded by a \Q is ignored '\\E' => { /* noop */ }; # Match any character '\.' => { currentSeq->addComponent(generateComponent(CLASS_ANY, false, mode)); }; # Match one byte '\\C' => { if (mode.utf8) { throw LocatedParseError("\\C is unsupported in UTF8"); } currentSeq->addComponent(ue2::make_unique()); }; # Match 0 or more times (greedy) '\*' => { if (!currentSeq->addRepeat(0, ComponentRepeat::NoLimit, ComponentRepeat::REPEAT_GREEDY)) { throwInvalidRepeat(); } }; # Match 0 or more times (non-greedy) '\*\?' => { if (!currentSeq->addRepeat(0, ComponentRepeat::NoLimit, ComponentRepeat::REPEAT_NONGREEDY)) { throwInvalidRepeat(); } }; # Match 0 or more times (possessive) '\*\+' => { if (!currentSeq->addRepeat(0, ComponentRepeat::NoLimit, ComponentRepeat::REPEAT_POSSESSIVE)) { throwInvalidRepeat(); } }; # Match 1 or more times (greedy) '\+' => { if (!currentSeq->addRepeat(1, ComponentRepeat::NoLimit, ComponentRepeat::REPEAT_GREEDY)) { throwInvalidRepeat(); } }; # Match 1 or more times (non-greedy) '\+\?' => { if (!currentSeq->addRepeat(1, ComponentRepeat::NoLimit, ComponentRepeat::REPEAT_NONGREEDY)) { throwInvalidRepeat(); } }; # Match 1 or more times (possessive) '\+\+' => { if (!currentSeq->addRepeat(1, ComponentRepeat::NoLimit, ComponentRepeat::REPEAT_POSSESSIVE)) { throwInvalidRepeat(); } }; # Match 0 or 1 times (greedy) '\?' => { if (!currentSeq->addRepeat( 0, 1, ComponentRepeat::REPEAT_GREEDY)) { throwInvalidRepeat(); } }; # Match 0 or 1 times (non-greedy) '\?\?' => { if (!currentSeq->addRepeat( 0, 1, ComponentRepeat::REPEAT_NONGREEDY)) { throwInvalidRepeat(); } }; # Match 0 or 1 times (possessive) '\?\+' => { if (!currentSeq->addRepeat( 0, 1, ComponentRepeat::REPEAT_POSSESSIVE)) { throwInvalidRepeat(); } }; # Match {n}|{n,}|{n,m} times (greedy) repeatNM1 => { if (repeatN > repeatM || repeatM == 0) { throwInvalidRepeat(); } else if (!currentSeq->addRepeat( repeatN, repeatM, ComponentRepeat::REPEAT_GREEDY)) { throwInvalidRepeat(); } }; # Match {n}|{n,}|{n,m} times (non-greedy) repeatNM1 '\?' => { if (repeatN > repeatM || repeatM == 0) { throwInvalidRepeat(); } else if (!currentSeq->addRepeat( repeatN, repeatM, ComponentRepeat::REPEAT_NONGREEDY)) { throwInvalidRepeat(); } }; # Match {n}|{n,}|{n,m} times (possessive) repeatNM1 '\+' => { if (repeatN > repeatM || repeatM == 0) { throwInvalidRepeat(); } else if (!currentSeq->addRepeat( repeatN, repeatM, ComponentRepeat::REPEAT_POSSESSIVE)) { throwInvalidRepeat(); } }; # In ignore_space mode, an unescaped # character introduces a # comment that runs until the next newline or the end of the # pattern. '\#' when is_ignore_space => enterNewlineTerminatedComment; # Perl 5.10 Special Backtracking Control Verbs: we support # UTF8/UCP, none of the others '(*' [^)] => { fhold; fcall readVerb; }; # Earlier parser code checked for the terminating NULL and exited # explicitly. '\0' => { assert(0); fbreak; }; ############################################################# # Boundaries ############################################################# # Start of data; also after internal newline in multiline mode '\^' => { auto bound = mode.multiline ? ComponentBoundary::BEGIN_LINE : ComponentBoundary::BEGIN_STRING; currentSeq->addComponent(ue2::make_unique(bound)); }; # End of data (with optional internal newline); also before # internal newline in multiline mode '\$' => { auto bound = mode.multiline ? ComponentBoundary::END_LINE : ComponentBoundary::END_STRING_OPTIONAL_LF; currentSeq->addComponent(ue2::make_unique(bound)); }; # Beginning of data '\\A' => { auto bound = ComponentBoundary::BEGIN_STRING; currentSeq->addComponent(ue2::make_unique(bound)); }; # End of data (with optional internal newline) '\\Z' => { auto bound = ComponentBoundary::END_STRING_OPTIONAL_LF; currentSeq->addComponent(ue2::make_unique(bound)); }; # End of data '\\z' => { auto bound = ComponentBoundary::END_STRING; currentSeq->addComponent(ue2::make_unique(bound)); }; # Word boundary '\\b' => { currentSeq->addComponent( ue2::make_unique(ts - ptr, false, mode)); }; # Non-word boundary '\\B' => { currentSeq->addComponent( ue2::make_unique(ts - ptr, true, mode)); }; ############################################################# # Escaped chars ############################################################# # Tab '\\t' => { addLiteral(currentSeq, '\x09', mode); }; # Newline '\\n' => { addLiteral(currentSeq, '\x0a', mode); }; # Carriage return '\\r' => { addLiteral(currentSeq, '\x0d', mode); }; # Form feed '\\f' => { addLiteral(currentSeq, '\x0c', mode); }; # Bell '\\a' => { addLiteral(currentSeq, '\x07', mode); }; # Escape '\\e' => { addLiteral(currentSeq, '\x1b', mode); }; # Octal escapedOctal0 => { addLiteral(currentSeq, octAccumulator, mode); }; escapedOctal2 => { // If there are enough capturing sub expressions, this may be // a back reference accumulator = parseAsDecimal(octAccumulator); if (accumulator < groupIndex) { currentSeq->addComponent(ue2::make_unique(accumulator)); } else { addEscapedOctal(currentSeq, octAccumulator, mode); } }; # Numeric back reference # everything less than 8 is a straight up back ref, even if # it is a forwards backward reference (aieeee!) # Note that \8 and \9 are the literal chars '8' and '9'. '\\' backRefIdSingle => addNumberedBackRef; # otherwise we need to munge through the possible backref '\\' backRefId => { // if there are enough left parens to this point, back ref if (accumulator < groupIndex) { currentSeq->addComponent(ue2::make_unique(accumulator)); } else { // Otherwise, we interpret the first three digits as an // octal escape, and the remaining characters stand for // themselves as literals. const u8 *s = ts; unsigned int accum = 0; unsigned int oct_digits = 0; assert(*s == '\\'); // token starts at backslash for (++s; s < te && oct_digits < 3; ++oct_digits, ++s) { u8 digit = *s - '0'; if (digit < 8) { accum = digit + accum * 8; } else { break; } } if (oct_digits > 0) { addEscapedOctal(currentSeq, accum, mode); } // And then the rest of the digits, if any, are literal. for (; s < te; ++s) { addLiteral(currentSeq, *s, mode); } } }; backReferenceG => addNumberedBackRef; backReferenceGNegative => addNegativeNumberedBackRef; backReferenceGBracket => addNumberedBackRef; backReferenceGBracket2 => addNegativeNumberedBackRef; backReferenceGBracketName => addNamedBackRef; backReferenceKBracketName => addNamedBackRef; backReferenceKBracketName2 => addNamedBackRef; backReferenceKBracketName3 => addNamedBackRef; backReferenceP => addNamedBackRef; # Oniguruma - either angle braces or single quotes for this one ('\\g<' [^>]*? '>'|'\\g\'' [^\']*? '\'') => { ostringstream str; str << "Onigiruma subroutine call at index " << ts - ptr << " not supported."; throw ParseError(str.str()); }; # Fallthrough: a \g that hasn't been caught by one of the above # is invalid syntax. Without this rule, we would accept /A\g/. '\\g' => { throw LocatedParseError("Invalid reference after \\g"); }; '\\o{' [0-7]+ '}' => { string oct((const char *)ts + 3, te - ts - 4); long int val = strtol(oct.c_str(), nullptr, 8); if ((!mode.utf8 && val > 255) || val > MAX_UNICODE) { throw LocatedParseError("Value in \\o{...} sequence is too large"); } addEscapedOctal(currentSeq, (unichar)val, mode); }; # And for when it goes wrong '\\o' => { throw LocatedParseError("Value in \\o{...} sequence is non-octal or missing braces"); }; # Hex escapedHex => { addEscapedHex(currentSeq, accumulator, mode); }; # Unicode Hex '\\x{' xdigit+ '}' => { string hex((const char *)ts + 3, te - ts - 4); long int val = strtol(hex.c_str(), nullptr, 16); if (val > MAX_UNICODE) { throw LocatedParseError("Value in \\x{...} sequence is too large"); } addEscapedHex(currentSeq, (unichar)val, mode); }; # And for when it goes wrong '\\x{' => { throw LocatedParseError("Value in \\x{...} sequence is non-hex or missing }"); }; # Control characters escapedCtrl => { if (te - ts < 3) { assert(te - ts == 2); throw LocatedParseError(SLASH_C_ERROR); } else { assert(te - ts == 3); addLiteral(currentSeq, decodeCtrl(ts[2]), mode); } }; # A bunch of unsupported (for now) escapes escapedUnsupported => { ostringstream str; str << "'\\" << (char)*(ts + 1) << "' at index " << ts - ptr << " not supported."; throw ParseError(str.str()); }; # Word character '\\w' => { auto cc = generateComponent(CLASS_WORD, false, mode); currentSeq->addComponent(move(cc)); }; # Non word character '\\W' => { auto cc = generateComponent(CLASS_WORD, true, mode); currentSeq->addComponent(move(cc)); }; # Whitespace character '\\s' => { auto cc = generateComponent(CLASS_SPACE, false, mode); currentSeq->addComponent(move(cc)); }; # Non whitespace character '\\S' => { auto cc = generateComponent(CLASS_SPACE, true, mode); currentSeq->addComponent(move(cc)); }; # Digit character '\\d' => { auto cc = generateComponent(CLASS_DIGIT, false, mode); currentSeq->addComponent(move(cc)); }; # Non digit character '\\D' => { auto cc = generateComponent(CLASS_DIGIT, true, mode); currentSeq->addComponent(move(cc)); }; # Horizontal whitespace '\\h' => { auto cc = generateComponent(CLASS_HORZ, false, mode); currentSeq->addComponent(move(cc)); }; # Not horizontal whitespace '\\H' => { auto cc = generateComponent(CLASS_HORZ, true, mode); currentSeq->addComponent(move(cc)); }; # Vertical whitespace '\\v' => { auto cc = generateComponent(CLASS_VERT, false, mode); currentSeq->addComponent(move(cc)); }; # Not vertical whitespace '\\V' => { auto cc = generateComponent(CLASS_VERT, true, mode); currentSeq->addComponent(move(cc)); }; '\\p{' => { assert(!currentCls && !inCharClass); currentCls = getComponentClass(mode); negated = false; fhold; fcall readBracedUCP; }; '\\p' any => { assert(!currentCls && !inCharClass); currentCls = getComponentClass(mode); negated = false; fhold; fcall readUCPSingle; }; '\\P{' => { assert(!currentCls && !inCharClass); currentCls = getComponentClass(mode); negated = true; fhold; fcall readBracedUCP; }; '\\P' any => { assert(!currentCls && !inCharClass); currentCls = getComponentClass(mode); negated = true; fhold; fcall readUCPSingle; }; '\\P' => { throw LocatedParseError("Malformed property"); }; '\\p' => { throw LocatedParseError("Malformed property"); }; # Newline sequence, hairy semantics that we don't do '\\R' => { ostringstream str; str << "\\R at index " << ts - ptr << " not supported."; throw ParseError(str.str()); }; # Reset start of match, also hairy semantics that we don't do '\\K' => { ostringstream str; str << "\\K at index " << ts - ptr << " not supported."; throw ParseError(str.str()); }; # \k without a backref is bugged in PCRE so we have no # idea what our semantics should be on it '\\k' => { ostringstream str; str << "\\k at index " << ts - ptr << " not supported."; throw ParseError(str.str()); }; # \G is more hairy pcre-api stuff, DO NOT WANT '\\G' => { ostringstream str; str << "\\G at index " << ts - ptr << " not supported."; throw ParseError(str.str()); }; '\\X' => { currentSeq->addComponent(ue2::make_unique(ts - ptr, mode)); }; # Fall through general escaped character '\\' any => { addLiteral(currentSeq, *(ts + 1), mode); }; # A backslash with no follower is not allowed '\\' => { assert(ts + 1 == pe); ostringstream str; str << "Unescaped \\ at end of input, index " << ts - ptr << "."; throw ParseError(str.str()); }; ############################################################# # Extended patterns ############################################################# # Comment '\(\?\#' => enterComment; # Match modifiers '\(\?' matchModifiers >resetModifiers ')' => applyModifiers; # Non-capturing group, with flag modifiers '\(\?' matchModifiers >resetModifiers ':' => enterModifiedGroup; # Zero width look ahead assertion '\(\?=' => enterZWLookAhead; # Zero width negative look ahead assertion '\(\?\!' => enterZWNegLookAhead; # Zero width look behind assertion '\(\?\<=' => enterZWLookBehind; # Zero width negative look behind assertion '\(\?\<\!' => enterZWNegLookBehind; # Code (TOTALLY unsupported... for good reason) '\(\?\{' => enterEmbeddedCode; '\(\?\?\{' => enterEmbeddedCode; # Atomic group '\(\?\>' => enterAtomicGroup; # Named capturing groups ( namedGroup1 | namedGroup2 | namedGroup3 ) => enterNamedGroup; # named/numbered subroutine references numberedSubExpression => enterReferenceUnsupported; namedSubExpression => enterReferenceUnsupported; # Conditional reference with a positive lookahead assertion '(?(?=' => { auto a = ue2::make_unique( ComponentAssertion::LOOKAHEAD, ComponentAssertion::POS); ComponentAssertion *a_seq = a.get(); PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(move(a))); PUSH_SEQUENCE; currentSeq = a_seq; }; # Conditional reference with a negative lookahead assertion '(?(?!' => { auto a = ue2::make_unique( ComponentAssertion::LOOKAHEAD, ComponentAssertion::NEG); ComponentAssertion *a_seq = a.get(); PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(move(a))); PUSH_SEQUENCE; currentSeq = a_seq; }; # Conditional reference with a positive lookbehind assertion '(?(?<=' => { auto a = ue2::make_unique( ComponentAssertion::LOOKBEHIND, ComponentAssertion::POS); ComponentAssertion *a_seq = a.get(); PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(move(a))); PUSH_SEQUENCE; currentSeq = a_seq; }; # Conditional reference with a negative lookbehind assertion '(?(? { auto a = ue2::make_unique( ComponentAssertion::LOOKBEHIND, ComponentAssertion::NEG); ComponentAssertion *a_seq = a.get(); PUSH_SEQUENCE; currentSeq = enterSequence(currentSeq, ue2::make_unique(move(a))); PUSH_SEQUENCE; currentSeq = a_seq; }; # Recursive conditional references (unsupported) '(?(R' ( [0-9]+ | ('&' [A-Za-z0-9_]+) ) ? ')' => { throw LocatedParseError("Pattern recursion not supported"); }; # Conditional references # numbered '\(\?\(' (backRefIdSingle | backRefId) ')' => enterNumberedConditionalRef; # named ( namedConditionalRef1 | namedConditionalRef2 | namedConditionalRef3 ) => enterNamedConditionalRef; # Conditions (unsupported) '\(\?\(' => enterConditionUnsupported; # Callouts (unsupported) '\(\?C' [0-9]* '\)' => { ostringstream str; str << "Callout at index " << ts - ptr << " not supported."; throw ParseError(str.str()); }; # Any other char after '(?' is a pattern modifier we don't # recognise. '\(\?' any => { throw LocatedParseError("Unrecognised character after (?"); }; #unicode chars utf8_2c when is_utf8 => { assert(mode.utf8); /* leverage ComponentClass to generate the vertices */ auto cc = getComponentClass(mode); cc->add(readUtf8CodePoint2c(ts)); cc->finalize(); currentSeq->addComponent(move(cc)); }; utf8_3c when is_utf8 => { assert(mode.utf8); /* leverage ComponentClass to generate the vertices */ auto cc = getComponentClass(mode); cc->add(readUtf8CodePoint3c(ts)); cc->finalize(); currentSeq->addComponent(move(cc)); }; utf8_4c when is_utf8 => { assert(mode.utf8); /* leverage ComponentClass to generate the vertices */ auto cc = getComponentClass(mode); cc->add(readUtf8CodePoint4c(ts)); cc->finalize(); currentSeq->addComponent(move(cc)); }; hi_byte when is_utf8 => { assert(mode.utf8); throwInvalidUtf8(); }; ############################################################# # Literal character ############################################################# # literal character whitespace => { if (mode.ignore_space == false) { addLiteral(currentSeq, *ts, mode); } }; any => { addLiteral(currentSeq, *ts, mode); }; *|; prepush { DEBUG_PRINTF("stack %zu top %d\n", stack.size(), top); if ((int)stack.size() == top) { stack.resize(2 * (top + 1)); } } }%% %% write data nofinal; /** \brief Main parser call, returns root Component or nullptr. */ unique_ptr parse(const char *const c_ptr, ParseMode &globalMode) { const u8 * const ptr = (const u8 * const)c_ptr; const u8 *p = ptr; const u8 *pe = ptr + strlen(c_ptr); const u8 *eof = pe; int cs; UNUSED int act; int top; vector stack; const u8 *ts, *te; unichar accumulator = 0; unichar octAccumulator = 0; /* required as we are also accumulating for * back ref when looking for octals */ unsigned repeatN = 0; unsigned repeatM = 0; string label; ParseMode mode = globalMode; ParseMode newMode; bool negated = false; bool inComment = false; // Stack of sequences and flags used to store state when we enter // sub-sequences. vector sequences; // Index of the next capturing group. Note that zero is reserved for the // root sequence. unsigned groupIndex = 1; // Set storing group names that are currently in use. ue2::flat_set groupNames; // Root sequence. unique_ptr rootSeq = ue2::make_unique(); rootSeq->setCaptureIndex(0); // Current sequence being appended to ComponentSequence *currentSeq = rootSeq.get(); // The current character class being appended to. This is used as the // accumulator for both character class and UCP properties. unique_ptr currentCls; // True if the machine is currently inside a character class, i.e. square // brackets [..]. bool inCharClass = false; // True if the machine is inside a character class but it has not processed // any "real" elements yet, i.e. it's still processing meta-characters like // '^'. bool inCharClassEarly = false; // Location at which the current character class began. const u8 *currentClsBegin = p; const u8 *ucp_start_p = p; /* for (*UCP) verb */ // We throw exceptions on various parsing failures beyond this point: we // use a try/catch block here to clean up our allocated memory before we // re-throw the exception to the caller. try { // Embed the Ragel machine here %% write init; %% write exec; if (p != pe && *p != '\0') { // didn't make it to the end of our input, but we didn't throw a ParseError? assert(0); ostringstream str; str << "Parse error at index " << (p - ptr) << "."; throw ParseError(str.str()); } if (currentCls) { assert(inCharClass); assert(currentClsBegin); ostringstream oss; oss << "Unterminated character class starting at index " << currentClsBegin - ptr << "."; throw ParseError(oss.str()); } if (inComment) { throw ParseError("Unterminated comment."); } if (!sequences.empty()) { ostringstream str; str << "Missing close parenthesis for group started at index " << sequences.back().seqOffset << "."; throw ParseError(str.str()); } // Unlikely, but possible if (groupIndex > 65535) { throw ParseError("The maximum number of capturing subexpressions is 65535."); } // Finalize the top-level sequence, which will take care of any // top-level alternation. currentSeq->finalize(); assert(currentSeq == rootSeq.get()); // Ensure that all references are valid. checkReferences(*rootSeq, groupIndex, groupNames); return move(rootSeq); } catch (LocatedParseError &error) { if (ts >= ptr && ts <= pe) { error.locate(ts - ptr); } else { error.locate(0); } throw; } } } // namespace ue2 hyperscan-4.4.1/src/parser/position_dump.h0000644000175000017500000000421513055426554021426 0ustar sleuthkidsleuthkid/* * 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 POSITION_DUMP_H #define POSITION_DUMP_H #include namespace ue2 { #ifdef DUMP_SUPPORT // implemented in buildstate.cpp void dump(std::ostream &os, const PositionInfo &p); #endif #if defined(DUMP_SUPPORT) || defined(DEBUG) template static UNUSED std::string dumpPositions(const Iterator &begin, const Iterator &end) { std::ostringstream oss; oss << '['; for (Iterator i = begin; i != end; ++i) { if (i != begin) { oss << ' '; } dump(oss, *i); } oss << ']'; return oss.str(); } #endif } // namespace ue2 #endif /* POSITION_DUMP_H */ hyperscan-4.4.1/src/parser/ComponentAtomicGroup.h0000644000175000017500000000454013055426554022652 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Atomic groups (?>...) */ #ifndef _COMPONENTATOMICGROUP_H_ #define _COMPONENTATOMICGROUP_H_ #include "ComponentSequence.h" namespace ue2 { // The atomic group component is a subclass of sequence that is only buildable // in prefilter mode, where we treat it as a standard sequence. class ComponentAtomicGroup : public ComponentSequence { friend class DumpVisitor; public: ComponentAtomicGroup() {} ~ComponentAtomicGroup() override {} ComponentAtomicGroup *clone() const override; Component *accept(ComponentVisitor &v) override; void accept(ConstComponentVisitor &v) const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/dump.h0000644000175000017500000000360313055426554017502 0ustar sleuthkidsleuthkid/* * 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 PARSER_DUMP_H_ #define PARSER_DUMP_H_ #ifdef DUMP_SUPPORT #include namespace ue2 { class Component; /** \brief Dump a text representation of the given component tree. Only * available in DUMP_SUPPORT builds. */ void dumpTree(std::ostream &os, const Component *const root); } // namespace ue2 #endif // DUMP_SUPPORT #endif // PARSER_DUMP_H_ hyperscan-4.4.1/src/parser/ucp_table.cpp0000644000175000017500000001054213055426554021026 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "Utf8ComponentClass.h" #include using namespace std; namespace ue2 { #define UCP_FN(cat) \ CodePointSet getUcp##cat(void) { \ CodePointSet rv; \ for (u32 i = 0; i < ARRAY_LENGTH(ucp_##cat##_def); i += 2) { \ rv.setRange(ucp_##cat##_def[i], ucp_##cat##_def[i + 1]); \ } \ return rv; \ } struct unicase { unichar base; unichar caseless; }; } // namespace ue2 #define UCP_TABLE_DEFINE_FN #include "ucp_table.h" namespace ue2 { static bool operator<(const unicase &a, const unicase &b) { if (a.base < b.base) { return true; } if (a.base > b.base) { return false; } return a.caseless < b.caseless; } void make_caseless(CodePointSet *cps) { assert(cps); DEBUG_PRINTF("hello\n"); // Cheap optimisation: if we are empty or a dot, we're already caseless. if (cps->begin() == cps->end()) { DEBUG_PRINTF("empty\n"); return; } if (lower(*cps->begin()) == 0 && upper(*cps->begin()) == MAX_UNICODE) { DEBUG_PRINTF("dot\n"); return; } CodePointSet base = *cps; auto uc_begin = begin(ucp_caseless_def); auto uc_end = end(ucp_caseless_def); DEBUG_PRINTF("uc len %zd\n", distance(uc_begin, uc_end)); for (const auto &elem : base) { unichar b = lower(elem); unichar e = upper(elem) + 1; for (; b < e; b++) { DEBUG_PRINTF("decasing %x\n", b); unicase test = {b, 0}; /* NUL is not a caseless version of anything, * so we are ok */ uc_begin = lower_bound(uc_begin, uc_end, test); if (uc_begin == uc_end) { DEBUG_PRINTF("EOL\n"); return; } while (uc_begin != uc_end && uc_begin->base == b) { DEBUG_PRINTF("at {%x,%x}\n", uc_begin->base, uc_begin->caseless); cps->set(uc_begin->caseless); ++uc_begin; } } } } /** \brief Flip the case of the codepoint in c, if possible. * * Note that this assumes a one-to-one case mapping, which (though not * realistic) is what PCRE does. */ bool flip_case(unichar *c) { assert(c); const unicase test = { *c, 0 }; const auto uc_begin = begin(ucp_caseless_def); const auto uc_end = end(ucp_caseless_def); const auto f = lower_bound(uc_begin, uc_end, test); if (f != uc_end && f->base == *c) { DEBUG_PRINTF("flipped c=%x to %x\n", *c, f->caseless); *c = f->caseless; return true; } return false; } } // namespace ue2 hyperscan-4.4.1/src/parser/utf8_validate.h0000644000175000017500000000341413055426554021274 0ustar sleuthkidsleuthkid/* * 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 PARSER_UTF8_VALIDATE_H #define PARSER_UTF8_VALIDATE_H namespace ue2 { /** \brief Validate that the given expression is well-formed UTF-8. */ bool isValidUtf8(const char *expression); } // namespace ue2 #endif // PARSER_UTF8_VALIDATE_H hyperscan-4.4.1/src/parser/ComponentWordBoundary.h0000644000175000017500000000634313055426554023043 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Word Boundary Assertion (\\b or \\B) */ #ifndef _RE_COMPONENTWORDBOUNDARY_H_ #define _RE_COMPONENTWORDBOUNDARY_H_ #include "Component.h" #include "position.h" namespace ue2 { struct ParseMode; /** \brief Encapsulates a positive (\\b) or negative (\\B) word boundary * assertion. */ class ComponentWordBoundary : public Component { friend class DumpVisitor; friend class PrintVisitor; friend class UnsupportedVisitor; public: ComponentWordBoundary(u32 loc, bool negated, const ParseMode &mode); ~ComponentWordBoundary() override; ComponentWordBoundary *clone() const override; Component *accept(ComponentVisitor &v) override { Component *c = v.visit(this); v.post(this); return c; } void accept(ConstComponentVisitor &v) const override { v.pre(*this); v.during(*this); v.post(*this); } std::vector first() const override; std::vector last() const override; bool empty() const override; bool repeatable() const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; void setPrefilter(bool p) { prefilter = p; } private: u32 loc; //!< location in pattern for error reporting. Position position; bool negated; bool ucp; bool prefilter; //!< set by PrefilterVisitor, this is ugly ComponentWordBoundary(const ComponentWordBoundary &other) : Component(other), loc(other.loc), position(other.position), negated(other.negated), ucp(other.ucp), prefilter(other.prefilter) {} }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/ComponentEmpty.h0000644000175000017500000000534713055426554021525 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Represents an empty regex element, like (?m) */ #ifndef PARSER_COMPONENT_EMPTY_H_ #define PARSER_COMPONENT_EMPTY_H_ #include "Component.h" namespace ue2 { class ComponentEmpty : public Component { friend class DumpVisitor; public: ComponentEmpty(); ~ComponentEmpty() override; ComponentEmpty *clone() const override; Component *accept(ComponentVisitor &v) override { Component *c = v.visit(this); v.post(this); return c; } void accept(ConstComponentVisitor &v) const override { v.pre(*this); v.during(*this); v.post(*this); } std::vector first() const override; std::vector last() const override; bool empty() const override; bool vacuous_everywhere() const override; bool repeatable() const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; bool checkEmbeddedStartAnchor(bool at_start) const override; bool checkEmbeddedEndAnchor(bool at_end) const override; }; } // namespace ue2 #endif // PARSER_COMPONENT_EMPTY_H_ hyperscan-4.4.1/src/parser/ComponentWordBoundary.cpp0000644000175000017500000000737613055426554023405 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Word Boundary Assertion (\\b or \\B) */ #include "ComponentWordBoundary.h" #include "buildstate.h" #include "parse_error.h" #include "Parser.h" #include "position_info.h" #include "nfagraph/ng_builder.h" using namespace std; namespace ue2 { ComponentWordBoundary::ComponentWordBoundary(u32 loc_in, bool neg, const ParseMode &mode) : loc(loc_in), position(GlushkovBuildState::POS_UNINITIALIZED), negated(neg), ucp(mode.ucp), prefilter(false) {} ComponentWordBoundary::~ComponentWordBoundary() { // empty } ComponentWordBoundary * ComponentWordBoundary::clone() const { return new ComponentWordBoundary(*this); } vector ComponentWordBoundary::first() const { vector firsts; firsts.push_back(position); return firsts; } vector ComponentWordBoundary::last() const { // Same as firsts return first(); } bool ComponentWordBoundary::empty() const { return false; } bool ComponentWordBoundary::repeatable() const { return false; } void ComponentWordBoundary::notePositions(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); position = builder.makePositions(1); if (ucp) { assert(prefilter); // only in prefiltering mode! if (negated) { builder.setAssertFlag(position, POS_FLAG_ASSERT_WORD_TO_WORD_UCP | POS_FLAG_ASSERT_NONWORD_TO_NONWORD_UCP); } else { builder.setAssertFlag(position, POS_FLAG_ASSERT_WORD_TO_NONWORD_UCP | POS_FLAG_ASSERT_NONWORD_TO_WORD_UCP); } } else { if (negated) { builder.setAssertFlag(position, POS_FLAG_ASSERT_WORD_TO_WORD | POS_FLAG_ASSERT_NONWORD_TO_NONWORD); } else { builder.setAssertFlag(position, POS_FLAG_ASSERT_WORD_TO_NONWORD | POS_FLAG_ASSERT_NONWORD_TO_WORD); } } recordPosBounds(position, position + 1); } void ComponentWordBoundary::buildFollowSet(GlushkovBuildState&, const vector&) { // No internal connections, nowt to do } } // namespace ue2 hyperscan-4.4.1/src/parser/ConstComponentVisitor.cpp0000644000175000017500000000604013055426554023417 0ustar sleuthkidsleuthkid/* * 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. */ #include "ConstComponentVisitor.h" #include "AsciiComponentClass.h" #include "ComponentAlternation.h" #include "ComponentAssertion.h" #include "ComponentAtomicGroup.h" #include "ComponentBackReference.h" #include "ComponentBoundary.h" #include "ComponentByte.h" #include "ComponentCondReference.h" #include "ComponentClass.h" #include "ComponentEmpty.h" #include "ComponentEUS.h" #include "ComponentRepeat.h" #include "ComponentSequence.h" #include "ComponentWordBoundary.h" #include "Utf8ComponentClass.h" namespace ue2 { ConstComponentVisitor::~ConstComponentVisitor() { // empty } // Default implementations. DefaultConstComponentVisitor::DefaultConstComponentVisitor() {} DefaultConstComponentVisitor::~DefaultConstComponentVisitor() {} #define DEFAULT_FUNCS(comp) \ void DefaultConstComponentVisitor::pre(const comp &) {} \ void DefaultConstComponentVisitor::during(const comp &) {} \ void DefaultConstComponentVisitor::post(const comp &) {} DEFAULT_FUNCS(AsciiComponentClass) DEFAULT_FUNCS(ComponentAlternation) DEFAULT_FUNCS(ComponentAssertion) DEFAULT_FUNCS(ComponentAtomicGroup) DEFAULT_FUNCS(ComponentBackReference) DEFAULT_FUNCS(ComponentBoundary) DEFAULT_FUNCS(ComponentByte) DEFAULT_FUNCS(ComponentCondReference) DEFAULT_FUNCS(ComponentEmpty) DEFAULT_FUNCS(ComponentEUS) DEFAULT_FUNCS(ComponentRepeat) DEFAULT_FUNCS(ComponentSequence) DEFAULT_FUNCS(ComponentWordBoundary) DEFAULT_FUNCS(UTF8ComponentClass) } // namespace ue2 hyperscan-4.4.1/src/parser/ComponentSequence.cpp0000644000175000017500000002554313055426554022532 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Sequence of Component objects. */ #include "ComponentSequence.h" #include "buildstate.h" #include "ComponentAlternation.h" #include "ComponentRepeat.h" #include "Parser.h" #include "ue2common.h" #include "parse_error.h" #include "position_dump.h" #include "position_info.h" #include "nfagraph/ng_builder.h" #include "util/container.h" #include "util/make_unique.h" #include #include using namespace std; namespace ue2 { ComponentSequence::ComponentSequence() : capture_index(NOT_CAPTURED) {} ComponentSequence::~ComponentSequence() {} ComponentSequence::ComponentSequence(const ComponentSequence &other) : Component(other), capture_index(other.capture_index) { // Deep copy children. for (const auto &c : other.children) { assert(c); children.push_back(unique_ptr(c->clone())); } if (other.alternation) { const ComponentAlternation &c = *other.alternation; alternation.reset(c.clone()); } } ComponentSequence *ComponentSequence::clone() const { return new ComponentSequence(*this); } Component *ComponentSequence::accept(ComponentVisitor &v) { assert(!alternation); // Sequence must be finalized first. Component *c = v.visit(this); if (c != this) { v.post(this); return c; } for (auto i = children.begin(), e = children.end(); i != e; ++i) { Component *child = i->get(); c = (*i)->accept(v); if (c != child) { // Child has been replaced (new Component pointer) or we've been // instructed to delete it (null). i->reset(c); } } // Remove deleted children. children.erase(remove(children.begin(), children.end(), nullptr), children.end()); v.post(this); return this; } void ComponentSequence::accept(ConstComponentVisitor &v) const { assert(!alternation); // Sequence must be finalized first. v.pre(*this); for (auto i = children.begin(), e = children.end(); i != e; ++i) { (*i)->accept(v); if (i + 1 != e) { v.during(*this); } } v.post(*this); } void ComponentSequence::addComponent(unique_ptr comp) { children.push_back(move(comp)); } bool ComponentSequence::addRepeat(u32 min, u32 max, ComponentRepeat::RepeatType type) { if (children.empty() || min > max || max == 0) { return false; } // We can't apply a repeat to some types of component. assert(children.back()); if (!children.back()->repeatable()) { return false; } children.back() = makeComponentRepeat(move(children.back()), min, max, type); assert(children.back()); return true; } void ComponentSequence::addAlternation() { if (!alternation) { alternation = ue2::make_unique(); } auto seq = ue2::make_unique(); seq->children.swap(children); alternation->append(move(seq)); } void ComponentSequence::finalize() { if (alternation) { addAlternation(); assert(children.empty()); children.push_back(move(alternation)); alternation = nullptr; } } vector ComponentSequence::first() const { vector firsts, subfirsts; for (const auto &c : children) { subfirsts = c->first(); replaceEpsilons(firsts, subfirsts); if (!c->empty()) { break; } } if (firsts.empty()) { DEBUG_PRINTF("trivial empty sequence %zu\n", firsts.size()); assert(children.empty()); firsts.push_back(GlushkovBuildState::POS_EPSILON); } DEBUG_PRINTF("%zu firsts\n", firsts.size()); return firsts; } namespace { struct eps_info { eps_info() : flags(0U) {} u32 flags; }; } static void epsilonVisit(vector *info, const vector &f) { vector out; out.reserve(info->size()); set seen_flags; assert(!info->empty()); for (auto eps = find(f.begin(), f.end(), GlushkovBuildState::POS_EPSILON); eps != f.end(); eps = find(eps + 1, f.end(), GlushkovBuildState::POS_EPSILON)) { for (auto it = info->begin(); it != info->end(); ++it) { u32 flags = it->flags | eps->flags; if (contains(seen_flags, flags)) { continue; } out.push_back(*it); out.back().flags = flags; seen_flags.insert(flags); } } info->swap(out); assert(!info->empty()); } static void applyEpsilonVisits(vector &lasts, const vector &eps_visits) { vector out; out.reserve(lasts.size() * eps_visits.size()); for (const auto &last : lasts) { for (const auto &e : eps_visits) { out.push_back(last); out.back().flags |= e.flags; } } cleanupPositions(out); lasts.swap(out); } vector ComponentSequence::last() const { vector lasts, sublasts; vector visits(1); auto i = children.rbegin(), e = children.rend(); for (; i != e; ++i) { sublasts = (*i)->last(); applyEpsilonVisits(sublasts, visits); lasts.insert(lasts.end(), sublasts.begin(), sublasts.end()); if ((*i)->empty()) { // this epsilon's flags should propagate to subsequent lasts' // enter/exit lists epsilonVisit(&visits, (*i)->first()); } else { break; } } DEBUG_PRINTF("lasts = %s\n", dumpPositions(lasts.begin(), lasts.end()).c_str()); return lasts; } bool ComponentSequence::empty(void) const { // a sequence can be empty if all its subcomponents can be empty for (const auto &c : children) { if (!c->empty()) { return false; } } return true; } void ComponentSequence::notePositions(GlushkovBuildState &bs) { u32 pb = bs.getBuilder().numVertices(); for (auto &c : children) { c->notePositions(bs); } recordPosBounds(pb, bs.getBuilder().numVertices()); } void ComponentSequence::buildFollowSet(GlushkovBuildState &bs, const vector &lastPos) { DEBUG_PRINTF("sequence of %zu components\n", children.size()); // If no components, no work to do. if (children.empty()) { return; } // First element children.front()->buildFollowSet(bs, lastPos); if (children.size() == 1) { // If our sequence contains precisely one component, then we've done // all our work. Hooking up its firsts and lasts will be done by our // parent component. return; } // Remaining elements, wiring last to first in sequence. vector prevLasts = children.front()->last(); for (auto it = next(children.begin()), ite = children.end(); it != ite; ++it) { assert(*it); Component &c = *(*it); // Build subcomponent follow set c.buildFollowSet(bs, prevLasts); // FIRST(curr) vector currFirsts(c.first()); // LAST(prev) => FIRST(curr) DEBUG_PRINTF("connecting lasts (|| %zu) to firsts of comp %zd\n", prevLasts.size(), it - children.begin()); bs.connectRegions(prevLasts, currFirsts); // Generate a new LAST(prev) for the next iteration; either c->last() // on its own if it can't be empty or c->last unioned with the previous // last if c can be empty vector currLasts(c.last()); if (!c.empty()) { // Current component can't be empty, so use its lasts only prevLasts.swap(currLasts); DEBUG_PRINTF("swapped lasts\n"); } else { // Add current lasts to previous lasts DEBUG_PRINTF("doing stuff for empty comp\n"); prevLasts.insert(prevLasts.end(), currLasts.begin(), currLasts.end()); DEBUG_PRINTF("done stuff for empty comp\n"); } } } bool ComponentSequence::checkEmbeddedStartAnchor(bool at_start) const { for (const auto &c : children) { at_start = c->checkEmbeddedStartAnchor(at_start); } return at_start; } bool ComponentSequence::checkEmbeddedEndAnchor(bool at_end) const { // Note reversed ordering. for (auto i = children.rbegin(), e = children.rend(); i != e; ++i) { at_end = (*i)->checkEmbeddedEndAnchor(at_end); } return at_end; } bool ComponentSequence::vacuous_everywhere() const { for (const auto &c : children) { if (!c->vacuous_everywhere()) { return false; } } return true; } void ComponentSequence::optimise(bool connected_to_sds) { DEBUG_PRINTF("opt %d\n", (int)connected_to_sds); for (u32 i = 0; i < children.size();) { DEBUG_PRINTF("opt %u: ctsds: %d\n", i, (int)connected_to_sds); Component &sub = *children[i]; sub.optimise(connected_to_sds); bool vacuous = sub.vacuous_everywhere(); if (connected_to_sds && vacuous) { DEBUG_PRINTF("delete opt %u\n", i); auto it = children.begin() + i; children.erase(it); continue; } connected_to_sds = connected_to_sds && vacuous; i++; } } } // namespace ue2 hyperscan-4.4.1/src/parser/ComponentByte.cpp0000644000175000017500000000474313055426554021664 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Single bytes (\\C metachar) */ #include "ComponentByte.h" #include "buildstate.h" #include "position.h" #include "position_info.h" #include "nfagraph/ng_builder.h" #include "util/charreach.h" using namespace std; namespace ue2 { ComponentByte::ComponentByte() : position(GlushkovBuildState::POS_UNINITIALIZED) {} ComponentByte::~ComponentByte() {} ComponentByte *ComponentByte::clone() const { return new ComponentByte(*this); } vector ComponentByte::first() const { return vector(1, PositionInfo(position)); } vector ComponentByte::last() const { return vector(1, PositionInfo(position)); } void ComponentByte::notePositions(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); position = builder.makePositions(1); builder.addCharReach(position, CharReach::dot()); builder.setNodeReportID(position, 0 /* offset adj */); } } // namespace ue2 hyperscan-4.4.1/src/parser/ComponentClass.h0000644000175000017500000002023313055426554021463 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Character classes and their mnemonics. */ #ifndef COMPONENTCLASS_H #define COMPONENTCLASS_H #include #include #include #include "Component.h" #include "Parser.h" #include "util/charreach.h" #include "util/unicode_def.h" #include "ue2common.h" namespace ue2 { enum PredefinedClass { CLASS_ALNUM, CLASS_ALPHA, CLASS_ANY, /* dot, not quite any when not in dotall mode */ CLASS_ASCII, CLASS_BLANK, CLASS_CNTRL, CLASS_DIGIT, CLASS_GRAPH, CLASS_HORZ, CLASS_LOWER, CLASS_PRINT, CLASS_PUNCT, CLASS_SPACE, /* has vertical tab */ CLASS_UPPER, CLASS_VERT, CLASS_WORD, CLASS_XDIGIT, CLASS_XGRAPH, /* [:graph:] in UCP mode */ CLASS_XPRINT, /* [:print:] in UCP mode */ CLASS_XPUNCT, /* [:punct:] in UCP mode */ CLASS_UCP_C, CLASS_UCP_CC, CLASS_UCP_CF, CLASS_UCP_CN, /* unallocated code points */ CLASS_UCP_CO, CLASS_UCP_CS, /* does not contain valid unicode codepoints */ CLASS_UCP_L, CLASS_UCP_LL, CLASS_UCP_LM, CLASS_UCP_LO, CLASS_UCP_LT, CLASS_UCP_LU, CLASS_UCP_L_AND, /* L& = LL+LU+LT */ CLASS_UCP_M, CLASS_UCP_MC, CLASS_UCP_ME, CLASS_UCP_MN, CLASS_UCP_N, CLASS_UCP_ND, CLASS_UCP_NL, CLASS_UCP_NO, CLASS_UCP_P, CLASS_UCP_PC, CLASS_UCP_PD, CLASS_UCP_PE, CLASS_UCP_PF, CLASS_UCP_PI, CLASS_UCP_PO, CLASS_UCP_PS, CLASS_UCP_S, CLASS_UCP_SC, CLASS_UCP_SK, CLASS_UCP_SM, CLASS_UCP_SO, CLASS_UCP_Z, CLASS_UCP_ZL, CLASS_UCP_ZP, CLASS_UCP_ZS, CLASS_UCP_XAN, CLASS_UCP_XPS, /* CLASS_SPACE */ CLASS_UCP_XSP, CLASS_UCP_XWD, CLASS_SCRIPT_ARABIC, CLASS_SCRIPT_ARMENIAN, CLASS_SCRIPT_AVESTAN, CLASS_SCRIPT_BALINESE, CLASS_SCRIPT_BAMUM, CLASS_SCRIPT_BATAK, CLASS_SCRIPT_BENGALI, CLASS_SCRIPT_BOPOMOFO, CLASS_SCRIPT_BRAHMI, CLASS_SCRIPT_BRAILLE, CLASS_SCRIPT_BUGINESE, CLASS_SCRIPT_BUHID, CLASS_SCRIPT_CANADIAN_ABORIGINAL, CLASS_SCRIPT_CARIAN, CLASS_SCRIPT_CHAM, CLASS_SCRIPT_CHEROKEE, CLASS_SCRIPT_COMMON, CLASS_SCRIPT_COPTIC, CLASS_SCRIPT_CUNEIFORM, CLASS_SCRIPT_CYPRIOT, CLASS_SCRIPT_CYRILLIC, CLASS_SCRIPT_DESERET, CLASS_SCRIPT_DEVANAGARI, CLASS_SCRIPT_EGYPTIAN_HIEROGLYPHS, CLASS_SCRIPT_ETHIOPIC, CLASS_SCRIPT_GEORGIAN, CLASS_SCRIPT_GLAGOLITIC, CLASS_SCRIPT_GOTHIC, CLASS_SCRIPT_GREEK, CLASS_SCRIPT_GUJARATI, CLASS_SCRIPT_GURMUKHI, CLASS_SCRIPT_HAN, CLASS_SCRIPT_HANGUL, CLASS_SCRIPT_HANUNOO, CLASS_SCRIPT_HEBREW, CLASS_SCRIPT_HIRAGANA, CLASS_SCRIPT_IMPERIAL_ARAMAIC, CLASS_SCRIPT_INHERITED, CLASS_SCRIPT_INSCRIPTIONAL_PAHLAVI, CLASS_SCRIPT_INSCRIPTIONAL_PARTHIAN, CLASS_SCRIPT_JAVANESE, CLASS_SCRIPT_KAITHI, CLASS_SCRIPT_KANNADA, CLASS_SCRIPT_KATAKANA, CLASS_SCRIPT_KAYAH_LI, CLASS_SCRIPT_KHAROSHTHI, CLASS_SCRIPT_KHMER, CLASS_SCRIPT_LAO, CLASS_SCRIPT_LATIN, CLASS_SCRIPT_LEPCHA, CLASS_SCRIPT_LIMBU, CLASS_SCRIPT_LINEAR_B, CLASS_SCRIPT_LISU, CLASS_SCRIPT_LYCIAN, CLASS_SCRIPT_LYDIAN, CLASS_SCRIPT_MALAYALAM, CLASS_SCRIPT_MANDAIC, CLASS_SCRIPT_MEETEI_MAYEK, CLASS_SCRIPT_MONGOLIAN, CLASS_SCRIPT_MYANMAR, CLASS_SCRIPT_NEW_TAI_LUE, CLASS_SCRIPT_NKO, CLASS_SCRIPT_OGHAM, CLASS_SCRIPT_OL_CHIKI, CLASS_SCRIPT_OLD_ITALIC, CLASS_SCRIPT_OLD_PERSIAN, CLASS_SCRIPT_OLD_SOUTH_ARABIAN, CLASS_SCRIPT_OLD_TURKIC, CLASS_SCRIPT_ORIYA, CLASS_SCRIPT_OSMANYA, CLASS_SCRIPT_PHAGS_PA, CLASS_SCRIPT_PHOENICIAN, CLASS_SCRIPT_REJANG, CLASS_SCRIPT_RUNIC, CLASS_SCRIPT_SAMARITAN, CLASS_SCRIPT_SAURASHTRA, CLASS_SCRIPT_SHAVIAN, CLASS_SCRIPT_SINHALA, CLASS_SCRIPT_SUNDANESE, CLASS_SCRIPT_SYLOTI_NAGRI, CLASS_SCRIPT_SYRIAC, CLASS_SCRIPT_TAGALOG, CLASS_SCRIPT_TAGBANWA, CLASS_SCRIPT_TAI_LE, CLASS_SCRIPT_TAI_THAM, CLASS_SCRIPT_TAI_VIET, CLASS_SCRIPT_TAMIL, CLASS_SCRIPT_TELUGU, CLASS_SCRIPT_THAANA, CLASS_SCRIPT_THAI, CLASS_SCRIPT_TIBETAN, CLASS_SCRIPT_TIFINAGH, CLASS_SCRIPT_UGARITIC, CLASS_SCRIPT_VAI, CLASS_SCRIPT_YI, CLASS_UCP_ANY }; CharReach getPredefinedCharReach(PredefinedClass c, const ParseMode &mode); class ComponentClass; class NFABuilder; /* Caller is responsible for lifecycle management, class finalized */ std::unique_ptr generateComponent(PredefinedClass c, bool negated, const ParseMode &mode); /* Caller is responsible for lifecycle management, class open */ std::unique_ptr getComponentClass(const ParseMode &mode); /** Common case: generate a component for a single literal character, possibly * in caseless mode. Caller is responsible for lifecycle management. */ std::unique_ptr getLiteralComponentClass(unsigned char c, bool nocase); class ComponentClass : public Component { friend class DumpVisitor; protected: explicit ComponentClass(const ParseMode &mode_in); public: ~ComponentClass() override; ComponentClass *clone() const override = 0; Component *accept(ComponentVisitor &v) override = 0; void accept(ConstComponentVisitor &v) const override = 0; /** \brief True if the class contains no members (i.e. it will not match * against anything). This function can only be called on a finalized * class. * * Note: This is a different concept to Component::empty. */ virtual bool class_empty(void) const = 0; virtual void add(PredefinedClass c, bool negated) = 0; virtual void add(unichar c) = 0; /* may throw LocatedParseError */ void addDash(void); void negate(void); virtual void finalize(void) = 0; bool isNegated() const { return m_negate; } std::vector first() const override = 0; std::vector last() const override = 0; bool empty() const override { return false; } /* always 1 codepoint wide */ void notePositions(GlushkovBuildState &bs) override = 0; void buildFollowSet(GlushkovBuildState &bs, const std::vector &) override = 0; protected: bool m_negate; const ParseMode mode; bool in_cand_range; unichar range_start; bool finalized; virtual void createRange(unichar) = 0; // Protected copy ctor. Use clone instead. ComponentClass(const ComponentClass &other) : Component(other), m_negate(other.m_negate), mode(other.mode), in_cand_range(other.in_cand_range), range_start(other.range_start), finalized(other.finalized) {} }; } // namespace ue2 #endif // COMPONENTCLASS_H hyperscan-4.4.1/src/parser/ComponentClass.cpp0000644000175000017500000003510113055426554022016 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Character classes and their mnemonics. */ #include "Parser.h" #include "ComponentClass.h" #include "AsciiComponentClass.h" #include "ucp_table.h" #include "Utf8ComponentClass.h" #include "util/charreach.h" #include "util/make_unique.h" #include using namespace std; namespace ue2 { static CharReach to_cr(const CodePointSet &cps) { CharReach cr; for (const auto &cp : cps) { if (lower(cp) >= CharReach::npos) { break; } cr.setRange(lower(cp), MIN(upper(cp), CharReach::npos - 1)); } return cr; } CharReach getPredefinedCharReach(PredefinedClass c, const ParseMode &mode) { const CharReach lower('a', 'z'); const CharReach upper('A', 'Z'); const CharReach number('0', '9'); switch (c) { case CLASS_ALNUM: return lower | upper | number; case CLASS_ALPHA: return lower | upper; case CLASS_ANY: if (mode.dotall) { return ~CharReach(); } else { return ~CharReach('\n'); } case CLASS_ASCII: return CharReach(0, 127); case CLASS_BLANK: return CharReach(" \t"); case CLASS_CNTRL: return CharReach(0, 31) | CharReach(127 /* del */); case CLASS_DIGIT: return number; case CLASS_GRAPH: return CharReach(0x21, 0x7e); case CLASS_XGRAPH: return to_cr(getPredefinedCodePointSet(c, mode)); case CLASS_HORZ: return CharReach("\x09\x20\xA0"); case CLASS_LOWER: if (mode.caseless) { return lower | upper; } else { return lower; } case CLASS_PRINT: return CharReach(0x20, 0x7e); case CLASS_XPRINT: return to_cr(getPredefinedCodePointSet(c, mode)); case CLASS_PUNCT: return CharReach(0x21, '0' - 1) | CharReach('9' + 1, 'A' - 1) | CharReach('Z' + 1, 'a' - 1) | CharReach('z' + 1, 126); case CLASS_XPUNCT: return to_cr(getPredefinedCodePointSet(c, mode)); case CLASS_SPACE: return CharReach("\x09\x0a\x0c\x0b\x0d\x20"); case CLASS_UPPER: if (mode.caseless) { return lower | upper; } else { return upper; } case CLASS_VERT: return CharReach("\x0a\x0b\x0c\x0d\x85"); case CLASS_WORD: return lower | upper | number | CharReach('_'); case CLASS_XDIGIT: return CharReach("0123456789abcdefABCDEF"); case CLASS_UCP_C: return to_cr(getUcpC()); case CLASS_UCP_CC: return to_cr(getUcpCc()); case CLASS_UCP_CF: return to_cr(getUcpCf()); case CLASS_UCP_CN: return to_cr(getUcpCn()); case CLASS_UCP_CO: return to_cr(getUcpCo()); case CLASS_UCP_CS: return to_cr(getUcpCs()); case CLASS_UCP_L: return to_cr(getUcpL()); case CLASS_UCP_L_AND: return to_cr(getUcpL_and()); case CLASS_UCP_LL: return to_cr(getUcpLl()); case CLASS_UCP_LM: return to_cr(getUcpLm()); case CLASS_UCP_LO: return to_cr(getUcpLo()); case CLASS_UCP_LT: return to_cr(getUcpLt()); case CLASS_UCP_LU: return to_cr(getUcpLu()); case CLASS_UCP_M: return to_cr(getUcpM()); case CLASS_UCP_MC: return to_cr(getUcpMc()); case CLASS_UCP_ME: return to_cr(getUcpMe()); case CLASS_UCP_MN: return to_cr(getUcpMn()); case CLASS_UCP_N: return to_cr(getUcpN()); case CLASS_UCP_ND: return to_cr(getUcpNd()); case CLASS_UCP_NL: return to_cr(getUcpNl()); case CLASS_UCP_NO: return to_cr(getUcpNo()); case CLASS_UCP_P: return to_cr(getUcpP()); case CLASS_UCP_PC: return to_cr(getUcpPc()); case CLASS_UCP_PD: return to_cr(getUcpPd()); case CLASS_UCP_PE: return to_cr(getUcpPe()); case CLASS_UCP_PF: return to_cr(getUcpPf()); case CLASS_UCP_PI: return to_cr(getUcpPi()); case CLASS_UCP_PO: return to_cr(getUcpPo()); case CLASS_UCP_PS: return to_cr(getUcpPs()); case CLASS_UCP_S: return to_cr(getUcpS()); case CLASS_UCP_SC: return to_cr(getUcpSc()); case CLASS_UCP_SK: return to_cr(getUcpSk()); case CLASS_UCP_SM: return to_cr(getUcpSm()); case CLASS_UCP_SO: return to_cr(getUcpSo()); case CLASS_UCP_XAN: return to_cr(getUcpXan()); case CLASS_UCP_XPS: case CLASS_UCP_XSP: return getPredefinedCharReach(CLASS_VERT, mode) | getPredefinedCharReach(CLASS_HORZ, mode); case CLASS_UCP_XWD: return to_cr(getUcpXwd()); case CLASS_UCP_Z: return to_cr(getUcpZ()); case CLASS_UCP_ZL: return to_cr(getUcpZl()); case CLASS_UCP_ZP: return to_cr(getUcpZp()); case CLASS_UCP_ZS: return to_cr(getUcpZs()); case CLASS_SCRIPT_ARABIC: return to_cr(getUcpArabic()); case CLASS_SCRIPT_ARMENIAN: return to_cr(getUcpArmenian()); case CLASS_SCRIPT_AVESTAN: return to_cr(getUcpAvestan()); case CLASS_SCRIPT_BALINESE: return to_cr(getUcpBalinese()); case CLASS_SCRIPT_BAMUM: return to_cr(getUcpBamum()); case CLASS_SCRIPT_BATAK: return to_cr(getUcpBatak()); case CLASS_SCRIPT_BENGALI: return to_cr(getUcpBengali()); case CLASS_SCRIPT_BOPOMOFO: return to_cr(getUcpBopomofo()); case CLASS_SCRIPT_BRAHMI: return to_cr(getUcpBrahmi()); case CLASS_SCRIPT_BRAILLE: return to_cr(getUcpBraille()); case CLASS_SCRIPT_BUGINESE: return to_cr(getUcpBuginese()); case CLASS_SCRIPT_BUHID: return to_cr(getUcpBuhid()); case CLASS_SCRIPT_CANADIAN_ABORIGINAL: return to_cr(getUcpCanadian_Aboriginal()); case CLASS_SCRIPT_CARIAN: return to_cr(getUcpCarian()); case CLASS_SCRIPT_CHAM: return to_cr(getUcpCham()); case CLASS_SCRIPT_CHEROKEE: return to_cr(getUcpCherokee()); case CLASS_SCRIPT_COMMON: return to_cr(getUcpCommon()); case CLASS_SCRIPT_COPTIC: return to_cr(getUcpCoptic()); case CLASS_SCRIPT_CUNEIFORM: return to_cr(getUcpCuneiform()); case CLASS_SCRIPT_CYPRIOT: return to_cr(getUcpCypriot()); case CLASS_SCRIPT_CYRILLIC: return to_cr(getUcpCyrillic()); case CLASS_SCRIPT_DESERET: return to_cr(getUcpDeseret()); case CLASS_SCRIPT_DEVANAGARI: return to_cr(getUcpDevanagari()); case CLASS_SCRIPT_EGYPTIAN_HIEROGLYPHS: return to_cr(getUcpEgyptian_Hieroglyphs()); case CLASS_SCRIPT_ETHIOPIC: return to_cr(getUcpEthiopic()); case CLASS_SCRIPT_GEORGIAN: return to_cr(getUcpGeorgian()); case CLASS_SCRIPT_GLAGOLITIC: return to_cr(getUcpGlagolitic()); case CLASS_SCRIPT_GOTHIC: return to_cr(getUcpGothic()); case CLASS_SCRIPT_GREEK: return to_cr(getUcpGreek()); case CLASS_SCRIPT_GUJARATI: return to_cr(getUcpGujarati()); case CLASS_SCRIPT_GURMUKHI: return to_cr(getUcpGurmukhi()); case CLASS_SCRIPT_HAN: return to_cr(getUcpHan()); case CLASS_SCRIPT_HANGUL: return to_cr(getUcpHangul()); case CLASS_SCRIPT_HANUNOO: return to_cr(getUcpHanunoo()); case CLASS_SCRIPT_HEBREW: return to_cr(getUcpHebrew()); case CLASS_SCRIPT_HIRAGANA: return to_cr(getUcpHiragana()); case CLASS_SCRIPT_IMPERIAL_ARAMAIC: return to_cr(getUcpImperial_Aramaic()); case CLASS_SCRIPT_INHERITED: return to_cr(getUcpInherited()); case CLASS_SCRIPT_INSCRIPTIONAL_PAHLAVI: return to_cr(getUcpInscriptional_Pahlavi()); case CLASS_SCRIPT_INSCRIPTIONAL_PARTHIAN: return to_cr(getUcpInscriptional_Parthian()); case CLASS_SCRIPT_JAVANESE: return to_cr(getUcpJavanese()); case CLASS_SCRIPT_KAITHI: return to_cr(getUcpKaithi()); case CLASS_SCRIPT_KANNADA: return to_cr(getUcpKannada()); case CLASS_SCRIPT_KATAKANA: return to_cr(getUcpKatakana()); case CLASS_SCRIPT_KAYAH_LI: return to_cr(getUcpKayah_Li()); case CLASS_SCRIPT_KHAROSHTHI: return to_cr(getUcpKharoshthi()); case CLASS_SCRIPT_KHMER: return to_cr(getUcpKhmer()); case CLASS_SCRIPT_LAO: return to_cr(getUcpLao()); case CLASS_SCRIPT_LATIN: return to_cr(getUcpLatin()); case CLASS_SCRIPT_LEPCHA: return to_cr(getUcpLepcha()); case CLASS_SCRIPT_LIMBU: return to_cr(getUcpLimbu()); case CLASS_SCRIPT_LINEAR_B: return to_cr(getUcpLinear_B()); case CLASS_SCRIPT_LISU: return to_cr(getUcpLisu()); case CLASS_SCRIPT_LYCIAN: return to_cr(getUcpLycian()); case CLASS_SCRIPT_LYDIAN: return to_cr(getUcpLydian()); case CLASS_SCRIPT_MALAYALAM: return to_cr(getUcpMalayalam()); case CLASS_SCRIPT_MANDAIC: return to_cr(getUcpMandaic()); case CLASS_SCRIPT_MEETEI_MAYEK: return to_cr(getUcpMeetei_Mayek()); case CLASS_SCRIPT_MONGOLIAN: return to_cr(getUcpMongolian()); case CLASS_SCRIPT_MYANMAR: return to_cr(getUcpMyanmar()); case CLASS_SCRIPT_NEW_TAI_LUE: return to_cr(getUcpNew_Tai_Lue()); case CLASS_SCRIPT_NKO: return to_cr(getUcpNko()); case CLASS_SCRIPT_OGHAM: return to_cr(getUcpOgham()); case CLASS_SCRIPT_OL_CHIKI: return to_cr(getUcpOl_Chiki()); case CLASS_SCRIPT_OLD_ITALIC: return to_cr(getUcpOld_Italic()); case CLASS_SCRIPT_OLD_PERSIAN: return to_cr(getUcpOld_Persian()); case CLASS_SCRIPT_OLD_SOUTH_ARABIAN: return to_cr(getUcpOld_South_Arabian()); case CLASS_SCRIPT_OLD_TURKIC: return to_cr(getUcpOld_Turkic()); case CLASS_SCRIPT_ORIYA: return to_cr(getUcpOriya()); case CLASS_SCRIPT_OSMANYA: return to_cr(getUcpOsmanya()); case CLASS_SCRIPT_PHAGS_PA: return to_cr(getUcpPhags_Pa()); case CLASS_SCRIPT_PHOENICIAN: return to_cr(getUcpPhoenician()); case CLASS_SCRIPT_REJANG: return to_cr(getUcpRejang()); case CLASS_SCRIPT_RUNIC: return to_cr(getUcpRunic()); case CLASS_SCRIPT_SAMARITAN: return to_cr(getUcpSamaritan()); case CLASS_SCRIPT_SAURASHTRA: return to_cr(getUcpSaurashtra()); case CLASS_SCRIPT_SHAVIAN: return to_cr(getUcpShavian()); case CLASS_SCRIPT_SINHALA: return to_cr(getUcpSinhala()); case CLASS_SCRIPT_SUNDANESE: return to_cr(getUcpSundanese()); case CLASS_SCRIPT_SYLOTI_NAGRI: return to_cr(getUcpSyloti_Nagri()); case CLASS_SCRIPT_SYRIAC: return to_cr(getUcpSyriac()); case CLASS_SCRIPT_TAGALOG: return to_cr(getUcpTagalog()); case CLASS_SCRIPT_TAGBANWA: return to_cr(getUcpTagbanwa()); case CLASS_SCRIPT_TAI_LE: return to_cr(getUcpTai_Le()); case CLASS_SCRIPT_TAI_THAM: return to_cr(getUcpTai_Tham()); case CLASS_SCRIPT_TAI_VIET: return to_cr(getUcpTai_Viet()); case CLASS_SCRIPT_TAMIL: return to_cr(getUcpTamil()); case CLASS_SCRIPT_TELUGU: return to_cr(getUcpTelugu()); case CLASS_SCRIPT_THAANA: return to_cr(getUcpThaana()); case CLASS_SCRIPT_THAI: return to_cr(getUcpThai()); case CLASS_SCRIPT_TIBETAN: return to_cr(getUcpTibetan()); case CLASS_SCRIPT_TIFINAGH: return to_cr(getUcpTifinagh()); case CLASS_SCRIPT_UGARITIC: return to_cr(getUcpUgaritic()); case CLASS_SCRIPT_VAI: return to_cr(getUcpVai()); case CLASS_SCRIPT_YI: return to_cr(getUcpYi()); case CLASS_UCP_ANY: /* always include newline */ return ~CharReach(); } assert(0); return CharReach(); } unique_ptr getComponentClass(const ParseMode &mode) { if (mode.utf8) { return ue2::make_unique(mode); } else { return ue2::make_unique(mode); } } unique_ptr generateComponent(PredefinedClass c, bool negate, const ParseMode &mode) { auto cc = getComponentClass(mode); cc->add(c, negate); cc->finalize(); return cc; } unique_ptr getLiteralComponentClass(unsigned char c, bool nocase) { ParseMode mode; mode.caseless = nocase; auto cc = getComponentClass(mode); cc->add(c); cc->finalize(); return cc; } ComponentClass::ComponentClass(const ParseMode &mode_in) : m_negate(false), mode(mode_in), in_cand_range(false), range_start(INVALID_UNICODE), finalized(false) {} ComponentClass::~ComponentClass() { } void ComponentClass::addDash(void) { if (!in_cand_range) { // this could be the start of a range if (range_start != INVALID_UNICODE) { in_cand_range = true; } else { /* no possible start character for range, this is just a literal */ add('-'); } } else { // already creating a range, so this must be literal '-' in_cand_range = false; createRange('-'); } } void ComponentClass::negate() { m_negate = true; } } // namespace ue2 hyperscan-4.4.1/src/parser/ComponentRepeat.h0000644000175000017500000001143513055426554021642 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Repeats ('*', '+', '?', '{M,N}', etc) */ #ifndef RE_COMPONENTREPEAT_H #define RE_COMPONENTREPEAT_H #include "Component.h" #include "position.h" #include "ue2common.h" #include #include namespace ue2 { /** * \brief Encapsulates a repeat of a subexpression ('*', '+', '?', '{M,N}', * etc). * * ASCII Art Time: * * Our standard representation of standard repeats. Other constructions (fan-in * vs fan-out) would also be possible and equivalent for our purposes. * * {n,m} * * S->M->M->M->O->O->O->T * | ^ ^ ^ * | | | | * \-----------/ * * {0,m} * * /-----------\ * | | * | V * S->O->O->O->T * | ^ ^ ^ * | | | | * \--------/ * */ class ComponentRepeat : public Component { friend class ConstructLiteralVisitor; friend class DumpVisitor; friend class PrintVisitor; friend class SimplifyVisitor; public: /** \brief Value representing no maximum bound. */ static constexpr u32 NoLimit = 0xffffffff; /** \brief Type of this repeat, characterising its * greediness/possessiveness. */ enum RepeatType { /** Minimising repeat, like 'a*?'. */ REPEAT_NONGREEDY, /** Maximising repeat, like 'a*'. This is the default in PCRE. */ REPEAT_GREEDY, /** Possessive, maximising repeat, like 'a*+'. Possessive repeats are * only currently supported in prefiltering mode, where we treat them * the same way we treat normal greedy repeats. */ REPEAT_POSSESSIVE, }; ComponentRepeat(std::unique_ptr sub_comp, u32 min, u32 max, RepeatType t); ~ComponentRepeat() override; ComponentRepeat *clone() const override; Component *accept(ComponentVisitor &v) override; void accept(ConstComponentVisitor &v) const override; std::vector first() const override; std::vector last() const override; bool empty() const override; bool repeatable() const override; bool vacuous_everywhere() const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; bool checkEmbeddedStartAnchor(bool at_start) const override; bool checkEmbeddedEndAnchor(bool at_end) const override; void optimise(bool connected_to_sds) override; virtual std::pair getBounds() const { return std::make_pair(m_min, m_max); } /** \brief From declared behaviour (not taking into account the * sub-component). */ enum RepeatType type; protected: void postSubNotePositionHook(); void wireRepeats(GlushkovBuildState &bs); std::unique_ptr sub_comp; u32 m_min; u32 m_max; std::vector > m_firsts; std::vector > m_lasts; Position posFirst; Position posLast; ComponentRepeat(const ComponentRepeat &other); }; std::unique_ptr makeComponentRepeat(std::unique_ptr sub_comp, u32 min, u32 max, ComponentRepeat::RepeatType t); } // namespace ue2 #endif // _RE_COMPONENTREPEAT_H_ hyperscan-4.4.1/src/parser/ComponentVisitor.cpp0000644000175000017500000000563413055426554022420 0ustar sleuthkidsleuthkid/* * 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. */ #include "AsciiComponentClass.h" #include "ComponentVisitor.h" #include "ComponentAlternation.h" #include "ComponentAssertion.h" #include "ComponentAtomicGroup.h" #include "ComponentBackReference.h" #include "ComponentBoundary.h" #include "ComponentByte.h" #include "ComponentCondReference.h" #include "ComponentClass.h" #include "ComponentEmpty.h" #include "ComponentEUS.h" #include "ComponentRepeat.h" #include "ComponentSequence.h" #include "ComponentWordBoundary.h" #include "Utf8ComponentClass.h" namespace ue2 { ComponentVisitor::~ComponentVisitor() { // empty } // Default implementations. DefaultComponentVisitor::DefaultComponentVisitor() {} DefaultComponentVisitor::~DefaultComponentVisitor() {} #define DEFAULT_FUNCS(comp) \ Component *DefaultComponentVisitor::visit(comp *c) { return c; } \ void DefaultComponentVisitor::post(comp *) {} DEFAULT_FUNCS(AsciiComponentClass) DEFAULT_FUNCS(ComponentAlternation) DEFAULT_FUNCS(ComponentAssertion) DEFAULT_FUNCS(ComponentAtomicGroup) DEFAULT_FUNCS(ComponentBackReference) DEFAULT_FUNCS(ComponentBoundary) DEFAULT_FUNCS(ComponentByte) DEFAULT_FUNCS(ComponentCondReference) DEFAULT_FUNCS(ComponentEmpty) DEFAULT_FUNCS(ComponentEUS) DEFAULT_FUNCS(ComponentRepeat) DEFAULT_FUNCS(ComponentSequence) DEFAULT_FUNCS(ComponentWordBoundary) DEFAULT_FUNCS(UTF8ComponentClass) } // namespace hyperscan-4.4.1/src/parser/unsupported.cpp0000644000175000017500000000662713055426554021471 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Checks component trees for unsupported components. */ #include "ConstComponentVisitor.h" #include "ComponentEUS.h" #include "ComponentRepeat.h" #include "ComponentWordBoundary.h" #include "parse_error.h" #include "unsupported.h" #include namespace ue2 { /** \brief Visitor class that throws a ParseError exception when it encounters * an unsupported component. */ class UnsupportedVisitor : public DefaultConstComponentVisitor { public: ~UnsupportedVisitor() override; using DefaultConstComponentVisitor::pre; void pre(const ComponentAssertion &) override { throw ParseError("Zero-width assertions are not supported."); } void pre(const ComponentAtomicGroup &) override { throw ParseError("Atomic groups are unsupported."); } void pre(const ComponentBackReference &) override { throw ParseError("Back-references are unsupported."); } void pre(const ComponentCondReference &) override { throw ParseError("Conditional references are not supported."); } void pre(const ComponentEUS &c) override { std::ostringstream str; str << "\\X unsupported at index " << c.loc << "."; throw ParseError(str.str()); } void pre(const ComponentRepeat &c) override { if (c.type == ComponentRepeat::REPEAT_POSSESSIVE) { throw ParseError("Possessive quantifiers are not supported."); } } void pre(const ComponentWordBoundary &c) override { if (c.ucp && !c.prefilter) { std::ostringstream str; str << (!c.negated ? "\\b" : "\\B") << " unsupported in UCP mode at index " << c.loc << "."; throw ParseError(str.str()); } } }; UnsupportedVisitor::~UnsupportedVisitor() {} void checkUnsupported(const Component &root) { UnsupportedVisitor vis; root.accept(vis); } } // namespace ue2 hyperscan-4.4.1/src/parser/Utf8ComponentClass.h0000644000175000017500000001003313055426554022227 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Character class in UTF-8 mode. */ #ifndef UTF8_COMPONENT_CLASS_H #define UTF8_COMPONENT_CLASS_H #include "ComponentClass.h" #include "ue2common.h" #include "util/unicode_set.h" #include #include #include #include namespace ue2 { class UTF8ComponentClass : public ComponentClass { friend class DumpVisitor; friend class PrintVisitor; friend class CaselessVisitor; friend class SimplifyVisitor; friend class SimplifyCandidatesVisitor; public: explicit UTF8ComponentClass(const ParseMode &mode); ~UTF8ComponentClass() override {} UTF8ComponentClass *clone() const override; Component *accept(ComponentVisitor &v) override { Component *c = v.visit(this); v.post(this); return c; } void accept(ConstComponentVisitor &v) const override { v.pre(*this); v.during(*this); v.post(*this); } bool class_empty(void) const override; void add(PredefinedClass c, bool negative) override; void add(unichar c) override; void finalize(void) override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &) override; std::vector first(void) const override; std::vector last(void) const override; protected: void createRange(unichar to) override; private: Position getHead(NFABuilder &builder, u8 first_byte); void addToTail(GlushkovBuildState &bs, std::map &finals, Position prev, unichar b, unichar e); void ensureDotTrailer(GlushkovBuildState &bs); void ensureTwoDotTrailer(GlushkovBuildState &bs); void ensureThreeDotTrailer(GlushkovBuildState &bs); void buildOneByte(GlushkovBuildState &bs); void buildTwoByte(GlushkovBuildState &bs); void buildThreeByte(GlushkovBuildState &bs); void buildFourByte(GlushkovBuildState &bs); CodePointSet cps; std::map heads; Position single_pos; Position one_dot_trailer; Position two_dot_trailer; Position three_dot_trailer; Position two_char_dot_head; Position three_char_dot_head; Position four_char_dot_head; std::set tails; }; PredefinedClass translateForUcpMode(PredefinedClass in, const ParseMode &mode); CodePointSet getPredefinedCodePointSet(PredefinedClass c, const ParseMode &mode); } // namespace #endif // UTF8_COMPONENT_CLASS_H hyperscan-4.4.1/src/parser/ComponentAlternation.cpp0000644000175000017500000001260513055426554023235 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Alternations (foo|bar|baz). */ #include "ComponentAlternation.h" #include "buildstate.h" #include "position.h" #include "position_info.h" #include "nfagraph/ng_builder.h" #include "ue2common.h" #include using namespace std; namespace ue2 { ComponentAlternation::ComponentAlternation() { // empty } ComponentAlternation::~ComponentAlternation() { // empty } ComponentAlternation::ComponentAlternation(const ComponentAlternation &other) : Component(other) { for (const auto &c : other.children) { assert(c); children.push_back(unique_ptr(c->clone())); } } ComponentAlternation * ComponentAlternation::clone() const { return new ComponentAlternation(*this); } Component *ComponentAlternation::accept(ComponentVisitor &v) { Component *c = v.visit(this); if (c != this) { v.post(this); return c; } for (auto i = children.begin(), e = children.end(); i != e; ++i) { Component *child = i->get(); c = (*i)->accept(v); if (c != child) { // Child has been replaced (new Component pointer) or we've been // instructed to delete it (null). i->reset(c); } } // Remove deleted children. children.erase(remove(children.begin(), children.end(), nullptr), children.end()); v.post(this); return this; } void ComponentAlternation::accept(ConstComponentVisitor &v) const { v.pre(*this); for (auto i = children.begin(), e = children.end(); i != e; ++i) { (*i)->accept(v); if (i + 1 != e) { v.during(*this); } } v.post(*this); } void ComponentAlternation::append(unique_ptr component) { children.push_back(move(component)); } vector ComponentAlternation::first() const { // firsts come from all our subcomponents in position order. This will // maintain left-to-right priority order. vector firsts, subfirsts; for (const auto &c : children) { subfirsts = c->first(); firsts.insert(firsts.end(), subfirsts.begin(), subfirsts.end()); } return firsts; } vector ComponentAlternation::last() const { vector lasts, sublasts; for (const auto &c : children) { sublasts = c->last(); lasts.insert(lasts.end(), sublasts.begin(), sublasts.end()); } return lasts; } bool ComponentAlternation::empty(void) const { // an alternation can be empty if any of its components are empty for (const auto &c : children) { if (c->empty()) { return true; } } return false; } void ComponentAlternation::notePositions(GlushkovBuildState &bs) { u32 pb = bs.getBuilder().numVertices(); for (auto &c : children) { c->notePositions(bs); } recordPosBounds(pb, bs.getBuilder().numVertices()); } void ComponentAlternation::buildFollowSet(GlushkovBuildState &bs, const vector &lastPos) { for (auto &c : children) { c->buildFollowSet(bs, lastPos); } } bool ComponentAlternation::checkEmbeddedStartAnchor(bool at_start) const { bool rv = at_start; for (const auto &c : children) { rv &= c->checkEmbeddedStartAnchor(at_start); } return rv; } bool ComponentAlternation::checkEmbeddedEndAnchor(bool at_end) const { bool rv = at_end; for (const auto &c : children) { rv &= c->checkEmbeddedEndAnchor(at_end); } return rv; } bool ComponentAlternation::vacuous_everywhere(void) const { for (const auto &c : children) { if (c->vacuous_everywhere()) { return true; } } return false; } void ComponentAlternation::optimise(bool connected_to_sds) { for (auto &c : children) { c->optimise(connected_to_sds); } } } // namespace ue2 hyperscan-4.4.1/src/parser/ComponentEmpty.cpp0000644000175000017500000000563113055426554022054 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Represents an empty regex element, like (?m) */ #include #include "ComponentEmpty.h" #include "position.h" #include "position_info.h" #include "buildstate.h" #include "ue2common.h" using namespace std; namespace ue2 { ComponentEmpty::ComponentEmpty() { // Surprise, it's EMPTY! } ComponentEmpty::~ComponentEmpty() { // Surprise, it's EMPTY! } ComponentEmpty *ComponentEmpty::clone() const { return new ComponentEmpty(); } bool ComponentEmpty::empty() const { return true; } bool ComponentEmpty::vacuous_everywhere(void) const { return true; } bool ComponentEmpty::repeatable() const { // This is the whole point of this class. Empty constructs like '(?m)' are // not repeatable. return false; } vector ComponentEmpty::first() const { return vector(1, GlushkovBuildState::POS_EPSILON); } vector ComponentEmpty::last() const { return vector(); } void ComponentEmpty::notePositions(GlushkovBuildState &) { // Nothing to do. } void ComponentEmpty::buildFollowSet(GlushkovBuildState &, const vector &) { // Nothing to do. } bool ComponentEmpty::checkEmbeddedStartAnchor(bool at_start) const { return at_start; } bool ComponentEmpty::checkEmbeddedEndAnchor(bool at_end) const { return at_end; } } // namespace ue2 hyperscan-4.4.1/src/parser/position.h0000644000175000017500000001213013055426554020374 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Per-position flags used during Glushkov construction, PositionInfo class. */ #ifndef PARSER_POSITION_H #define PARSER_POSITION_H #include "ue2common.h" #include namespace ue2 { #define POS_FLAG_NOFLOAT (1 << 0) //!< don't wire to start-dotstar #define POS_FLAG_MUST_FLOAT (1 << 1) //!< don't wire solely to start #define POS_FLAG_FIDDLE_ACCEPT (1 << 2) //!< add a dot with an offset adjustment when wiring to accept #define POS_FLAG_ASSERT_WORD_TO_NONWORD (1 << 3) //!< epsilon for word to nonword transition #define POS_FLAG_ASSERT_NONWORD_TO_WORD (1 << 4) //!< epsilon for nonword to word transition #define POS_FLAG_ASSERT_WORD_TO_WORD (1 << 5) //!< epsilon for word to word transition #define POS_FLAG_ASSERT_NONWORD_TO_NONWORD (1 << 6) //!< epsilon for nonword to nonword transition /** vertex created by cloning startDs, not considered part of the match. * mirrors POS_FLAG_FIDDLE_ACCEPT */ #define POS_FLAG_VIRTUAL_START (1 << 7) /** multi-line ^ does not match \\n at end of buffer. As a result, we must never * wire the \\n from ^ to eod */ #define POS_FLAG_MULTILINE_START (1 << 8) #define POS_FLAG_ASSERT_WORD_TO_NONWORD_UCP (1 << 9) #define POS_FLAG_ASSERT_NONWORD_TO_WORD_UCP (1 << 10) #define POS_FLAG_ASSERT_WORD_TO_WORD_UCP (1 << 11) #define POS_FLAG_ASSERT_NONWORD_TO_NONWORD_UCP (1 << 12) #define POS_FLAG_ASSERT_NONWORD_TO_ANY (POS_FLAG_ASSERT_NONWORD_TO_NONWORD \ | POS_FLAG_ASSERT_NONWORD_TO_WORD) #define POS_FLAG_ASSERT_WORD_TO_ANY (POS_FLAG_ASSERT_WORD_TO_NONWORD \ | POS_FLAG_ASSERT_WORD_TO_WORD) #define POS_FLAG_ASSERT_ANY_TO_NONWORD (POS_FLAG_ASSERT_NONWORD_TO_NONWORD \ | POS_FLAG_ASSERT_WORD_TO_NONWORD) #define POS_FLAG_ASSERT_ANY_TO_WORD (POS_FLAG_ASSERT_NONWORD_TO_WORD \ | POS_FLAG_ASSERT_WORD_TO_WORD) #define POS_FLAG_ASSERT_NONWORD_TO_ANY_UCP \ (POS_FLAG_ASSERT_NONWORD_TO_NONWORD_UCP \ | POS_FLAG_ASSERT_NONWORD_TO_WORD_UCP) #define POS_FLAG_ASSERT_WORD_TO_ANY_UCP (POS_FLAG_ASSERT_WORD_TO_NONWORD_UCP \ | POS_FLAG_ASSERT_WORD_TO_WORD_UCP) #define POS_FLAG_ASSERT_ANY_TO_NONWORD_UCP \ (POS_FLAG_ASSERT_NONWORD_TO_NONWORD_UCP \ | POS_FLAG_ASSERT_WORD_TO_NONWORD_UCP) #define POS_FLAG_ASSERT_ANY_TO_WORD_UCP (POS_FLAG_ASSERT_WORD_TO_WORD_UCP \ | POS_FLAG_ASSERT_NONWORD_TO_WORD_UCP) #define UCP_ASSERT_FLAGS (POS_FLAG_ASSERT_WORD_TO_ANY_UCP \ | POS_FLAG_ASSERT_NONWORD_TO_ANY_UCP) #define NON_UCP_ASSERT_FLAGS (POS_FLAG_ASSERT_WORD_TO_ANY \ | POS_FLAG_ASSERT_NONWORD_TO_ANY) /** do not wire to accept or other pos; may still wire to eod, etc if * instructed */ #define POS_FLAG_ONLY_ENDS (1 << 23) #define POS_FLAG_WIRE_EOD (1 << 24) /**< wire to accept eod */ #define POS_FLAG_WIRE_NL_EOD (1 << 25) /**< wire to nl before accept eod */ #define POS_FLAG_WIRE_NL_ACCEPT (1 << 26) /**< wire to nl before accept */ #define POS_FLAG_NO_NL_EOD (1 << 27) /**< disallow nl before accept eod */ #define POS_FLAG_NO_NL_ACCEPT (1 << 28) /**< disallow nl before accept */ /** \brief Parse and Glushkov construction use only. State number within the * NFA as it is being constructed. */ typedef u32 Position; } // namespace ue2 #endif // PARSER_POSITION_H hyperscan-4.4.1/src/parser/ComponentSequence.h0000644000175000017500000000764513055426554022202 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Sequence of Component objects. */ #ifndef COMPONENT_SEQUENCE_H #define COMPONENT_SEQUENCE_H #include "Component.h" #include "ComponentRepeat.h" // for ComponentRepeat::RepeatType #include "ue2common.h" #include #include #include namespace ue2 { class ComponentAlternation; class GlushkovBuildState; // Encapsulates a number of sub expressions to be applied sequentially class ComponentSequence : public Component { friend class DumpVisitor; friend class PrintVisitor; friend class SimplifyVisitor; public: /** \brief capture index representing a sequence that ISN'T capturing */ static constexpr unsigned int NOT_CAPTURED = 65536; ComponentSequence(); ~ComponentSequence() override; ComponentSequence *clone() const override; Component *accept(ComponentVisitor &v) override; void accept(ConstComponentVisitor &v) const override; bool addRepeat(u32 min, u32 max, ComponentRepeat::RepeatType type); // overridden by ComponentCondReference, which can only have 1 or 2 // branches. virtual void addAlternation(); virtual void finalize(); void addComponent(std::unique_ptr comp); std::vector first() const override; std::vector last() const override; bool empty(void) const override; bool vacuous_everywhere() const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; bool checkEmbeddedStartAnchor(bool at_start) const override; bool checkEmbeddedEndAnchor(bool at_end) const override; void optimise(bool connected_to_sds) override; void setCaptureIndex(unsigned int idx) { capture_index = idx; } unsigned int getCaptureIndex() const { return capture_index; } void setCaptureName(const std::string &s) { capture_name = s; } const std::string &getCaptureName() const { return capture_name; } virtual const std::vector> &getChildren() const { return children; } protected: ComponentSequence(const ComponentSequence &other); std::vector> children; std::unique_ptr alternation; private: unsigned int capture_index; std::string capture_name; //!< empty means no name }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/ComponentCondReference.h0000644000175000017500000000626613055426554023132 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Conditional reference. */ #ifndef PARSER_COMPONENTCONDREFERENCE_H_ #define PARSER_COMPONENTCONDREFERENCE_H_ #include "ComponentSequence.h" #include #include namespace ue2 { class ComponentCondReference : public ComponentSequence { friend class DumpVisitor; friend class PrefilterVisitor; friend class ReferenceVisitor; friend class PrintVisitor; public: explicit ComponentCondReference(unsigned ref); explicit ComponentCondReference(const std::string &name); explicit ComponentCondReference(std::unique_ptr c); ~ComponentCondReference() override; ComponentCondReference *clone() const override; Component *accept(ComponentVisitor &v) override; void accept(ConstComponentVisitor &v) const override; void addAlternation() override; std::vector first() const override; std::vector last() const override; bool empty() const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; bool repeatable() const override; private: ComponentCondReference(const ComponentCondReference &other); enum Condition { CONDITION_NUMBER, CONDITION_NAME, CONDITION_ASSERTION }; enum Condition kind; unsigned ref_id; std::string ref_name; std::unique_ptr assertion; /** True if an alternation has been added, which means we have both a YES * and a NO branch. */ bool hasBothBranches; }; } // namespace ue2 #endif // PARSER_COMPONENTCONDREFERENCE_H_ hyperscan-4.4.1/src/parser/prefilter.cpp0000644000175000017500000002615513055426554021073 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Prefiltering component tree transformation. */ #include "ComponentAssertion.h" #include "ComponentAtomicGroup.h" #include "ComponentBackReference.h" #include "ComponentBoundary.h" #include "ComponentClass.h" #include "ComponentCondReference.h" #include "ComponentRepeat.h" #include "ComponentSequence.h" #include "ComponentVisitor.h" #include "ComponentWordBoundary.h" #include "ConstComponentVisitor.h" #include "Parser.h" #include "prefilter.h" #include #include using namespace std; namespace ue2 { /** \brief Max number of positions a referent can have to be considered safe to * replace a reference in prefiltering mode. */ static const size_t MAX_REFERENT_POSITIONS = 1; /** \brief Constructs a \ref ComponentClass that matches a dot (any * byte/codepoint, depending on whether UTF-8). */ static unique_ptr makeDotClass(const ParseMode &mode_in) { ParseMode mode(mode_in); mode.dotall = true; return generateComponent(CLASS_ANY, false, mode); } namespace { /** * \brief Visitor used to determine if a given referent component is safe to * replace its reference in prefiltering mode. Throws * SafeReferentVisitor::Unsafe to terminate early on unsafe cases. */ class SafeReferentVisitor : public DefaultConstComponentVisitor { public: struct Unsafe {}; SafeReferentVisitor() : numPositions(0) {} bool is_safe() const { DEBUG_PRINTF("numPositions = %zu\n", numPositions); return numPositions <= MAX_REFERENT_POSITIONS; } using DefaultConstComponentVisitor::pre; using DefaultConstComponentVisitor::post; void pre(const AsciiComponentClass &) override { numPositions++; } void pre(const UTF8ComponentClass &) override { // FIXME: we should be able to tell precisely how many positions this // class will use. Right now, use the worst case. numPositions += 4; } void pre(const ComponentBoundary &) override { numPositions++; } void pre(const ComponentByte &) override { numPositions++; } void pre(const ComponentEUS &) override { numPositions++; } void pre(const ComponentRepeat &) override { // Record the number of positions used before we visit the contents of // the repeat. countStack.push(numPositions); } void post(const ComponentRepeat &c) override { assert(!countStack.empty()); size_t before = countStack.top(); countStack.pop(); assert(before <= numPositions); std::pair bounds = c.getBounds(); size_t subPositions = numPositions - before; size_t copies = bounds.second < ComponentRepeat::NoLimit ? bounds.second : max(bounds.first, 1U); numPositions = before + (subPositions * copies); } void pre(const ComponentWordBoundary &) override { // not quite accurate, as these are expanded out in assert // resolution... numPositions++; } void pre(const ComponentBackReference &) override { throw Unsafe(); } void pre(const ComponentCondReference &) override { throw Unsafe(); } private: size_t numPositions; // For temporary use std::stack countStack; }; static bool isSafeReferent(const Component &c) { try { SafeReferentVisitor vis; c.accept(vis); return vis.is_safe(); } catch (const SafeReferentVisitor::Unsafe &) { return false; } } /** * \brief Visitor to find the \ref ComponentSequence with a given reference ID * or name: if found, the visitor will throw a const ptr to it. */ class FindSequenceVisitor : public DefaultConstComponentVisitor { public: explicit FindSequenceVisitor(unsigned ref_id) : id(ref_id) {} explicit FindSequenceVisitor(const std::string &s) : name(s) {} using DefaultConstComponentVisitor::pre; void pre(const ComponentSequence &c) override { if (!name.empty()) { if (c.getCaptureName() == name) { throw &c; } } else if (c.getCaptureIndex() == id) { throw &c; } } private: const std::string name; const unsigned id = 0; }; static const ComponentSequence *findCapturingGroup(const Component *root, FindSequenceVisitor &vis) { try { root->accept(vis); DEBUG_PRINTF("group not found\n"); return nullptr; } catch (const ComponentSequence *seq) { return seq; } } } // namespace /** * \brief Visitor to apply prefilter reductions, swapping components for which * we don't have real implementations with implementable ones. Any such * replacement should produce a superset of the matches that would be produced * by the original. */ class PrefilterVisitor : public DefaultComponentVisitor { public: PrefilterVisitor(Component *c, const ParseMode &m) : root(c), mode(m) {} ~PrefilterVisitor() override; using DefaultComponentVisitor::visit; /** \brief Calls the visitor (recursively) on a new replacement component * we've just created. Takes care of freeing it if the sequence is itself * replaced. */ template Component *visit_replacement(T *r) { Component *c = r->accept(*this); if (c != r) { delete r; } return c; } Component *visit(ComponentBackReference *c) override { assert(c); // If the referent is simple (represents a single position), then we // replace the back-reference with a copy of it. const ComponentSequence *ref = nullptr; const std::string &ref_name = c->getRefName(); const unsigned ref_id = c->getRefID(); if (!ref_name.empty()) { FindSequenceVisitor vis(ref_name); ref = findCapturingGroup(root, vis); } else if (ref_id > 0) { FindSequenceVisitor vis(ref_id); ref = findCapturingGroup(root, vis); } if (ref && isSafeReferent(*ref)) { DEBUG_PRINTF("found safe ref %p\n", ref); ComponentSequence *seq = ref->clone(); // Remove labels from cloned sequence. seq->setCaptureName(""); seq->setCaptureIndex(ComponentSequence::NOT_CAPTURED); return visit_replacement(seq); } // Replace with ".*". auto rep = makeComponentRepeat(makeDotClass(mode), 0, ComponentRepeat::NoLimit, ComponentRepeat::REPEAT_GREEDY); return rep.release(); // FIXME: owning raw ptr } Component *visit(UNUSED ComponentAssertion *c) override { assert(c); // Replace with an empty sequence. return new ComponentSequence(); } Component *visit(ComponentRepeat *c) override { assert(c); // Possessive repeats become greedy. if (c->type == ComponentRepeat::REPEAT_POSSESSIVE) { c->type = ComponentRepeat::REPEAT_GREEDY; } return c; } Component *visit(ComponentAtomicGroup *c) override { assert(c); // Replace with a plain sequence containing the atomic group's // children. ComponentSequence *seq = new ComponentSequence(); const auto &children = c->getChildren(); for (const auto &child : children) { assert(child); seq->addComponent(unique_ptr(child->clone())); } return visit_replacement(seq); } Component *visit(UNUSED ComponentEUS *c) override { assert(c); // Replace with ".+". auto rep = makeComponentRepeat(makeDotClass(mode), 1, ComponentRepeat::NoLimit, ComponentRepeat::REPEAT_GREEDY); return rep.release(); // FIXME: owning raw ptr } Component *visit(ComponentWordBoundary *c) override { assert(c); // TODO: Right now, we do not have correct code for resolving these // when prefiltering is on, UCP is on, and UTF-8 is *off*. For now, we // just replace with an empty sequence (as that will return a superset // of matches). if (mode.ucp && !mode.utf8) { return new ComponentSequence(); } // All other cases can be prefiltered. c->setPrefilter(true); return c; } Component *visit(ComponentCondReference *c) override { assert(c); // Replace with a plain sequence containing the conditional reference's // children. ComponentSequence *seq = new ComponentSequence(); const auto &children = c->getChildren(); // Empty children is accepted by PCRE as a "do nothing" case. if (children.empty()) { return seq; } for (const auto &child : children) { assert(child); seq->addComponent(unique_ptr(child->clone())); } // If the conditional reference had just a YES branch, we want this to // be an alternation with an empty sequence (the NO branch). if (!c->hasBothBranches) { seq->addAlternation(); seq->finalize(); } return visit_replacement(seq); } private: Component *root; const ParseMode &mode; }; PrefilterVisitor::~PrefilterVisitor() {} void prefilterTree(unique_ptr &root, const ParseMode &mode) { assert(root); PrefilterVisitor vis(root.get(), mode); Component *c = root->accept(vis); if (c != root.get()) { root.reset(c); } } } // namespace ue2 hyperscan-4.4.1/src/parser/shortcut_literal.cpp0000644000175000017500000001700713055426554022462 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Shortcut literal pass: directly add literal components to Rose. */ #include "AsciiComponentClass.h" #include "Utf8ComponentClass.h" #include "ComponentAssertion.h" #include "ComponentAtomicGroup.h" #include "ComponentBackReference.h" #include "ComponentBoundary.h" #include "ComponentClass.h" #include "ComponentCondReference.h" #include "ComponentRepeat.h" #include "ComponentSequence.h" #include "ComponentVisitor.h" #include "ComponentWordBoundary.h" #include "ConstComponentVisitor.h" #include "parse_error.h" #include "shortcut_literal.h" #include "grey.h" #include "nfagraph/ng.h" #include "compiler/compiler.h" #include "util/ue2string.h" #include "ue2common.h" #include using namespace std; namespace ue2 { /** * \brief Visitor that constructs a ue2_literal from a component tree. * * If a component that can't be part of a literal is encountered, this visitor * will throw ConstructLiteralVisitor::NotLiteral. */ class ConstructLiteralVisitor : public ConstComponentVisitor { public: ~ConstructLiteralVisitor() override; /** \brief Thrown if this component does not represent a literal. */ struct NotLiteral {}; void pre(const AsciiComponentClass &c) override { const CharReach &cr = c.cr; const size_t width = cr.count(); if (width == 1) { lit.push_back(cr.find_first(), false); } else if (width == 2 && cr.isCaselessChar()) { lit.push_back(cr.find_first(), true); } else { throw NotLiteral(); } } void pre(const ComponentRepeat &c) override { if (c.m_min == 0 || c.m_min != c.m_max) { throw NotLiteral(); } if (c.m_max < ComponentRepeat::NoLimit && c.m_max > 32767) { throw ParseError("Bounded repeat is too large."); } // Store the current length of the literal; in this repeat's post() // call we will append N-1 more copies of [index..end]. repeat_stack.push(lit.length()); } void post(const ComponentRepeat &c) override { // Add N-1 copies of the string between the entry to the repeat and the // current end of the literal. assert(!repeat_stack.empty()); const ue2_literal suffix = lit.substr(repeat_stack.top()); repeat_stack.pop(); for (unsigned i = 1; i < c.m_min; i++) { lit += suffix; } } void pre(const ComponentSequence &) override { // Pass through. } void pre(const ComponentAlternation &) override { throw NotLiteral(); } void pre(const ComponentAssertion &) override { throw NotLiteral(); } void pre(const ComponentAtomicGroup &) override { throw NotLiteral(); } void pre(const ComponentBackReference &) override { throw NotLiteral(); } void pre(const ComponentBoundary &) override { throw NotLiteral(); } void pre(const ComponentByte &) override { throw NotLiteral(); } void pre(const ComponentCondReference &) override { throw NotLiteral(); } void pre(const ComponentEmpty &) override { throw NotLiteral(); } void pre(const ComponentEUS &) override { throw NotLiteral(); } void pre(const ComponentWordBoundary &) override { throw NotLiteral(); } void pre(const UTF8ComponentClass &) override { throw NotLiteral(); } void during(const AsciiComponentClass &) override {} void during(const ComponentAlternation &) override {} void during(const ComponentAssertion &) override {} void during(const ComponentAtomicGroup &) override {} void during(const ComponentBackReference &) override {} void during(const ComponentBoundary &) override {} void during(const ComponentByte &) override {} void during(const ComponentCondReference &) override {} void during(const ComponentEmpty &) override {} void during(const ComponentEUS &) override {} void during(const ComponentRepeat &) override {} void during(const ComponentSequence &) override {} void during(const ComponentWordBoundary &) override {} void during(const UTF8ComponentClass &) override {} void post(const AsciiComponentClass &) override {} void post(const ComponentAlternation &) override {} void post(const ComponentAssertion &) override {} void post(const ComponentAtomicGroup &) override {} void post(const ComponentBackReference &) override {} void post(const ComponentBoundary &) override {} void post(const ComponentByte &) override {} void post(const ComponentCondReference &) override {} void post(const ComponentEmpty &) override {} void post(const ComponentEUS &) override {} void post(const ComponentSequence &) override {} void post(const ComponentWordBoundary &) override {} void post(const UTF8ComponentClass &) override {} ue2_literal lit; stack repeat_stack; //!< index of entry to repeat. }; ConstructLiteralVisitor::~ConstructLiteralVisitor() {} /** \brief True if the literal expression \a expr could be added to Rose. */ bool shortcutLiteral(NG &ng, const ParsedExpression &expr) { assert(expr.component); if (!ng.cc.grey.allowLiteral) { return false; } // XXX: don't shortcut literals with extended params (yet) if (expr.min_offset || expr.max_offset != MAX_OFFSET || expr.min_length) { DEBUG_PRINTF("extended params not allowed\n"); return false; } ConstructLiteralVisitor vis; try { assert(expr.component); expr.component->accept(vis); assert(vis.repeat_stack.empty()); } catch (const ConstructLiteralVisitor::NotLiteral&) { DEBUG_PRINTF("not a literal\n"); return false; } const ue2_literal &lit = vis.lit; if (lit.empty()) { DEBUG_PRINTF("empty literal\n"); return false; } if (expr.highlander && lit.length() <= 1) { DEBUG_PRINTF("not shortcutting SEP literal\n"); return false; } DEBUG_PRINTF("constructed literal %s\n", dumpString(lit).c_str()); return ng.addLiteral(lit, expr.index, expr.id, expr.highlander, expr.som); } } // namespace ue2 hyperscan-4.4.1/src/parser/Parser.h0000644000175000017500000000507613055426554017777 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Interface to Parser. */ #ifndef _RE_PARSER_H_ #define _RE_PARSER_H_ #include "ue2common.h" #include namespace ue2 { class Component; /** \brief Represents the current "mode flags" at any point in the parsing * process. * * This is necessary as some modes can be changed part-way through an * expression, such as in: * * /foo(?i)bar/ */ struct ParseMode { ParseMode() {} explicit ParseMode(u32 hs_flags); bool caseless = false; bool dotall = false; bool ignore_space = false; bool multiline = false; bool ucp = false; bool utf8 = false; }; /** \brief Parse the given regular expression into a \ref Component tree. * * The \a mode parameter should contain the initial mode flags, and will be * updated by the parser if additional global flags are introduced in the * expression (for example, via "(*UTF8)".) * * This call will throw a ParseError on failure. */ std::unique_ptr parse(const char *const ptr, ParseMode &mode); } // namespace ue2 #endif // _RE_PARSER_H_ hyperscan-4.4.1/src/parser/ComponentVisitor.h0000644000175000017500000001375113055426554022064 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Visitor base class for working with the component tree. */ #ifndef COMPONENTVISITOR_H #define COMPONENTVISITOR_H namespace ue2 { class AsciiComponentClass; class Component; class ComponentAlternation; class ComponentAssertion; class ComponentAtomicGroup; class ComponentBackReference; class ComponentBoundary; class ComponentByte; class ComponentClass; class ComponentCondReference; class ComponentEmpty; class ComponentEUS; class ComponentRepeat; class ComponentSequence; class ComponentWordBoundary; class UTF8ComponentClass; /** * \brief Visitor base class for working with the component tree. * * Our approach to implementing the visitor pattern for traversing (and * optionally mutating) the Component tree for a pattern. Each _visit_ function * takes a Component subclass pointer in and returns a Component pointer. That * pointer can have several values, dictating what the containing Component * should do: * * 1. If ptr == c, then do nothing. * 2. If ptr == nullptr, then remove c from the tree. * 3. If ptr != c && ptr != nullptr, then replace c with ptr. * * Traversal order is pre-order. * * After a Component's subcomponents have been visited, the _post_ function for * that Component will be called. */ class ComponentVisitor { public: virtual ~ComponentVisitor(); virtual Component *visit(AsciiComponentClass *c) = 0; virtual Component *visit(ComponentAlternation *c) = 0; virtual Component *visit(ComponentAssertion *c) = 0; virtual Component *visit(ComponentAtomicGroup *c) = 0; virtual Component *visit(ComponentBackReference *c) = 0; virtual Component *visit(ComponentBoundary *c) = 0; virtual Component *visit(ComponentByte *c) = 0; virtual Component *visit(ComponentCondReference *c) = 0; virtual Component *visit(ComponentEmpty *c) = 0; virtual Component *visit(ComponentEUS *c) = 0; virtual Component *visit(ComponentRepeat *c) = 0; virtual Component *visit(ComponentSequence *c) = 0; virtual Component *visit(ComponentWordBoundary *c) = 0; virtual Component *visit(UTF8ComponentClass *c) = 0; virtual void post(AsciiComponentClass *c) = 0; virtual void post(ComponentAlternation *c) = 0; virtual void post(ComponentAssertion *c) = 0; virtual void post(ComponentAtomicGroup *c) = 0; virtual void post(ComponentBackReference *c) = 0; virtual void post(ComponentBoundary *c) = 0; virtual void post(ComponentByte *c) = 0; virtual void post(ComponentCondReference *c) = 0; virtual void post(ComponentEmpty *c) = 0; virtual void post(ComponentEUS *c) = 0; virtual void post(ComponentRepeat *c) = 0; virtual void post(ComponentSequence *c) = 0; virtual void post(ComponentWordBoundary *c) = 0; virtual void post(UTF8ComponentClass *c) = 0; }; /** * \brief Concrete subclass of ComponentVisitor with default behaviour, * allowing you to just implement the member functions you need. */ class DefaultComponentVisitor : public ComponentVisitor { public: DefaultComponentVisitor(); ~DefaultComponentVisitor() override; Component *visit(AsciiComponentClass *c) override; Component *visit(ComponentAlternation *c) override; Component *visit(ComponentAssertion *c) override; Component *visit(ComponentAtomicGroup *c) override; Component *visit(ComponentBackReference *c) override; Component *visit(ComponentBoundary *c) override; Component *visit(ComponentByte *c) override; Component *visit(ComponentCondReference *c) override; Component *visit(ComponentEmpty *c) override; Component *visit(ComponentEUS *c) override; Component *visit(ComponentRepeat *c) override; Component *visit(ComponentSequence *c) override; Component *visit(ComponentWordBoundary *c) override; Component *visit(UTF8ComponentClass *c) override; void post(AsciiComponentClass *c) override; void post(ComponentAlternation *c) override; void post(ComponentAssertion *c) override; void post(ComponentAtomicGroup *c) override; void post(ComponentBackReference *c) override; void post(ComponentBoundary *c) override; void post(ComponentByte *c) override; void post(ComponentCondReference *c) override; void post(ComponentEmpty *c) override; void post(ComponentEUS *c) override; void post(ComponentRepeat *c) override; void post(ComponentSequence *c) override; void post(ComponentWordBoundary *c) override; void post(UTF8ComponentClass *c) override; }; } // namespace ue2 #endif // COMPONENTVISITOR_H hyperscan-4.4.1/src/parser/ComponentAssertion.h0000644000175000017500000000544713055426554022377 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Lookahead/lookbehind zero-width assertions. */ #ifndef _RE_COMPONENTASSERTION_H_ #define _RE_COMPONENTASSERTION_H_ #include "ComponentSequence.h" namespace ue2 { class ComponentAssertion : public ComponentSequence { friend class DumpVisitor; friend class PrintVisitor; public: enum Direction { LOOKAHEAD, //!< lookahead (forward) assertion LOOKBEHIND //!< lookbehind (backward) assertion }; enum Sense { POS, //!< positive assertion, (?=...) or (?<=...) NEG //!< negative assertion, (?!...) or (? first() const override; std::vector last() const override; bool empty() const override; void notePositions(GlushkovBuildState &bs) override; void buildFollowSet(GlushkovBuildState &bs, const std::vector &lastPos) override; bool repeatable() const override; private: enum Direction m_dir; enum Sense m_sense; }; } // namespace ue2 #endif hyperscan-4.4.1/src/parser/ComponentEUS.cpp0000644000175000017500000000523713055426554021414 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Extended Unicode sequences (\\X) */ #include "ComponentEUS.h" #include "buildstate.h" #include "position.h" #include "position_info.h" #include "Parser.h" #include "nfagraph/ng_builder.h" #include "util/charreach.h" using namespace std; namespace ue2 { ComponentEUS::ComponentEUS(u32 loc_in, const ParseMode &mode) : loc(loc_in), utf8(mode.utf8), position(GlushkovBuildState::POS_UNINITIALIZED) {} ComponentEUS::~ComponentEUS() {} ComponentEUS * ComponentEUS::clone() const { return new ComponentEUS(*this); } vector ComponentEUS::first() const { return vector(1, PositionInfo(position)); } vector ComponentEUS::last() const { return vector(1, PositionInfo(position)); } void ComponentEUS::notePositions(GlushkovBuildState &bs) { NFABuilder &builder = bs.getBuilder(); position = builder.makePositions(1); builder.addCharReach(position, CharReach::dot()); builder.setNodeReportID(position, 0 /* offset adj */); if (utf8) { /* we are prefiltering, turn to.+ */ builder.addEdge(position, position); } } } // namespace ue2 hyperscan-4.4.1/COPYING0000644000175000017500000000270613055426554015337 0ustar sleuthkidsleuthkidCopyright (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. hyperscan-4.4.1/examples/0000755000175000017500000000000013055426554016115 5ustar sleuthkidsleuthkidhyperscan-4.4.1/examples/simplegrep.c0000644000175000017500000001754113055426554020440 0ustar sleuthkidsleuthkid/* * 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. */ /* * Hyperscan example program 1: simplegrep * * This is a simple example of Hyperscan's most basic functionality: it will * search a given input file for a pattern supplied as a command-line argument. * It is intended to demonstrate correct usage of the hs_compile and hs_scan * functions of Hyperscan. * * Patterns are scanned in 'DOTALL' mode, which is equivalent to PCRE's '/s' * modifier. This behaviour can be changed by modifying the "flags" argument to * hs_compile. * * Build instructions: * * gcc -o simplegrep simplegrep.c $(pkg-config --cflags --libs libhs) * * Usage: * * ./simplegrep * * Example: * * ./simplegrep int simplegrep.c * */ #include #include #include #include #include #include /** * This is the function that will be called for each match that occurs. @a ctx * is to allow you to have some application-specific state that you will get * access to for each match. In our simple example we're just going to use it * to pass in the pattern that was being searched for so we can print it out. */ static int eventHandler(unsigned int id, unsigned long long from, unsigned long long to, unsigned int flags, void *ctx) { printf("Match for pattern \"%s\" at offset %llu\n", (char *)ctx, to); return 0; } /** * Fill a data buffer from the given filename, returning it and filling @a * length with its length. Returns NULL on failure. */ static char *readInputData(const char *inputFN, unsigned int *length) { FILE *f = fopen(inputFN, "rb"); if (!f) { fprintf(stderr, "ERROR: unable to open file \"%s\": %s\n", inputFN, strerror(errno)); return NULL; } /* We use fseek/ftell to get our data length, in order to keep this example * code as portable as possible. */ if (fseek(f, 0, SEEK_END) != 0) { fprintf(stderr, "ERROR: unable to seek file \"%s\": %s\n", inputFN, strerror(errno)); fclose(f); return NULL; } long dataLen = ftell(f); if (dataLen < 0) { fprintf(stderr, "ERROR: ftell() failed: %s\n", strerror(errno)); fclose(f); return NULL; } if (fseek(f, 0, SEEK_SET) != 0) { fprintf(stderr, "ERROR: unable to seek file \"%s\": %s\n", inputFN, strerror(errno)); fclose(f); return NULL; } /* Hyperscan's hs_scan function accepts length as an unsigned int, so we * limit the size of our buffer appropriately. */ if ((unsigned long)dataLen > UINT_MAX) { dataLen = UINT_MAX; printf("WARNING: clipping data to %ld bytes\n", dataLen); } else if (dataLen == 0) { fprintf(stderr, "ERROR: input file \"%s\" is empty\n", inputFN); fclose(f); return NULL; } char *inputData = malloc(dataLen); if (!inputData) { fprintf(stderr, "ERROR: unable to malloc %ld bytes\n", dataLen); fclose(f); return NULL; } char *p = inputData; size_t bytesLeft = dataLen; while (bytesLeft) { size_t bytesRead = fread(p, 1, bytesLeft, f); bytesLeft -= bytesRead; p += bytesRead; if (ferror(f) != 0) { fprintf(stderr, "ERROR: fread() failed\n"); free(inputData); fclose(f); return NULL; } } fclose(f); *length = (unsigned int)dataLen; return inputData; } int main(int argc, char *argv[]) { if (argc != 3) { fprintf(stderr, "Usage: %s \n", argv[0]); return -1; } char *pattern = argv[1]; char *inputFN = argv[2]; /* First, we attempt to compile the pattern provided on the command line. * We assume 'DOTALL' semantics, meaning that the '.' meta-character will * match newline characters. The compiler will analyse the given pattern and * either return a compiled Hyperscan database, or an error message * explaining why the pattern didn't compile. */ hs_database_t *database; hs_compile_error_t *compile_err; if (hs_compile(pattern, HS_FLAG_DOTALL, HS_MODE_BLOCK, NULL, &database, &compile_err) != HS_SUCCESS) { fprintf(stderr, "ERROR: Unable to compile pattern \"%s\": %s\n", pattern, compile_err->message); hs_free_compile_error(compile_err); return -1; } /* Next, we read the input data file into a buffer. */ unsigned int length; char *inputData = readInputData(inputFN, &length); if (!inputData) { hs_free_database(database); return -1; } /* Finally, we issue a call to hs_scan, which will search the input buffer * for the pattern represented in the bytecode. Note that in order to do * this, scratch space needs to be allocated with the hs_alloc_scratch * function. In typical usage, you would reuse this scratch space for many * calls to hs_scan, but as we're only doing one, we'll be allocating it * and deallocating it as soon as our matching is done. * * When matches occur, the specified callback function (eventHandler in * this file) will be called. Note that although it is reminiscent of * asynchronous APIs, Hyperscan operates synchronously: all matches will be * found, and all callbacks issued, *before* hs_scan returns. * * In this example, we provide the input pattern as the context pointer so * that the callback is able to print out the pattern that matched on each * match event. */ hs_scratch_t *scratch = NULL; if (hs_alloc_scratch(database, &scratch) != HS_SUCCESS) { fprintf(stderr, "ERROR: Unable to allocate scratch space. Exiting.\n"); free(inputData); hs_free_database(database); return -1; } printf("Scanning %u bytes with Hyperscan\n", length); if (hs_scan(database, inputData, length, 0, scratch, eventHandler, pattern) != HS_SUCCESS) { fprintf(stderr, "ERROR: Unable to scan input buffer. Exiting.\n"); hs_free_scratch(scratch); free(inputData); hs_free_database(database); return -1; } /* Scanning is complete, any matches have been handled, so now we just * clean up and exit. */ hs_free_scratch(scratch); free(inputData); hs_free_database(database); return 0; } hyperscan-4.4.1/examples/patbench.cc0000644000175000017500000007306413055426554020222 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /* * Hyperscan pattern benchmarker. * * This program allows users to detect which signatures may be the most * expensive in a set of patterns. It is designed for use with small to medium * pattern set sizes (e.g. 5-500). If used with very large pattern sets it may * take a very long time - the number of recompiles done is g * O(lg2(n)) where * g is the number of generations and n is the number of patterns (assuming * that n >> g). * * This utility will return a cumulative series of removed patterns. The first * generation will find and remove a single pattern. The second generation will * begin with the first pattern removed and find another pattern to remove, * etc. So if we have 100 patterns and 15 generations, the final generation's * score will be a run over 85 patterns. * * This utility is probabilistic. It is possible that the pattern removed in a * generation is not a particularly expensive pattern. To reduce noise in the * results use 'taskset' and set the number of repeats to a level that still * completes in reasonable time (this will reduce the effect of random * measurement noise). * * The criterion for performance can be altered by use of the -C flag where * can be t,r,s,c,b, selecting pattern matching throughput, scratch size, * stream state size (only available in streaming mode), compile time and * bytecode size respectively. * * This utility will also not produce good results if all the patterns are * roughly equally expensive. * * Factor Group Size: * * If there are multiple expensive patterns that are very similar on the * left-hand-side or identical, this utility will typically not find these * groups unless the -F flag is used to search for a group size that is equal * to or larger than the size of the group of similar patterns. * * Otherwise, removing a portion of the similar patterns will have no or almost * no effect, and the search procedure used relies on the ability to remove all * of the similar patterns in at least one search case, something which will * only happen if the factor_group_size is large enough. * * This alters the operation of our tool so that instead of trying to find the * single pattern whose removal has the most effect by binary search (the * default with factor_group_size == 1), we attempt to find the N patterns * whose removal has the most effect by searching over N+1 evenly sized groups, * removing only 1/(N+1) of the search signatures per iteration. * * Note that the number of recompiles done greatly increases with increased * factor group size. For example, with factor_group_size = 1, we do g * 2 * * lg2(n) recompiles, while with factor_group_size = 4, we do g * 4 * * log(5/4)(n). Informally the number of generations we require goes up as we * eliminate a smaller number of signatures and the we have to do more work per * generation. * * * Build instructions: * * g++ -o patbench patbench.cc $(pkg-config --cflags --libs libhs) -lpcap * * Usage: * * ./patbench [ -n repeats] [ -G generations] [ -C criterion ] * [ -F factor_group_size ] [ -N | -S ] * * -n repeats sets the number of times the PCAP is repeatedly scanned * with the pattern * -G generations sets the number of generations that the algorithm is * run for * -N sets non-streaming mode, -S sets streaming mode (default) * -F sets the factor group size (must be >0); this allows the detection * of multiple interacting factors * * -C sets the "criterion", which can be either: * t throughput (the default) - this requires a pcap file * r scratch size * s stream state size * c compile time * b bytecode size * * We recommend the use of a utility like 'taskset' on multiprocessor hosts to * lock execution to a single processor: this will remove processor migration * by the scheduler as a source of noise in the results. * */ #include #include #include #include #include #include #include #include #include #include #include // We use the BSD primitives throughout as they exist on both BSD and Linux. #define __FAVOR_BSD #include #include #include #include #include #include #include #include #include #include using std::cerr; using std::cout; using std::endl; using std::ifstream; using std::string; using std::unordered_map; using std::vector; using std::set; using std::min; using std::max; using std::copy; enum Criterion { CRITERION_THROUGHPUT, CRITERION_BYTECODE_SIZE, CRITERION_COMPILE_TIME, CRITERION_STREAM_STATE, CRITERION_SCRATCH_SIZE }; static bool higher_is_better(Criterion c) { return c == CRITERION_THROUGHPUT; } static void print_criterion(Criterion c, double val) { switch (c) { case CRITERION_THROUGHPUT: cout << std::fixed << std::setprecision(3) << val << " Megabits/s"; break; case CRITERION_COMPILE_TIME: cout << std::fixed << std::setprecision(3) << val << " seconds"; break; case CRITERION_BYTECODE_SIZE: case CRITERION_STREAM_STATE: case CRITERION_SCRATCH_SIZE: default: cout << static_cast(val) << " bytes"; break; } } // Key for identifying a stream in our pcap input data, using data from its IP // headers. struct FiveTuple { unsigned int protocol; unsigned int srcAddr; unsigned int srcPort; unsigned int dstAddr; unsigned int dstPort; // Construct a FiveTuple from a TCP or UDP packet. FiveTuple(const struct ip *iphdr) { // IP fields protocol = iphdr->ip_p; srcAddr = iphdr->ip_src.s_addr; dstAddr = iphdr->ip_dst.s_addr; // UDP/TCP ports const struct udphdr *uh = (const struct udphdr *) (((const char *)iphdr) + (iphdr->ip_hl * 4)); srcPort = uh->uh_sport; dstPort = uh->uh_dport; } bool operator==(const FiveTuple &a) const { return protocol == a.protocol && srcAddr == a.srcAddr && srcPort == a.srcPort && dstAddr == a.dstAddr && dstPort == a.dstPort; } }; // A *very* simple hash function, used when we create an unordered_map of // FiveTuple objects. struct FiveTupleHash { size_t operator()(const FiveTuple &x) const { return x.srcAddr ^ x.dstAddr ^ x.protocol ^ x.srcPort ^ x.dstPort; } }; // Helper function. See end of file. static bool payloadOffset(const unsigned char *pkt_data, unsigned int *offset, unsigned int *length); // Match event handler: called every time Hyperscan finds a match. static int onMatch(unsigned int id, unsigned long long from, unsigned long long to, unsigned int flags, void *ctx) { // Our context points to a size_t storing the match count size_t *matches = (size_t *)ctx; (*matches)++; return 0; // continue matching } // Simple timing class class Clock { public: void start() { time_start = std::chrono::system_clock::now(); } void stop() { time_end = std::chrono::system_clock::now(); } double seconds() const { std::chrono::duration delta = time_end - time_start; return delta.count(); } private: std::chrono::time_point time_start, time_end; }; // Class wrapping all state associated with the benchmark class Benchmark { private: // Packet data to be scanned vector packets; // Stream ID for each packet vector stream_ids; // Map used to construct stream_ids unordered_map stream_map; // Hyperscan compiled database hs_database_t *db = nullptr; // Hyperscan temporary scratch space hs_scratch_t *scratch = nullptr; // Vector of Hyperscan stream state vector streams; // Count of matches found while scanning size_t matchCount = 0; public: ~Benchmark() { hs_free_scratch(scratch); hs_free_database(db); } // Initialisation; after this call, Benchmark owns the database and will // ensure it is freed. void setDatabase(hs_database_t *hs_db) { hs_free_database(db); // Free previous database. db = hs_db; // (Re)allocate scratch to ensure that it is large enough to handle the // database. hs_error_t err = hs_alloc_scratch(db, &scratch); if (err != HS_SUCCESS) { cerr << "ERROR: could not allocate scratch space. Exiting." << endl; exit(-1); } } const hs_database_t *getDatabase() const { return db; } size_t getScratchSize() const { size_t scratch_size; hs_error_t err = hs_scratch_size(scratch, &scratch_size); if (err != HS_SUCCESS) { cerr << "ERROR: could not query scratch space size. Exiting." << endl; exit(-1); } return scratch_size; } // Read a set of streams from a pcap file bool readStreams(const char *pcapFile) { // Open PCAP file for input char errbuf[PCAP_ERRBUF_SIZE]; pcap_t *pcapHandle = pcap_open_offline(pcapFile, errbuf); if (pcapHandle == nullptr) { cerr << "ERROR: Unable to open pcap file \"" << pcapFile << "\": " << errbuf << endl; return false; } struct pcap_pkthdr pktHeader; const unsigned char *pktData; while ((pktData = pcap_next(pcapHandle, &pktHeader)) != nullptr) { unsigned int offset = 0, length = 0; if (!payloadOffset(pktData, &offset, &length)) { continue; } // Valid TCP or UDP packet const struct ip *iphdr = (const struct ip *)(pktData + sizeof(struct ether_header)); const char *payload = (const char *)pktData + offset; size_t id = stream_map.insert(std::make_pair(FiveTuple(iphdr), stream_map.size())).first->second; packets.push_back(string(payload, length)); stream_ids.push_back(id); } pcap_close(pcapHandle); return !packets.empty(); } // Return the number of bytes scanned size_t bytes() const { size_t sum = 0; for (const auto &packet : packets) { sum += packet.size(); } return sum; } // Return the number of matches found. size_t matches() const { return matchCount; } // Clear the number of matches found. void clearMatches() { matchCount = 0; } // Open a Hyperscan stream for each stream in stream_ids void openStreams() { streams.resize(stream_map.size()); for (auto &stream : streams) { hs_error_t err = hs_open_stream(db, 0, &stream); if (err != HS_SUCCESS) { cerr << "ERROR: Unable to open stream. Exiting." << endl; exit(-1); } } } // Close all open Hyperscan streams (potentially generating any // end-anchored matches) void closeStreams() { for (auto &stream : streams) { hs_error_t err = hs_close_stream(stream, scratch, onMatch, &matchCount); if (err != HS_SUCCESS) { cerr << "ERROR: Unable to close stream. Exiting." << endl; exit(-1); } } } // Scan each packet (in the ordering given in the PCAP file) through // Hyperscan using the streaming interface. void scanStreams() { for (size_t i = 0; i != packets.size(); ++i) { const std::string &pkt = packets[i]; hs_error_t err = hs_scan_stream(streams[stream_ids[i]], pkt.c_str(), pkt.length(), 0, scratch, onMatch, &matchCount); if (err != HS_SUCCESS) { cerr << "ERROR: Unable to scan packet. Exiting." << endl; exit(-1); } } } // Scan each packet (in the ordering given in the PCAP file) through // Hyperscan using the block-mode interface. void scanBlock() { for (size_t i = 0; i != packets.size(); ++i) { const std::string &pkt = packets[i]; hs_error_t err = hs_scan(db, pkt.c_str(), pkt.length(), 0, scratch, onMatch, &matchCount); if (err != HS_SUCCESS) { cerr << "ERROR: Unable to scan packet. Exiting." << endl; exit(-1); } } } }; // helper function - see end of file static void parseFile(const char *filename, vector &patterns, vector &flags, vector &ids, vector &originals); class Sigdata { vector flags; vector ids; vector patterns; vector originals; public: Sigdata() {} Sigdata(const char *filename) { parseFile(filename, patterns, flags, ids, originals); } const string &get_original(unsigned index) const { return originals[index]; } hs_database_t *compileDatabase(unsigned mode, double *compileTime) const { hs_database_t *db = nullptr; hs_compile_error_t *compileErr; // Turn our vector of strings into a vector of char*'s to pass in to // hs_compile_multi. (This is just using the vector of strings as // dynamic storage.) vector cstrPatterns; cstrPatterns.reserve(patterns.size()); for (const auto &pattern : patterns) { cstrPatterns.push_back(pattern.c_str()); } Clock clock; clock.start(); hs_error_t err = hs_compile_multi(cstrPatterns.data(), flags.data(), ids.data(), cstrPatterns.size(), mode, nullptr, &db, &compileErr); clock.stop(); if (err != HS_SUCCESS) { if (compileErr->expression < 0) { // The error does not refer to a particular expression. cerr << "ERROR: " << compileErr->message << endl; } else { cerr << "ERROR: Pattern '" << patterns[compileErr->expression] << "' failed with error '" << compileErr->message << "'" << endl; } // As the compileErr pointer points to dynamically allocated memory, // if we get an error, we must be sure to release it. This is not // necessary when no error is detected. hs_free_compile_error(compileErr); exit(-1); } *compileTime = clock.seconds(); return db; } unsigned size() const { return patterns.size(); } Sigdata cloneExclude(const set &excludeIndexSet) const { Sigdata c; for (unsigned i = 0, e = size(); i != e; ++i) { if (excludeIndexSet.find(i) == excludeIndexSet.end()) { c.flags.push_back(flags[i]); c.ids.push_back(ids[i]); c.patterns.push_back(patterns[i]); c.originals.push_back(originals[i]); } } return c; } }; static void usage(const char *) { cerr << "Usage:" << endl << endl; cerr << " patbench [-n repeats] [ -G generations] [ -C criterion ]" << endl << " [ -F factor_group_size ] [ -N | -S ] " << " " << endl << endl << " -n repeats sets the number of times the PCAP is repeatedly " "scanned" << endl << " with the pattern." << endl << " -G generations sets the number of generations that the " "algorithm is" << endl << " run for." << endl << " -N sets non-streaming mode, -S sets streaming mode (default)." << endl << " -F sets the factor group size (must be >0); this " "allows the detection" << endl << " of multiple interacting factors." << endl << "" << endl << " -C sets the 'criterion', which can be either:" << endl << " t throughput (the default) - this requires a pcap file" << endl << " r scratch size" << endl << " s stream state size" << endl << " c compile time" << endl << " b bytecode size" << endl << endl << "We recommend the use of a utility like 'taskset' on " "multiprocessor hosts to" << endl << "lock execution to a single processor: this will remove processor " "migration" << endl << "by the scheduler as a source of noise in the results." << endl; } static double measure_stream_time(Benchmark &bench, unsigned int repeatCount) { Clock clock; bench.clearMatches(); clock.start(); for (unsigned int i = 0; i < repeatCount; i++) { bench.openStreams(); bench.scanStreams(); bench.closeStreams(); } clock.stop(); double secsScan = clock.seconds(); return secsScan; } static double measure_block_time(Benchmark &bench, unsigned int repeatCount) { Clock clock; bench.clearMatches(); clock.start(); for (unsigned int i = 0; i < repeatCount; i++) { bench.scanBlock(); } clock.stop(); double secsScan = clock.seconds(); return secsScan; } static double eval_set(Benchmark &bench, Sigdata &sigs, unsigned int mode, unsigned repeatCount, Criterion criterion, bool diagnose = true) { double compileTime = 0; bench.setDatabase(sigs.compileDatabase(mode, &compileTime)); switch (criterion) { case CRITERION_BYTECODE_SIZE: { size_t dbSize; hs_error_t err = hs_database_size(bench.getDatabase(), &dbSize); if (err != HS_SUCCESS) { cerr << "ERROR: could not retrieve bytecode size" << endl; exit(1); } return dbSize; } case CRITERION_COMPILE_TIME: return compileTime; case CRITERION_STREAM_STATE: { size_t streamStateSize; hs_error_t err = hs_stream_size(bench.getDatabase(), &streamStateSize); if (err != HS_SUCCESS) { cerr << "ERROR: could not retrieve stream state size" << endl; exit(1); } return streamStateSize; } case CRITERION_SCRATCH_SIZE: return bench.getScratchSize(); case CRITERION_THROUGHPUT: default: break; // do nothing - we are THROUGHPUT } double scan_time; if (mode == HS_MODE_NOSTREAM) { scan_time = measure_block_time(bench, repeatCount); } else { scan_time = measure_stream_time(bench, repeatCount); } size_t bytes = bench.bytes(); size_t matches = bench.matches(); if (diagnose) { cout << "Scan time " << std::fixed << std::setprecision(3) << scan_time << " sec, Scanned " << bytes * repeatCount << " bytes, Throughput " << std::fixed << std::setprecision(3) << (bytes * 8 * repeatCount) / (scan_time * 1000000) << " Mbps, Matches " << matches << endl; } return (bytes * 8 * repeatCount) / (scan_time * 1000000); } // Main entry point. int main(int argc, char **argv) { unsigned int repeatCount = 1; unsigned int mode = HS_MODE_STREAM; Criterion criterion = CRITERION_THROUGHPUT; unsigned int gen_max = 10; unsigned int factor_max = 1; // Process command line arguments. int opt; while ((opt = getopt(argc, argv, "SNn:G:F:C:")) != -1) { switch (opt) { case 'F': factor_max = atoi(optarg); break; case 'G': gen_max = atoi(optarg); break; case 'S': mode = HS_MODE_STREAM; break; case 'N': mode = HS_MODE_NOSTREAM; break; case 'C': switch (optarg[0]) { case 't': criterion = CRITERION_THROUGHPUT; break; case 'b': criterion = CRITERION_BYTECODE_SIZE; break; case 'c': criterion = CRITERION_COMPILE_TIME; break; case 's': criterion = CRITERION_STREAM_STATE; break; case 'r': criterion = CRITERION_SCRATCH_SIZE; break; default: cerr << "Unrecognised criterion: " << optarg[0] << endl; usage(argv[0]); exit(-1); } break; case 'n': repeatCount = atoi(optarg); break; default: usage(argv[0]); exit(-1); } } if (argc - optind != ((criterion == CRITERION_THROUGHPUT) ? 2 : 1)) { usage(argv[0]); exit(-1); } const char *patternFile = argv[optind]; const char *pcapFile = argv[optind + 1]; // Read our input PCAP file in Benchmark bench; if (criterion == CRITERION_THROUGHPUT) { if (!bench.readStreams(pcapFile)) { cerr << "Unable to read packets from PCAP file. Exiting." << endl; exit(-1); } } if ((criterion == CRITERION_STREAM_STATE) && (mode != HS_MODE_STREAM)) { cerr << "Cannot evaluate stream state for block mode compile. Exiting." << endl; exit(-1); } cout << "Base signatures: " << patternFile; if (pcapFile) { cout << "\tPCAP input file: " << pcapFile << "\tRepeat count: " << repeatCount; } if (mode == HS_MODE_STREAM) { cout << "\tMode: streaming"; } else { cout << "\tMode: block"; } cout << endl; Sigdata sigs(patternFile); // calculate and show a baseline eval_set(bench, sigs, mode, repeatCount, criterion); set work_sigs, exclude; for (unsigned i = 0; i < sigs.size(); ++i) { work_sigs.insert(i); } double score_base = eval_set(bench, sigs, mode, repeatCount, criterion, false); bool maximize = higher_is_better(criterion); cout << "Number of signatures: " << sigs.size() << endl; cout << "Base performance: "; print_criterion(criterion, score_base); cout << endl; unsigned generations = min(gen_max, (sigs.size() - 1) / factor_max); cout << "Cutting signatures cumulatively for " << generations << " generations" << endl; for (unsigned gen = 0; gen < generations; ++gen) { cout << "Generation " << gen << " "; set s(work_sigs.begin(), work_sigs.end()); double best = maximize ? 0 : 1000000000000.0; unsigned count = 0; while (s.size() > factor_max) { count++; cout << "." << std::flush; vector sv(s.begin(), s.end()); random_shuffle(sv.begin(), sv.end()); unsigned groups = factor_max + 1; for (unsigned current_group = 0; current_group < groups; current_group++) { unsigned sz = sv.size(); unsigned lo = (current_group * sz) / groups; unsigned hi = ((current_group + 1) * sz) / groups; set s_part1(sv.begin(), sv.begin() + lo); set s_part2(sv.begin() + hi, sv.end()); set s_tmp = s_part1; s_tmp.insert(s_part2.begin(), s_part2.end()); set tmp = s_tmp; tmp.insert(exclude.begin(), exclude.end()); Sigdata sigs_tmp = sigs.cloneExclude(tmp); double score = eval_set(bench, sigs_tmp, mode, repeatCount, criterion, false); if ((current_group == 0) || (!maximize ? (score < best) : (score > best))) { s = s_tmp; best = score; } } } for (unsigned i = count; i < 16; i++) { cout << " "; } cout << "Performance: "; print_criterion(criterion, best); cout << " (" << std::fixed << std::setprecision(3) << (best / score_base) << "x) after cutting:" << endl; // s now has factor_max signatures for (const auto &found : s) { exclude.insert(found); work_sigs.erase(found); cout << sigs.get_original(found) << endl; } cout << endl; } return 0; } /** * Helper function to locate the offset of the first byte of the payload in the * given ethernet frame. Offset into the packet, and the length of the payload * are returned in the arguments @a offset and @a length. */ static bool payloadOffset(const unsigned char *pkt_data, unsigned int *offset, unsigned int *length) { const ip *iph = (const ip *)(pkt_data + sizeof(ether_header)); const tcphdr *th = nullptr; // Ignore packets that aren't IPv4 if (iph->ip_v != 4) { return false; } // Ignore fragmented packets. if (iph->ip_off & htons(IP_MF | IP_OFFMASK)) { return false; } // IP header length, and transport header length. unsigned int ihlen = iph->ip_hl * 4; unsigned int thlen = 0; switch (iph->ip_p) { case IPPROTO_TCP: th = (const tcphdr *)((const char *)iph + ihlen); thlen = th->th_off * 4; break; case IPPROTO_UDP: thlen = sizeof(udphdr); break; default: return false; } *offset = sizeof(ether_header) + ihlen + thlen; *length = sizeof(ether_header) + ntohs(iph->ip_len) - *offset; return *length != 0; } static unsigned parseFlags(const string &flagsStr) { unsigned flags = 0; for (const auto &c : flagsStr) { switch (c) { case 'i': flags |= HS_FLAG_CASELESS; break; case 'm': flags |= HS_FLAG_MULTILINE; break; case 's': flags |= HS_FLAG_DOTALL; break; case 'H': flags |= HS_FLAG_SINGLEMATCH; break; case 'V': flags |= HS_FLAG_ALLOWEMPTY; break; case '8': flags |= HS_FLAG_UTF8; break; case 'W': flags |= HS_FLAG_UCP; break; case '\r': // stray carriage-return break; default: cerr << "Unsupported flag \'" << c << "\'" << endl; exit(-1); } } return flags; } static void parseFile(const char *filename, vector &patterns, vector &flags, vector &ids, vector &originals) { ifstream inFile(filename); if (!inFile.good()) { cerr << "ERROR: Can't open pattern file \"" << filename << "\"" << endl; exit(-1); } for (unsigned i = 1; !inFile.eof(); ++i) { string line; getline(inFile, line); // if line is empty, or a comment, we can skip it if (line.empty() || line[0] == '#') { continue; } // otherwise, it should be ID:PCRE, e.g. // 10001:/foobar/is size_t colonIdx = line.find_first_of(':'); if (colonIdx == string::npos) { cerr << "ERROR: Could not parse line " << i << endl; exit(-1); } // we should have an unsigned int as an ID, before the colon unsigned id = std::stoi(line.substr(0, colonIdx).c_str()); // rest of the expression is the PCRE const string expr(line.substr(colonIdx + 1)); size_t flagsStart = expr.find_last_of('/'); if (flagsStart == string::npos) { cerr << "ERROR: no trailing '/' char" << endl; exit(-1); } string pcre(expr.substr(1, flagsStart - 1)); string flagsStr(expr.substr(flagsStart + 1, expr.size() - flagsStart)); unsigned flag = parseFlags(flagsStr); originals.push_back(line); patterns.push_back(pcre); flags.push_back(flag); ids.push_back(id); } } hyperscan-4.4.1/examples/CMakeLists.txt0000644000175000017500000000133113055426554020653 0ustar sleuthkidsleuthkidfind_library(PCAP_LIBRARY pcap) if (NOT PCAP_LIBRARY) message(STATUS "Could not find libpcap - some examples will not be built") endif() add_executable(simplegrep simplegrep.c) set_source_files_properties(simplegrep.c PROPERTIES COMPILE_FLAGS "-Wall -Wno-unused-parameter") target_link_libraries(simplegrep hs) if (PCAP_LIBRARY) add_executable(pcapscan pcapscan.cc) set_source_files_properties(pcapscan.cc PROPERTIES COMPILE_FLAGS "-Wall -Wno-unused-parameter") target_link_libraries(pcapscan hs pcap) endif() if (PCAP_LIBRARY) add_executable(patbench patbench.cc) set_source_files_properties(patbench.cc PROPERTIES COMPILE_FLAGS "-Wall -Wno-unused-parameter") target_link_libraries(patbench hs pcap) endif() hyperscan-4.4.1/examples/README.md0000644000175000017500000001712013055426554017375 0ustar sleuthkidsleuthkidHyperscan Example Code ====================== Copyright (C) 2015 Intel Corporation. All rights reserved. The files in this directory contain example code demonstrating the use of the Hyperscan regular expression matching library. The examples have been constructed to be useful utility programs, but they have been simplified somewhat, so generally contain "shortcuts" that one would not take if building a "real" system. The examples each contain a short description in a comment at the top of the file, including build instructions. --- Example 1: simplegrep --------------------- The first example program (`simplegrep.c`) is modelled on the ubiquitous grep tool to search a file for a single regular expression. 'simplegrep' does the same, but eschews a lot of grep's complexity: it is unable to read data from `stdin`, and doesn't support grep's plethora of command-line arguments. This code is intended to be simple portable C99. simplegrep demonstrates the following Hyperscan concepts: - Single pattern compilation: As simplegrep can scan for one pattern only, it uses the `hs_compile` function instead of the multi-pattern variant: `hs_compile_multi`. - Block mode pattern-matching: simplegrep will search a single data buffer for the given pattern, so it has no need to set up and tear down streams. (See the next section for a streaming mode example) - Scratch space allocation and use: Hyperscan requires a small amount of temporary memory that is used in the `hs_scan` call. The caller needs to guarantee that only one instance of `hs_scan` is using the scratch space at a time, but there is no requirement that the same scratch area be used on consecutive calls to `hs_scan`. Given that it is expensive to allocate the scratch space, one would typically allocate all necessary scratch space at system startup and reuse it throughout execution of the program. Example 2: pcapscan ------------------- The second example program (`pcapscan.cc`) is a very simple packet scanning benchmark. It scans a given PCAP file full of network traffic against a group of regular expressions and returns some coarse performance measurements. This example provides a quick way to examine the performance achievable on a particular combination of platform, pattern set and input data. In block mode, pcapscan scans each packet individually against a Hyperscan database. In streaming mode, pcapscan assigns packets to flows using a rudimentary connection tracker, then scans the packets in each flow with Hyperscan's streaming mode interface. This demonstrates the use of streaming mode operation to detect matches that straddle packet boundaries. **Note**: the flow assignment implemented here is intended as a simple demo; it merely ensures that packets with the same 5-tuple are written to the same stream in the order in which they appear in the PCAP file. No packet re-ordering or connection state tracking (as you would expect to find in a real network scanning application) is done. pcapscan introduces the following Hyperscan concepts: - Multi-pattern compilation: Unlike simplegrep, pcapscan requires a file of expressions as input instead of a single pattern. pcapscan will read this file in, one pattern per line, and use it as input to the `hs_compile_multi` function. This function generates a pattern database that will match all the input patterns in parallel. - Streamed pattern-matching: pcapscan uses the `hs_scan_stream` function (instead of the block-mode `hs_scan` call) to allow it to identify matches that occur in a stream of data, even if they straddle the boundaries between blocks. Streaming mode operation has a number of unique properties: - Stream state that persists for the lifetime of the stream must be allocated with the `hs_open_stream` function before scanning can take place. Similarly, it must be freed with `hs_close_stream` after it is no longer needed. Each stream being scanned concurrently requires its own stream state. - In streaming mode, a non-zero return from the user-specified event-handler function has consequences for the rest of that stream's lifetime: when a non-zero return occurs, it signals that no more of the stream should be scanned. Consequently if the user makes a subsequent call to `hs_scan_stream` on a stream whose processing was terminated in this way, hs_scan_stream will return `HS_SCAN_TERMINATED`. This case has not been demonstrated in pcapscan, as its callback always returns 0. - Match handling during stream shutdown: As matches may occur when the `hs_close_stream` function is called, it too must be provided with scratch space in order to perform this match processing. Similarly, the user must be prepared to be issued match event callbacks during the `hs_close_stream` call. For this reason, we advise that stream shutdown be an integral part of the system design. Example 3: patbench ------------------- This program allows users to detect which signatures may be the most expensive in a set of patterns. It is designed for use with small to medium pattern set sizes (e.g. 5-500). If used with very large pattern sets it may take a very long time - the number of recompiles done is `g * O(lg2(n))` where `g` is the number of generations and `n` is the number of patterns (assuming that `n >> g`). This utility will return a cumulative series of removed patterns. The first generation will find and remove a single pattern. The second generation will begin with the first pattern removed and find another pattern to remove, etc. So if we have 100 patterns and 15 generations, the final generation's score will be a run over 85 patterns. This utility is probabilistic. It is possible that the pattern removed in a generation is not a particularly expensive pattern. To reduce noise in the results use 'taskset' and set the number of repeats to a level that still completes in reasonable time (this will reduce the effect of random measurement noise). The criterion for performance can be altered by use of the `-C` flag where `` can be `t,r,s,c,b`, selecting pattern matching throughput, scratch size, stream state size (only available in streaming mode), compile time and bytecode size respectively. This utility will also not produce good results if all the patterns are roughly equally expensive. ### Factor Group Size: If there are multiple expensive patterns that are very similar on the left-hand-side or identical, this utility will typically not find these groups unless the `-F` flag is used to search for a group size that is equal to or larger than the size of the group of similar patterns. Otherwise, removing a portion of the similar patterns will have no or almost no effect, and the search procedure used relies on the ability to remove all of the similar patterns in at least one search case, something which will only happen if the `factor_group_size` is large enough. This alters the operation of the tool so that instead of trying to find the single pattern whose removal has the most effect by binary search (the default with `factor_group_size == 1`), we attempt to find the N patterns whose removal has the most effect by searching over `N + 1` evenly sized groups, removing only `1/(N + 1)` of the search signatures per iteration. Note that the number of recompiles done greatly increases with increased factor group size. For example, with `factor_group_size = 1`, we do `g * 2 * lg2(n)` recompiles, while with `factor_group_size = 4`, we do `g * 4 * log(5/4)(n)`. Informally the number of generations we require goes up as we eliminate a smaller number of signatures and the we have to do more work per generation. hyperscan-4.4.1/examples/pcapscan.cc0000644000175000017500000005461413055426554020226 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /* * Hyperscan example program 2: pcapscan * * This example is a very simple packet scanning benchmark. It scans a given * PCAP file full of network traffic against a group of regular expressions and * returns some coarse performance measurements. This example provides a quick * way to examine the performance achievable on a particular combination of * platform, pattern set and input data. * * Build instructions: * * g++ -std=c++11 -O2 -o pcapscan pcapscan.cc $(pkg-config --cflags --libs libhs) -lpcap * * Usage: * * ./pcapscan [-n repeats] * * We recommend the use of a utility like 'taskset' on multiprocessor hosts to * pin execution to a single processor: this will remove processor migration * by the scheduler as a source of noise in the results. * */ #include #include #include #include #include #include #include #include #include // We use the BSD primitives throughout as they exist on both BSD and Linux. #define __FAVOR_BSD #include #include #include #include #include #include #include #include #include #include using std::cerr; using std::cout; using std::endl; using std::ifstream; using std::string; using std::unordered_map; using std::vector; // Key for identifying a stream in our pcap input data, using data from its IP // headers. struct FiveTuple { unsigned int protocol; unsigned int srcAddr; unsigned int srcPort; unsigned int dstAddr; unsigned int dstPort; // Construct a FiveTuple from a TCP or UDP packet. FiveTuple(const struct ip *iphdr) { // IP fields protocol = iphdr->ip_p; srcAddr = iphdr->ip_src.s_addr; dstAddr = iphdr->ip_dst.s_addr; // UDP/TCP ports const struct udphdr *uh = (const struct udphdr *)(((const char *)iphdr) + (iphdr->ip_hl * 4)); srcPort = uh->uh_sport; dstPort = uh->uh_dport; } bool operator==(const FiveTuple &a) const { return protocol == a.protocol && srcAddr == a.srcAddr && srcPort == a.srcPort && dstAddr == a.dstAddr && dstPort == a.dstPort; } }; // A *very* simple hash function, used when we create an unordered_map of // FiveTuple objects. struct FiveTupleHash { size_t operator()(const FiveTuple &x) const { return x.srcAddr ^ x.dstAddr ^ x.protocol ^ x.srcPort ^ x.dstPort; } }; // Helper function. See end of file. static bool payloadOffset(const unsigned char *pkt_data, unsigned int *offset, unsigned int *length); // Match event handler: called every time Hyperscan finds a match. static int onMatch(unsigned int id, unsigned long long from, unsigned long long to, unsigned int flags, void *ctx) { // Our context points to a size_t storing the match count size_t *matches = (size_t *)ctx; (*matches)++; return 0; // continue matching } // Simple timing class class Clock { public: void start() { time_start = std::chrono::system_clock::now(); } void stop() { time_end = std::chrono::system_clock::now(); } double seconds() const { std::chrono::duration delta = time_end - time_start; return delta.count(); } private: std::chrono::time_point time_start, time_end; }; // Class wrapping all state associated with the benchmark class Benchmark { private: // Packet data to be scanned. vector packets; // The stream ID to which each packet belongs vector stream_ids; // Map used to construct stream_ids unordered_map stream_map; // Hyperscan compiled database (streaming mode) const hs_database_t *db_streaming; // Hyperscan compiled database (block mode) const hs_database_t *db_block; // Hyperscan temporary scratch space (used in both modes) hs_scratch_t *scratch; // Vector of Hyperscan stream state (used in streaming mode) vector streams; // Count of matches found during scanning size_t matchCount; public: Benchmark(const hs_database_t *streaming, const hs_database_t *block) : db_streaming(streaming), db_block(block), scratch(nullptr), matchCount(0) { // Allocate enough scratch space to handle either streaming or block // mode, so we only need the one scratch region. hs_error_t err = hs_alloc_scratch(db_streaming, &scratch); if (err != HS_SUCCESS) { cerr << "ERROR: could not allocate scratch space. Exiting." << endl; exit(-1); } // This second call will increase the scratch size if more is required // for block mode. err = hs_alloc_scratch(db_block, &scratch); if (err != HS_SUCCESS) { cerr << "ERROR: could not allocate scratch space. Exiting." << endl; exit(-1); } } ~Benchmark() { // Free scratch region hs_free_scratch(scratch); } // Read a set of streams from a pcap file bool readStreams(const char *pcapFile) { // Open PCAP file for input char errbuf[PCAP_ERRBUF_SIZE]; pcap_t *pcapHandle = pcap_open_offline(pcapFile, errbuf); if (pcapHandle == nullptr) { cerr << "ERROR: Unable to open pcap file \"" << pcapFile << "\": " << errbuf << endl; return false; } struct pcap_pkthdr pktHeader; const unsigned char *pktData; while ((pktData = pcap_next(pcapHandle, &pktHeader)) != nullptr) { unsigned int offset = 0, length = 0; if (!payloadOffset(pktData, &offset, &length)) { continue; } // Valid TCP or UDP packet const struct ip *iphdr = (const struct ip *)(pktData + sizeof(struct ether_header)); const char *payload = (const char *)pktData + offset; size_t id = stream_map.insert(std::make_pair(FiveTuple(iphdr), stream_map.size())).first->second; packets.push_back(string(payload, length)); stream_ids.push_back(id); } pcap_close(pcapHandle); return !packets.empty(); } // Return the number of bytes scanned size_t bytes() const { size_t sum = 0; for (const auto &packet : packets) { sum += packet.size(); } return sum; } // Return the number of matches found. size_t matches() const { return matchCount; } // Clear the number of matches found. void clearMatches() { matchCount = 0; } // Open a Hyperscan stream for each stream in stream_ids void openStreams() { streams.resize(stream_map.size()); for (auto &stream : streams) { hs_error_t err = hs_open_stream(db_streaming, 0, &stream); if (err != HS_SUCCESS) { cerr << "ERROR: Unable to open stream. Exiting." << endl; exit(-1); } } } // Close all open Hyperscan streams (potentially generating any // end-anchored matches) void closeStreams() { for (auto &stream : streams) { hs_error_t err = hs_close_stream(stream, scratch, onMatch, &matchCount); if (err != HS_SUCCESS) { cerr << "ERROR: Unable to close stream. Exiting." << endl; exit(-1); } } } // Scan each packet (in the ordering given in the PCAP file) through // Hyperscan using the streaming interface. void scanStreams() { for (size_t i = 0; i != packets.size(); ++i) { const std::string &pkt = packets[i]; hs_error_t err = hs_scan_stream(streams[stream_ids[i]], pkt.c_str(), pkt.length(), 0, scratch, onMatch, &matchCount); if (err != HS_SUCCESS) { cerr << "ERROR: Unable to scan packet. Exiting." << endl; exit(-1); } } } // Scan each packet (in the ordering given in the PCAP file) through // Hyperscan using the block-mode interface. void scanBlock() { for (size_t i = 0; i != packets.size(); ++i) { const std::string &pkt = packets[i]; hs_error_t err = hs_scan(db_block, pkt.c_str(), pkt.length(), 0, scratch, onMatch, &matchCount); if (err != HS_SUCCESS) { cerr << "ERROR: Unable to scan packet. Exiting." << endl; exit(-1); } } } // Display some information about the compiled database and scanned data. void displayStats() { size_t numPackets = packets.size(); size_t numStreams = stream_map.size(); size_t numBytes = bytes(); hs_error_t err; cout << numPackets << " packets in " << numStreams << " streams, totalling " << numBytes << " bytes." << endl; cout << "Average packet length: " << numBytes / numPackets << " bytes." << endl; cout << "Average stream length: " << numBytes / numStreams << " bytes." << endl; cout << endl; size_t dbStream_size = 0; err = hs_database_size(db_streaming, &dbStream_size); if (err == HS_SUCCESS) { cout << "Streaming mode Hyperscan database size : " << dbStream_size << " bytes." << endl; } else { cout << "Error getting streaming mode Hyperscan database size" << endl; } size_t dbBlock_size = 0; err = hs_database_size(db_block, &dbBlock_size); if (err == HS_SUCCESS) { cout << "Block mode Hyperscan database size : " << dbBlock_size << " bytes." << endl; } else { cout << "Error getting block mode Hyperscan database size" << endl; } size_t stream_size = 0; err = hs_stream_size(db_streaming, &stream_size); if (err == HS_SUCCESS) { cout << "Streaming mode Hyperscan stream state size: " << stream_size << " bytes (per stream)." << endl; } else { cout << "Error getting stream state size" << endl; } } }; // helper function - see end of file static void parseFile(const char *filename, vector &patterns, vector &flags, vector &ids); static hs_database_t *buildDatabase(const vector &expressions, const vector flags, const vector ids, unsigned int mode) { hs_database_t *db; hs_compile_error_t *compileErr; hs_error_t err; Clock clock; clock.start(); err = hs_compile_multi(expressions.data(), flags.data(), ids.data(), expressions.size(), mode, nullptr, &db, &compileErr); clock.stop(); if (err != HS_SUCCESS) { if (compileErr->expression < 0) { // The error does not refer to a particular expression. cerr << "ERROR: " << compileErr->message << endl; } else { cerr << "ERROR: Pattern '" << expressions[compileErr->expression] << "' failed compilation with error: " << compileErr->message << endl; } // As the compileErr pointer points to dynamically allocated memory, if // we get an error, we must be sure to release it. This is not // necessary when no error is detected. hs_free_compile_error(compileErr); exit(-1); } cout << "Hyperscan " << (mode == HS_MODE_STREAM ? "streaming" : "block") << " mode database compiled in " << clock.seconds() << " seconds." << endl; return db; } /** * This function will read in the file with the specified name, with an * expression per line, ignoring lines starting with '#' and build a Hyperscan * database for it. */ static void databasesFromFile(const char *filename, hs_database_t **db_streaming, hs_database_t **db_block) { // hs_compile_multi requires three parallel arrays containing the patterns, // flags and ids that we want to work with. To achieve this we use // vectors and new entries onto each for each valid line of input from // the pattern file. vector patterns; vector flags; vector ids; // do the actual file reading and string handling parseFile(filename, patterns, flags, ids); // Turn our vector of strings into a vector of char*'s to pass in to // hs_compile_multi. (This is just using the vector of strings as dynamic // storage.) vector cstrPatterns; for (const auto &pattern : patterns) { cstrPatterns.push_back(pattern.c_str()); } cout << "Compiling Hyperscan databases with " << patterns.size() << " patterns." << endl; *db_streaming = buildDatabase(cstrPatterns, flags, ids, HS_MODE_STREAM); *db_block = buildDatabase(cstrPatterns, flags, ids, HS_MODE_BLOCK); } static void usage(const char *prog) { cerr << "Usage: " << prog << " [-n repeats] " << endl; } // Main entry point. int main(int argc, char **argv) { unsigned int repeatCount = 1; // Process command line arguments. int opt; while ((opt = getopt(argc, argv, "n:")) != -1) { switch (opt) { case 'n': repeatCount = atoi(optarg); break; default: usage(argv[0]); exit(-1); } } if (argc - optind != 2) { usage(argv[0]); exit(-1); } const char *patternFile = argv[optind]; const char *pcapFile = argv[optind + 1]; // Read our pattern set in and build Hyperscan databases from it. cout << "Pattern file: " << patternFile << endl; hs_database_t *db_streaming, *db_block; databasesFromFile(patternFile, &db_streaming, &db_block); // Read our input PCAP file in Benchmark bench(db_streaming, db_block); cout << "PCAP input file: " << pcapFile << endl; if (!bench.readStreams(pcapFile)) { cerr << "Unable to read packets from PCAP file. Exiting." << endl; exit(-1); } if (repeatCount != 1) { cout << "Repeating PCAP scan " << repeatCount << " times." << endl; } bench.displayStats(); Clock clock; // Streaming mode scans. double secsStreamingScan = 0.0, secsStreamingOpenClose = 0.0; for (unsigned int i = 0; i < repeatCount; i++) { // Open streams. clock.start(); bench.openStreams(); clock.stop(); secsStreamingOpenClose += clock.seconds(); // Scan all our packets in streaming mode. clock.start(); bench.scanStreams(); clock.stop(); secsStreamingScan += clock.seconds(); // Close streams. clock.start(); bench.closeStreams(); clock.stop(); secsStreamingOpenClose += clock.seconds(); } // Collect data from streaming mode scans. size_t bytes = bench.bytes(); double tputStreamScanning = (bytes * 8 * repeatCount) / secsStreamingScan; double tputStreamOverhead = (bytes * 8 * repeatCount) / (secsStreamingScan + secsStreamingOpenClose); size_t matchesStream = bench.matches(); double matchRateStream = matchesStream / ((bytes * repeatCount) / 1024.0); // matches per kilobyte // Scan all our packets in block mode. bench.clearMatches(); clock.start(); for (unsigned int i = 0; i < repeatCount; i++) { bench.scanBlock(); } clock.stop(); double secsScanBlock = clock.seconds(); // Collect data from block mode scans. double tputBlockScanning = (bytes * 8 * repeatCount) / secsScanBlock; size_t matchesBlock = bench.matches(); double matchRateBlock = matchesBlock / ((bytes * repeatCount) / 1024.0); // matches per kilobyte cout << endl << "Streaming mode:" << endl << endl; cout << " Total matches: " << matchesStream << endl; cout << std::fixed << std::setprecision(4); cout << " Match rate: " << matchRateStream << " matches/kilobyte" << endl; cout << std::fixed << std::setprecision(2); cout << " Throughput (with stream overhead): " << tputStreamOverhead/1000000 << " megabits/sec" << endl; cout << " Throughput (no stream overhead): " << tputStreamScanning/1000000 << " megabits/sec" << endl; cout << endl << "Block mode:" << endl << endl; cout << " Total matches: " << matchesBlock << endl; cout << std::fixed << std::setprecision(4); cout << " Match rate: " << matchRateBlock << " matches/kilobyte" << endl; cout << std::fixed << std::setprecision(2); cout << " Throughput: " << tputBlockScanning/1000000 << " megabits/sec" << endl; cout << endl; if (bytes < (2*1024*1024)) { cout << endl << "WARNING: Input PCAP file is less than 2MB in size." << endl << "This test may have been too short to calculate accurate results." << endl; } // Close Hyperscan databases hs_free_database(db_streaming); hs_free_database(db_block); return 0; } /** * Helper function to locate the offset of the first byte of the payload in the * given ethernet frame. Offset into the packet, and the length of the payload * are returned in the arguments @a offset and @a length. */ static bool payloadOffset(const unsigned char *pkt_data, unsigned int *offset, unsigned int *length) { const ip *iph = (const ip *)(pkt_data + sizeof(ether_header)); const tcphdr *th = nullptr; // Ignore packets that aren't IPv4 if (iph->ip_v != 4) { return false; } // Ignore fragmented packets. if (iph->ip_off & htons(IP_MF|IP_OFFMASK)) { return false; } // IP header length, and transport header length. unsigned int ihlen = iph->ip_hl * 4; unsigned int thlen = 0; switch (iph->ip_p) { case IPPROTO_TCP: th = (const tcphdr *)((const char *)iph + ihlen); thlen = th->th_off * 4; break; case IPPROTO_UDP: thlen = sizeof(udphdr); break; default: return false; } *offset = sizeof(ether_header) + ihlen + thlen; *length = sizeof(ether_header) + ntohs(iph->ip_len) - *offset; return *length != 0; } static unsigned parseFlags(const string &flagsStr) { unsigned flags = 0; for (const auto &c : flagsStr) { switch (c) { case 'i': flags |= HS_FLAG_CASELESS; break; case 'm': flags |= HS_FLAG_MULTILINE; break; case 's': flags |= HS_FLAG_DOTALL; break; case 'H': flags |= HS_FLAG_SINGLEMATCH; break; case 'V': flags |= HS_FLAG_ALLOWEMPTY; break; case '8': flags |= HS_FLAG_UTF8; break; case 'W': flags |= HS_FLAG_UCP; break; case '\r': // stray carriage-return break; default: cerr << "Unsupported flag \'" << c << "\'" << endl; exit(-1); } } return flags; } static void parseFile(const char *filename, vector &patterns, vector &flags, vector &ids) { ifstream inFile(filename); if (!inFile.good()) { cerr << "ERROR: Can't open pattern file \"" << filename << "\"" << endl; exit(-1); } for (unsigned i = 1; !inFile.eof(); ++i) { string line; getline(inFile, line); // if line is empty, or a comment, we can skip it if (line.empty() || line[0] == '#') { continue; } // otherwise, it should be ID:PCRE, e.g. // 10001:/foobar/is size_t colonIdx = line.find_first_of(':'); if (colonIdx == string::npos) { cerr << "ERROR: Could not parse line " << i << endl; exit(-1); } // we should have an unsigned int as an ID, before the colon unsigned id = std::stoi(line.substr(0, colonIdx).c_str()); // rest of the expression is the PCRE const string expr(line.substr(colonIdx + 1)); size_t flagsStart = expr.find_last_of('/'); if (flagsStart == string::npos) { cerr << "ERROR: no trailing '/' char" << endl; exit(-1); } string pcre(expr.substr(1, flagsStart - 1)); string flagsStr(expr.substr(flagsStart + 1, expr.size() - flagsStart)); unsigned flag = parseFlags(flagsStr); patterns.push_back(pcre); flags.push_back(flag); ids.push_back(id); } } hyperscan-4.4.1/CMakeLists.txt0000644000175000017500000011555013055426554017046 0ustar sleuthkidsleuthkidcmake_minimum_required (VERSION 2.8.11) project (Hyperscan C CXX) set (HS_MAJOR_VERSION 4) set (HS_MINOR_VERSION 4) set (HS_PATCH_VERSION 1) set (HS_VERSION ${HS_MAJOR_VERSION}.${HS_MINOR_VERSION}.${HS_PATCH_VERSION}) set(CMAKE_MODULE_PATH ${PROJECT_SOURCE_DIR}/cmake) include(CheckCCompilerFlag) include(CheckCXXCompilerFlag) INCLUDE (CheckFunctionExists) INCLUDE (CheckIncludeFiles) INCLUDE (CheckIncludeFileCXX) INCLUDE (CheckLibraryExists) INCLUDE (CheckSymbolExists) include (CMakeDependentOption) include (${CMAKE_MODULE_PATH}/platform.cmake) include (${CMAKE_MODULE_PATH}/ragel.cmake) find_package(PkgConfig QUIET) if (NOT CMAKE_BUILD_TYPE) message(STATUS "Default build type 'Release with debug info'") set(CMAKE_BUILD_TYPE RELWITHDEBINFO CACHE STRING "" FORCE ) else() string(TOUPPER ${CMAKE_BUILD_TYPE} CMAKE_BUILD_TYPE) message(STATUS "Build type ${CMAKE_BUILD_TYPE}") endif() if(CMAKE_BUILD_TYPE MATCHES RELEASE|RELWITHDEBINFO) set(RELEASE_BUILD TRUE) else() set(RELEASE_BUILD FALSE) endif() set(BINDIR "${PROJECT_BINARY_DIR}/bin") set(LIBDIR "${PROJECT_BINARY_DIR}/lib") # First for the generic no-config case set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${BINDIR}") set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${LIBDIR}") set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY "${LIBDIR}") # Second, for multi-config builds (e.g. msvc) foreach (OUTPUTCONFIG ${CMAKE_CONFIGURATION_TYPES}) string (TOUPPER ${OUTPUTCONFIG} OUTPUTCONFIG) set(CMAKE_RUNTIME_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${BINDIR}") set(CMAKE_LIBRARY_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${LIBDIR}") set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY_${OUTPUTCONFIG} "${LIBDIR}") endforeach (OUTPUTCONFIG CMAKE_CONFIGURATION_TYPES) if(CMAKE_GENERATOR STREQUAL Xcode) set(XCODE TRUE) endif() set(CMAKE_INCLUDE_CURRENT_DIR 1) include_directories(${PROJECT_SOURCE_DIR}/src) include_directories(${PROJECT_BINARY_DIR}) include_directories(SYSTEM include) set(BOOST_USE_STATIC_LIBS OFF) set(BOOST_USE_MULTITHREADED OFF) set(BOOST_USE_STATIC_RUNTIME OFF) if (CMAKE_SYSTEM_NAME MATCHES "Darwin" OR (CMAKE_SYSTEM_NAME MATCHES "FreeBSD" AND CMAKE_C_COMPILER_ID MATCHES "Clang")) # we need a more recent boost for libc++ used by clang on OSX and FreeBSD set(BOOST_MINVERSION 1.61.0) else () set(BOOST_MINVERSION 1.57.0) endif () set(BOOST_NO_BOOST_CMAKE ON) # first check for Boost installed on the system find_package(Boost ${BOOST_MINVERSION}) if(NOT Boost_FOUND) # we might have boost in tree, so provide a hint and try again message(STATUS "trying include dir for boost") set(BOOST_INCLUDEDIR "${PROJECT_SOURCE_DIR}/include") find_package(Boost ${BOOST_MINVERSION}) if(NOT Boost_FOUND) message(FATAL_ERROR "Boost ${BOOST_MINVERSION} or later not found. Either install system packages if available, extract Boost headers to ${CMAKE_SOURCE_DIR}/include, or set the CMake BOOST_ROOT variable.") endif() endif() include (${CMAKE_MODULE_PATH}/boost.cmake) # -- make this work? set(python_ADDITIONAL_VERSIONS 2.7 2.6) find_package(PythonInterp) find_program(RAGEL ragel) if(PYTHONINTERP_FOUND) set(PYTHON ${PYTHON_EXECUTABLE}) else() message(FATAL_ERROR "No python interpreter found") endif() # allow for reproducible builds - python for portability if (DEFINED ENV{SOURCE_DATE_EPOCH}) execute_process( COMMAND "${PYTHON}" "${CMAKE_MODULE_PATH}/formatdate.py" "$ENV{SOURCE_DATE_EPOCH}" OUTPUT_VARIABLE BUILD_DATE OUTPUT_STRIP_TRAILING_WHITESPACE) else () string (TIMESTAMP BUILD_DATE "%Y-%m-%d") endif () message(STATUS "Build date: ${BUILD_DATE}") if(${RAGEL} STREQUAL "RAGEL-NOTFOUND") message(FATAL_ERROR "Ragel state machine compiler not found") endif() option(OPTIMISE "Turns off compiler optimizations (on by default unless debug output enabled or coverage testing)" TRUE) option(DEBUG_OUTPUT "Enable debug output (warning: very verbose)" FALSE) if(DEBUG_OUTPUT) add_definitions(-DDEBUG) set(OPTIMISE FALSE) endif(DEBUG_OUTPUT) option(BUILD_SHARED_LIBS "Build shared libs instead of static" OFF) option(BUILD_STATIC_AND_SHARED "Build shared libs as well as static" OFF) if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS) if (WIN32) message(FATAL_ERROR "Windows DLLs currently not supported") else() message(STATUS "Building shared libraries") endif() endif() #for config if (OPTIMISE) set(HS_OPTIMIZE ON) endif() CMAKE_DEPENDENT_OPTION(DUMP_SUPPORT "Dump code support; normally on, except in release builds" ON "NOT RELEASE_BUILD" OFF) CMAKE_DEPENDENT_OPTION(DISABLE_ASSERTS "Disable assert(); Asserts are enabled in debug builds, disabled in release builds" OFF "NOT RELEASE_BUILD" ON) option(WINDOWS_ICC "Use Intel C++ Compiler on Windows, default off, requires ICC to be set in project" OFF) # TODO: per platform config files? # TODO: windows generator on cmake always uses msvc, even if we plan to build with icc if(MSVC OR MSVC_IDE) message(STATUS "Building for Windows") if (MSVC_VERSION LESS 1700) message(FATAL_ERROR "The project requires C++11 features.") else() if (WINDOWS_ICC) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /O3 /Qstd=c99 /Qrestrict /QxHost /wd4267 /Qdiag-disable:remark") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /Qstd=c++11 /Qrestrict /QxHost /wd4267 /wd4800 /Qdiag-disable:remark -DBOOST_DETAIL_NO_CONTAINER_FWD -D_SCL_SECURE_NO_WARNINGS") else() #TODO: don't hardcode arch set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} /O2 /arch:AVX /wd4267") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} /O2 /arch:AVX /wd4244 /wd4267 /wd4800 -DBOOST_DETAIL_NO_CONTAINER_FWD -D_SCL_SECURE_NO_WARNINGS") endif() string(REPLACE "/RTC1" "" CMAKE_CXX_FLAGS_DEBUG "${CMAKE_CXX_FLAGS_DEBUG}") string(REPLACE "/RTC1" "" CMAKE_C_FLAGS_DEBUG "${CMAKE_C_FLAGS_DEBUG}") if (DISABLE_ASSERTS) set(CMAKE_C_FLAGS_DEBUG "/DNDEBUG ${CMAKE_C_FLAGS_DEBUG}") set(CMAKE_CXX_FLAGS_DEBUG "/DNDEBUG ${CMAKE_CXX_FLAGS_DEBUG}") endif () endif() else() # compiler version checks TODO: test more compilers if (CMAKE_COMPILER_IS_GNUCXX) set (GNUCXX_MINVER "4.8.1") exec_program(${CMAKE_CXX_COMPILER} ARGS ${CMAKE_CXX_COMPILER_ARG1} --version OUTPUT_VARIABLE _GXX_OUTPUT) # is the following too fragile? string(REGEX REPLACE ".* ([0-9]\\.[0-9](\\.[0-9])?)( |\n).*" "\\1" GNUCXX_VERSION "${_GXX_OUTPUT}") message(STATUS "g++ version ${GNUCXX_VERSION}") if (GNUCXX_VERSION VERSION_LESS ${GNUCXX_MINVER}) message(FATAL_ERROR "A minimum of g++ ${GNUCXX_MINVER} is required for C++11 support") endif() unset(_GXX_OUTPUT) endif() # remove CMake's idea of optimisation foreach (CONFIG ${CMAKE_BUILD_TYPE} ${CMAKE_CONFIGURATION_TYPES}) string(REGEX REPLACE "-O[^ ]*" "" CMAKE_C_FLAGS_${CONFIG} "${CMAKE_C_FLAGS_${CONFIG}}") string(REGEX REPLACE "-O[^ ]*" "" CMAKE_CXX_FLAGS_${CONFIG} "${CMAKE_CXX_FLAGS_${CONFIG}}") endforeach () if(OPTIMISE) set(OPT_C_FLAG "-O3") set(OPT_CXX_FLAG "-O2") else() set(OPT_C_FLAG "-O0") set(OPT_CXX_FLAG "-O0") endif(OPTIMISE) # set compiler flags - more are tested and added later set(EXTRA_C_FLAGS "${OPT_C_FLAG} -std=c99 -Wall -Wextra -Wshadow -Wcast-qual -fno-strict-aliasing") set(EXTRA_CXX_FLAGS "${OPT_CXX_FLAG} -std=c++11 -Wall -Wextra -Wshadow -Wswitch -Wreturn-type -Wcast-qual -Wno-deprecated -Wnon-virtual-dtor -fno-strict-aliasing") if (NOT RELEASE_BUILD) # -Werror is most useful during development, don't potentially break # release builds set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Werror") set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -Werror") endif() if (DISABLE_ASSERTS) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -DNDEBUG") set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -DNDEBUG") endif() if (NOT CMAKE_C_FLAGS MATCHES .*march.*) set(ARCH_C_FLAGS "${ARCH_C_FLAGS} -march=native -mtune=native") endif() if (NOT CMAKE_CXX_FLAGS MATCHES .*march.*) set(ARCH_CXX_FLAGS "${ARCH_CXX_FLAGS} -march=native -mtune=native") endif() if(CMAKE_COMPILER_IS_GNUCC) # spurious warnings? set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-array-bounds -Wno-maybe-uninitialized") endif() if(CMAKE_COMPILER_IS_GNUCXX) set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -fabi-version=0 -Wno-unused-local-typedefs -Wno-maybe-uninitialized") endif() if (NOT(ARCH_IA32 AND RELEASE_BUILD)) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fno-omit-frame-pointer") set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -fno-omit-frame-pointer") endif() if (RELEASE_BUILD) # we don't need the noise of ABI warnings in a release build set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-abi") set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -Wno-abi") endif () endif() CHECK_INCLUDE_FILES(unistd.h HAVE_UNISTD_H) CHECK_INCLUDE_FILES(intrin.h HAVE_C_INTRIN_H) CHECK_INCLUDE_FILE_CXX(intrin.h HAVE_CXX_INTRIN_H) CHECK_INCLUDE_FILES(x86intrin.h HAVE_C_X86INTRIN_H) CHECK_INCLUDE_FILE_CXX(x86intrin.h HAVE_CXX_X86INTRIN_H) CHECK_FUNCTION_EXISTS(posix_memalign HAVE_POSIX_MEMALIGN) CHECK_FUNCTION_EXISTS(_aligned_malloc HAVE__ALIGNED_MALLOC) # these end up in the config file CHECK_C_COMPILER_FLAG(-fvisibility=hidden HAS_C_HIDDEN) CHECK_CXX_COMPILER_FLAG(-fvisibility=hidden HAS_CXX_HIDDEN) if (RELEASE_BUILD) if (HAS_C_HIDDEN) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -fvisibility=hidden") endif() if (HAS_CXX_HIDDEN) set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -fvisibility=hidden") endif() endif() if (CMAKE_SYSTEM_NAME MATCHES "Linux") # This is a Linux-only feature for now - requires platform support # elsewhere message(STATUS "generator is ${CMAKE_GENERATOR}") if (CMAKE_C_COMPILER_ID MATCHES "Clang" AND CMAKE_C_COMPILER_VERSION VERSION_LESS "3.9") message (STATUS "Clang v3.9 or higher required for fat runtime, cannot build fat runtime") set (FAT_RUNTIME_REQUISITES FALSE) elseif (NOT (CMAKE_GENERATOR MATCHES "Unix Makefiles" OR (CMAKE_VERSION VERSION_GREATER "3.0" AND CMAKE_GENERATOR MATCHES "Ninja"))) message (STATUS "Building the fat runtime requires the Unix Makefiles generator, or Ninja with CMake v3.0 or higher") set (FAT_RUNTIME_REQUISITES FALSE) else() include (${CMAKE_MODULE_PATH}/attrib.cmake) if (NOT HAS_C_ATTR_IFUNC) message(STATUS "Compiler does not support ifunc attribute, cannot build fat runtime") set (FAT_RUNTIME_REQUISITES FALSE) else () set (FAT_RUNTIME_REQUISITES TRUE) endif() endif() CMAKE_DEPENDENT_OPTION(FAT_RUNTIME "Build a library that supports multiple microarchitecures" ${RELEASE_BUILD} "FAT_RUNTIME_REQUISITES" OFF) endif () include (${CMAKE_MODULE_PATH}/arch.cmake) if (NOT FAT_RUNTIME AND NOT HAVE_SSSE3) message(FATAL_ERROR "A minimum of SSSE3 compiler support is required") endif () # testing a builtin takes a little more work CHECK_C_SOURCE_COMPILES("void *aa_test(void *x) { return __builtin_assume_aligned(x, 16);}\nint main(void) { return 0; }" HAVE_CC_BUILTIN_ASSUME_ALIGNED) CHECK_CXX_SOURCE_COMPILES("void *aa_test(void *x) { return __builtin_assume_aligned(x, 16);}\nint main(void) { return 0; }" HAVE_CXX_BUILTIN_ASSUME_ALIGNED) if (NOT WIN32) set(C_FLAGS_TO_CHECK # Variable length arrays are way bad, most especially at run time "-Wvla" # Pointer arith on void pointers is doing it wong. "-Wpointer-arith" # Build our C code with -Wstrict-prototypes -Wmissing-prototypes "-Wstrict-prototypes" "-Wmissing-prototypes" ) foreach (FLAG ${C_FLAGS_TO_CHECK}) # munge the name so it doesn't break things string(REPLACE "-" "_" FNAME C_FLAG${FLAG}) CHECK_C_COMPILER_FLAG("${FLAG}" ${FNAME}) if (${FNAME}) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} ${FLAG}") endif() endforeach() set(CXX_FLAGS_TO_CHECK "-Wvla" "-Wpointer-arith" ) foreach (FLAG ${CXX_FLAGS_TO_CHECK}) string(REPLACE "-" "_" FNAME CXX_FLAG${FLAG}) CHECK_CXX_COMPILER_FLAG("${FLAG}" ${FNAME}) if (${FNAME}) set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} ${FLAG}") endif() endforeach() # self-assign should be thrown away, but clang whinges CHECK_C_COMPILER_FLAG("-Wself-assign" CC_SELF_ASSIGN) if (CC_SELF_ASSIGN) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-self-assign") endif() CHECK_CXX_COMPILER_FLAG("-Wself-assign" CXX_SELF_ASSIGN) if (CXX_SELF_ASSIGN) set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -Wno-self-assign") endif() # clang gets up in our face for going paren crazy with macros CHECK_C_COMPILER_FLAG("-Wparentheses-equality" CC_PAREN_EQUALITY) if (CC_PAREN_EQUALITY) set(EXTRA_C_FLAGS "${EXTRA_C_FLAGS} -Wno-parentheses-equality") endif() # clang compains about unused const vars in our Ragel-generated code. CHECK_CXX_COMPILER_FLAG("-Wunused-const-variable" CXX_UNUSED_CONST_VAR) if (CXX_UNUSED_CONST_VAR) set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -Wno-unused-const-variable") endif() # gcc 6 complains about type attributes that get ignored, like alignment CHECK_CXX_COMPILER_FLAG("-Wignored-attributes" CXX_IGNORED_ATTR) if (CXX_IGNORED_ATTR) set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -Wno-ignored-attributes") endif() # note this for later # g++ doesn't have this flag but clang does CHECK_CXX_COMPILER_FLAG("-Wweak-vtables" CXX_WEAK_VTABLES) if (CXX_WEAK_VTABLES) set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -Wweak-vtables") endif() CHECK_CXX_COMPILER_FLAG("-Wmissing-declarations" CXX_MISSING_DECLARATIONS) if (CXX_MISSING_DECLARATIONS) set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -Wmissing-declarations") endif() # gcc5 complains about this CHECK_CXX_COMPILER_FLAG("-Wunused-variable" CXX_WUNUSED_VARIABLE) endif() if (NOT XCODE) include_directories(SYSTEM ${Boost_INCLUDE_DIRS}) else() # cmake doesn't think Xcode supports isystem set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -isystem ${Boost_INCLUDE_DIRS}") endif() if(CMAKE_SYSTEM_NAME MATCHES "Linux") set(LINUX TRUE) endif(CMAKE_SYSTEM_NAME MATCHES "Linux") if(CMAKE_SYSTEM_NAME MATCHES "FreeBSD") set(FREEBSD true) endif(CMAKE_SYSTEM_NAME MATCHES "FreeBSD") if(NOT WIN32) if(CMAKE_C_COMPILER_ID MATCHES "Intel") SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -diag-error 10006 -diag-disable 177 -diag-disable 2304 -diag-disable 2305 -diag-disable 2338 -diag-disable 1418 -diag-disable=remark") endif() if(CMAKE_CXX_COMPILER_ID MATCHES "Intel") SET(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -diag-error 10006 -diag-disable 177 -diag-disable 2304 -diag-disable 2305 -diag-disable 2338 -diag-disable 1418 -diag-disable 1170 -diag-disable 3373 -diag-disable=remark") endif() endif() if (NOT FAT_RUNTIME) message(STATUS "Building for current host CPU") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${ARCH_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${ARCH_CXX_FLAGS}") else() message(STATUS "Building runtime for multiple microarchitectures") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") endif() add_subdirectory(util) add_subdirectory(unit) add_subdirectory(doc/dev-reference) if (EXISTS ${CMAKE_SOURCE_DIR}/tools/CMakeLists.txt) add_subdirectory(tools) endif() # do substitutions configure_file(${CMAKE_MODULE_PATH}/config.h.in ${PROJECT_BINARY_DIR}/config.h) configure_file(src/hs_version.h.in ${PROJECT_BINARY_DIR}/hs_version.h) if (NOT WIN32) # expand out library names for pkgconfig static link info foreach (LIB ${CMAKE_CXX_IMPLICIT_LINK_LIBRARIES}) # this is fragile, but protects us from toolchain specific files if (NOT EXISTS ${LIB}) set(PRIVATE_LIBS "${PRIVATE_LIBS} -l${LIB}") endif() endforeach() configure_file(libhs.pc.in libhs.pc @ONLY) # only replace @ quoted vars install(FILES ${CMAKE_BINARY_DIR}/libhs.pc DESTINATION "${CMAKE_INSTALL_PREFIX}/lib/pkgconfig") endif() # only set these after all tests are done if (NOT FAT_RUNTIME) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}") else() set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}") endif() if(NOT WIN32) set(RAGEL_C_FLAGS "-Wno-unused") endif() set_source_files_properties( ${CMAKE_BINARY_DIR}/src/parser/Parser.cpp PROPERTIES COMPILE_FLAGS "${RAGEL_C_FLAGS}") ragelmaker(src/parser/Parser.rl) SET(hs_HEADERS src/hs.h src/hs_common.h src/hs_compile.h src/hs_runtime.h ) install(FILES ${hs_HEADERS} DESTINATION include/hs) set (hs_exec_common_SRCS src/alloc.c src/scratch.c src/util/cpuid_flags.c src/util/cpuid_flags.h src/util/multibit.c ) set (hs_exec_SRCS ${hs_HEADERS} src/hs_version.h src/ue2common.h src/allocator.h src/crc32.c src/crc32.h src/report.h src/runtime.c src/fdr/fdr.c src/fdr/fdr.h src/fdr/fdr_internal.h src/fdr/fdr_confirm.h src/fdr/fdr_confirm_runtime.h src/fdr/flood_runtime.h src/fdr/fdr_loadval.h src/fdr/teddy.c src/fdr/teddy.h src/fdr/teddy_internal.h src/fdr/teddy_runtime_common.h src/hwlm/hwlm.c src/hwlm/hwlm.h src/hwlm/hwlm_internal.h src/hwlm/noodle_engine.c src/hwlm/noodle_engine.h src/hwlm/noodle_internal.h src/nfa/accel.c src/nfa/accel.h src/nfa/castle.c src/nfa/castle.h src/nfa/castle_internal.h src/nfa/gough.c src/nfa/gough_internal.h src/nfa/lbr.c src/nfa/lbr.h src/nfa/lbr_common_impl.h src/nfa/lbr_internal.h src/nfa/limex_accel.c src/nfa/limex_accel.h src/nfa/limex_exceptional.h src/nfa/limex_native.c src/nfa/limex_ring.h src/nfa/limex_64.c src/nfa/limex_simd128.c src/nfa/limex_simd256.c src/nfa/limex_simd384.c src/nfa/limex_simd512.c src/nfa/limex.h src/nfa/limex_common_impl.h src/nfa/limex_context.h src/nfa/limex_internal.h src/nfa/limex_runtime.h src/nfa/limex_runtime_impl.h src/nfa/limex_shuffle.h src/nfa/limex_state_impl.h src/nfa/mcclellan.c src/nfa/mcclellan.h src/nfa/mcclellan_common_impl.h src/nfa/mcclellan_internal.h src/nfa/mcsheng.c src/nfa/mcsheng_data.c src/nfa/mcsheng.h src/nfa/mcsheng_internal.h 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/multishufti.c src/nfa/multishufti_avx2.h src/nfa/multishufti_sse.h src/nfa/multishufti.h src/nfa/multitruffle.c src/nfa/multitruffle_avx2.h src/nfa/multitruffle_sse.h src/nfa/multitruffle.h src/nfa/multivermicelli.c src/nfa/multivermicelli.h src/nfa/multivermicelli_sse.h src/nfa/multivermicelli_avx2.h src/nfa/nfa_api.h src/nfa/nfa_api_dispatch.c src/nfa/nfa_internal.h src/nfa/nfa_rev_api.h src/nfa/repeat.c src/nfa/repeat.h src/nfa/repeat_internal.h src/nfa/sheng.c src/nfa/sheng.h src/nfa/sheng_defs.h src/nfa/sheng_impl.h src/nfa/sheng_impl4.h src/nfa/sheng_internal.h src/nfa/shufti_common.h src/nfa/shufti.c src/nfa/shufti.h src/nfa/tamarama.c src/nfa/tamarama.h src/nfa/tamarama_internal.h src/nfa/truffle_common.h src/nfa/truffle.c src/nfa/truffle.h src/nfa/vermicelli.h src/nfa/vermicelli_run.h src/nfa/vermicelli_sse.h src/som/som.h src/som/som_operation.h src/som/som_runtime.h src/som/som_runtime.c src/som/som_stream.c src/som/som_stream.h src/rose/block.c src/rose/catchup.h src/rose/catchup.c src/rose/infix.h src/rose/init.h src/rose/init.c src/rose/stream.c src/rose/stream_long_lit.h src/rose/stream_long_lit_hash.h src/rose/match.h src/rose/match.c src/rose/miracle.h src/rose/program_runtime.c src/rose/program_runtime.h src/rose/runtime.h src/rose/rose.h src/rose/rose_internal.h src/rose/rose_program.h src/rose/rose_types.h src/rose/rose_common.h src/rose/validate_mask.h src/rose/validate_shufti.h src/util/bitutils.h src/util/copybytes.h src/util/exhaust.h src/util/fatbit.h src/util/join.h src/util/masked_move.h src/util/multibit.h src/util/multibit.c src/util/multibit_internal.h src/util/pack_bits.h src/util/popcount.h src/util/pqueue.h src/util/scatter.h src/util/scatter_runtime.h src/util/simd_utils.h src/util/simd_utils.c src/util/state_compress.h src/util/state_compress.c src/util/unaligned.h src/util/uniform_ops.h src/database.c src/database.h ) set (hs_exec_avx2_SRCS src/fdr/teddy_avx2.c src/util/masked_move.c ) SET (hs_SRCS ${hs_HEADERS} src/crc32.h src/database.h src/grey.cpp src/grey.h src/hs.cpp src/hs_internal.h src/hs_version.c src/hs_version.h src/scratch.h src/state.h src/ue2common.h src/compiler/asserts.cpp src/compiler/asserts.h src/compiler/compiler.cpp src/compiler/compiler.h src/compiler/error.cpp src/compiler/error.h src/fdr/engine_description.cpp src/fdr/engine_description.h src/fdr/fdr_compile.cpp src/fdr/fdr_compile.h src/fdr/fdr_compile_internal.h src/fdr/fdr_compile_util.cpp src/fdr/fdr_confirm_compile.cpp src/fdr/fdr_confirm.h src/fdr/fdr_engine_description.cpp src/fdr/fdr_engine_description.h src/fdr/fdr_internal.h src/fdr/flood_compile.cpp src/fdr/teddy_compile.cpp src/fdr/teddy_compile.h src/fdr/teddy_engine_description.cpp src/fdr/teddy_engine_description.h src/fdr/teddy_internal.h src/hwlm/hwlm_build.cpp src/hwlm/hwlm_build.h src/hwlm/hwlm_internal.h src/hwlm/hwlm_literal.cpp src/hwlm/hwlm_literal.h src/hwlm/noodle_build.cpp src/hwlm/noodle_build.h src/hwlm/noodle_internal.h src/nfa/accel.h src/nfa/accel_dfa_build_strat.cpp src/nfa/accel_dfa_build_strat.h src/nfa/accelcompile.cpp src/nfa/accelcompile.h src/nfa/callback.h src/nfa/castlecompile.cpp src/nfa/castlecompile.h src/nfa/dfa_build_strat.cpp src/nfa/dfa_build_strat.h src/nfa/dfa_min.cpp src/nfa/dfa_min.h src/nfa/goughcompile.cpp src/nfa/goughcompile.h src/nfa/goughcompile_accel.cpp src/nfa/goughcompile_internal.h src/nfa/goughcompile_reg.cpp src/nfa/mcclellan.h src/nfa/mcclellan_internal.h src/nfa/mcclellancompile.cpp src/nfa/mcclellancompile.h src/nfa/mcclellancompile_util.cpp src/nfa/mcclellancompile_util.h src/nfa/mcsheng_compile.cpp src/nfa/mcsheng_compile.h src/nfa/limex_compile.cpp src/nfa/limex_compile.h src/nfa/limex_accel.h src/nfa/limex_internal.h src/nfa/mpv_internal.h src/nfa/mpvcompile.cpp src/nfa/mpvcompile.h src/nfa/multiaccel_compilehelper.cpp src/nfa/multiaccel_compilehelper.h src/nfa/nfa_api.h src/nfa/nfa_api_queue.h src/nfa/nfa_api_util.h src/nfa/nfa_build_util.cpp src/nfa/nfa_build_util.h src/nfa/nfa_internal.h src/nfa/nfa_kind.h src/nfa/rdfa.h src/nfa/rdfa_graph.cpp src/nfa/rdfa_graph.h src/nfa/rdfa_merge.cpp src/nfa/rdfa_merge.h src/nfa/repeat_internal.h src/nfa/repeatcompile.cpp src/nfa/repeatcompile.h src/nfa/sheng_internal.h src/nfa/shengcompile.cpp src/nfa/shengcompile.h src/nfa/shufticompile.cpp src/nfa/shufticompile.h src/nfa/tamaramacompile.cpp src/nfa/tamaramacompile.h src/nfa/trufflecompile.cpp src/nfa/trufflecompile.h src/nfagraph/ng.cpp src/nfagraph/ng.h src/nfagraph/ng_anchored_acyclic.cpp src/nfagraph/ng_anchored_acyclic.h src/nfagraph/ng_anchored_dots.cpp src/nfagraph/ng_anchored_dots.h src/nfagraph/ng_asserts.cpp src/nfagraph/ng_asserts.h src/nfagraph/ng_builder.cpp src/nfagraph/ng_builder.h src/nfagraph/ng_calc_components.cpp src/nfagraph/ng_calc_components.h src/nfagraph/ng_cyclic_redundancy.cpp src/nfagraph/ng_cyclic_redundancy.h src/nfagraph/ng_depth.cpp src/nfagraph/ng_depth.h src/nfagraph/ng_dominators.cpp src/nfagraph/ng_dominators.h src/nfagraph/ng_edge_redundancy.cpp src/nfagraph/ng_edge_redundancy.h src/nfagraph/ng_equivalence.cpp src/nfagraph/ng_equivalence.h src/nfagraph/ng_execute.cpp src/nfagraph/ng_execute.h src/nfagraph/ng_expr_info.cpp src/nfagraph/ng_expr_info.h src/nfagraph/ng_extparam.cpp src/nfagraph/ng_extparam.h src/nfagraph/ng_fixed_width.cpp src/nfagraph/ng_fixed_width.h src/nfagraph/ng_haig.cpp src/nfagraph/ng_haig.h src/nfagraph/ng_holder.cpp src/nfagraph/ng_holder.h src/nfagraph/ng_is_equal.cpp src/nfagraph/ng_is_equal.h src/nfagraph/ng_lbr.cpp src/nfagraph/ng_lbr.h src/nfagraph/ng_literal_analysis.cpp src/nfagraph/ng_literal_analysis.h src/nfagraph/ng_literal_component.cpp src/nfagraph/ng_literal_component.h src/nfagraph/ng_literal_decorated.cpp src/nfagraph/ng_literal_decorated.h src/nfagraph/ng_mcclellan.cpp src/nfagraph/ng_mcclellan.h src/nfagraph/ng_mcclellan_internal.h src/nfagraph/ng_limex.cpp src/nfagraph/ng_limex.h src/nfagraph/ng_limex_accel.cpp src/nfagraph/ng_limex_accel.h src/nfagraph/ng_misc_opt.cpp src/nfagraph/ng_misc_opt.h src/nfagraph/ng_netflow.cpp src/nfagraph/ng_netflow.h src/nfagraph/ng_prefilter.cpp src/nfagraph/ng_prefilter.h src/nfagraph/ng_prune.cpp src/nfagraph/ng_prune.h src/nfagraph/ng_puff.cpp src/nfagraph/ng_puff.h src/nfagraph/ng_redundancy.cpp src/nfagraph/ng_redundancy.h src/nfagraph/ng_region.cpp src/nfagraph/ng_region.h src/nfagraph/ng_region_redundancy.cpp src/nfagraph/ng_region_redundancy.h src/nfagraph/ng_repeat.cpp src/nfagraph/ng_repeat.h src/nfagraph/ng_reports.cpp src/nfagraph/ng_reports.h src/nfagraph/ng_restructuring.cpp src/nfagraph/ng_restructuring.h src/nfagraph/ng_revacc.cpp src/nfagraph/ng_revacc.h src/nfagraph/ng_rose.cpp src/nfagraph/ng_rose.h src/nfagraph/ng_sep.cpp src/nfagraph/ng_sep.h src/nfagraph/ng_small_literal_set.cpp src/nfagraph/ng_small_literal_set.h src/nfagraph/ng_som.cpp src/nfagraph/ng_som.h src/nfagraph/ng_som_add_redundancy.cpp src/nfagraph/ng_som_add_redundancy.h src/nfagraph/ng_som_util.cpp src/nfagraph/ng_som_util.h src/nfagraph/ng_split.cpp src/nfagraph/ng_split.h src/nfagraph/ng_squash.cpp src/nfagraph/ng_squash.h src/nfagraph/ng_stop.cpp src/nfagraph/ng_stop.h src/nfagraph/ng_uncalc_components.cpp src/nfagraph/ng_uncalc_components.h src/nfagraph/ng_undirected.h src/nfagraph/ng_utf8.cpp src/nfagraph/ng_utf8.h src/nfagraph/ng_util.cpp src/nfagraph/ng_util.h src/nfagraph/ng_vacuous.cpp src/nfagraph/ng_vacuous.h src/nfagraph/ng_violet.cpp src/nfagraph/ng_violet.h src/nfagraph/ng_width.cpp src/nfagraph/ng_width.h src/parser/AsciiComponentClass.cpp src/parser/AsciiComponentClass.h src/parser/Component.cpp src/parser/Component.h src/parser/ComponentAlternation.cpp src/parser/ComponentAlternation.h src/parser/ComponentAssertion.cpp src/parser/ComponentAssertion.h src/parser/ComponentAtomicGroup.cpp src/parser/ComponentAtomicGroup.h src/parser/ComponentBackReference.cpp src/parser/ComponentBackReference.h src/parser/ComponentBoundary.cpp src/parser/ComponentBoundary.h src/parser/ComponentByte.cpp src/parser/ComponentByte.h src/parser/ComponentClass.cpp src/parser/ComponentClass.h src/parser/ComponentCondReference.cpp src/parser/ComponentCondReference.h src/parser/ComponentEUS.cpp src/parser/ComponentEUS.h src/parser/ComponentEmpty.cpp src/parser/ComponentEmpty.h src/parser/ComponentRepeat.cpp src/parser/ComponentRepeat.h src/parser/ComponentSequence.cpp src/parser/ComponentSequence.h src/parser/ComponentVisitor.cpp src/parser/ComponentVisitor.h src/parser/ComponentWordBoundary.cpp src/parser/ComponentWordBoundary.h src/parser/ConstComponentVisitor.cpp src/parser/ConstComponentVisitor.h src/parser/Parser.cpp src/parser/Parser.h src/parser/Utf8ComponentClass.cpp src/parser/Utf8ComponentClass.h src/parser/buildstate.cpp src/parser/buildstate.h src/parser/check_refs.cpp src/parser/check_refs.h src/parser/parse_error.cpp src/parser/parse_error.h src/parser/parser_util.cpp src/parser/position.h src/parser/position_info.h src/parser/prefilter.cpp src/parser/prefilter.h src/parser/shortcut_literal.cpp src/parser/shortcut_literal.h src/parser/ucp_table.cpp src/parser/ucp_table.h src/parser/unsupported.cpp src/parser/unsupported.h src/parser/utf8_validate.h src/parser/utf8_validate.cpp src/smallwrite/smallwrite_build.cpp src/smallwrite/smallwrite_build.h src/smallwrite/smallwrite_internal.h src/som/slot_manager.cpp src/som/slot_manager.h src/som/slot_manager_internal.h src/som/som.h src/som/som_operation.h src/rose/rose_build.h src/rose/rose_build_add.cpp src/rose/rose_build_add_internal.h src/rose/rose_build_add_mask.cpp src/rose/rose_build_anchored.cpp src/rose/rose_build_anchored.h src/rose/rose_build_bytecode.cpp src/rose/rose_build_castle.h src/rose/rose_build_castle.cpp src/rose/rose_build_compile.cpp src/rose/rose_build_convert.cpp src/rose/rose_build_convert.h src/rose/rose_build_engine_blob.h src/rose/rose_build_exclusive.cpp src/rose/rose_build_exclusive.h src/rose/rose_build_groups.cpp src/rose/rose_build_groups.h src/rose/rose_build_impl.h src/rose/rose_build_infix.cpp src/rose/rose_build_infix.h src/rose/rose_build_long_lit.cpp src/rose/rose_build_long_lit.h src/rose/rose_build_lookaround.cpp src/rose/rose_build_lookaround.h src/rose/rose_build_matchers.cpp src/rose/rose_build_matchers.h src/rose/rose_build_merge.cpp src/rose/rose_build_merge.h src/rose/rose_build_misc.cpp src/rose/rose_build_program.cpp src/rose/rose_build_program.h src/rose/rose_build_role_aliasing.cpp src/rose/rose_build_scatter.cpp src/rose/rose_build_scatter.h src/rose/rose_build_util.h src/rose/rose_build_width.cpp src/rose/rose_build_width.h src/rose/rose_graph.h src/rose/rose_in_graph.h src/rose/rose_in_util.cpp src/rose/rose_in_util.h src/util/accel_scheme.h src/util/alloc.cpp src/util/alloc.h src/util/bitfield.h src/util/boundary_reports.h src/util/charreach.cpp src/util/charreach.h src/util/charreach_util.h src/util/clique.cpp src/util/clique.h src/util/compare.h src/util/compile_context.cpp src/util/compile_context.h src/util/compile_error.cpp src/util/compile_error.h src/util/container.h src/util/depth.cpp src/util/depth.h src/util/determinise.h src/util/dump_mask.cpp src/util/dump_mask.h src/util/fatbit_build.cpp src/util/fatbit_build.h src/util/graph.h src/util/hash.h src/util/multibit_build.cpp src/util/multibit_build.h src/util/order_check.h src/util/partial_store.h src/util/partitioned_set.h src/util/popcount.h src/util/queue_index_factory.h src/util/report.h src/util/report_manager.cpp src/util/report_manager.h src/util/simd_utils.h src/util/target_info.cpp src/util/target_info.h src/util/ue2_containers.h src/util/ue2_graph.h src/util/ue2string.cpp src/util/ue2string.h src/util/unaligned.h src/util/unicode_def.h src/util/unicode_set.h src/util/uniform_ops.h src/util/verify_types.h ) set(hs_dump_SRCS src/scratch_dump.cpp src/scratch_dump.h src/fdr/fdr_dump.cpp src/hwlm/hwlm_dump.cpp src/hwlm/hwlm_dump.h src/nfa/accel_dump.cpp src/nfa/accel_dump.h src/nfa/castle_dump.cpp src/nfa/castle_dump.h src/nfagraph/ng_dump.cpp src/nfagraph/ng_dump.h src/nfa/goughcompile_dump.cpp src/nfa/goughcompile_dump.h src/nfa/goughdump.cpp src/nfa/goughdump.h src/nfa/lbr_dump.cpp src/nfa/limex_dump.cpp src/nfa/mcclellandump.cpp src/nfa/mcclellandump.h src/nfa/mcsheng_dump.cpp src/nfa/mcsheng_dump.h src/nfa/mpv_dump.cpp src/nfa/nfa_dump_api.h src/nfa/nfa_dump_dispatch.cpp src/nfa/nfa_dump_internal.cpp src/nfa/nfa_dump_internal.h src/nfa/shengdump.cpp src/nfa/shengdump.h src/nfa/tamarama_dump.cpp src/nfa/tamarama_dump.h src/parser/dump.cpp src/parser/dump.h src/parser/position_dump.h src/smallwrite/smallwrite_dump.cpp src/smallwrite/smallwrite_dump.h src/som/slot_manager_dump.cpp src/som/slot_manager_dump.h src/rose/rose_build_dump.cpp src/rose/rose_build_dump.h src/rose/rose_in_dump.cpp src/rose/rose_in_dump.h src/rose/rose_dump.cpp src/rose/rose_dump.h src/util/dump_charclass.cpp src/util/dump_charclass.h src/util/dump_util.cpp src/util/dump_util.h ) if (DUMP_SUPPORT) set(hs_SRCS ${hs_SRCS} ${hs_dump_SRCS}) endif() # we group things by sublibraries, specifying shared and static and then # choose which ones to build set (LIB_VERSION ${HS_VERSION}) set (LIB_SOVERSION ${HS_MAJOR_VERSION}) if (NOT FAT_RUNTIME) set(hs_exec_SRCS ${hs_exec_SRCS} ${hs_exec_common_SRCS}) if (HAVE_AVX2) set(hs_exec_SRCS ${hs_exec_SRCS} ${hs_exec_avx2_SRCS}) endif() add_library(hs_exec OBJECT ${hs_exec_SRCS}) add_library(hs_runtime STATIC src/hs_version.c src/hs_valid_platform.c $) set_target_properties(hs_runtime PROPERTIES LINKER_LANGUAGE C) if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS) add_library(hs_exec_shared OBJECT ${hs_exec_SRCS}) set_target_properties(hs_exec_shared PROPERTIES POSITION_INDEPENDENT_CODE TRUE) endif() else (FAT_RUNTIME) set(BUILD_WRAPPER "${PROJECT_SOURCE_DIR}/cmake/build_wrapper.sh") add_library(hs_exec_core2 OBJECT ${hs_exec_SRCS}) set_target_properties(hs_exec_core2 PROPERTIES COMPILE_FLAGS "-march=core2" RULE_LAUNCH_COMPILE "${BUILD_WRAPPER} core2 ${CMAKE_MODULE_PATH}/keep.syms.in" ) add_library(hs_exec_corei7 OBJECT ${hs_exec_SRCS}) set_target_properties(hs_exec_corei7 PROPERTIES COMPILE_FLAGS "-march=corei7" RULE_LAUNCH_COMPILE "${BUILD_WRAPPER} corei7 ${CMAKE_MODULE_PATH}/keep.syms.in" ) add_library(hs_exec_avx2 OBJECT ${hs_exec_SRCS} ${hs_exec_avx2_SRCS}) set_target_properties(hs_exec_avx2 PROPERTIES COMPILE_FLAGS "-march=core-avx2" RULE_LAUNCH_COMPILE "${BUILD_WRAPPER} avx2 ${CMAKE_MODULE_PATH}/keep.syms.in" ) add_library(hs_exec_common OBJECT ${hs_exec_common_SRCS} src/dispatcher.c ) set_source_files_properties(src/dispatcher.c PROPERTIES COMPILE_FLAGS "-Wno-unused-parameter -Wno-unused-function") if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS) add_library(hs_exec_shared_core2 OBJECT ${hs_exec_SRCS}) set_target_properties(hs_exec_shared_core2 PROPERTIES COMPILE_FLAGS "-march=core2" POSITION_INDEPENDENT_CODE TRUE RULE_LAUNCH_COMPILE "${BUILD_WRAPPER} core2 ${CMAKE_MODULE_PATH}/keep.syms.in" ) add_library(hs_exec_shared_corei7 OBJECT ${hs_exec_SRCS}) set_target_properties(hs_exec_shared_corei7 PROPERTIES COMPILE_FLAGS "-march=corei7" POSITION_INDEPENDENT_CODE TRUE RULE_LAUNCH_COMPILE "${BUILD_WRAPPER} corei7 ${CMAKE_MODULE_PATH}/keep.syms.in" ) add_library(hs_exec_shared_avx2 OBJECT ${hs_exec_SRCS} ${hs_exec_avx2_SRCS}) set_target_properties(hs_exec_shared_avx2 PROPERTIES COMPILE_FLAGS "-march=core-avx2" POSITION_INDEPENDENT_CODE TRUE RULE_LAUNCH_COMPILE "${BUILD_WRAPPER} avx2 ${CMAKE_MODULE_PATH}/keep.syms.in" ) add_library(hs_exec_common_shared OBJECT ${hs_exec_common_SRCS} src/dispatcher.c ) set_target_properties(hs_exec_common_shared PROPERTIES OUTPUT_NAME hs_exec_common POSITION_INDEPENDENT_CODE TRUE) endif() # SHARED # hs_version.c is added explicitly to avoid some build systems that refuse to # create a lib without any src (I'm looking at you Xcode) add_library(hs_runtime STATIC src/hs_version.c $ $ $ $) endif (NOT FAT_RUNTIME) set_target_properties(hs_runtime PROPERTIES LINKER_LANGUAGE C) if (NOT BUILD_SHARED_LIBS) install(TARGETS hs_runtime DESTINATION lib) endif() if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS) if (NOT FAT_RUNTIME) add_library(hs_runtime_shared SHARED src/hs_version.c src/hs_valid_platform.c $) else() add_library(hs_runtime_shared SHARED src/hs_version.c src/hs_valid_platform.c $ $ $ $) endif() set_target_properties(hs_runtime_shared PROPERTIES VERSION ${LIB_VERSION} SOVERSION ${LIB_SOVERSION} OUTPUT_NAME hs_runtime MACOSX_RPATH ON LINKER_LANGUAGE C) install(TARGETS hs_runtime_shared RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib) endif() if (NOT FAT_RUNTIME) add_library(hs STATIC ${hs_SRCS} src/hs_valid_platform.c $) else() # we want the static lib for testing add_library(hs STATIC src/hs_version.c src/hs_valid_platform.c ${hs_SRCS} $ $ $ $) endif() add_dependencies(hs ragel_Parser) if (NOT BUILD_SHARED_LIBS) install(TARGETS hs DESTINATION lib) endif() if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS) if (NOT FAT_RUNTIME) add_library(hs_shared SHARED src/hs_version.c src/hs_valid_platform.c ${hs_SRCS} $) else() add_library(hs_shared SHARED src/hs_version.c src/hs_valid_platform.c ${hs_SRCS} $ $ $ $) endif() add_dependencies(hs_shared ragel_Parser) set_target_properties(hs_shared PROPERTIES OUTPUT_NAME hs VERSION ${LIB_VERSION} SOVERSION ${LIB_SOVERSION} MACOSX_RPATH ON) install(TARGETS hs_shared RUNTIME DESTINATION bin ARCHIVE DESTINATION lib LIBRARY DESTINATION lib) endif() if(NOT WIN32) add_subdirectory(examples) endif() hyperscan-4.4.1/util/0000755000175000017500000000000013055426554015254 5ustar sleuthkidsleuthkidhyperscan-4.4.1/util/ng_find_matches.cpp0000644000175000017500000002613513055426554021077 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Pattern lifetime analysis. */ #include "config.h" #include "ng_find_matches.h" #include "nfagraph/ng_holder.h" #include "nfagraph/ng_util.h" #include "parser/position.h" #include "util/container.h" #include "util/compare.h" #include "util/report.h" #include "util/report_manager.h" #include using namespace std; using namespace ue2; namespace { struct StateSet { explicit StateSet(size_t sz) : s(sz), som(sz, 0) {} boost::dynamic_bitset<> s; // bitset of states that are on vector som; // som value for each state }; using MatchSet = set>; struct fmstate { const size_t num_states; // number of vertices in graph StateSet states; // currently active states StateSet next; // states on after this iteration vector vertices; // mapping from index to vertex size_t offset = 0; unsigned char cur = 0; unsigned char prev = 0; const bool som; const bool utf8; const bool allowStartDs; const ReportManager &rm; boost::dynamic_bitset<> accept; // states leading to accept boost::dynamic_bitset<> accept_with_eod; // states leading to accept or eod fmstate(const NGHolder &g, bool som_in, bool utf8_in, bool aSD_in, const ReportManager &rm_in) : num_states(num_vertices(g)), states(num_states), next(num_states), vertices(num_vertices(g), NGHolder::null_vertex()), som(som_in), utf8(utf8_in), allowStartDs(aSD_in), rm(rm_in), accept(num_states), accept_with_eod(num_states) { // init states states.s.set(g[g.start].index); if (allowStartDs) { states.s.set(g[g.startDs].index); } // fill vertex mapping for (const auto &v : vertices_range(g)) { vertices[g[v].index] = v; } // init accept states for (const auto &u : inv_adjacent_vertices_range(g.accept, g)) { accept.set(g[u].index); } accept_with_eod = accept; for (const auto &u : inv_adjacent_vertices_range(g.acceptEod, g)) { accept_with_eod.set(g[u].index); } } }; } // namespace static bool isWordChar(const unsigned char c) { // check if it's an alpha character if (ourisalpha(c)) { return true; } // check if it's a digit if (c >= '0' && c <= '9') { return true; } // check if it's an underscore if (c == '_') { return true; } return false; } static bool isUtf8CodePoint(const char c) { // check if this is a start of 4-byte character if ((c & 0xF8) == 0xF0) { return true; } // check if this is a start of 3-byte character if ((c & 0xF0) == 0xE0) { return true; } // check if this is a start of 2-byte character if ((c & 0xE0) == 0xC0) { return true; } // check if this is a single-byte character if ((c & 0x80) == 0) { return true; } return false; } static bool canReach(const NGHolder &g, const NFAEdge &e, struct fmstate &state) { auto flags = g[e].assert_flags; if (!flags) { return true; } if (flags & POS_FLAG_ASSERT_WORD_TO_NONWORD) { if (isWordChar(state.prev) && !isWordChar(state.cur)) { return true; } } if (flags & POS_FLAG_ASSERT_NONWORD_TO_WORD) { if (!isWordChar(state.prev) && isWordChar(state.cur)) { return true; } } if (flags & POS_FLAG_ASSERT_WORD_TO_WORD) { if (isWordChar(state.prev) && isWordChar(state.cur)) { return true; } } if (flags & POS_FLAG_ASSERT_NONWORD_TO_NONWORD) { if (!isWordChar(state.prev) && !isWordChar(state.cur)) { return true; } } return false; } static void getMatches(const NGHolder &g, MatchSet &matches, struct fmstate &state, bool allowEodMatches) { auto acc_states = state.states.s; acc_states &= allowEodMatches ? state.accept_with_eod : state.accept; for (size_t i = acc_states.find_first(); i != acc_states.npos; i = acc_states.find_next(i)) { const NFAVertex u = state.vertices[i]; const size_t &som_offset = state.states.som[i]; // we can't accept anything from startDs in between UTF-8 codepoints if (state.utf8 && u == g.startDs && !isUtf8CodePoint(state.cur)) { continue; } for (const auto &e : out_edges_range(u, g)) { NFAVertex v = target(e, g); if (v == g.accept || (v == g.acceptEod && allowEodMatches)) { // check edge assertions if we are allowed to reach accept if (!canReach(g, e, state)) { continue; } DEBUG_PRINTF("match found at %zu\n", state.offset); assert(!g[u].reports.empty()); for (const auto &report_id : g[u].reports) { const Report &ri = state.rm.getReport(report_id); DEBUG_PRINTF("report %u has offset adjustment %d\n", report_id, ri.offsetAdjust); matches.emplace(som_offset, state.offset + ri.offsetAdjust); } } } } } static void step(const NGHolder &g, struct fmstate &state) { state.next.s.reset(); for (size_t i = state.states.s.find_first(); i != state.states.s.npos; i = state.states.s.find_next(i)) { const NFAVertex &u = state.vertices[i]; const size_t &u_som_offset = state.states.som[i]; for (const auto &e : out_edges_range(u, g)) { NFAVertex v = target(e, g); if (v == g.acceptEod) { // can't know the future: we don't know if we're at EOD. continue; } if (v == g.accept) { continue; } if (!state.allowStartDs && v == g.startDs) { continue; } const CharReach &cr = g[v].char_reach; const size_t v_idx = g[v].index; // check reachability and edge assertions if (cr.test(state.cur) && canReach(g, e, state)) { // if we aren't in SOM mode, just set every SOM to 0 if (!state.som) { state.next.s.set(v_idx); state.next.som[v_idx] = 0; continue; } // if this is first vertex since start, use current offset as SOM size_t next_som; if (u == g.start || u == g.startDs || is_virtual_start(u, g)) { next_som = state.offset; } else { // else, inherit SOM from predecessor next_som = u_som_offset; } // check if the vertex is already active // if this vertex is not yet active, use current SOM if (!state.next.s.test(v_idx)) { state.next.s.set(v_idx); state.next.som[v_idx] = next_som; } else { // else, work out leftmost SOM state.next.som[v_idx] = min(next_som, state.next.som[v_idx]); } } } } } // filter extraneous matches static void filterMatches(MatchSet &matches) { set eom; // first, collect all end-offset matches for (const auto &match : matches) { eom.insert(match.second); } // now, go through all the end-offsets and filter extra matches for (const auto &elem : eom) { // find minimum SOM for this EOM size_t min_som = -1U; for (const auto &match : matches) { // skip entries with wrong EOM if (match.second != elem) { continue; } min_som = min(min_som, match.first); } auto msit = matches.begin(); while (msit != matches.end()) { // skip everything that doesn't match if (msit->second != elem || msit->first <= min_som) { ++msit; continue; } DEBUG_PRINTF("erasing match %zu, %zu\n", msit->first, msit->second); matches.erase(msit++); } } } /** \brief Find all matches for a given graph when executed against \a input. * * Fills \a matches with offsets into the data stream where a match is found. */ void findMatches(const NGHolder &g, const ReportManager &rm, const string &input, MatchSet &matches, const bool notEod, const bool som, const bool utf8) { assert(hasCorrectlyNumberedVertices(g)); const bool allowStartDs = (proper_out_degree(g.startDs, g) > 0); struct fmstate state(g, som, utf8, allowStartDs, rm); for (auto it = input.begin(), ite = input.end(); it != ite; ++it) { state.offset = distance(input.begin(), it); state.cur = *it; step(g, state); getMatches(g, matches, state, false); DEBUG_PRINTF("index %zu, %zu states on\n", state.offset, state.next.s.count()); if (state.next.s.empty()) { if (state.som) { filterMatches(matches); } return; } state.states = state.next; state.prev = state.cur; } state.offset = input.size(); state.cur = 0; // do additional step to get matches after stream end, this time count eod // matches also (or not, if we're in notEod mode) getMatches(g, matches, state, !notEod); if (state.som) { filterMatches(matches); } } hyperscan-4.4.1/util/expression_path.h0000644000175000017500000000617113055426554020645 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 EXPRESSION_PATH_H #define EXPRESSION_PATH_H #include "ue2common.h" #include #include #include #include #include #include #if !defined(_WIN32) #include #include #endif // // Utility functions // /** * Given a path to a signature file, infer the path of the pcre directory. */ static inline std::string inferExpressionPath(const std::string &sigFile) { #ifndef _WIN32 // POSIX variant. // dirname() may modify its argument, so we must make a copy. std::vector path(sigFile.size() + 1); memcpy(path.data(), sigFile.c_str(), sigFile.size()); path[sigFile.size()] = 0; // ensure null termination. std::string rv = dirname(path.data()); #else // Windows variant. if (sigFile.size() >= _MAX_DIR) { return std::string(); } char path[_MAX_DIR]; _splitpath(sigFile.c_str(), nullptr, path, nullptr, nullptr); std::string rv(path); #endif rv += "/../pcre"; return rv; } #if defined(_WIN32) #define stat _stat #define S_IFREG _S_IFREG #endif static inline bool isDir(const std::string &filename) { struct stat s; if (stat(filename.c_str(), &s) == -1) { std::cerr << "stat: " << strerror(errno) << std::endl; return false; } return (S_IFDIR & s.st_mode); } static inline bool isFile(const std::string &filename) { struct stat s; if (stat(filename.c_str(), &s) == -1) { std::cerr << "stat: " << strerror(errno) << std::endl; return false; } return (S_IFREG & s.st_mode); } #endif /* EXPRESSION_PATH_H */ hyperscan-4.4.1/util/ng_corpus_properties.cpp0000644000175000017500000000653313055426554022242 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief State for corpus generator. */ #include "config.h" #include "ng_corpus_properties.h" #include "ue2common.h" #include // default constructor CorpusProperties::CorpusProperties() : matchness(100), unmatchness(0), randomness(0), prefixRange(0, 0), suffixRange(0, 0), cycleMin(1), cycleMax(1), corpusLimit(DEFAULT_CORPUS_GENERATOR_LIMIT), editDistance(0), alphabetSize(~0) { // empty } bool CorpusProperties::setPercentages(unsigned int match, unsigned int unmatch, unsigned int random) { if (match + unmatch + random != 100) { // Do not update probabilities return false; } matchness = match; unmatchness = unmatch; randomness = random; return true; } void CorpusProperties::seed(unsigned val) { rngSeed = val; randomGen.seed(val); } unsigned CorpusProperties::getSeed() const { return rngSeed; } unsigned CorpusProperties::rand(unsigned n, unsigned m) { boost::random::uniform_int_distribution<> dist(n, m); return dist(randomGen); } // not const because it stores state for the random number generator CorpusProperties::RollResult CorpusProperties::throwDice() { if (matchness == 100) { return ROLLED_MATCH; } if (unmatchness == 100) { return ROLLED_UNMATCH; } if (randomness == 100) { return ROLLED_RANDOM; } // This assumes a uniform distribution. Perhaps factor some 'depth' param // and whether this 'depth' should increase or decrease the likelihood of // unmatch or random rolls. unsigned int outcome = rand(0, 99); if (outcome < matchness) { return ROLLED_MATCH; } if (outcome < matchness + unmatchness) { return ROLLED_UNMATCH; } return ROLLED_RANDOM; } hyperscan-4.4.1/util/database_util.h0000644000175000017500000000345513055426554020235 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 DATABASE_UTIL_H #define DATABASE_UTIL_H struct hs_database; bool saveDatabase(const hs_database *db, const char *filename, bool verbose = false); hs_database *loadDatabase(const char *filename, bool verbose = false); #endif /* DATABASE_UTIL_H */ hyperscan-4.4.1/util/ng_corpus_editor.cpp0000644000175000017500000002036713055426554021335 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Corpus Editor: applies random transformation to a corpus. */ #include "config.h" #include "ng_corpus_editor.h" #include "ng_corpus_properties.h" #include "ue2common.h" #include "util/compare.h" #include "util/unicode_def.h" #include "parser/ucp_table.h" #include #include #include using namespace std; using namespace ue2; namespace { enum Operation { EDIT_INSERT = 0, //!< insert a character EDIT_REMOVE = 1, //!< remove a character EDIT_SUBSTITUTE = 2, //!< substitute a character for another EDIT_TRANSPOSE = 3, //!< swap two characters EDIT_FLIP_CASE = 4, //!< invert the case of an alpha character }; template static size_t choosePosition(const SeqT &corpus, CorpusProperties &props) { assert(!corpus.empty()); unsigned pos = props.rand(0, corpus.size() - 1); return pos; } class CorpusEditor { public: CorpusEditor(CorpusProperties &p) : props(p) {} // Apply edits to a corpus void applyEdits(string &corpus); private: // operations void insert(string &corpus); void remove(string &corpus); void substitute(string &corpus); void transpose(string &corpus); void flip_case(string &corpus); Operation chooseOperation(); u8 chooseByte(); CorpusProperties &props; }; Operation CorpusEditor::chooseOperation() { return (Operation)props.rand(EDIT_INSERT, EDIT_FLIP_CASE); } void CorpusEditor::applyEdits(string &corpus) { for (size_t i = 0; i != props.editDistance; i++) { Operation op = chooseOperation(); switch (op) { case EDIT_INSERT: insert(corpus); break; case EDIT_REMOVE: remove(corpus); break; case EDIT_SUBSTITUTE: substitute(corpus); break; case EDIT_TRANSPOSE: transpose(corpus); break; case EDIT_FLIP_CASE: flip_case(corpus); break; } } } void CorpusEditor::insert(string &corpus) { unsigned pos = props.rand(0, corpus.size()); u8 c = chooseByte(); corpus.insert(pos, 1, (char)c); } void CorpusEditor::remove(string &corpus) { if (corpus.empty()) return; size_t pos = choosePosition(corpus, props); corpus.erase(pos, 1); } void CorpusEditor::substitute(string &corpus) { if (corpus.empty()) return; size_t pos = choosePosition(corpus, props); corpus[pos] = chooseByte(); } void CorpusEditor::transpose(string &corpus) { if (corpus.empty()) return; size_t a = choosePosition(corpus, props); size_t b = choosePosition(corpus, props); u8 tmp = corpus[a]; corpus[a] = corpus[b]; corpus[b] = tmp; } void CorpusEditor::flip_case(string &corpus) { if (corpus.empty()) return; // Pick a random starting position and walk forward (wrapping at the end) // until we find an alpha character. const size_t len = corpus.size(); const size_t pos = choosePosition(corpus, props); size_t i = pos; for (;;) { char c = corpus[i]; if (ourisalpha(c)) { char upper = mytoupper(c), lower = mytolower(c); corpus[i] = c == upper ? lower : upper; DEBUG_PRINTF("flipped c=%c to %c\n", c, corpus[i]); return; } if (++i == len) { i = 0; } if (i == pos) { // wrapped, no alpha characters break; } } } u8 CorpusEditor::chooseByte() { return (u8)props.rand(0, 255); } class CorpusEditorUtf8 { public: CorpusEditorUtf8(CorpusProperties &p) : props(p) {} // Apply edits to a corpus. void applyEdits(vector &corpus); private: // operations void insert(vector &corpus); void remove(vector &corpus); void substitute(vector &corpus); void transpose(vector &corpus); void flip_case(vector &corpus); Operation chooseOperation(); unichar chooseCodePoint(); CorpusProperties &props; }; Operation CorpusEditorUtf8::chooseOperation() { return (Operation)props.rand(EDIT_INSERT, EDIT_FLIP_CASE); } void CorpusEditorUtf8::applyEdits(vector &corpus) { for (size_t i = 0; i != props.editDistance; i++) { Operation op = chooseOperation(); switch (op) { case EDIT_INSERT: insert(corpus); break; case EDIT_REMOVE: remove(corpus); break; case EDIT_SUBSTITUTE: substitute(corpus); break; case EDIT_TRANSPOSE: transpose(corpus); break; case EDIT_FLIP_CASE: flip_case(corpus); break; } } } void CorpusEditorUtf8::insert(vector &corpus) { unsigned pos = props.rand(0, corpus.size()); corpus.insert(corpus.begin() + pos, chooseCodePoint()); } void CorpusEditorUtf8::remove(vector &corpus) { if (corpus.empty()) return; size_t pos = choosePosition(corpus, props); corpus.erase(corpus.begin() + pos); } void CorpusEditorUtf8::substitute(vector &corpus) { if (corpus.empty()) return; size_t pos = choosePosition(corpus, props); corpus[pos] = chooseCodePoint(); } void CorpusEditorUtf8::transpose(vector &corpus) { if (corpus.empty()) return; size_t a = choosePosition(corpus, props); size_t b = choosePosition(corpus, props); unichar tmp = corpus[a]; corpus[a] = corpus[b]; corpus[b] = tmp; } void CorpusEditorUtf8::flip_case(vector &corpus) { if (corpus.empty()) return; // Pick a random starting position and walk forward (wrapping at the end) // until we find an alpha character. const size_t len = corpus.size(); const size_t pos = choosePosition(corpus, props); size_t i = pos; for (;;) { if (::flip_case(&corpus[i])) { return; } if (++i == len) { i = 0; } if (i == pos) { // wrapped, no alpha characters break; } } } unichar CorpusEditorUtf8::chooseCodePoint(void) { /* We need to ensure that we don't pick a surrogate cp */ const u32 range = MAX_UNICODE + 1 - (UNICODE_SURROGATE_MAX + UNICODE_SURROGATE_MIN + 1); unichar raw = props.rand(0, range - 1); if (raw < UNICODE_SURROGATE_MIN) { return raw; } else { return raw + UNICODE_SURROGATE_MAX + 1; } } } // namespace void editCorpus(string *corpus, CorpusProperties &props) { CorpusEditor ed(props); ed.applyEdits(*corpus); } void editCorpus(vector *corpus, CorpusProperties &props) { CorpusEditorUtf8 ed(props); ed.applyEdits(*corpus); } hyperscan-4.4.1/util/ng_find_matches.h0000644000175000017500000000431713055426554020542 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Pattern matching based on direct NFA execution. */ #ifndef NG_FIND_MATCHES_H #define NG_FIND_MATCHES_H #include #include namespace ue2 { class NGHolder; class ReportManager; struct BoundaryReports; } // namespace ue2 /** \brief Find all matches for a given graph when executed against \a input. * * Fills \a matches with offsets into the data stream where a match is found. */ void findMatches(const ue2::NGHolder &g, const ue2::ReportManager &rm, const std::string &input, std::set> &matches, const bool notEod, const bool som, const bool utf8); #endif // NG_FIND_MATCHES_H hyperscan-4.4.1/util/CMakeLists.txt0000644000175000017500000000220613055426554020014 0ustar sleuthkidsleuthkid# utility libs CHECK_FUNCTION_EXISTS(mmap HAVE_MMAP) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}") include_directories(${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR} ${PROJECT_SOURCE_DIR}) set_source_files_properties( ${CMAKE_BINARY_DIR}/tools/ExpressionParser.cpp PROPERTIES COMPILE_FLAGS "${RAGEL_C_FLAGS}") ragelmaker(ExpressionParser.rl) set(expressionutil_SRCS expressions.cpp expressions.h ExpressionParser.h ExpressionParser.cpp ) add_library(expressionutil STATIC ${expressionutil_SRCS}) add_dependencies(expressionutil ragel_ExpressionParser) SET(corpusomatic_SRCS ng_corpus_editor.h ng_corpus_editor.cpp ng_corpus_generator.h ng_corpus_generator.cpp ng_corpus_properties.h ng_corpus_properties.cpp ng_find_matches.h ng_find_matches.cpp ) add_library(corpusomatic STATIC ${corpusomatic_SRCS}) set(databaseutil_SRCS database_util.cpp database_util.h ) add_library(databaseutil STATIC ${databaseutil_SRCS}) set(crosscompileutil_SRCS cross_compile.cpp cross_compile.h ) add_library(crosscompileutil STATIC ${crosscompileutil_SRCS}) hyperscan-4.4.1/util/ExpressionParser.h0000644000175000017500000000345413055426554020747 0ustar sleuthkidsleuthkid/* * 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 EXPRESSIONPARSER_H #define EXPRESSIONPARSER_H #include struct hs_expr_ext; bool readExpression(const std::string &line, std::string &expr, unsigned int *flags, hs_expr_ext *ext, bool *must_be_ordered = nullptr); #endif hyperscan-4.4.1/util/cross_compile.h0000644000175000017500000000347613055426554020300 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 CROSS_COMPILE_H #define CROSS_COMPILE_H #include #include struct hs_platform_info; std::unique_ptr xcompileReadMode(const char *s); std::string xcompileUsage(void); std::string to_string(const hs_platform_info &p); #endif /* CROSS_COMPILE_H */ hyperscan-4.4.1/util/ng_corpus_generator.cpp0000644000175000017500000005254213055426554022035 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Corpus Generation tool. */ #include "config.h" #include "ng_corpus_generator.h" #include "ng_corpus_editor.h" #include "nfagraph/ng.h" #include "nfagraph/ng_util.h" #include "ue2common.h" #include "util/container.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "util/ue2_containers.h" #include "util/ue2string.h" #include "util/unicode_def.h" #include "util/unicode_set.h" #include #include #include #include #include #include using namespace std; using namespace ue2; using boost::ptr_vector; typedef vector VertexPath; #if defined(DEBUG) // For debugging output static string pathToString(const NGHolder &g, const VertexPath &p) { ostringstream oss; oss << '['; for (auto i = p.begin(); i != p.end(); ++i) { if (i != p.begin()) { oss << ','; } oss << g[*i].index; } oss << ']'; return oss.str(); } #endif /** True if this graph has no non-special successors of start or startDs. */ static bool graph_is_empty(const NGHolder &g) { for (const auto &v : adjacent_vertices_range(g.start, g)) { if (!is_special(v, g)) { return false; } } for (const auto &v : adjacent_vertices_range(g.start, g)) { if (!is_special(v, g)) { return false; } } return true; } static string encodeUtf8(const vector &v) { string rv; for (const unichar &cp : v) { if (cp < UTF_2CHAR_MIN) { rv.push_back(cp); } else if (cp < UTF_3CHAR_MIN) { rv.push_back(UTF_TWO_BYTE_HEADER | (cp >> UTF_CONT_SHIFT)); rv.push_back(makeContByte(cp)); } else if (cp < UTF_4CHAR_MIN) { rv.push_back(UTF_THREE_BYTE_HEADER | (cp >> (2 * UTF_CONT_SHIFT))); rv.push_back(makeContByte(cp >> UTF_CONT_SHIFT)); rv.push_back(makeContByte(cp)); } else { rv.push_back(UTF_FOUR_BYTE_HEADER | (cp >> (3 * UTF_CONT_SHIFT))); rv.push_back(makeContByte(cp >> (2 * UTF_CONT_SHIFT))); rv.push_back(makeContByte(cp >> UTF_CONT_SHIFT)); rv.push_back(makeContByte(cp)); } } return rv; } template static bool has_greater_than(Iter it, Iter end, const Val &v, size_t limit) { for (; it != end; ++it) { if (*it == v) { if (limit == 0) { return true; } --limit; } } return false; } static void findPaths(const NGHolder &g, CorpusProperties &cProps, vector &allPaths, size_t cycleLimit, size_t corpusLimit) { // The maximum number of open (in progress) paths. New paths beyond this // limit will evict a random existing one. const size_t MAX_OPEN = min((size_t)1000, corpusLimit * 10); ptr_vector open; open.push_back(new VertexPath(1, g.start)); ue2::unordered_set one_way_in; for (const auto &v : vertices_range(g)) { if (in_degree(v, g) <= 1) { one_way_in.insert(v); } } while (!open.empty()) { u32 slot = cProps.rand(0, open.size() - 1); swap(open.at(slot), open.back()); ptr_vector::auto_type p = open.pop_back(); NFAVertex u = p->back(); DEBUG_PRINTF("dequeuing path %s, back %zu\n", pathToString(g, *p).c_str(), g[u].index); NGHolder::adjacency_iterator ai, ae; for (tie(ai, ae) = adjacent_vertices(u, g); ai != ae; ++ai) { NFAVertex v = *ai; if (u == g.startDs && v == g.startDs) { // explicitly avoid following startDs self-loop, as we have // other mechanisms for adding prefixes to our corpora. continue; } // Accept vertices generate completed paths. if (v == g.accept || v == g.acceptEod) { DEBUG_PRINTF("path complete: %s\n", pathToString(g, *p).c_str()); allPaths.push_back(*p); if (allPaths.size() >= corpusLimit) { DEBUG_PRINTF("full, going home\n"); return; } // No meaningful edges out of accept or acceptEod. continue; } if (!contains(one_way_in, v) && has_greater_than(p->begin(), p->end(), v, cycleLimit)) { // Note that vertices that only have one predecessor don't need // their cycle limit checked, as their predecessors will have // the same count. DEBUG_PRINTF("exceeded cycle limit for v=%zu, pruning path\n", g[v].index); continue; } // If we've got no further adjacent vertices, re-use p rather than // copying it for the next path. VertexPath *new_path; if (boost::next(ai) == ae) { new_path = p.release(); } else { new_path = new VertexPath(*p); } new_path->push_back(v); if (open.size() < MAX_OPEN) { open.push_back(new_path); } else { u32 victim = cProps.rand(0, open.size() - 1); open.replace(victim, new_path); } } } DEBUG_PRINTF("bored, going home\n"); } namespace { /** \brief Concrete implementation */ class CorpusGeneratorImpl : public CorpusGenerator { public: CorpusGeneratorImpl(const NGHolder &graph_in, CorpusProperties &props); ~CorpusGeneratorImpl() {} void generateCorpus(vector &data); private: unsigned char getRandomChar(); unsigned char getMatchChar(const CharReach &cr); unsigned char getUnmatchChar(const CharReach &cr); unsigned char getChar(NFAVertex v); void newGenerator(vector &data); string pathToCorpus(const VertexPath &path); /** \brief Generate a string of random bytes between minLen and maxLen * bytes in length. */ void addRandom(const min_max &mm, string *out); /** \brief The NFA graph we operate over. */ const NGHolder &graph; /** \brief Reference to our corpus generator properties object (stores some * state) */ CorpusProperties &cProps; }; CorpusGeneratorImpl::CorpusGeneratorImpl(const NGHolder &graph_in, CorpusProperties &props) : graph(graph_in), cProps(props) { // empty } void CorpusGeneratorImpl::generateCorpus(vector &data) { newGenerator(data); // If the caller has asked us, apply edit distance to corpora if (cProps.editDistance) { for (auto &s : data) { editCorpus(&s, cProps); } } } /** \brief Generate a random character, taking care to stick to the alphabet * that we've been asked for. */ u8 CorpusGeneratorImpl::getRandomChar() { return 'a' + cProps.rand(0, min(cProps.alphabetSize, (u32)CharReach::npos)); } /** \brief Select a random character from the given string of valid match * characters. */ unsigned char CorpusGeneratorImpl::getMatchChar(const CharReach &cr) { unsigned int num = cr.count(); if (num == 0) { return 0; } else if (num == 1) { return (unsigned char)cr.find_first(); } else if (num == 256) { // Dot class, any character is OK! return (unsigned char)cProps.rand(0, 255); } else { unsigned idx = cProps.rand(0, num - 1); return (unsigned char)cr.find_nth(idx); } } /** \brief Select a character that does not belong to the given bitset. This * makes no guarantees on unmatchability if the bitset is full. */ unsigned char CorpusGeneratorImpl::getUnmatchChar(const CharReach &cr) { return getMatchChar(~cr); } void CorpusGeneratorImpl::addRandom(const min_max &mm, string *out) { assert(mm.min <= mm.max); u32 range = mm.max - mm.min; u32 len = mm.min + (range ? cProps.rand(0, range - 1) : 0); for (u32 i = 0; i < len; ++i) { out->push_back(getRandomChar()); } } unsigned char CorpusGeneratorImpl::getChar(NFAVertex v) { const CharReach &cr = graph[v].char_reach; switch (cProps.throwDice()) { case CorpusProperties::ROLLED_MATCH: return getMatchChar(cr); case CorpusProperties::ROLLED_UNMATCH: return getUnmatchChar(cr); case CorpusProperties::ROLLED_RANDOM: /* character pulled from hat */ return getRandomChar(); } assert(0); return 0; } /** \brief Convert a path through the graph to a corpus string. */ string CorpusGeneratorImpl::pathToCorpus(const VertexPath &path) { string s; // Add random prefix if (cProps.prefixRange.max) { addRandom(cProps.prefixRange, &s); } // Generate a corpus from our path for (const auto &e : path) { if (!is_special(e, graph)) { s += getChar(e); } } // Add random suffix if (cProps.suffixRange.max) { addRandom(cProps.suffixRange, &s); } return s; } void CorpusGeneratorImpl::newGenerator(vector &outdata) { const unsigned int maxCycles = cProps.getCycleLimit().second; DEBUG_PRINTF("generating up to %u corpora, cycle limit of %u\n", cProps.corpusLimit, maxCycles); vector allPaths; // Special case: if the graph has ONLY special vertices, then this is // likely to be an odd vacuous pattern or a pattern that can never match. // In these cases, an empty corpus is useful. if (graph_is_empty(graph)) { VertexPath empty(1, graph.start); allPaths.push_back(empty); } // build a set of unique paths findPaths(graph, cProps, allPaths, maxCycles, cProps.corpusLimit); // transform paths into corpora: we do this repeatedly until we (a) hit our // limit, or (b) don't generate any new corpora for any of our paths. set data; while (data.size() < cProps.corpusLimit) { size_t count = data.size(); for (const auto &path : allPaths) { string s = pathToCorpus(path); if (data.insert(s).second) { DEBUG_PRINTF("corpus %zu (%zu bytes): '%s'\n", data.size(), s.size(), escapeString(s).c_str()); if (data.size() == cProps.corpusLimit) { goto hit_limit; } } } if (data.size() == count) { break; // we're finding it hard to generate more corpora } } hit_limit: DEBUG_PRINTF("%zu corpora built\n", data.size()); // populate the output vector from the set we built. outdata.reserve(data.size()); copy(data.begin(), data.end(), back_inserter(outdata)); } /** \brief Concrete implementation for UTF-8 */ class CorpusGeneratorUtf8 : public CorpusGenerator { public: CorpusGeneratorUtf8(const NGHolder &graph_in, CorpusProperties &props); ~CorpusGeneratorUtf8() {} void generateCorpus(vector &data); private: unichar getRandomChar(); unichar getMatchChar(CodePointSet cps); unichar getUnmatchChar(const CodePointSet &cps); unichar getChar(const CodePointSet &cps); void newGenerator(vector > &data); vector pathToCorpus(const vector &path); /** \brief Generate a random string between min and max codepoints in * length. */ void addRandom(const min_max &mm, vector *out); /** \brief The NFA graph we operate over. */ const NGHolder &graph; /** \brief Reference to our corpus generator properties object (stores some * state) */ CorpusProperties &cProps; }; CorpusGeneratorUtf8::CorpusGeneratorUtf8(const NGHolder &graph_in, CorpusProperties &props) : graph(graph_in), cProps(props) { // empty } void CorpusGeneratorUtf8::generateCorpus(vector &data) { vector> raw; newGenerator(raw); // If the caller has asked us, apply edit distance to corpora if (cProps.editDistance) { for (auto &e : raw) { editCorpus(&e, cProps); } } for (const auto &e : raw) { data.push_back(encodeUtf8(e)); } } /** \brief Generate a random character, taking care to stick to the alphabet * that we've been asked for. */ unichar CorpusGeneratorUtf8::getRandomChar() { u32 range = MAX_UNICODE + 1 - (UNICODE_SURROGATE_MAX + UNICODE_SURROGATE_MIN + 1); range = min(cProps.alphabetSize, range); assert(range); unichar c = 'a' + cProps.rand(0, range - 1); if (c >= UNICODE_SURROGATE_MIN) { c =+ UNICODE_SURROGATE_MAX + 1; } return c % (MAX_UNICODE + 1); } /** \brief Select a random character from the given string of valid match * characters. */ unichar CorpusGeneratorUtf8::getMatchChar(CodePointSet cps) { cps.unsetRange(UNICODE_SURROGATE_MIN, UNICODE_SURROGATE_MAX); u32 num = cps.count(); if (num == 0) { return 0; } else if (num == 1) { return lower(*cps.begin()); } else { unichar rv = cps.at(cProps.rand(0, num - 1)); assert(rv != INVALID_UNICODE); return rv; } } /** \brief Select a character that does not belong to the given bitset. This * makes no guarantees on unmatchability if the bitset is full. */ unichar CorpusGeneratorUtf8::getUnmatchChar(const CodePointSet &cps) { return getMatchChar(~cps); } void CorpusGeneratorUtf8::addRandom(const min_max &mm, vector *out) { assert(mm.min <= mm.max); u32 range = mm.max - mm.min; u32 len = mm.min + (range ? cProps.rand(0, range - 1) : 0); for (u32 i = 0; i < len; ++i) { out->push_back(getRandomChar()); } } unichar CorpusGeneratorUtf8::getChar(const CodePointSet &cps) { switch (cProps.throwDice()) { case CorpusProperties::ROLLED_MATCH: return getMatchChar(cps); case CorpusProperties::ROLLED_UNMATCH: return getUnmatchChar(cps); case CorpusProperties::ROLLED_RANDOM: /* character pulled from hat */ return getRandomChar(); } assert(0); return 0; } /** \brief Convert a path through the graph to a corpus string. */ vector CorpusGeneratorUtf8::pathToCorpus(const vector &path) { vector s; // Add random prefix if (cProps.prefixRange.max) { addRandom(cProps.prefixRange, &s); } // Generate a corpus from our path for (const auto &e : path) { s.push_back(getChar(e)); } // Add random suffix if (cProps.suffixRange.max) { addRandom(cProps.suffixRange, &s); } return s; } static u32 classify_vertex(const NGHolder &g, NFAVertex v) { const CharReach &cr = g[v].char_reach; if (cr.isSubsetOf(UTF_ASCII_CR)) { return 1; } else if (cr.isSubsetOf(UTF_TWO_START_CR)) { return 2; } else if (cr.isSubsetOf(UTF_THREE_START_CR)) { return 3; } else if (cr.isSubsetOf(UTF_FOUR_START_CR)) { return 4; } /* this can happen due to dummy vertices from zwa */ return 1; } static void fillCodePointSet(const CharReach &cr, CodePointSet *out, u8 mask = 0xff) { for (u32 i = cr.find_first(); i != CharReach::npos; i = cr.find_next(i)) { out->set(i & mask); } } static void expandCodePointSet(const CharReach &cr, CodePointSet *out, u32 mask, u32 n) { CodePointSet base; base.swap(*out); for (u32 i = cr.find_first(); i != CharReach::npos; i = cr.find_next(i)) { u32 val = (i & mask) << (n * UTF_CONT_SHIFT); for (const auto &cp : base) { unichar ll = lower(cp); unichar uu = upper(cp); out->setRange(val + ll, MIN(val + uu, MAX_UNICODE)); } } } static void decodePath(const NGHolder &g, const VertexPath &in, vector &out) { VertexPath::const_iterator it = in.begin(); while (it != in.end()) { if (is_special(*it, g)) { ++it; continue; } out.push_back(CodePointSet()); CodePointSet &cps = out.back(); switch (classify_vertex(g, *it)) { case 1: fillCodePointSet(g[*it].char_reach, &cps); ++it; break; case 2: fillCodePointSet(g[*(it + 1)].char_reach, &cps, UTF_CONT_BYTE_VALUE_MASK); expandCodePointSet(g[*it].char_reach, &cps, ~UTF_TWO_BYTE_HEADER, 1); it += 2; break; case 3: fillCodePointSet(g[*(it + 2)].char_reach, &cps, UTF_CONT_BYTE_VALUE_MASK); expandCodePointSet(g[*(it + 1)].char_reach, &cps, UTF_CONT_BYTE_VALUE_MASK, 1); expandCodePointSet(g[*it].char_reach, &cps, ~UTF_THREE_BYTE_HEADER, 2); it += 3; break; case 4: fillCodePointSet(g[*(it + 3)].char_reach, &cps, UTF_CONT_BYTE_VALUE_MASK); expandCodePointSet(g[*(it + 2)].char_reach, &cps, UTF_CONT_BYTE_VALUE_MASK, 1); expandCodePointSet(g[*(it + 1)].char_reach, &cps, UTF_CONT_BYTE_VALUE_MASK, 2); expandCodePointSet(g[*it].char_reach, &cps, ~UTF_FOUR_BYTE_HEADER, 3); it += 4; break; default:; assert(0); ++it; } } } static void translatePaths(const NGHolder &graph, const vector &allPathsTemp, vector> *out) { assert(out); for (const auto &path : allPathsTemp) { out->push_back(vector()); decodePath(graph, path, out->back()); } } void CorpusGeneratorUtf8::newGenerator(vector> &outdata) { const u32 maxCycles = cProps.getCycleLimit().second; DEBUG_PRINTF("generating up to %u corpora, cycle limit of %u\n", cProps.corpusLimit, maxCycles); vector> allPaths; // Special case: if the graph has ONLY special vertices, then this is // likely to be an odd vacuous pattern or a pattern that can never match. // In these cases, an empty corpus is useful. if (graph_is_empty(graph)) { allPaths.push_back(vector()); } else { // build a set of unique paths vector allPathsTemp; findPaths(graph, cProps, allPathsTemp, maxCycles, cProps.corpusLimit); translatePaths(graph, allPathsTemp, &allPaths); } // transform paths into corpora: we do this repeatedly until we (a) hit our // limit, or (b) don't generate any new corpora for any of our paths. set > data; while (data.size() < cProps.corpusLimit) { size_t count = data.size(); for (const auto &path : allPaths) { vector vu = pathToCorpus(path); if (data.insert(vu).second) { if (data.size() == cProps.corpusLimit) { goto hit_limit; } } } if (data.size() == count) { break; // we're finding it hard to generate more corpora } } hit_limit: DEBUG_PRINTF("%zu corpora built\n", data.size()); // populate the output vector from the set we built. outdata.reserve(data.size()); copy(data.begin(), data.end(), back_inserter(outdata)); } } // namespace CorpusGenerator::~CorpusGenerator() { } // External entry point unique_ptr makeCorpusGenerator(const NGWrapper &graph, CorpusProperties &props) { if (graph.utf8) { return ue2::make_unique(graph, props); } else { return ue2::make_unique(graph, props); } } hyperscan-4.4.1/util/string_util.h0000644000175000017500000000740013055426554017771 0ustar sleuthkidsleuthkid/* * 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 STRING_UTIL_H #define STRING_UTIL_H #include "ue2common.h" #include #include #include #include #include #include // // Utility functions // // read a string in and convert it to another type, anything supported // by stringstream template inline bool fromString(const std::string &s, T& val) { std::istringstream i(s); char c; if (!(i >> val) || i.get(c)) { return false; } return true; } // read in a comma-separated set of values: very simple impl, not for // external consumption template inline bool strToList(const std::string &s, std::vector& out) { std::istringstream i(s); char c; do { T val; if (!(i >> val)) { break; } out.push_back(val); } while (i.get(c) && c == ','); return !out.empty(); } // return a nicely escaped version of a string: this should probably become // an IO manipulator or something UNUSED static const std::string printable(const std::string &in) { std::ostringstream oss; for (size_t i = 0; i < in.size(); ++i) { unsigned char c = in[i]; if (c == '\"') { oss << "\\\""; } else if (c == '\n') { oss << "\\n"; } else if (c == '\t') { oss << "\\t"; } else if (c == '\r') { oss << "\\r"; } else if (0x20 <= c && c <= 0x7e && c != '\\') { oss << c; } else { oss << "\\x" << std::hex << std::setw(2) << std::setfill('0') << (unsigned)(in[i] & 0xff) << std::dec; } } return oss.str(); } template void prettyPrintRange(std::ostream &out, it_t begin, it_t end) { bool in_range = false; it_t it = begin; it_t itp = it; for (; it != end; itp = it++) { if (it != begin && *it == *itp + 1) { in_range = true; continue; } else if (it != begin) { if (in_range) { out << "-" << *itp; } out << ", "; in_range = false; } out << *it; } if (in_range) { out << "-" << *itp; } } #endif // STRING_UTIL_H hyperscan-4.4.1/util/ng_corpus_generator.h0000644000175000017500000000465613055426554021505 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Corpus Generation tool. */ #ifndef NG_CORPUS_GENERATOR_H_ #define NG_CORPUS_GENERATOR_H_ #include "ng_corpus_properties.h" #include #include #include namespace ue2 { class NGWrapper; } // namespace ue2 /** \brief Abstract interface to corpus generator tool. */ class CorpusGenerator { public: virtual ~CorpusGenerator(); /** \brief Build some corpora. * * Generate a set of corpora, placed in the \a data vector, for the current * NFAGraph according to the parameters provided by the CorpusProperties * object. Returns the number of corpora generated. */ virtual void generateCorpus(std::vector &data) = 0; }; /** \brief Build a concrete impl conforming to the \ref CorpusGenerator * interface. */ std::unique_ptr makeCorpusGenerator(const ue2::NGWrapper &graph, CorpusProperties &props); #endif hyperscan-4.4.1/util/ExpressionParser.rl0000644000175000017500000001245713055426554021140 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "ExpressionParser.h" #include #include #include #include #include #include "ue2common.h" #include "hs_compile.h" using std::string; namespace { // anon enum ParamKey { PARAM_NONE, PARAM_MIN_OFFSET, PARAM_MAX_OFFSET, PARAM_MIN_LENGTH }; %%{ machine ExpressionParser; action accumulateNum { num = (num * 10) + (fc - '0'); } action handleFlag { switch (fc) { case 'i': *flags |= HS_FLAG_CASELESS; break; case 's': *flags |= HS_FLAG_DOTALL; break; case 'm': *flags |= HS_FLAG_MULTILINE; break; case 'H': *flags |= HS_FLAG_SINGLEMATCH; break; case 'O': if (must_be_ordered) { *must_be_ordered = true; } break; case 'V': *flags |= HS_FLAG_ALLOWEMPTY; break; case 'W': *flags |= HS_FLAG_UCP; break; case '8': *flags |= HS_FLAG_UTF8; break; case 'P': *flags |= HS_FLAG_PREFILTER; break; case 'L': *flags |= HS_FLAG_SOM_LEFTMOST; break; default: fbreak; } } action handleExtParam { switch (key) { case PARAM_MIN_OFFSET: ext->flags |= HS_EXT_FLAG_MIN_OFFSET; ext->min_offset = num; break; case PARAM_MAX_OFFSET: ext->flags |= HS_EXT_FLAG_MAX_OFFSET; ext->max_offset = num; break; case PARAM_MIN_LENGTH: ext->flags |= HS_EXT_FLAG_MIN_LENGTH; ext->min_length = num; break; case PARAM_NONE: default: // No key specified, syntax invalid. return false; } } write data; }%% } // namespace static void initExt(hs_expr_ext *ext) { memset(ext, 0, sizeof(*ext)); ext->max_offset = MAX_OFFSET; } bool readExpression(const std::string &input, std::string &expr, unsigned int *flags, hs_expr_ext *ext, bool *must_be_ordered) { assert(flags); assert(ext); // Init flags and ext params. *flags = 0; initExt(ext); if (must_be_ordered) { *must_be_ordered = false; } // Extract expr, which is easier to do in straight C++ than with Ragel. if (input.empty() || input[0] != '/') { return false; } size_t end = input.find_last_of('/'); if (end == string::npos || end == 0) { return false; } expr = input.substr(1, end - 1); // Use a Ragel scanner to handle flags and params. const char *p = input.c_str() + end + 1; const char *pe = input.c_str() + input.size(); UNUSED const char *eof = pe; UNUSED const char *ts = p, *te = p; int cs; UNUSED int act; assert(p); assert(pe); // For storing integers as they're scanned. u64a num = 0; enum ParamKey key = PARAM_NONE; %%{ single_flag = [ismW8HPLVO]; param = ('min_offset' @{ key = PARAM_MIN_OFFSET; } | 'max_offset' @{ key = PARAM_MAX_OFFSET; } | 'min_length' @{ key = PARAM_MIN_LENGTH; } ); value = (digit @accumulateNum)+ >{num = 0;}; param_spec = (' '* param '=' value ' '*) >{ key = PARAM_NONE; } %handleExtParam; main := ( single_flag @handleFlag )* # single-char flags ( '{' param_spec (',' param_spec)* '}' )? # list of ext params $^{ return false; }; # Intialize and execute. write init; write exec; }%% DEBUG_PRINTF("expr='%s', flags=%u\n", expr.c_str(), *flags); return (cs != ExpressionParser_error) && (p == pe); } hyperscan-4.4.1/util/ng_corpus_properties.h0000644000175000017500000001021413055426554021676 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief State for corpus generator. */ #ifndef NG_CORPUS_PROPERTIES_H #define NG_CORPUS_PROPERTIES_H #include // for std::pair #include #include "ue2common.h" #define DEFAULT_CORPUS_GENERATOR_LIMIT 500000 struct min_max { min_max(u32 min_in, u32 max_in) : min(min_in), max(max_in) { assert(min <= max); } u32 min; u32 max; }; class CorpusProperties { public: /** * Default constructor with default properties: * - generate match char with 100% probability * - generate unmatch char with 0% probability * - generate random char with 0% probability * - follow cycles once * - do not expand character classes (including case classes) * - generate data for all possible paths through graph * - pick random characters from the full ASCII alphabet */ CorpusProperties(); /** * Set probabilities (as percentages). Returns true if sum == 100, * else returns false and no changes are made to current probabilities. */ bool setPercentages(unsigned int match, unsigned int unmatch, unsigned int random); unsigned percentMatch() const { return matchness; } unsigned percentUnmatch() const { return unmatchness; } unsigned percentRandom() const { return randomness; } // The number of times a cycle is followed void setCycleLimit(unsigned int min, unsigned int max) { cycleMin = min; cycleMax = max; } std::pair getCycleLimit() const { return std::make_pair(cycleMin, cycleMax); } // Roll for initiative enum RollResult { ROLLED_MATCH, ROLLED_UNMATCH, ROLLED_RANDOM, }; RollResult throwDice(); /** \brief Set the PRNG seed. */ void seed(unsigned val); unsigned int getSeed() const; /** \brief Retrieve a value from the PRNG in the closed range [n, m]. */ unsigned rand(unsigned n, unsigned m); private: // Percentages unsigned int matchness; unsigned int unmatchness; unsigned int randomness; public: // Extra data min_max prefixRange; min_max suffixRange; private: // Behaviours unsigned int cycleMin; unsigned int cycleMax; public: // FIXME: Limit the number of corpus files generated to the first 'limit' // number of paths - note that this means the corpus will not be a complete // representation of the pattern. unsigned int corpusLimit; unsigned int editDistance; unsigned int alphabetSize; private: // PRNG. boost::random::mt19937 randomGen; unsigned int rngSeed; }; #endif hyperscan-4.4.1/util/database_util.cpp0000644000175000017500000001036213055426554020563 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "database_util.h" #include "hs_common.h" #include #include #include #include #include #if defined(HAVE_MMAP) #include // for mmap #include // for close #include #include #endif using namespace std; bool saveDatabase(const hs_database_t *db, const char *filename, bool verbose) { assert(db); assert(filename); if (verbose) { cout << "Saving database to: " << filename << endl; } char *bytes = nullptr; size_t length = 0; hs_error_t err = hs_serialize_database(db, &bytes, &length); if (err != HS_SUCCESS) { return false; } assert(bytes); assert(length > 0); ofstream out(filename, ios::binary); out.write(bytes, length); out.close(); ::free(bytes); return true; } hs_database_t * loadDatabase(const char *filename, bool verbose) { assert(filename); if (verbose) { cout << "Loading database from: " << filename << endl; } char *bytes = nullptr; #if defined(HAVE_MMAP) // Use mmap to read the file int fd = open(filename, O_RDONLY); if (fd < 0) { return nullptr; } struct stat st; if (fstat(fd, &st) < 0) { close(fd); return nullptr; } size_t len = st.st_size; bytes = (char *)mmap(nullptr, len, PROT_READ, MAP_SHARED, fd, 0); if (bytes == MAP_FAILED) { cout << "mmap failed" << endl; close(fd); return nullptr; } #else // Fall back on stream IO ifstream is; is.open(filename, ios::in | ios::binary); if (!is.is_open()) { return nullptr; } is.seekg(0, ios::end); size_t len = is.tellg(); if (verbose) { cout << "Reading " << len << " bytes" << endl; } is.seekg(0, ios::beg); bytes = new char[len]; is.read(bytes, len); is.close(); #endif assert(bytes); if (verbose) { char *info = nullptr; hs_error_t err = hs_serialized_database_info(bytes, len, &info); if (err) { cout << "Unable to decode serialized database info: " << err << endl; } else if (info) { cout << "Serialized database info: " << info << endl; std::free(info); } else { cout << "Unable to decode serialized database info." << endl; } } hs_database_t *db = nullptr; hs_error_t err = hs_deserialize_database(bytes, len, &db); #if defined(HAVE_MMAP) munmap(bytes, len); close(fd); #else delete [] bytes; #endif if (err != HS_SUCCESS) { cout << "hs_deserialize_database call failed: " << err << endl; return nullptr; } assert(db); return db; } hyperscan-4.4.1/util/cross_compile.cpp0000644000175000017500000000717213055426554020630 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "cross_compile.h" #include "src/ue2common.h" #include "src/hs_compile.h" #include "src/util/make_unique.h" #include #include using namespace std; struct XcompileMode { const char *name; unsigned long long cpu_features; }; static const XcompileMode xcompile_options[] = { { "avx2", HS_CPU_FEATURES_AVX2 }, { "base", 0 }, }; unique_ptr xcompileReadMode(const char *s) { hs_platform_info rv; UNUSED hs_error_t err; err = hs_populate_platform(&rv); assert(!err); string str(s); string mode = str.substr(0, str.find(":")); string opt = str.substr(str.find(":")+1, str.npos); bool found_mode = false; if (!opt.empty()) { const size_t numOpts = ARRAY_LENGTH(xcompile_options); for (size_t i = 0; i < numOpts; i++) { if (opt.compare(xcompile_options[i].name) == 0) { DEBUG_PRINTF("found opt %zu:%llu\n", i, xcompile_options[i].cpu_features); rv.cpu_features = xcompile_options[i].cpu_features; found_mode = true; break; } } } if (!found_mode) { return nullptr; } else { DEBUG_PRINTF("cpu_features %llx\n", rv.cpu_features); return ue2::make_unique(rv); } } string to_string(const hs_platform_info &p) { ostringstream out; if (p.tune) { out << p.tune; } if (p.cpu_features) { u64a features = p.cpu_features; if (features & HS_CPU_FEATURES_AVX2) { out << " avx2"; features &= ~HS_CPU_FEATURES_AVX2; } if (features) { out << " " << "?cpu_features?:" << features; } } return out.str(); } string xcompileUsage(void) { string variants = "Instruction set options: "; const size_t numOpts = ARRAY_LENGTH(xcompile_options); for (size_t i = 0; i < numOpts; i++) { variants += xcompile_options[i].name; if (i + 1 != numOpts) { variants += ", "; } } return variants; } hyperscan-4.4.1/util/ng_corpus_editor.h0000644000175000017500000000364013055426554020775 0ustar sleuthkidsleuthkid/* * 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. */ /** \file * \brief Corpus Editor: applies random transformation to a corpus. */ #ifndef CORPUS_EDITOR_H #define CORPUS_EDITOR_H #include #include #include "ue2common.h" #include "util/unicode_def.h" class CorpusProperties; void editCorpus(std::string *corpus, CorpusProperties &props); void editCorpus(std::vector *corpus, CorpusProperties &props); #endif hyperscan-4.4.1/util/expressions.h0000644000175000017500000000464713055426554020022 0ustar sleuthkidsleuthkid/* * 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 EXPRESSIONS_H #define EXPRESSIONS_H #include #include #include typedef std::map ExpressionMap; typedef std::list SignatureSet; // load all of the expressions from the given directory into the given // expression map. Exits on failure. void loadExpressions(const std::string &inDir, ExpressionMap &exprMap); void loadExpressionsFromFile(const std::string &fname, ExpressionMap &exprMap); // load a list of signature IDs void loadSignatureList(const std::string &inFile, SignatureSet &signatures); // produce a new expression map only containing those signatures in the // expression list void generateExprMap(const SignatureSet &signatures, const ExpressionMap &allExprs, ExpressionMap &out); // trim expression map to only the given signatures (in-place) void limitBySignature(ExpressionMap &exprMap, const SignatureSet &signatures); #endif hyperscan-4.4.1/util/expressions.cpp0000644000175000017500000002141313055426554020343 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include #include #include #include #include #include #include #include #if !defined(_WIN32) #include #include #else // Windows support is probably very fragile #include #endif #include "expressions.h" #include "hs.h" #include "string_util.h" using namespace std; static void failLine(unsigned lineNum, const string &file, const string &line, const string &error) { cerr << "Parse error in file " << file << " on line " << lineNum << ": " << error << endl << "Line is: '" << line << "'" << endl; exit(1); } static void processLine(string &line, unsigned lineNum, const string &file, ExpressionMap &exprMap) { // if line is empty, or a comment, we can skip it if (line.empty() || line[0] == '#') { return; } // cull any whitespace boost::trim(line); // otherwise, it should be ID:PCRE, e.g. // 10001:/foobar/is size_t colonIdx = line.find_first_of(':'); if (colonIdx == string::npos) { failLine(lineNum, file, line, "Could not parse line."); } // we should have an unsigned int as an ID, before the colon unsigned id; if (!fromString(line.substr(0, colonIdx), id)) { failLine(lineNum, file, line, "Unable to parse ID."); } // rest of the expression is the PCRE const string pcre_str(line.substr(colonIdx + 1)); //cout << "Inserting expr: id=" << id << ", pcre=" << pcre_str << endl; bool ins = exprMap.insert(ExpressionMap::value_type(id, pcre_str)).second; if (!ins) { failLine(lineNum, file, line, "Duplicate ID found."); } } #if defined(_WIN32) #define stat _stat #define S_ISDIR(st_m) (_S_IFDIR & (st_m)) #define S_ISREG(st_m) (_S_IFREG & (st_m)) #endif void loadExpressionsFromFile(const string &fname, ExpressionMap &exprMap) { struct stat st; if (stat(fname.c_str(), &st) != 0) { return; } if (!S_ISREG(st.st_mode)) { return; } ifstream f(fname.c_str()); if (!f.good()) { throw runtime_error("Can't open file"); } unsigned lineNum = 0; string line; while (getline(f, line)) { lineNum++; processLine(line, lineNum, fname, exprMap); } } static bool isIgnorable(const std::string &f) { if (f.empty()) { return true; } // Editor backup files if (*f.rbegin() == '~') { return true; } // Ignore dotfiles if (*f.begin() == '.') { return true; } return false; } #ifndef _WIN32 void loadExpressions(const string &inPath, ExpressionMap &exprMap) { // Is our input path a file or a directory? struct stat st; if (stat(inPath.c_str(), &st) != 0) { cerr << "Can't stat path: '" << inPath << "'" << endl; exit(1); } if (S_ISREG(st.st_mode)) { // process file try { loadExpressionsFromFile(inPath, exprMap); } catch (runtime_error &e) { cerr << e.what() << ": '" << inPath << "'" << endl; exit(1); } } else if (S_ISDIR(st.st_mode)) { DIR *d = opendir(inPath.c_str()); if (d == nullptr) { cerr << "Can't open directory: '" << inPath << "'" << endl; exit(1); } for (struct dirent *ent = readdir(d); ent; ent = readdir(d)) { string basename(ent->d_name); string fname(inPath); fname.push_back('/'); fname.append(basename); // Ignore '.' and '..' if (basename == "." || basename == "..") { continue; } // Skip emacs backup files, dotfiles (such as VIM swap). if (isIgnorable(basename)) { cerr << "Ignoring signature file " << fname << endl; continue; } try { loadExpressionsFromFile(fname, exprMap); } catch (runtime_error &e) { cerr << e.what() << ": '" << fname << "'" << endl; exit(1); } } closedir(d); } else { cerr << "Can't stat path: '" << inPath << "'" << endl; exit(1); } } #else // windows TODO: improve void loadExpressions(const string &inPath, ExpressionMap &exprMap) { // Is our input path a file or a directory? struct stat st; if (stat(inPath.c_str(), &st) != 0) { cerr << "Can't stat path: '" << inPath << "'" << endl; exit(1); } if (S_ISREG(st.st_mode)) { // process file try { loadExpressionsFromFile(inPath, exprMap); } catch (runtime_error &e) { cerr << e.what() << ": '" << inPath << "'" << endl; exit(1); } } else if (S_ISDIR(st.st_mode)) { WIN32_FIND_DATA ffd; HANDLE hFind = INVALID_HANDLE_VALUE; string glob = inPath + "/*"; hFind = FindFirstFile(glob.c_str(), &ffd); if (hFind == INVALID_HANDLE_VALUE) { cerr << "Can't open directory: '" << inPath << "'" << endl; exit(1); } do { string basename(ffd.cFileName); string fname(inPath); fname.push_back('/'); fname.append(basename); // Ignore '.' and '..' if (basename == "." || basename == "..") { continue; } // Skip emacs backup files, dotfiles (such as VIM swap). if (isIgnorable(basename)) { cerr << "Ignoring signature file " << fname << endl; continue; } try { loadExpressionsFromFile(fname, exprMap); } catch (runtime_error &e) { cerr << e.what() << ": '" << fname << "'" << endl; exit(1); } } while (FindNextFile(hFind, &ffd) != 0); FindClose(hFind); } else { cerr << "Can't stat path: '" << inPath << "'" << endl; exit(1); } } #endif void loadSignatureList(const string &inFile, SignatureSet &signatures) { ifstream f(inFile.c_str()); if (!f.good()) { cerr << "Can't open file: '" << inFile << "'" << endl; exit(1); } unsigned lineNum = 0; string line; while (getline(f, line)) { lineNum++; // if line is empty, or a comment, we can skip it if (line.empty() || line[0] == '#') { continue; } unsigned id; if (fromString(line, id)) { signatures.push_back(id); } else { // Parse error occurred failLine(lineNum, inFile, line, "Unable to parse ID."); } } } void limitBySignature(ExpressionMap &exprMap, const SignatureSet &signatures) { ExpressionMap keepers; SignatureSet::const_iterator it, ite; for (it = signatures.begin(), ite = signatures.end(); it != ite; ++it) { ExpressionMap::const_iterator match = exprMap.find(*it); if (match == exprMap.end()) { cerr << "Unable to find signature " << *it << " in expression set!" << endl; exit(1); } keepers.insert(*match); } exprMap.swap(keepers); } hyperscan-4.4.1/README.md0000644000175000017500000000307513055426554015563 0ustar sleuthkidsleuthkid# Hyperscan Hyperscan is a high-performance multiple regex matching library. It follows the regular expression syntax of the commonly-used libpcre library, but is a standalone library with its own C API. Hyperscan uses hybrid automata techniques to allow simultaneous matching of large numbers (up to tens of thousands) of regular expressions and for the matching of regular expressions across streams of data. Hyperscan is typically used in a DPI library stack. # Documentation Information on building the Hyperscan library and using its API is available in the [Developer Reference Guide](http://01org.github.io/hyperscan/dev-reference/). # License Hyperscan is licensed under the BSD License. See the LICENSE file in the project repository. # Versioning The `master` branch on Github will always contain the most recent release of Hyperscan. Each version released to `master` goes through QA and testing before it is released; if you're a user, rather than a developer, this is the version you should be using. Further development towards the next release takes place on the `develop` branch. # Get Involved The official homepage for Hyperscan is at [01.org/hyperscan](https://01.org/hyperscan). If you have questions or comments, we encourage you to [join the mailing list](https://lists.01.org/mailman/listinfo/hyperscan). Bugs can be filed by sending email to the list, or by creating an issue on Github. If you wish to contact the Hyperscan team at Intel directly, without posting publicly to the mailing list, send email to [hyperscan@intel.com](mailto:hyperscan@intel.com). hyperscan-4.4.1/libhs.pc.in0000644000175000017500000000044713055426554016336 0ustar sleuthkidsleuthkidprefix=@CMAKE_INSTALL_PREFIX@ exec_prefix=@CMAKE_INSTALL_PREFIX@ libdir=@CMAKE_INSTALL_PREFIX@/lib includedir=@CMAKE_INSTALL_PREFIX@/include Name: libhs Description: Intel(R) Hyperscan Library Version: @HS_VERSION@ Libs: -L${libdir} -lhs Libs.private: @PRIVATE_LIBS@ Cflags: -I${includedir}/hs hyperscan-4.4.1/cmake/0000755000175000017500000000000013055426554015357 5ustar sleuthkidsleuthkidhyperscan-4.4.1/cmake/ragel.cmake0000644000175000017500000000140413055426554017452 0ustar sleuthkidsleuthkid# function for doing all the dirty work in turning a .rl into C++ function(ragelmaker src_rl) get_filename_component(src_dir ${src_rl} PATH) # old cmake needs PATH get_filename_component(src_file ${src_rl} NAME_WE) set(rl_out ${CMAKE_CURRENT_BINARY_DIR}/${src_dir}/${src_file}.cpp) add_custom_command( OUTPUT ${CMAKE_CURRENT_BINARY_DIR}/${src_dir}/${src_file}.cpp COMMAND ${CMAKE_COMMAND} -E make_directory ${CMAKE_CURRENT_BINARY_DIR}/${src_dir} COMMAND ${RAGEL} ${CMAKE_CURRENT_SOURCE_DIR}/${src_rl} -o ${rl_out} DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/${src_rl} ) add_custom_target(ragel_${src_file} DEPENDS ${rl_out}) set_source_files_properties(${rl_out} PROPERTIES GENERATED TRUE) endfunction(ragelmaker) hyperscan-4.4.1/cmake/keep.syms.in0000644000175000017500000000024413055426554017625 0ustar sleuthkidsleuthkid# names to exclude hs_misc_alloc hs_misc_free hs_free_scratch hs_stream_alloc hs_stream_free hs_scratch_alloc hs_scratch_free hs_database_alloc hs_database_free ^_ hyperscan-4.4.1/cmake/arch.cmake0000644000175000017500000000153613055426554017303 0ustar sleuthkidsleuthkid# detect architecture features # # must be called after determining where compiler intrinsics are defined if (HAVE_C_X86INTRIN_H) set (INTRIN_INC_H "x86intrin.h") elseif (HAVE_C_INTRIN_H) set (INTRIN_INC_H "intrin.h") else () message (FATAL_ERROR "No intrinsics header found") endif () set (CMAKE_REQUIRED_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS} ${ARCH_C_FLAGS}") # ensure we have the minimum of SSSE3 - call a SSSE3 intrinsic CHECK_C_SOURCE_COMPILES("#include <${INTRIN_INC_H}> int main() { __m128i a = _mm_set1_epi8(1); (void)_mm_shuffle_epi8(a, a); }" HAVE_SSSE3) # now look for AVX2 CHECK_C_SOURCE_COMPILES("#include <${INTRIN_INC_H}> #if !defined(__AVX2__) #error no avx2 #endif int main(){ __m256i z = _mm256_setzero_si256(); (void)_mm256_xor_si256(z, z); }" HAVE_AVX2) unset (CMAKE_REQUIRED_FLAGS) unset (INTRIN_INC_H) hyperscan-4.4.1/cmake/config.h.in0000644000175000017500000000452313055426554017406 0ustar sleuthkidsleuthkid/* used by cmake */ /* "Define if the build is 32 bit" */ #cmakedefine ARCH_32_BIT /* "Define if the build is 64 bit" */ #cmakedefine ARCH_64_BIT /* "Define if building for IA32" */ #cmakedefine ARCH_IA32 /* "Define if building for EM64T" */ #cmakedefine ARCH_X86_64 /* internal build, switch on dump support. */ #cmakedefine DUMP_SUPPORT /* Define if building "fat" runtime. */ #cmakedefine FAT_RUNTIME /* Define to 1 if `backtrace' works. */ #cmakedefine HAVE_BACKTRACE /* C compiler has __builtin_assume_aligned */ #cmakedefine HAVE_CC_BUILTIN_ASSUME_ALIGNED /* C++ compiler has __builtin_assume_aligned */ #cmakedefine HAVE_CXX_BUILTIN_ASSUME_ALIGNED /* C++ compiler has x86intrin.h */ #cmakedefine HAVE_CXX_X86INTRIN_H /* C compiler has x86intrin.h */ #cmakedefine HAVE_C_X86INTRIN_H /* C++ compiler has intrin.h */ #cmakedefine HAVE_CXX_INTRIN_H /* C compiler has intrin.h */ #cmakedefine HAVE_C_INTRIN_H /* Define to 1 if you have the declaration of `pthread_setaffinity_np', and to 0 if you don't. */ #cmakedefine HAVE_DECL_PTHREAD_SETAFFINITY_NP /* Define to 1 if you have the `malloc_info' function. */ #cmakedefine HAVE_MALLOC_INFO /* Define to 1 if you have the `memmem' function. */ #cmakedefine HAVE_MEMMEM /* Define to 1 if you have a working `mmap' system call. */ #cmakedefine HAVE_MMAP /* Define to 1 if `posix_memalign' works. */ #cmakedefine HAVE_POSIX_MEMALIGN /* Define to 1 if you have the `setrlimit' function. */ #cmakedefine HAVE_SETRLIMIT /* Define to 1 if you have the `shmget' function. */ #cmakedefine HAVE_SHMGET /* Define to 1 if you have the `sigaction' function. */ #cmakedefine HAVE_SIGACTION /* Define to 1 if you have the `sigaltstack' function. */ #cmakedefine HAVE_SIGALTSTACK /* Define if the sqlite3_open_v2 call is available */ #cmakedefine HAVE_SQLITE3_OPEN_V2 /* Define to 1 if you have the header file. */ #cmakedefine HAVE_UNISTD_H /* Define to 1 if you have the `_aligned_malloc' function. */ #cmakedefine HAVE__ALIGNED_MALLOC /* Optimize, inline critical functions */ #cmakedefine HS_OPTIMIZE #cmakedefine HS_VERSION #cmakedefine HS_MAJOR_VERSION #cmakedefine HS_MINOR_VERSION #cmakedefine HS_PATCH_VERSION #cmakedefine BUILD_DATE /* define if this is a release build. */ #cmakedefine RELEASE_BUILD /* define if reverse_graph requires patch for boost 1.62.0 */ #cmakedefine BOOST_REVGRAPH_PATCH hyperscan-4.4.1/cmake/boost.cmake0000644000175000017500000000240113055426554017504 0ustar sleuthkidsleuthkid# Boost 1.62 has a bug that we've patched around, check if it is required if (Boost_VERSION EQUAL 106200) set (CMAKE_REQUIRED_INCLUDES ${BOOST_INCLUDEDIR} "${PROJECT_SOURCE_DIR}/include") set (BOOST_REV_TEST " #include #include #include #include int main(int,char*[]) { using namespace boost; // Check const reverse_graph { typedef adjacency_list< vecS, vecS, bidirectionalS, property, property, property > AdjList; typedef reverse_graph Graph; BOOST_CONCEPT_ASSERT(( BidirectionalGraphConcept )); } return 0; } ") CHECK_CXX_SOURCE_COMPILES("${BOOST_REV_TEST}" BOOST_REVGRAPH_OK) if (NOT BOOST_REVGRAPH_OK) message(STATUS "trying patched") CHECK_CXX_SOURCE_COMPILES(" #include ${BOOST_REV_TEST}" BOOST_REVGRAPH_PATCH) endif() if (NOT BOOST_REVGRAPH_OK AND NOT BOOST_REVGRAPH_PATCH) message(FATAL_ERROR "Something is wrong with this copy of boost::reverse_graph") endif() unset (CMAKE_REQUIRED_INCLUDES) endif () # Boost 1.62.0 hyperscan-4.4.1/cmake/backtrace.cmake0000644000175000017500000000360313055426554020302 0ustar sleuthkidsleuthkid# The `backtrace' function is available on Linux via glibc, and on FreeBSD if # the 'libexecinfo' package is installed. CHECK_C_SOURCE_COMPILES( "#include \n#include \nint main () { backtrace(NULL, 0); }" BACKTRACE_LIBC) if(BACKTRACE_LIBC) set(HAVE_BACKTRACE TRUE) set(BACKTRACE_CFLAGS "") set(BACKTRACE_LDFLAGS "") endif() if(NOT BACKTRACE_LIBC) # FreeBSD 10 has backtrace but requires libexecinfo list(INSERT CMAKE_REQUIRED_LIBRARIES 0 "-lexecinfo") CHECK_C_SOURCE_COMPILES( "#include \n#include \nint main () { backtrace(NULL, 0); }" BACKTRACE_LIBEXECINFO) list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "-lexecinfo") if(BACKTRACE_LIBEXECINFO) set(HAVE_BACKTRACE TRUE) set(BACKTRACE_CFLAGS "") set(BACKTRACE_LDFLAGS "-lexecinfo") else() # older FreeBSD requires it from ports list(INSERT CMAKE_REQUIRED_INCLUDES 0 "/usr/local/include") list(INSERT CMAKE_REQUIRED_LIBRARIES 0 "-L/usr/local/lib -lexecinfo") CHECK_C_SOURCE_COMPILES( "#include \n#include \nint main () { backtrace(NULL, 0); }" BACKTRACE_LIBEXECINFO_LOCAL) list(REMOVE_ITEM CMAKE_REQUIRED_INCLUDES 0 "/usr/local/include") list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES "-L/usr/local/lib -lexecinfo") if(BACKTRACE_LIBEXECINFO_LOCAL) set(HAVE_BACKTRACE TRUE) set(BACKTRACE_CFLAGS "-I/usr/local/include") set(BACKTRACE_LDFLAGS "-L/usr/local/lib -lexecinfo") endif() endif() endif() if(HAVE_BACKTRACE) CHECK_C_COMPILER_FLAG(-rdynamic HAS_RDYNAMIC) if(HAS_RDYNAMIC) list(INSERT BACKTRACE_LDFLAGS 0 -rdynamic) endif() # cmake scope fun set(HAVE_BACKTRACE ${HAVE_BACKTRACE} PARENT_SCOPE) else() set(BACKTRACE_CFLAGS "") set(BACKTRACE_LDFLAGS "") endif() hyperscan-4.4.1/cmake/build_wrapper.sh0000755000175000017500000000174513055426554020564 0ustar sleuthkidsleuthkid#!/bin/sh -e # This is used for renaming symbols for the fat runtime, don't call directly # TODO: make this a lot less fragile! PREFIX=$1 KEEPSYMS_IN=$2 shift 2 BUILD=$@ OUT=$(echo $BUILD | sed 's/.* -o \(.*\.o\).*/\1/') SYMSFILE=/tmp/${PREFIX}_rename.syms.$$ KEEPSYMS=/tmp/keep.syms.$$ # grab the command without the target obj or src file flags # we don't just call gcc directly as there may be flags modifying the arch CC_CMD=$(echo $BUILD | sed 's/ -o .*\.o//;s/ -c //;s/ .[^ ]*\.c//;') # find me a libc LIBC_SO=$(${CC_CMD} --print-file-name=libc.so.6) cp ${KEEPSYMS_IN} ${KEEPSYMS} # get all symbols from libc and turn them into patterns nm -f p -g -D ${LIBC_SO} | sed -s 's/\([^ ]*\).*/^\1$/' >> ${KEEPSYMS} # build the object ${BUILD} # rename the symbols in the object nm -f p -g ${OUT} | cut -f1 -d' ' | grep -v -f ${KEEPSYMS} | sed -e "s/\(.*\)/\1\ ${PREFIX}_\1/" >> ${SYMSFILE} if test -s ${SYMSFILE} then objcopy --redefine-syms=${SYMSFILE} ${OUT} fi rm -f ${SYMSFILE} ${KEEPSYMS} hyperscan-4.4.1/cmake/platform.cmake0000644000175000017500000000065013055426554020206 0ustar sleuthkidsleuthkid# determine the target arch # really only interested in the preprocessor here CHECK_C_SOURCE_COMPILES("#if !(defined(__x86_64__) || defined(_M_X64))\n#error not 64bit\n#endif\nint main(void) { return 0; }" ARCH_64_BIT) CHECK_C_SOURCE_COMPILES("#if !(defined(__i386__) || defined(_M_IX86))\n#error not 64bit\n#endif\nint main(void) { return 0; }" ARCH_32_BIT) set(ARCH_X86_64 ${ARCH_64_BIT}) set(ARCH_IA32 ${ARCH_32_BIT}) hyperscan-4.4.1/cmake/formatdate.py0000755000175000017500000000054213055426554020063 0ustar sleuthkidsleuthkid#!/usr/bin/env python from __future__ import print_function import os import sys import datetime def usage(): print("Usage:", os.path.basename(sys.argv[0]), "") if len(sys.argv) != 2: usage() sys.exit(1) ts = sys.argv[1] build_date = datetime.datetime.utcfromtimestamp(int(ts)) print(build_date.strftime("%Y-%m-%d")) hyperscan-4.4.1/cmake/sqlite3.cmake0000644000175000017500000000402013055426554017741 0ustar sleuthkidsleuthkid# # a lot of noise to find sqlite # option(SQLITE_PREFER_STATIC "Build sqlite3 statically instead of using an installed lib" OFF) if(NOT WIN32 AND NOT SQLITE_PREFER_STATIC) find_package(PkgConfig QUIET) # first check for sqlite on the system pkg_check_modules(SQLITE3 sqlite3) endif() if (NOT SQLITE3_FOUND) message(STATUS "looking for sqlite3 in source tree") # look in the source tree if (EXISTS "${PROJECT_SOURCE_DIR}/sqlite3/sqlite3.h" AND EXISTS "${PROJECT_SOURCE_DIR}/sqlite3/sqlite3.c") message(STATUS " found sqlite3 in source tree") set(SQLITE3_FOUND TRUE) set(SQLITE3_BUILD_SOURCE TRUE) set(SQLITE3_INCLUDE_DIRS "${PROJECT_SOURCE_DIR}/sqlite3") set(SQLITE3_LDFLAGS sqlite3_static) else() message(FATAL_ERROR " no sqlite3 in source tree") endif() endif() # now do version checks if (SQLITE3_FOUND) list(INSERT CMAKE_REQUIRED_INCLUDES 0 "${SQLITE3_INCLUDE_DIRS}") CHECK_C_SOURCE_COMPILES("#include \n#if SQLITE_VERSION_NUMBER >= 3008007 && SQLITE_VERSION_NUMBER < 3008010\n#error broken sqlite\n#endif\nint main() {return 0;}" SQLITE_VERSION_OK) if (NOT SQLITE_VERSION_OK) message(FATAL_ERROR "sqlite3 is broken from 3.8.7 to 3.8.10 - please find a working version") endif() if (NOT SQLITE3_BUILD_SOURCE) set(_SAVED_FLAGS ${CMAKE_REQUIRED_FLAGS}) list(INSERT CMAKE_REQUIRED_LIBRARIES 0 ${SQLITE3_LDFLAGS}) CHECK_SYMBOL_EXISTS(sqlite3_open_v2 sqlite3.h HAVE_SQLITE3_OPEN_V2) list(REMOVE_ITEM CMAKE_REQUIRED_INCLUDES "${SQLITE3_INCLUDE_DIRS}") list(REMOVE_ITEM CMAKE_REQUIRED_LIBRARIES ${SQLITE3_LDFLAGS}) else() if (NOT TARGET sqlite3_static) # build sqlite as a static lib to compile into our test programs add_library(sqlite3_static STATIC "${PROJECT_SOURCE_DIR}/sqlite3/sqlite3.c") if (NOT WIN32) set_target_properties(sqlite3_static PROPERTIES COMPILE_FLAGS "-Wno-unused -Wno-cast-qual -DSQLITE_OMIT_LOAD_EXTENSION") endif() endif() endif() endif() # that's enough about sqlite hyperscan-4.4.1/cmake/attrib.cmake0000644000175000017500000000055213055426554017650 0ustar sleuthkidsleuthkid# tests for compiler properties # set -Werror so we can't ignore unused attribute warnings set (CMAKE_REQUIRED_FLAGS "-Werror") CHECK_C_SOURCE_COMPILES(" int foo(int) __attribute__ ((ifunc(\"foo_i\"))); int f1(int i) { return i; } void (*foo_i()) { return f1; } int main(void) { return 0; } " HAS_C_ATTR_IFUNC) unset(CMAKE_REQUIRED_FLAGS) hyperscan-4.4.1/tools/0000755000175000017500000000000013055426554015437 5ustar sleuthkidsleuthkidhyperscan-4.4.1/tools/hsbench/0000755000175000017500000000000013055426554017051 5ustar sleuthkidsleuthkidhyperscan-4.4.1/tools/hsbench/heapstats.h0000644000175000017500000000320113055426554021212 0ustar sleuthkidsleuthkid/* * 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 HEAPSTATS_H #define HEAPSTATS_H #include // for size_t size_t getPeakHeap(void); #endif hyperscan-4.4.1/tools/hsbench/thread_barrier.h0000644000175000017500000000452313055426554022203 0ustar sleuthkidsleuthkid/* * 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. */ /** * \file * \brief Simple thread barrier. */ #ifndef TOOLS_THREAD_BARRIER_H #define TOOLS_THREAD_BARRIER_H #include #include /** * \brief Simple thread barrier class. * * Blocks until wait() has been called N times. */ class thread_barrier { public: explicit thread_barrier(unsigned int n) : max(n) { if (max == 0) { throw std::runtime_error("invalid barrier"); } } void wait() { std::unique_lock lock(mtx); count++; if (count >= max) { count = 0; condvar.notify_all(); } else { condvar.wait(lock); } } private: std::mutex mtx; std::condition_variable condvar; unsigned int count = 0; unsigned int max; }; #endif // TOOLS_THREAD_BARRIER_H hyperscan-4.4.1/tools/hsbench/huge.h0000644000175000017500000000325313055426554020155 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 HUGE_H #define HUGE_H #include "hs.h" hs_database_t *get_huge(hs_database_t *db); void release_huge(hs_database_t *db); #endif /* HUGE_H */ hyperscan-4.4.1/tools/hsbench/data_corpus.cpp0000644000175000017500000001071613055426554022066 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "data_corpus.h" #include "util/container.h" #include "ue2common.h" #include #include #include #include #include #include using namespace std; using namespace ue2; static void readRow(sqlite3_stmt *statement, vector &blocks, map &stream_indices) { unsigned int id = sqlite3_column_int(statement, 0); unsigned int stream_id = sqlite3_column_int(statement, 1); const char *blob = (const char *)sqlite3_column_blob(statement, 2); unsigned int bytes = sqlite3_column_bytes(statement, 2); if (!contains(stream_indices, stream_id)) { unsigned int internal_stream_index = stream_indices.size(); stream_indices[stream_id] = internal_stream_index; } auto internal_stream_index = stream_indices[stream_id]; assert(blob || bytes > 0); blocks.emplace_back(id, stream_id, internal_stream_index, string(blob, blob + bytes)); } vector readCorpus(const string &filename) { int status; sqlite3 *db = nullptr; status = sqlite3_open_v2(filename.c_str(), &db, SQLITE_OPEN_READONLY, nullptr); assert(db); if (status != SQLITE_OK) { ostringstream err; err << "Unable to open database '" << filename << "': " << sqlite3_errmsg(db); status = sqlite3_close(db); assert(status == SQLITE_OK); throw DataCorpusError(err.str()); } static const string query("SELECT id, stream_id, data " "FROM chunk ORDER BY id;"); sqlite3_stmt *statement = nullptr; status = sqlite3_prepare_v2(db, query.c_str(), query.size(), &statement, nullptr); if (status != SQLITE_OK) { status = sqlite3_finalize(statement); assert(status == SQLITE_OK); status = sqlite3_close(db); assert(status == SQLITE_OK); ostringstream oss; oss << "Query failed: " << query; throw DataCorpusError(oss.str()); } vector blocks; map stream_indices; status = sqlite3_step(statement); while (status == SQLITE_ROW) { readRow(statement, blocks, stream_indices); status = sqlite3_step(statement); } if (status != SQLITE_DONE) { ostringstream oss; oss << "Error retrieving blocks from corpus: " << sqlite3_errstr(status); status = sqlite3_finalize(statement); assert(status == SQLITE_OK); status = sqlite3_close(db); assert(status == SQLITE_OK); throw DataCorpusError(oss.str()); } status = sqlite3_finalize(statement); assert(status == SQLITE_OK); status = sqlite3_close(db); assert(status == SQLITE_OK); if (blocks.empty()) { throw DataCorpusError("Database contains no blocks."); } return blocks; } hyperscan-4.4.1/tools/hsbench/timer.h0000644000175000017500000000407613055426554020351 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 TIMER_H #define TIMER_H #include "ue2common.h" #include class Timer { public: Timer() = default; void start() { clock_start = Clock::now(); } void complete() { clock_end = Clock::now(); } double seconds() const { std::chrono::duration secs = clock_end - clock_start; return secs.count(); } protected: using Clock = std::chrono::steady_clock; std::chrono::time_point clock_start; std::chrono::time_point clock_end; }; #endif // TIMER_H hyperscan-4.4.1/tools/hsbench/CMakeLists.txt0000644000175000017500000000166613055426554021622 0ustar sleuthkidsleuthkidinclude (${CMAKE_MODULE_PATH}/sqlite3.cmake) if (NOT XCODE) include_directories(SYSTEM ${SQLITE3_INCLUDE_DIRS}) else() # cmake doesn't think Xcode supports isystem set(EXTRA_CXX_FLAGS "${EXTRA_CXX_FLAGS} -isystem ${SQLITE3_INCLUDE_DIRS}") endif() CHECK_FUNCTION_EXISTS(malloc_info HAVE_MALLOC_INFO) CHECK_FUNCTION_EXISTS(shmget HAVE_SHMGET) set(HAVE_SHMGET ${HAVE_SHMGET} CACHE BOOL "shmget()") # only set these after all tests are done set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}") SET(hsbench_SOURCES common.h data_corpus.cpp data_corpus.h engine_hyperscan.cpp engine_hyperscan.h heapstats.cpp heapstats.h huge.cpp huge.h main.cpp thread_barrier.h timer.h ) add_executable(hsbench ${hsbench_SOURCES}) target_link_libraries(hsbench hs databaseutil expressionutil ${SQLITE3_LDFLAGS} ${CMAKE_THREAD_LIBS_INIT}) hyperscan-4.4.1/tools/hsbench/data_corpus.h0000644000175000017500000000511713055426554021532 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 DATACORPUS_H #define DATACORPUS_H #include #include class DataBlock { public: DataBlock(unsigned int in_id, unsigned int in_stream, unsigned int int_stream_index_in, std::string in_data) : id(in_id), stream_id(in_stream), internal_stream_index(int_stream_index_in), payload(std::move(in_data)) {} unsigned int id; // unique block identifier unsigned int stream_id; // unique stream identifier (from corpus file) unsigned int internal_stream_index; /* dense index for this stream * (allocated by hsbench) */ std::string payload; // actual block payload }; /** Exception thrown if an error occurs. */ class DataCorpusError { public: explicit DataCorpusError(std::string msg_in) : msg(std::move(msg_in)) {} std::string msg; }; /** * Interface to a corpus database. Any error will produce a DataCorpusError * and should be considered fatal. */ std::vector readCorpus(const std::string &filename); #endif // DATACORPUS_H hyperscan-4.4.1/tools/hsbench/scripts/0000755000175000017500000000000013055426554020540 5ustar sleuthkidsleuthkidhyperscan-4.4.1/tools/hsbench/scripts/gutenbergCorpus.py0000755000175000017500000000365313055426554024302 0ustar sleuthkidsleuthkid#!/usr/bin/python ''' This script creates a Hyperscan benchmarking corpus database from a supplied group of Project Gutenberg texts. ''' import sys, getopt, os.path import gutenberg.acquire, gutenberg.cleanup, gutenberg.query from CorpusBuilder import CorpusBuilder stream_id = 0 stream_bytes = 0 def addBlocks(builder, block_size, stream_size, text_id, text): global stream_id global stream_bytes print "text", text_id, "len", len(text) i = 0 while i < len(text): chunk = text[i:min(len(text), i + block_size)] builder.add_chunk(stream_id, chunk) i += block_size stream_bytes += len(chunk) if stream_bytes >= stream_size: stream_id += 1 stream_bytes = 0 print "Text", text_id, ": added", i/block_size, "blocks of", block_size, "bytes." def buildCorpus(outFN, block_size, stream_size, text_ids): if len(text_ids) == 0: print >>sys.stderr, "Must provide at least one input ID" sys.exit(0) builder = CorpusBuilder(outFN) total_bytes = 0 stream_id = 0 stream_bytes = 0 for text_id in text_ids: text_id = int(text_id) text = gutenberg.acquire.load_etext(text_id) text = gutenberg.cleanup.strip_headers(text).strip() addBlocks(builder, block_size, stream_size, text_id, text) total_bytes += len(text) builder.finish() print "Total:", total_bytes, "bytes." def usage(exeName): errmsg = "Usage: %s -o -b -s ..." errmsg = errmsg % exeName print >> sys.stderr, errmsg sys.exit(-1) if __name__ == '__main__': opts, args = getopt.getopt(sys.argv[1:], 'o:b:s:') opts = dict(opts) requiredKeys = [ '-o', '-b', '-s' ] for k in requiredKeys: if not opts.has_key(k): usage(os.path.basename(sys.argv[0])) buildCorpus(opts['-o'], int(opts['-b']), int(opts['-s']), args) hyperscan-4.4.1/tools/hsbench/scripts/pcapCorpus.py0000755000175000017500000002251313055426554023237 0ustar sleuthkidsleuthkid#!/usr/bin/env python ''' Script to convert a pcap file containing UDP and TCP packets to a corpus file. ''' import sys, getopt, pprint, os from sqlite3 import dbapi2 as sqlite import pcap from optparse import OptionParser from socket import AF_INET, IPPROTO_UDP, IPPROTO_TCP, inet_ntop, ntohs, ntohl, inet_ntoa import struct from CorpusBuilder import CorpusBuilder ETHERTYPE_IP = 0x0800 # IP protocol ETHERTYPE_ARP = 0x0806 # Addr. resolution protocol ETHERTYPE_REVARP = 0x8035 # reverse Addr. resolution protocol ETHERTYPE_VLAN = 0x8100 # IEEE 802.1Q VLAN tagging ETHERTYPE_IPV6 = 0x86dd # IPv6 # # A dictionary of active TCP streams # tcp_streams = {} # # A dictionary of UDP streams # udp_streams = {} # # Current stream id cur_stream_id = 0 def usage(exeName) : errmsg = "Usage: %s -i -o " errmsg = errmsg % exeName print >> sys.stderr, errmsg sys.exit(-1) class FiveTuple(object): def __init__(self, protocol, src_addr, src_port, dst_addr, dst_port): self.protocol = protocol self.src_addr = src_addr self.src_port = src_port self.dst_addr = dst_addr self.dst_port = dst_port def __str__(self): return "%d,%s,%d,%s,%d" % (self.protocol, self.src_addr, self.src_port, self.dst_addr, self.dst_port) class UdpSegment: """Definition of a UDP segment """ def __init__(self, five_tuple, header, payload): self.five_tuple = five_tuple self.udp_header = header self.udp_payload = payload class TcpSegment: """Definition of a TCP segment """ def __init__(self, five_tuple, header, payload): self.five_tuple = five_tuple self.tcp_header = header self.tcp_payload = payload self.tcp_sequence_number, self.tcp_acknowledgement_number = struct.unpack('!LL', header[4:12]) def opt_isset_FIN(self): opts = ord(self.tcp_header[13]) & 0x3F return (opts & 0x01) def opt_isset_SYN(self): opts = ord(self.tcp_header[13]) & 0x3F return (opts & 0x02) def get_sequence_number(self): return self.tcp_sequence_number def __cmp__(self, other): return cmp(self.tcp_sequence_number, other.tcp_sequence_number) class TcpStream: """Definition of a TCP stream. """ TCP_STREAM_ACTIVE = 0x1 TCP_STREAM_CLOSED = 0x02 def __init__(self, five_tuple): self.five_tuple = five_tuple self.initial_sequence_number = 0 self.segments = [] def reset_stream(self): self.segments = [] self.initial_sequence_number = 0 def set_initial_sequence_number(self, sequence_number): self.initial_sequence_number = sequence_number def append_segment(self, tcp_segment): if len(self.segments) == 0: self.set_initial_sequence_number(tcp_segment.get_sequence_number()) self.segments.append(tcp_segment) def get_segments_sorted(self): return sorted(self.segments) class UdpStream: """A container for UDP packets that share the same 5-tuple """ def __init__(self, five_tuple): self.five_tuple = five_tuple self.segments = [] def append_segment(self, udp_segment): self.segments.append(udp_segment) def newStream(five_tuple): ''' Create a new stream using the arguments passed-in and return its ID. ''' global cur_stream_id stream_id = cur_stream_id cur_stream_id += 1 return stream_id def process_tcp_segment(builder, segment): """Process a tcp segment. It checks for SYN and FIN segments are if set modifies the associated stream. """ segment_id = str(segment.five_tuple) if segment_id in tcp_streams: m_tcp_stream = tcp_streams[segment_id] m_tcp_stream.append_segment(segment) else: m_tcp_stream = TcpStream(segment.five_tuple) m_tcp_stream.append_segment(segment) tcp_streams[segment_id] = m_tcp_stream if segment.opt_isset_SYN(): m_tcp_stream.segments = [] if segment.opt_isset_FIN(): # # Finished with the stream - add the segments in the # stream to db allowing the stream to be reused. # db_add_tcp_stream_segments(builder, m_tcp_stream) del tcp_streams[segment_id] def process_udp_segment(builder, segment): """ Process a UDP segment. Given the connectionless nature of the UDP protocol we simple accumulate the segment for later processing when all the packets have been read """ segment_id = str(segment.five_tuple) if segment_id in udp_streams: m_udp_stream = udp_streams[segment_id] m_udp_stream.append_segment(segment) else: m_udp_stream = UdpStream(segment.five_tuple) m_udp_stream.append_segment(segment) udp_streams[segment_id] = m_udp_stream def db_add_tcp_stream_segments(builder, tcp_stream): """Add the contents of a tcp stream to the database """ tcp_segments = tcp_stream.get_segments_sorted() last_sequence_num = 0 streamID = None for tcp_segment in tcp_segments: if (len(tcp_segment.tcp_payload) > 0) and (tcp_segment.tcp_sequence_number > last_sequence_num): # # Segment with an actual payload - add it to the stream's # list of chunks. # # Note: delay creating the stream until we have a via chunk to # commit to it # if streamID == None: streamID = newStream(tcp_stream.five_tuple) builder.add_chunk(streamID, tcp_segment.tcp_payload) last_sequence_num = tcp_segment.tcp_sequence_number def db_add_udp_stream_segments(builder, udp_stream): """Add the contents of a UDP stream to the database. Since UDP is connection-less, a UDP stream object is really just an accumulation of all the packets associated with a given 5-tuple. """ udp_segments = udp_stream.segments streamID = None for udp_segment in udp_segments: if len(udp_segment.udp_payload) > 0: if streamID == None: streamID = newStream(udp_stream.five_tuple) builder.add_chunk(streamID, udp_segment.udp_payload) def enchunk_pcap(pcapFN, sqliteFN): """Read the contents of a pcap file with name @pcapFN and produce a sqlite db with name @sqliteFN. It will contain chunks of data from TCP and UDP streams, """ if not os.path.exists(pcapFN): print >> sys.stderr, "Input file '%s' does not exist. Exiting." % pcapFN sys.exit(-1) builder = CorpusBuilder(sqliteFN) # # Read in the contents of the pcap file, adding stream segments as found # pkt_cnt = 0; ip_pkt_cnt = 0; unsupported_ip_protocol_cnt = 0 pcap_ref = pcap.pcap(pcapFN) done = False while not done: try: ts, packet = pcap_ref.next() except: break pkt_cnt += 1 linkLayerType = struct.unpack('!H', packet[(pcap_ref.dloff - 2):pcap_ref.dloff])[0] if linkLayerType != ETHERTYPE_IP: # # We're only interested in IP packets # continue ip_pkt_cnt += 1 ip_pkt_total_len = struct.unpack('!H', packet[pcap_ref.dloff + 2: pcap_ref.dloff + 4])[0] ip_pkt = packet[pcap_ref.dloff:pcap_ref.dloff + ip_pkt_total_len] pkt_protocol = struct.unpack('B', ip_pkt[9])[0] if (pkt_protocol != IPPROTO_UDP) and (pkt_protocol != IPPROTO_TCP): # # we're only interested in UDP and TCP packets at the moment # continue pkt_src_addr = inet_ntoa(ip_pkt[12:16]) pkt_dst_addr = inet_ntoa(ip_pkt[16:20]) ip_hdr_len_offset = (ord(ip_pkt[0]) & 0x0f) * 4 ip_payload = ip_pkt[ip_hdr_len_offset:len(ip_pkt)] pkt_src_port, pkt_dst_port = struct.unpack('!HH', ip_payload[0:4]) five_tuple = FiveTuple(pkt_protocol, pkt_src_addr, pkt_src_port, pkt_dst_addr, pkt_dst_port) five_tuple_id = str(five_tuple) if pkt_protocol == IPPROTO_UDP: udp_payload_len = struct.unpack('!H', ip_payload[4:6])[0] - 8 udp_header = ip_payload[0:8] udp_payload = ip_payload[8:len(ip_payload)] udp_segment = UdpSegment(five_tuple, udp_header, udp_payload) process_udp_segment(builder, udp_segment) elif pkt_protocol == IPPROTO_TCP: tcp_hdr_len = (ord(ip_payload[12]) >> 4) * 4 tcp_header = ip_payload[0:tcp_hdr_len] tcp_payload = ip_payload[tcp_hdr_len:len(ip_payload)] segment = TcpSegment(five_tuple, tcp_header, tcp_payload) process_tcp_segment(builder, segment) # # Having read the contents of the pcap, we fill the database with any # remaining TCP and UDP segments # for tcp_stream in tcp_streams.itervalues(): db_add_tcp_stream_segments(builder, tcp_stream) for udp_stream in udp_streams.itervalues(): db_add_udp_stream_segments(builder, udp_stream) # # We've finished with the database # builder.finish() if __name__ == '__main__' : args = getopt.getopt(sys.argv[1:], 'i:o:') args = dict(args[0]) requiredKeys = [ '-i', '-o'] for k in requiredKeys : if not args.has_key(k) : usage(os.path.basename(sys.argv[0])) fnArgs = tuple([ args[k] for k in requiredKeys ]) enchunk_pcap(*fnArgs) hyperscan-4.4.1/tools/hsbench/scripts/CorpusBuilder.py0000755000175000017500000000261613055426554023704 0ustar sleuthkidsleuthkid#!/usr/bin/python ''' A module to construct corpora databases for the Hyperscan benchmarker (hsbench). After construction, simply add blocks with the add_chunk() method, then call finish() when you're done. ''' import os.path try: from sqlite3 import dbapi2 as sqlite except: from pysqlite2 import dbapi2 as sqlite class CorpusBuilder: SCHEMA = ''' CREATE TABLE chunk ( id integer primary key, stream_id integer not null, data blob ); ''' def __init__(self, outfile): if os.path.exists(outfile): raise RuntimeError("Database '%s' already exists" % outfile) self.outfile = outfile self.db = sqlite.connect(self.outfile) self.db.executescript(CorpusBuilder.SCHEMA) self.current_chunk_id = 0; def add_chunk(self, stream_id, data): chunk_id = self.current_chunk_id; c = self.db.cursor() q = 'insert into chunk (id, stream_id, data) values (?, ?, ?)' c.execute(q, (chunk_id, stream_id, sqlite.Binary(data))) self.current_chunk_id += 1 return chunk_id def finish(self): self.db.commit() c = self.db.cursor() q = 'create index chunk_stream_id_idx on chunk(stream_id)' c.execute(q) c = self.db.cursor() q = 'vacuum' c.execute(q) c = self.db.cursor() q = 'analyze' c.execute(q) self.db.commit() hyperscan-4.4.1/tools/hsbench/scripts/linebasedCorpus.py0000755000175000017500000000246313055426554024244 0ustar sleuthkidsleuthkid#!/usr/bin/python ''' Simple script to take a file full of lines of text and push them into a Hyperscan benchmarking corpus database, one block per line. ''' import sys, getopt, os.path from CorpusBuilder import CorpusBuilder def lineCorpus(inFN, outFN): ''' Read lines from file name @inFN and write them as blocks to a new db with name @outFN. ''' if not os.path.exists(inFN): print >> sys.stderr, "Input file '%s' does not exist. Exiting." % outFN sys.exit(-1) lines = open(inFN).readlines() if len(lines) == 0: print >> sys.stderr, "Input file contained no lines. Exiting." sys.exit(0) builder = CorpusBuilder(outFN) # write a single stream to contain everything streamId = 0 for l in lines: builder.add_chunk(streamId, l.rstrip()) builder.finish() def usage(exeName): errmsg = "Usage: %s -i -o " errmsg = errmsg % exeName print >> sys.stderr, errmsg sys.exit(-1) if __name__ == '__main__': args = getopt.getopt(sys.argv[1:], 'i:o:c:') args = dict(args[0]) requiredKeys = [ '-i', '-o' ] for k in requiredKeys: if not args.has_key(k): usage(os.path.basename(sys.argv[0])) fnArgs = tuple([args[k] for k in requiredKeys]) lineCorpus(*fnArgs) hyperscan-4.4.1/tools/hsbench/common.h0000644000175000017500000000345313055426554020517 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 COMMON_H #define COMMON_H #include enum class ScanMode { BLOCK, STREAMING, VECTORED }; extern bool echo_matches; extern bool saveDatabases; extern bool loadDatabases; extern std::string serializePath; extern unsigned int somPrecisionMode; #endif // COMMON_H hyperscan-4.4.1/tools/hsbench/README.md0000644000175000017500000000055413055426554020334 0ustar sleuthkidsleuthkidHyperscan Benchmarker: hsbench ============================== The `hsbench` tool provides an easy way to measure Hyperscan's performance for a particular set of patterns and corpus of data to be scanned. Documentation describing its operation is available in the Tools section of the [Developer Reference Guide](http://01org.github.io/hyperscan/dev-reference/). hyperscan-4.4.1/tools/hsbench/huge.cpp0000644000175000017500000001242413055426554020510 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "hs.h" #include "ue2common.h" #include "common.h" #include "huge.h" #ifndef _WIN32 #include #include #include #include #include #include #include #if defined(HAVE_SHMGET) #include #include #endif UNUSED static int hsdb_shmid; using namespace std; long gethugepagesize(void); hs_database_t *get_huge(hs_database_t *db) { #if defined(HAVE_SHMGET) && defined(SHM_HUGETLB) /* move the database to huge pages where possible, but fail politely */ hs_error_t err; size_t len; char *bytes; long hpage_size = gethugepagesize(); if (hpage_size < 0) { printf("Couldn't determine huge page size\n"); hsdb_shmid = -1; return db; } err = hs_serialize_database(db, &bytes, &len); if (err != HS_SUCCESS) { printf("Failed to serialize database for copy: %d\n", err); // this is weird - don't fail gracefully this time return nullptr; } size_t size; err = hs_serialized_database_size(bytes, len, &size); if (err != HS_SUCCESS) { printf("Failed to get database size: %d\n", err); // this is weird - don't fail gracefully this time return nullptr; } void *shmaddr; if ((hsdb_shmid = shmget(IPC_PRIVATE, ROUNDUP_N(size, gethugepagesize()), SHM_HUGETLB | IPC_CREAT | SHM_R | SHM_W)) < 0) { // This could fail if the user doesn't have permission to shmget(), // which is OK. goto fini; } shmaddr = shmat(hsdb_shmid, nullptr, SHM_RND); if (shmaddr == (char *)-1) { perror("Shared memory attach failure"); goto fini; } // Mark this segment to be destroyed after this process detaches. shmctl(hsdb_shmid, IPC_RMID, nullptr); err = hs_deserialize_database_at(bytes, len, (hs_database_t *)shmaddr); if (err != HS_SUCCESS) { printf("Failed to deserialize database into shm: %d\n", err); shmdt((const void *)shmaddr); goto fini; } free(bytes); hs_free_database(db); return (hs_database_t *)shmaddr; fini: free(bytes); hsdb_shmid = -1; return db; #else return db; #endif } void release_huge(hs_database_t *db) { #if defined(HAVE_SHMGET) && defined(SHM_HUGETLB) if (hsdb_shmid != -1) { if (shmdt((const void *)db) != 0) { perror("Detach failure"); } } else { // fallback hs_free_database(db); } #else hs_free_database(db); #endif } #define BUF_SIZE 4096 static long read_meminfo(const char *tag) { int fd; char buf[BUF_SIZE]; int len; char *p, *q; long val; fd = open("/proc/meminfo", O_RDONLY); if (fd < 0) { perror("Couldn't open /proc/meminfo"); return -1; } len = read(fd, buf, sizeof(buf)); close(fd); if (len < 0) { perror("Error reading /proc/meminfo"); return -1; } if (len == sizeof(buf)) { printf("/proc/meminfo is too large\n"); return -1; } buf[len] = '\0'; p = strstr(buf, tag); if (!p) { return -1; } p += strlen(tag); val = strtol(p, &q, 0); if (!isspace(*q)) { printf("Couldn't parse /proc/meminfo value\n"); return -1; } return val; } long gethugepagesize(void) { long hpage_size; int hpage_kb; hpage_kb = read_meminfo("Hugepagesize:"); if (hpage_kb < 0) { hpage_size = -1; } else { /* convert from kb to bytes */ hpage_size = 1024 * hpage_kb; } return hpage_size; } #else /* No huge page support on WIN32. */ hs_database_t *get_huge(hs_database_t *db) { return db; } void release_huge(hs_database_t *db) { hs_free_database(db); } #endif hyperscan-4.4.1/tools/hsbench/engine_hyperscan.h0000644000175000017500000000664413055426554022555 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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 ENGINEHYPERSCAN_H #define ENGINEHYPERSCAN_H #include "expressions.h" #include "common.h" #include "hs_runtime.h" #include /** Structure for the result of a single complete scan. */ struct ResultEntry { double seconds = 0; //!< Time taken for scan. unsigned int matches = 0; //!< Count of matches found. }; /** Engine context which is allocated on a per-thread basis. */ class EngineContext { public: explicit EngineContext(const hs_database_t *db); ~EngineContext(); hs_scratch_t *scratch = nullptr; }; /** Streaming mode scans have persistent stream state associated with them. */ class EngineStream { public: hs_stream_t *id; unsigned int sn; EngineContext *ctx; }; /** Hyperscan Engine for scanning data. */ class EngineHyperscan { public: explicit EngineHyperscan(hs_database_t *db); ~EngineHyperscan(); std::unique_ptr makeContext() const; void scan(const char *data, unsigned int len, unsigned int id, ResultEntry &result, EngineContext &ctx) const; void scan_vectored(const char *const *data, const unsigned int *len, unsigned int count, unsigned int streamId, ResultEntry &result, EngineContext &ctx) const; std::unique_ptr streamOpen(EngineContext &ctx, unsigned id) const; void streamClose(std::unique_ptr stream, ResultEntry &result) const; void streamScan(EngineStream &stream, const char *data, unsigned int len, unsigned int id, ResultEntry &result) const; private: hs_database_t *db; }; namespace ue2 { struct Grey; } std::unique_ptr buildEngineHyperscan(const ExpressionMap &expressions, ScanMode scan_mode, const std::string &name, const ue2::Grey &grey); #endif // ENGINEHYPERSCAN_H hyperscan-4.4.1/tools/hsbench/engine_hyperscan.cpp0000644000175000017500000002777413055426554023117 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "ExpressionParser.h" #include "common.h" #include "engine_hyperscan.h" #include "expressions.h" #include "heapstats.h" #include "huge.h" #include "timer.h" #include "crc32.h" #include "database.h" #include "hs_compile.h" #include "hs_internal.h" #include "hs_runtime.h" #include "util/database_util.h" #include "util/make_unique.h" #include #include #include #include #include #include #include using namespace std; EngineContext::EngineContext(const hs_database_t *db) { hs_alloc_scratch(db, &scratch); assert(scratch); } EngineContext::~EngineContext() { hs_free_scratch(scratch); } namespace /* anonymous */ { /** Scan context structure passed to the onMatch callback function. */ struct ScanContext { ScanContext(unsigned id_in, ResultEntry &result_in, const EngineStream *stream_in) : id(id_in), result(result_in), stream(stream_in) {} unsigned id; ResultEntry &result; const EngineStream *stream; // nullptr except in streaming mode. }; } // namespace /** * Callback function called for every match that Hyperscan produces, used when * "echo matches" is off. */ static int onMatch(unsigned int, unsigned long long, unsigned long long, unsigned int, void *ctx) { ScanContext *sc = static_cast(ctx); assert(sc); sc->result.matches++; return 0; } /** * Callback function called for every match that Hyperscan produces when "echo * matches" is enabled. */ static int onMatchEcho(unsigned int id, unsigned long long, unsigned long long to, unsigned int, void *ctx) { ScanContext *sc = static_cast(ctx); assert(sc); sc->result.matches++; if (sc->stream) { printf("Match @%u:%u:%llu for %u\n", sc->stream->sn, sc->id, to, id); } else { printf("Match @%u:%llu for %u\n", sc->id, to, id); } return 0; } EngineHyperscan::EngineHyperscan(hs_database_t *db_in) : db(db_in) { assert(db); } EngineHyperscan::~EngineHyperscan() { release_huge(db); } unique_ptr EngineHyperscan::makeContext() const { return ue2::make_unique(db); } void EngineHyperscan::scan(const char *data, unsigned int len, unsigned int id, ResultEntry &result, EngineContext &ctx) const { assert(data); ScanContext sc(id, result, nullptr); auto callback = echo_matches ? onMatchEcho : onMatch; hs_error_t rv = hs_scan(db, data, len, 0, ctx.scratch, callback, &sc); if (rv != HS_SUCCESS) { printf("Fatal error: hs_scan returned error %d\n", rv); abort(); } } void EngineHyperscan::scan_vectored(const char *const *data, const unsigned int *len, unsigned int count, unsigned streamId, ResultEntry &result, EngineContext &ctx) const { assert(data); assert(len); ScanContext sc(streamId, result, nullptr); auto callback = echo_matches ? onMatchEcho : onMatch; hs_error_t rv = hs_scan_vector(db, data, len, count, 0, ctx.scratch, callback, &sc); if (rv != HS_SUCCESS) { printf("Fatal error: hs_scan_vector returned error %d\n", rv); abort(); } } unique_ptr EngineHyperscan::streamOpen(EngineContext &ctx, unsigned streamId) const { auto stream = ue2::make_unique(); stream->ctx = &ctx; hs_open_stream(db, 0, &stream->id); if (!stream->id) { // an error occurred, propagate to caller return nullptr; } stream->sn = streamId; return stream; } void EngineHyperscan::streamClose(unique_ptr stream, ResultEntry &result) const { assert(stream); auto &s = static_cast(*stream); EngineContext &ctx = *s.ctx; ScanContext sc(0, result, &s); auto callback = echo_matches ? onMatchEcho : onMatch; assert(s.id); hs_close_stream(s.id, ctx.scratch, callback, &sc); s.id = nullptr; } void EngineHyperscan::streamScan(EngineStream &stream, const char *data, unsigned len, unsigned id, ResultEntry &result) const { assert(data); auto &s = static_cast(stream); EngineContext &ctx = *s.ctx; ScanContext sc(id, result, &s); auto callback = echo_matches ? onMatchEcho : onMatch; hs_error_t rv = hs_scan_stream(s.id, data, len, 0, ctx.scratch, callback, &sc); if (rv != HS_SUCCESS) { printf("Fatal error: hs_scan_stream returned error %d\n", rv); abort(); } } static unsigned makeModeFlags(ScanMode scan_mode) { switch (scan_mode) { case ScanMode::BLOCK: return HS_MODE_BLOCK; case ScanMode::STREAMING: return HS_MODE_STREAM; case ScanMode::VECTORED: return HS_MODE_VECTORED; } assert(0); return HS_MODE_STREAM; } /** * Hash the settings used to compile a database, returning a string that can be * used as a filename. */ static string dbSettingsHash(const string &filename, u32 mode) { ostringstream info_oss; info_oss << filename.c_str() << ' '; info_oss << mode << ' '; string info = info_oss.str(); u32 crc = Crc32c_ComputeBuf(0, info.data(), info.size()); // return STL string with printable version of digest ostringstream oss; oss << hex << setw(8) << setfill('0') << crc << dec; return oss.str(); } static string dbFilename(const std::string &name, unsigned mode) { ostringstream oss; oss << serializePath << '/' << dbSettingsHash(name, mode) << ".db"; return oss.str(); } std::unique_ptr buildEngineHyperscan(const ExpressionMap &expressions, ScanMode scan_mode, const std::string &name, UNUSED const ue2::Grey &grey) { if (expressions.empty()) { assert(0); return nullptr; } long double compileSecs = 0.0; size_t compiledSize = 0.0; size_t streamSize = 0; size_t scratchSize = 0; unsigned int peakMemorySize = 0; unsigned int crc = 0; std::string db_info; unsigned int mode = makeModeFlags(scan_mode); hs_database_t *db; hs_error_t err; if (loadDatabases) { db = loadDatabase(dbFilename(name, mode).c_str()); if (!db) { return nullptr; } } else { const unsigned int count = expressions.size(); vector exprs; vector flags, ids; vector ext; for (const auto &m : expressions) { string expr; unsigned int f = 0; hs_expr_ext extparam; extparam.flags = 0; if (!readExpression(m.second, expr, &f, &extparam)) { printf("Error parsing PCRE: %s (id %u)\n", m.second.c_str(), m.first); return nullptr; } exprs.push_back(expr); ids.push_back(m.first); flags.push_back(f); ext.push_back(extparam); } unsigned full_mode = mode; if (mode == HS_MODE_STREAM) { full_mode |= somPrecisionMode; } // Our compiler takes an array of plain ol' C strings. vector patterns(count); for (unsigned int i = 0; i < count; i++) { patterns[i] = exprs[i].c_str(); } // Extended parameters are passed as pointers to hs_expr_ext structures. vector ext_ptr(count); for (unsigned int i = 0; i < count; i++) { ext_ptr[i] = &ext[i]; } Timer timer; timer.start(); hs_compile_error_t *compile_err; #ifndef RELEASE_BUILD err = hs_compile_multi_int(patterns.data(), flags.data(), ids.data(), ext_ptr.data(), count, full_mode, nullptr, &db, &compile_err, grey); #else err = hs_compile_ext_multi(patterns.data(), flags.data(), ids.data(), ext_ptr.data(), count, full_mode, nullptr, &db, &compile_err); #endif timer.complete(); compileSecs = timer.seconds(); peakMemorySize = getPeakHeap(); if (err == HS_COMPILER_ERROR) { if (compile_err->expression >= 0) { printf("Compile error for signature #%u: %s\n", compile_err->expression, compile_err->message); } else { printf("Compile error: %s\n", compile_err->message); } hs_free_compile_error(compile_err); return nullptr; } } // copy the db into huge pages (where available) to reduce TLB pressure db = get_huge(db); if (!db) { return nullptr; } err = hs_database_size(db, &compiledSize); if (err != HS_SUCCESS) { return nullptr; } assert(compiledSize > 0); crc = db->crc32; if (saveDatabases) { saveDatabase(db, dbFilename(name, mode).c_str()); } if (mode & HS_MODE_STREAM) { err = hs_stream_size(db, &streamSize); if (err != HS_SUCCESS) { return nullptr; } } else { streamSize = 0; } char *info; err = hs_database_info(db, &info); if (err != HS_SUCCESS) { return nullptr; } else { db_info = string(info); free(info); } // Allocate scratch temporarily to find its size: this is a good test // anyway. hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); if (err != HS_SUCCESS) { return nullptr; } err = hs_scratch_size(scratch, &scratchSize); if (err != HS_SUCCESS) { return nullptr; } hs_free_scratch(scratch); // Output summary information. printf("Signatures: %s\n", name.c_str()); printf("Hyperscan info: %s\n", db_info.c_str()); printf("Expression count: %'zu\n", expressions.size()); printf("Bytecode size: %'zu bytes\n", compiledSize); printf("Database CRC: 0x%x\n", crc); if (mode & HS_MODE_STREAM) { printf("Stream state size: %'zu bytes\n", streamSize); } printf("Scratch size: %'zu bytes\n", scratchSize); printf("Compile time: %'0.3Lf seconds\n", compileSecs); printf("Peak heap usage: %'u bytes\n", peakMemorySize); return ue2::make_unique(db); } hyperscan-4.4.1/tools/hsbench/main.cpp0000644000175000017500000005546313055426554020516 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "common.h" #include "data_corpus.h" #include "engine_hyperscan.h" #include "expressions.h" #include "thread_barrier.h" #include "timer.h" #include "util/expression_path.h" #include "util/string_util.h" #include "grey.h" #include "hs.h" #include "ue2common.h" #include "util/make_unique.h" #include #include #include #include #include #include #include #include #include #include #include #ifndef _WIN32 #include #include #endif #include #include using namespace std; using namespace ue2; using boost::adaptors::map_keys; // Globals common to all files. bool echo_matches = false; bool saveDatabases = false; bool loadDatabases = false; string serializePath(""); unsigned int somPrecisionMode = HS_MODE_SOM_HORIZON_LARGE; namespace /* anonymous */ { // Globals local to this file. bool display_per_scan = false; ScanMode scan_mode = ScanMode::STREAMING; unsigned repeats = 20; string exprPath(""); string corpusFile(""); vector threadCores; Timer totalTimer; double totalSecs = 0; typedef void (*thread_func_t)(void *context); class ThreadContext : boost::noncopyable { public: ThreadContext(unsigned num_in, const EngineHyperscan &db_in, thread_barrier &tb_in, thread_func_t function_in, vector corpus_data_in) : num(num_in), results(repeats), engine(db_in), enginectx(db_in.makeContext()), corpus_data(move(corpus_data_in)), tb(tb_in), function(function_in) {} // Start the thread. bool start(int cpu) { thr = thread(function, this); // affine if it's asked for if (cpu >= 0) { return affine(cpu); } return true; } // Wait for the thread to exit. void join() { thr.join(); } // Serialise all threads on a global barrier. void barrier() { tb.wait(); } // Apply processor affinity (if available) to this thread. bool affine(UNUSED int cpu) { #ifdef HAVE_DECL_PTHREAD_SETAFFINITY_NP cpu_set_t cpuset; CPU_ZERO(&cpuset); assert(cpu >= 0 && cpu < CPU_SETSIZE); // The 'clang' compiler complains about an unused result here, so we // silence it. (void)CPU_SET(cpu, &cpuset); int rv = pthread_setaffinity_np(thr.native_handle(), sizeof(cpuset), &cpuset); return (rv == 0); #endif return false; // not available } unsigned num; Timer timer; vector results; const EngineHyperscan &engine; unique_ptr enginectx; vector corpus_data; protected: thread_barrier &tb; // shared barrier for time sync thread_func_t function; thread thr; }; /** Display usage information, with an optional error. */ static void usage(const char *error) { printf("Usage: hsbench [OPTIONS...]\n\n"); printf("Options:\n\n"); printf(" -h Display help and exit.\n"); printf(" -G OVERRIDES Overrides for the grey box.\n"); printf(" -e PATH Path to expression directory.\n"); printf(" -s FILE Signature file to use.\n"); printf(" -z NUM Signature ID to use.\n"); printf(" -c FILE File to use as corpus.\n"); printf(" -n NUMBER Repeat scan NUMBER times (default 20).\n"); printf(" -N Benchmark in block mode" " (default: streaming).\n"); printf(" -V Benchmark in vectored mode" " (default: streaming).\n"); printf(" -T CPU,CPU,... Benchmark with threads on these CPUs.\n"); printf(" -i DIR Don't compile, load from files in DIR" " instead.\n"); printf(" -w DIR After compiling, save to files in DIR.\n"); printf(" -d NUMBER Set SOM precision mode (default: 8 (large)).\n"); printf("\n"); printf(" --per-scan Display per-scan Mbit/sec results.\n"); printf(" --echo-matches Display all matches that occur during scan.\n"); printf("\n\n"); if (error) { printf("Error: %s\n", error); } } /** Wraps up a name and the set of signature IDs it refers to. */ struct BenchmarkSigs { BenchmarkSigs(string name_in, SignatureSet sigs_in) : name(move(name_in)), sigs(move(sigs_in)) {} string name; SignatureSet sigs; }; /** Process command-line arguments. Prints usage and exits on error. */ static void processArgs(int argc, char *argv[], vector &sigSets, UNUSED Grey &grey) { const char options[] = "-b:c:Cd:e:G:hi:n:No:p:sT:Vw:z:"; int in_sigfile = 0; int do_per_scan = 0; int do_echo_matches = 0; vector sigFiles; static struct option longopts[] = { {"per-scan", 0, &do_per_scan, 1}, {"echo-matches", 0, &do_echo_matches, 1}, {nullptr, 0, nullptr, 0} }; for (;;) { int c = getopt_long(argc, argv, options, longopts, nullptr); if (c < 0) { break; } switch (c) { case 'c': corpusFile.assign(optarg); break; case 'd': { unsigned dist; if (!fromString(optarg, dist)) { usage("Must provide an integer argument to '-d' flag"); exit(1); } switch (dist) { case 2: somPrecisionMode = HS_MODE_SOM_HORIZON_SMALL; break; case 4: somPrecisionMode = HS_MODE_SOM_HORIZON_MEDIUM; break; case 8: somPrecisionMode = HS_MODE_SOM_HORIZON_LARGE; break; default: usage("SOM precision must be 2, 4 or 8"); exit(1); } break; } case 'e': exprPath.assign(optarg); break; #ifndef RELEASE_BUILD case 'G': applyGreyOverrides(&grey, string(optarg)); break; #endif case 'h': usage(nullptr); exit(0); break; case 'n': if (!fromString(optarg, repeats) || repeats == 0) { usage("Couldn't parse argument to -n flag, should be" " a positive integer."); exit(1); } break; case 's': in_sigfile = 2; break; case 'N': scan_mode = ScanMode::BLOCK; break; case 'V': scan_mode = ScanMode::VECTORED; break; case 'T': if (!strToList(optarg, threadCores)) { usage("Couldn't parse argument to -T flag, should be" " a list of positive integers."); exit(1); } break; case 'z': { unsigned int sinumber; if (!fromString(optarg, sinumber)) { usage("Argument to '-z' flag must be an integer"); exit(1); } SignatureSet sigs = {sinumber}; sigSets.emplace_back(string("-z ") + optarg, sigs); break; } case 'i': loadDatabases = true; serializePath = optarg; break; case 'w': saveDatabases = true; serializePath = optarg; break; case 1: if (in_sigfile) { sigFiles.push_back(optarg); in_sigfile = 2; break; } case 0: break; default: usage("Unrecognised command line argument."); exit(1); } if (in_sigfile) { in_sigfile--; } } if (do_echo_matches) { echo_matches = true; } if (do_per_scan) { display_per_scan = true; } if (exprPath.empty() && !sigFiles.empty()) { /* attempt to infer an expression directory */ auto si = sigFiles.begin(); exprPath = inferExpressionPath(*si); for (++si; si != sigFiles.end(); ++si) { if (exprPath != inferExpressionPath(*si)) { usage("Unable to infer consistent expression directory"); exit(1); } } } // Must have a valid expression path if (exprPath.empty()) { usage("Must specify an expression path with the -e option."); exit(1); } // Must have valid database to scan if (corpusFile.empty()) { usage("Must specify a corpus file with the -c option."); exit(1); } // Cannot ask for both loading and saving if (loadDatabases && saveDatabases) { usage("You cannot both load and save databases."); exit(1); } // Read in any -s signature sets. for (const auto &file : sigFiles) { SignatureSet sigs; loadSignatureList(file, sigs); sigSets.emplace_back(file, move(sigs)); } } /** Start the global timer. */ static void startTotalTimer(ThreadContext *ctx) { if (ctx->num != 0) { return; // only runs in the first thread } totalTimer.start(); } /** Stop the global timer and calculate totals. */ static void stopTotalTimer(ThreadContext *ctx) { if (ctx->num != 0) { return; // only runs in the first thread } totalTimer.complete(); totalSecs = totalTimer.seconds(); } /** Run a benchmark over a given engine and corpus in block mode. */ static void benchBlock(void *context) { ThreadContext *ctx = (ThreadContext *)context; // Synchronization point ctx->barrier(); startTotalTimer(ctx); for (ResultEntry &r : ctx->results) { ctx->timer.start(); for (const DataBlock &block : ctx->corpus_data) { ctx->engine.scan(block.payload.c_str(), block.payload.size(), block.id, r, *ctx->enginectx); } ctx->timer.complete(); r.seconds = ctx->timer.seconds(); } // Synchronization point ctx->barrier(); // Now that all threads are finished, we can stop the clock. stopTotalTimer(ctx); } /** Structure used to represent a stream. */ struct StreamInfo { unsigned int stream_id = ~0U; unsigned int first_block_id = ~0U; unsigned int last_block_id = 0; unique_ptr eng_handle; }; static u64a count_streams(const vector &corpus_blocks) { set streams; for (const DataBlock &block : corpus_blocks) { streams.insert(block.stream_id); } return (u64a)streams.size(); } /** * Take a ThreadContext and prepare a vector for streaming mode * scanning from it. */ static vector prepStreamingData(const ThreadContext *ctx) { vector info(count_streams(ctx->corpus_data)); for (const DataBlock &block : ctx->corpus_data) { assert(block.internal_stream_index < info.size()); StreamInfo &si = info[block.internal_stream_index]; /* check if this is the first time we have encountered this stream */ if (si.first_block_id > si.last_block_id) { si.stream_id = block.stream_id; si.first_block_id = block.id; si.last_block_id = block.id; } else { assert(block.stream_id == si.stream_id); assert(block.id > si.last_block_id); assert(block.id > si.first_block_id); si.last_block_id = block.id; } } return info; } static void benchStreamingInternal(ThreadContext *ctx, vector &streams) { assert(ctx); const EngineHyperscan &e = ctx->engine; const vector &blocks = ctx->corpus_data; for (ResultEntry &r : ctx->results) { ctx->timer.start(); for (const auto &b : blocks) { StreamInfo &stream = streams[b.internal_stream_index]; assert(stream.stream_id == b.stream_id); // If this is the first block in the stream, open the stream // handle. if (b.id == stream.first_block_id) { assert(!stream.eng_handle); stream.eng_handle = e.streamOpen(*ctx->enginectx, b.stream_id); if (!stream.eng_handle) { printf("Fatal error: stream open failed!\n"); exit(1); } } assert(stream.eng_handle); e.streamScan(*stream.eng_handle, b.payload.c_str(), b.payload.size(), b.id, r); // if this was the last block in the stream, close the stream handle if (b.id == stream.last_block_id) { e.streamClose(move(stream.eng_handle), r); stream.eng_handle = nullptr; } } ctx->timer.complete(); r.seconds = ctx->timer.seconds(); } } /** Run a benchmark over a given engine and corpus in streaming mode. */ static void benchStreaming(void *context) { ThreadContext *ctx = (ThreadContext *)context; vector streams = prepStreamingData(ctx); // Synchronization point ctx->barrier(); startTotalTimer(ctx); benchStreamingInternal(ctx, streams); // Synchronization point ctx->barrier(); // Now that all threads are finished, we can stop the clock. stopTotalTimer(ctx); } /** In-memory structure for a data block to be scanned in vectored mode. */ struct VectoredInfo { vector data; vector len; unsigned int stream_id; }; /** * Take a ThreadContext and prepare a vector for vectored mode * scanning from it. */ static vector prepVectorData(const ThreadContext *ctx) { vector out(count_streams(ctx->corpus_data)); for (const DataBlock &block : ctx->corpus_data) { VectoredInfo &vi = out[block.internal_stream_index]; if (vi.data.empty()) { vi.stream_id = block.stream_id; } else { assert(vi.stream_id == block.stream_id); } vi.data.push_back(block.payload.c_str()); vi.len.push_back(block.payload.size()); } return out; } /** Run a benchmark over a given engine and corpus in vectored mode. */ static void benchVectored(void *context) { ThreadContext *ctx = (ThreadContext *)context; vector v_plans = prepVectorData(ctx); // Synchronization point ctx->barrier(); startTotalTimer(ctx); for (ResultEntry &r : ctx->results) { ctx->timer.start(); for (const VectoredInfo &v_plan : v_plans) { ctx->engine.scan_vectored(&v_plan.data[0], &v_plan.len[0], v_plan.data.size(), v_plan.stream_id, r, *ctx->enginectx); } ctx->timer.complete(); r.seconds = ctx->timer.seconds(); } // Synchronization point ctx->barrier(); // Now that all threads are finished, we can stop the clock. stopTotalTimer(ctx); } /** Given a time and a size, compute the throughput in megabits/sec. */ static long double calc_mbps(double seconds, u64a bytes) { assert(seconds > 0); return (long double)bytes / ((long double)seconds * 125000); } /** Dump per-scan throughput data to screen. */ static void displayPerScanResults(const vector> &threads, u64a bytesPerRun) { for (const auto &t : threads) { const auto &results = t->results; for (size_t j = 0; j != results.size(); j++) { const auto &r = results[j]; double mbps = calc_mbps(r.seconds, bytesPerRun); printf("T %2u Scan %2zu: %'0.2f Mbit/sec\n", t->num, j, mbps); } } printf("\n"); } static u64a byte_size(const vector &corpus_blocks) { u64a total = 0; for (const DataBlock &block : corpus_blocks) { total += block.payload.size(); } return total; } /** Dump benchmark results to screen. */ static void displayResults(const vector> &threads, const vector &corpus_blocks) { u64a bytesPerRun = byte_size(corpus_blocks); u64a matchesPerRun = threads[0]->results[0].matches; // Sanity check: all of our results should have the same match count. for (const auto &t : threads) { if (!all_of(begin(t->results), end(t->results), [&matchesPerRun](const ResultEntry &e) { return e.matches == matchesPerRun; })) { printf("\nWARNING: PER-SCAN MATCH COUNTS ARE INCONSISTENT!\n\n"); break; } } printf("Time spent scanning: %'0.3f seconds\n", totalSecs); printf("Corpus size: %'llu bytes ", bytesPerRun); switch (scan_mode) { case ScanMode::STREAMING: printf("(%'zu blocks in %'llu streams)\n", corpus_blocks.size(), count_streams(corpus_blocks)); break; case ScanMode::VECTORED: printf("(%'zu blocks in %'llu vectors)\n", corpus_blocks.size(), count_streams(corpus_blocks)); break; case ScanMode::BLOCK: printf("(%'zu blocks)\n", corpus_blocks.size()); break; } u64a totalBytes = bytesPerRun * repeats * threads.size(); u64a totalBlocks = corpus_blocks.size() * repeats * threads.size(); double matchRate = ((double)matchesPerRun * 1024) / bytesPerRun; printf("Matches per iteration: %'llu (%'0.3f matches/kilobyte)\n", matchesPerRun, matchRate); double blockRate = (double)totalBlocks / (double)totalSecs; printf("Overall block rate: %'0.2f blocks/sec\n", blockRate); printf("Overall throughput: %'0.2Lf Mbit/sec\n", calc_mbps(totalSecs, totalBytes)); printf("\n"); if (display_per_scan) { displayPerScanResults(threads, bytesPerRun); } } /** * Construct a thread context for this scanning mode. * * Note: does not take blocks by reference. This is to give every thread their * own copy of the data. It would be unrealistic for every thread to be scanning * the same copy of the data. */ static unique_ptr makeThreadContext(const EngineHyperscan &db, const vector &blocks, unsigned id, thread_barrier &sync_barrier) { thread_func_t fn = nullptr; switch (scan_mode) { case ScanMode::STREAMING: fn = benchStreaming; break; case ScanMode::VECTORED: fn = benchVectored; break; case ScanMode::BLOCK: fn = benchBlock; break; } assert(fn); return ue2::make_unique(id, db, sync_barrier, fn, blocks); } /** Run the given benchmark. */ static void runBenchmark(const EngineHyperscan &db, const vector &corpus_blocks) { size_t numThreads; bool useAffinity = false; if (threadCores.empty()) { numThreads = 1; } else { numThreads = threadCores.size(); #ifdef HAVE_DECL_PTHREAD_SETAFFINITY_NP useAffinity = true; #else useAffinity = false; #endif } // Initialise a barrier that will let us sync threads before/after scanning // for timer measurements. thread_barrier sync_barrier(numThreads); vector> threads; for (unsigned i = 0; i < numThreads; i++) { auto t = makeThreadContext(db, corpus_blocks, i, sync_barrier); int core = useAffinity ? (int)threadCores[i] : -1; if (!t->start(core)) { printf("Unable to start processing thread %u\n", i); exit(1); } threads.push_back(move(t)); } // Reap threads. for (auto &t : threads) { t->join(); } // Display global results. displayResults(threads, corpus_blocks); } } // namespace /** Main driver. */ int main(int argc, char *argv[]) { Grey grey; setlocale(LC_ALL, ""); // use the user's locale #ifndef NDEBUG printf("\nWARNING: DO NOT BENCHMARK A HYPERSCAN BUILD WITH ASSERTIONS\n\n"); #endif vector sigSets; processArgs(argc, argv, sigSets, grey); // read in and process our expressions ExpressionMap exprMapTemplate; loadExpressions(exprPath, exprMapTemplate); // If we have no signature sets, the user wants us to benchmark all the // known expressions together. if (sigSets.empty()) { SignatureSet sigs; for (auto i : exprMapTemplate | map_keys) { sigs.push_back(i); } sigSets.emplace_back(exprPath, move(sigs)); } // read in and process our corpus vector corpus_blocks; try { corpus_blocks = readCorpus(corpusFile); } catch (const DataCorpusError &e) { printf("Corpus data error: %s\n", e.msg.c_str()); return 1; } for (const auto &s : sigSets) { ExpressionMap exprMap = exprMapTemplate; // copy limitBySignature(exprMap, s.sigs); if (exprMap.empty()) { continue; } auto engine = buildEngineHyperscan(exprMap, scan_mode, s.name, grey); if (!engine) { printf("Error: expressions failed to compile.\n"); exit(1); } printf("\n"); runBenchmark(*engine, corpus_blocks); } return 0; } hyperscan-4.4.1/tools/hsbench/heapstats.cpp0000644000175000017500000000757213055426554021564 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** \file * \brief Peak heap usage code. * * At present, we only have an implementation for modern glibc systems, using * the malloc_info() call. We return zero elsewhere. */ #include "config.h" #include "heapstats.h" #if defined HAVE_MALLOC_INFO #include #include #include #include #include size_t getPeakHeap(void) { FILE *tmpf = tmpfile(); if (!tmpf) { return 0; } int rv = malloc_info(0, tmpf); if (rv != 0) { fclose(tmpf); return 0; } rewind(tmpf); // We don't want to depend on a real XML parser. This is ugly and brittle // and hopefully good enough for the time being. We look for the last // system tag with type max, which should be the malloc-wide one. static const char begin[] = " #include #include #include #include #include using namespace std; size_t getPeakHeap(void) { // Modern Linux kernels write a 'VmPeak' value into /proc/$PID/status. This // is a reasonable approximation, though it likely includes shared libs and // the like as well... ostringstream path; path << "/proc/" << getpid() << "/status"; ifstream f(path.str().c_str()); if (!f.good()) { return 0; } const string vmpeak("VmPeak:"); string line; while (getline(f, line)) { istringstream iss(line, istringstream::in); string word; iss >> word; if (word != vmpeak) { continue; } // Skip spaces while (iss.good() && !isdigit(iss.peek())) { iss.ignore(); } size_t num = 0; iss >> num; return num * 1024; } f.close(); return 0; } #else // Stub. size_t getPeakHeap(void) { return 0; } #endif hyperscan-4.4.1/tools/CMakeLists.txt0000644000175000017500000000117013055426554020176 0ustar sleuthkidsleuthkidfind_package(Threads) # remove some warnings if(CMAKE_CXX_FLAGS MATCHES "-Wmissing-declarations" ) string(REPLACE "-Wmissing-declarations" "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") endif() include_directories(${PROJECT_SOURCE_DIR}) include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src) include_directories(${PROJECT_SOURCE_DIR}/util) # add any subdir with a cmake file file(GLOB dirents RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *) foreach(e ${dirents}) if(IS_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/${e} AND EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${e}/CMakeLists.txt) add_subdirectory(${e}) endif () endforeach () hyperscan-4.4.1/unit/0000755000175000017500000000000013055426554015256 5ustar sleuthkidsleuthkidhyperscan-4.4.1/unit/gtest/0000755000175000017500000000000013055426554016404 5ustar sleuthkidsleuthkidhyperscan-4.4.1/unit/gtest/gtest-all.cc0000644000175000017500000126407013055426554020621 0ustar sleuthkidsleuthkid// Copyright 2008, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: mheule@google.com (Markus Heule) // // Google C++ Testing Framework (Google Test) // // Sometimes it's desirable to build Google Test by compiling a single file. // This file serves this purpose. // This line ensures that gtest.h can be compiled on its own, even // when it's fused. #include "gtest/gtest.h" // The following lines pull in the real gtest *.cc files. // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // // The Google C++ Testing Framework (Google Test) // Copyright 2007, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // // Utilities for testing Google Test itself and code that uses Google Test // (e.g. frameworks built on top of Google Test). #ifndef GTEST_INCLUDE_GTEST_GTEST_SPI_H_ #define GTEST_INCLUDE_GTEST_GTEST_SPI_H_ namespace testing { // This helper class can be used to mock out Google Test failure reporting // so that we can test Google Test or code that builds on Google Test. // // An object of this class appends a TestPartResult object to the // TestPartResultArray object given in the constructor whenever a Google Test // failure is reported. It can either intercept only failures that are // generated in the same thread that created this object or it can intercept // all generated failures. The scope of this mock object can be controlled with // the second argument to the two arguments constructor. class GTEST_API_ ScopedFakeTestPartResultReporter : public TestPartResultReporterInterface { public: // The two possible mocking modes of this object. enum InterceptMode { INTERCEPT_ONLY_CURRENT_THREAD, // Intercepts only thread local failures. INTERCEPT_ALL_THREADS // Intercepts all failures. }; // The c'tor sets this object as the test part result reporter used // by Google Test. The 'result' parameter specifies where to report the // results. This reporter will only catch failures generated in the current // thread. DEPRECATED explicit ScopedFakeTestPartResultReporter(TestPartResultArray* result); // Same as above, but you can choose the interception scope of this object. ScopedFakeTestPartResultReporter(InterceptMode intercept_mode, TestPartResultArray* result); // The d'tor restores the previous test part result reporter. virtual ~ScopedFakeTestPartResultReporter(); // Appends the TestPartResult object to the TestPartResultArray // received in the constructor. // // This method is from the TestPartResultReporterInterface // interface. virtual void ReportTestPartResult(const TestPartResult& result); private: void Init(); const InterceptMode intercept_mode_; TestPartResultReporterInterface* old_reporter_; TestPartResultArray* const result_; GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedFakeTestPartResultReporter); }; namespace internal { // A helper class for implementing EXPECT_FATAL_FAILURE() and // EXPECT_NONFATAL_FAILURE(). Its destructor verifies that the given // TestPartResultArray contains exactly one failure that has the given // type and contains the given substring. If that's not the case, a // non-fatal failure will be generated. class GTEST_API_ SingleFailureChecker { public: // The constructor remembers the arguments. SingleFailureChecker(const TestPartResultArray* results, TestPartResult::Type type, const string& substr); ~SingleFailureChecker(); private: const TestPartResultArray* const results_; const TestPartResult::Type type_; const string substr_; GTEST_DISALLOW_COPY_AND_ASSIGN_(SingleFailureChecker); }; } // namespace internal } // namespace testing // A set of macros for testing Google Test assertions or code that's expected // to generate Google Test fatal failures. It verifies that the given // statement will cause exactly one fatal Google Test failure with 'substr' // being part of the failure message. // // There are two different versions of this macro. EXPECT_FATAL_FAILURE only // affects and considers failures generated in the current thread and // EXPECT_FATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. // // The verification of the assertion is done correctly even when the statement // throws an exception or aborts the current function. // // Known restrictions: // - 'statement' cannot reference local non-static variables or // non-static members of the current object. // - 'statement' cannot return a value. // - You cannot stream a failure message to this macro. // // Note that even though the implementations of the following two // macros are much alike, we cannot refactor them to use a common // helper macro, due to some peculiarity in how the preprocessor // works. The AcceptsMacroThatExpandsToUnprotectedComma test in // gtest_unittest.cc will fail to compile if we do that. #define EXPECT_FATAL_FAILURE(statement, substr) \ do { \ class GTestExpectFatalFailureHelper {\ public:\ static void Execute() { statement; }\ };\ ::testing::TestPartResultArray gtest_failures;\ ::testing::internal::SingleFailureChecker gtest_checker(\ >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ {\ ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ ::testing::ScopedFakeTestPartResultReporter:: \ INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ GTestExpectFatalFailureHelper::Execute();\ }\ } while (::testing::internal::AlwaysFalse()) #define EXPECT_FATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ do { \ class GTestExpectFatalFailureHelper {\ public:\ static void Execute() { statement; }\ };\ ::testing::TestPartResultArray gtest_failures;\ ::testing::internal::SingleFailureChecker gtest_checker(\ >est_failures, ::testing::TestPartResult::kFatalFailure, (substr));\ {\ ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ ::testing::ScopedFakeTestPartResultReporter:: \ INTERCEPT_ALL_THREADS, >est_failures);\ GTestExpectFatalFailureHelper::Execute();\ }\ } while (::testing::internal::AlwaysFalse()) // A macro for testing Google Test assertions or code that's expected to // generate Google Test non-fatal failures. It asserts that the given // statement will cause exactly one non-fatal Google Test failure with 'substr' // being part of the failure message. // // There are two different versions of this macro. EXPECT_NONFATAL_FAILURE only // affects and considers failures generated in the current thread and // EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS does the same but for all threads. // // 'statement' is allowed to reference local variables and members of // the current object. // // The verification of the assertion is done correctly even when the statement // throws an exception or aborts the current function. // // Known restrictions: // - You cannot stream a failure message to this macro. // // Note that even though the implementations of the following two // macros are much alike, we cannot refactor them to use a common // helper macro, due to some peculiarity in how the preprocessor // works. If we do that, the code won't compile when the user gives // EXPECT_NONFATAL_FAILURE() a statement that contains a macro that // expands to code containing an unprotected comma. The // AcceptsMacroThatExpandsToUnprotectedComma test in gtest_unittest.cc // catches that. // // For the same reason, we have to write // if (::testing::internal::AlwaysTrue()) { statement; } // instead of // GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) // to avoid an MSVC warning on unreachable code. #define EXPECT_NONFATAL_FAILURE(statement, substr) \ do {\ ::testing::TestPartResultArray gtest_failures;\ ::testing::internal::SingleFailureChecker gtest_checker(\ >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ (substr));\ {\ ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ ::testing::ScopedFakeTestPartResultReporter:: \ INTERCEPT_ONLY_CURRENT_THREAD, >est_failures);\ if (::testing::internal::AlwaysTrue()) { statement; }\ }\ } while (::testing::internal::AlwaysFalse()) #define EXPECT_NONFATAL_FAILURE_ON_ALL_THREADS(statement, substr) \ do {\ ::testing::TestPartResultArray gtest_failures;\ ::testing::internal::SingleFailureChecker gtest_checker(\ >est_failures, ::testing::TestPartResult::kNonFatalFailure, \ (substr));\ {\ ::testing::ScopedFakeTestPartResultReporter gtest_reporter(\ ::testing::ScopedFakeTestPartResultReporter::INTERCEPT_ALL_THREADS, \ >est_failures);\ if (::testing::internal::AlwaysTrue()) { statement; }\ }\ } while (::testing::internal::AlwaysFalse()) #endif // GTEST_INCLUDE_GTEST_GTEST_SPI_H_ #include #include #include #include #include #include #include #include #include #include #include #include // NOLINT #include #include #if GTEST_OS_LINUX // TODO(kenton@google.com): Use autoconf to detect availability of // gettimeofday(). # define GTEST_HAS_GETTIMEOFDAY_ 1 # include // NOLINT # include // NOLINT # include // NOLINT // Declares vsnprintf(). This header is not available on Windows. # include // NOLINT # include // NOLINT # include // NOLINT # include // NOLINT # include #elif GTEST_OS_SYMBIAN # define GTEST_HAS_GETTIMEOFDAY_ 1 # include // NOLINT #elif GTEST_OS_ZOS # define GTEST_HAS_GETTIMEOFDAY_ 1 # include // NOLINT // On z/OS we additionally need strings.h for strcasecmp. # include // NOLINT #elif GTEST_OS_WINDOWS_MOBILE // We are on Windows CE. # include // NOLINT #elif GTEST_OS_WINDOWS // We are on Windows proper. # include // NOLINT # include // NOLINT # include // NOLINT # include // NOLINT # if GTEST_OS_WINDOWS_MINGW // MinGW has gettimeofday() but not _ftime64(). // TODO(kenton@google.com): Use autoconf to detect availability of // gettimeofday(). // TODO(kenton@google.com): There are other ways to get the time on // Windows, like GetTickCount() or GetSystemTimeAsFileTime(). MinGW // supports these. consider using them instead. # define GTEST_HAS_GETTIMEOFDAY_ 1 # include // NOLINT # endif // GTEST_OS_WINDOWS_MINGW // cpplint thinks that the header is already included, so we want to // silence it. # include // NOLINT #else // Assume other platforms have gettimeofday(). // TODO(kenton@google.com): Use autoconf to detect availability of // gettimeofday(). # define GTEST_HAS_GETTIMEOFDAY_ 1 // cpplint thinks that the header is already included, so we want to // silence it. # include // NOLINT # include // NOLINT #endif // GTEST_OS_LINUX #if GTEST_HAS_EXCEPTIONS # include #endif #if GTEST_CAN_STREAM_RESULTS_ # include // NOLINT # include // NOLINT #endif // Indicates that this translation unit is part of Google Test's // implementation. It must come before gtest-internal-inl.h is // included, or there will be a compiler error. This trick is to // prevent a user from accidentally including gtest-internal-inl.h in // his code. #define GTEST_IMPLEMENTATION_ 1 // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // Utility functions and classes used by the Google C++ testing framework. // // Author: wan@google.com (Zhanyong Wan) // // This file contains purely Google Test's internal implementation. Please // DO NOT #INCLUDE IT IN A USER PROGRAM. #ifndef GTEST_SRC_GTEST_INTERNAL_INL_H_ #define GTEST_SRC_GTEST_INTERNAL_INL_H_ // GTEST_IMPLEMENTATION_ is defined to 1 iff the current translation unit is // part of Google Test's implementation; otherwise it's undefined. #if !GTEST_IMPLEMENTATION_ // A user is trying to include this from his code - just say no. # error "gtest-internal-inl.h is part of Google Test's internal implementation." # error "It must not be included except by Google Test itself." #endif // GTEST_IMPLEMENTATION_ #ifndef _WIN32_WCE # include #endif // !_WIN32_WCE #include #include // For strtoll/_strtoul64/malloc/free. #include // For memmove. #include #include #include #if GTEST_CAN_STREAM_RESULTS_ # include // NOLINT # include // NOLINT #endif #if GTEST_OS_WINDOWS # include // NOLINT #endif // GTEST_OS_WINDOWS namespace testing { // Declares the flags. // // We don't want the users to modify this flag in the code, but want // Google Test's own unit tests to be able to access it. Therefore we // declare it here as opposed to in gtest.h. GTEST_DECLARE_bool_(death_test_use_fork); namespace internal { // The value of GetTestTypeId() as seen from within the Google Test // library. This is solely for testing GetTestTypeId(). GTEST_API_ extern const TypeId kTestTypeIdInGoogleTest; // Names of the flags (needed for parsing Google Test flags). const char kAlsoRunDisabledTestsFlag[] = "also_run_disabled_tests"; const char kBreakOnFailureFlag[] = "break_on_failure"; const char kCatchExceptionsFlag[] = "catch_exceptions"; const char kColorFlag[] = "color"; const char kFilterFlag[] = "filter"; const char kListTestsFlag[] = "list_tests"; const char kOutputFlag[] = "output"; const char kPrintTimeFlag[] = "print_time"; const char kRandomSeedFlag[] = "random_seed"; const char kRepeatFlag[] = "repeat"; const char kShuffleFlag[] = "shuffle"; const char kStackTraceDepthFlag[] = "stack_trace_depth"; const char kStreamResultToFlag[] = "stream_result_to"; const char kThrowOnFailureFlag[] = "throw_on_failure"; // A valid random seed must be in [1, kMaxRandomSeed]. const int kMaxRandomSeed = 99999; // g_help_flag is true iff the --help flag or an equivalent form is // specified on the command line. GTEST_API_ extern bool g_help_flag; // Returns the current time in milliseconds. GTEST_API_ TimeInMillis GetTimeInMillis(); // Returns true iff Google Test should use colors in the output. GTEST_API_ bool ShouldUseColor(bool stdout_is_tty); // Formats the given time in milliseconds as seconds. GTEST_API_ std::string FormatTimeInMillisAsSeconds(TimeInMillis ms); // Converts the given time in milliseconds to a date string in the ISO 8601 // format, without the timezone information. N.B.: due to the use the // non-reentrant localtime() function, this function is not thread safe. Do // not use it in any code that can be called from multiple threads. GTEST_API_ std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms); // Parses a string for an Int32 flag, in the form of "--flag=value". // // On success, stores the value of the flag in *value, and returns // true. On failure, returns false without changing *value. GTEST_API_ bool ParseInt32Flag( const char* str, const char* flag, Int32* value); // Returns a random seed in range [1, kMaxRandomSeed] based on the // given --gtest_random_seed flag value. inline int GetRandomSeedFromFlag(Int32 random_seed_flag) { const unsigned int raw_seed = (random_seed_flag == 0) ? static_cast(GetTimeInMillis()) : static_cast(random_seed_flag); // Normalizes the actual seed to range [1, kMaxRandomSeed] such that // it's easy to type. const int normalized_seed = static_cast((raw_seed - 1U) % static_cast(kMaxRandomSeed)) + 1; return normalized_seed; } // Returns the first valid random seed after 'seed'. The behavior is // undefined if 'seed' is invalid. The seed after kMaxRandomSeed is // considered to be 1. inline int GetNextRandomSeed(int seed) { GTEST_CHECK_(1 <= seed && seed <= kMaxRandomSeed) << "Invalid random seed " << seed << " - must be in [1, " << kMaxRandomSeed << "]."; const int next_seed = seed + 1; return (next_seed > kMaxRandomSeed) ? 1 : next_seed; } // This class saves the values of all Google Test flags in its c'tor, and // restores them in its d'tor. class GTestFlagSaver { public: // The c'tor. GTestFlagSaver() { also_run_disabled_tests_ = GTEST_FLAG(also_run_disabled_tests); break_on_failure_ = GTEST_FLAG(break_on_failure); catch_exceptions_ = GTEST_FLAG(catch_exceptions); color_ = GTEST_FLAG(color); death_test_style_ = GTEST_FLAG(death_test_style); death_test_use_fork_ = GTEST_FLAG(death_test_use_fork); filter_ = GTEST_FLAG(filter); internal_run_death_test_ = GTEST_FLAG(internal_run_death_test); list_tests_ = GTEST_FLAG(list_tests); output_ = GTEST_FLAG(output); print_time_ = GTEST_FLAG(print_time); random_seed_ = GTEST_FLAG(random_seed); repeat_ = GTEST_FLAG(repeat); shuffle_ = GTEST_FLAG(shuffle); stack_trace_depth_ = GTEST_FLAG(stack_trace_depth); stream_result_to_ = GTEST_FLAG(stream_result_to); throw_on_failure_ = GTEST_FLAG(throw_on_failure); } // The d'tor is not virtual. DO NOT INHERIT FROM THIS CLASS. ~GTestFlagSaver() { GTEST_FLAG(also_run_disabled_tests) = also_run_disabled_tests_; GTEST_FLAG(break_on_failure) = break_on_failure_; GTEST_FLAG(catch_exceptions) = catch_exceptions_; GTEST_FLAG(color) = color_; GTEST_FLAG(death_test_style) = death_test_style_; GTEST_FLAG(death_test_use_fork) = death_test_use_fork_; GTEST_FLAG(filter) = filter_; GTEST_FLAG(internal_run_death_test) = internal_run_death_test_; GTEST_FLAG(list_tests) = list_tests_; GTEST_FLAG(output) = output_; GTEST_FLAG(print_time) = print_time_; GTEST_FLAG(random_seed) = random_seed_; GTEST_FLAG(repeat) = repeat_; GTEST_FLAG(shuffle) = shuffle_; GTEST_FLAG(stack_trace_depth) = stack_trace_depth_; GTEST_FLAG(stream_result_to) = stream_result_to_; GTEST_FLAG(throw_on_failure) = throw_on_failure_; } private: // Fields for saving the original values of flags. bool also_run_disabled_tests_; bool break_on_failure_; bool catch_exceptions_; std::string color_; std::string death_test_style_; bool death_test_use_fork_; std::string filter_; std::string internal_run_death_test_; bool list_tests_; std::string output_; bool print_time_; internal::Int32 random_seed_; internal::Int32 repeat_; bool shuffle_; internal::Int32 stack_trace_depth_; std::string stream_result_to_; bool throw_on_failure_; } GTEST_ATTRIBUTE_UNUSED_; // Converts a Unicode code point to a narrow string in UTF-8 encoding. // code_point parameter is of type UInt32 because wchar_t may not be // wide enough to contain a code point. // If the code_point is not a valid Unicode code point // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted // to "(Invalid Unicode 0xXXXXXXXX)". GTEST_API_ std::string CodePointToUtf8(UInt32 code_point); // Converts a wide string to a narrow string in UTF-8 encoding. // The wide string is assumed to have the following encoding: // UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) // UTF-32 if sizeof(wchar_t) == 4 (on Linux) // Parameter str points to a null-terminated wide string. // Parameter num_chars may additionally limit the number // of wchar_t characters processed. -1 is used when the entire string // should be processed. // If the string contains code points that are not valid Unicode code points // (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding // and contains invalid UTF-16 surrogate pairs, values in those pairs // will be encoded as individual Unicode characters from Basic Normal Plane. GTEST_API_ std::string WideStringToUtf8(const wchar_t* str, int num_chars); // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file // if the variable is present. If a file already exists at this location, this // function will write over it. If the variable is present, but the file cannot // be created, prints an error and exits. void WriteToShardStatusFileIfNeeded(); // Checks whether sharding is enabled by examining the relevant // environment variable values. If the variables are present, // but inconsistent (e.g., shard_index >= total_shards), prints // an error and exits. If in_subprocess_for_death_test, sharding is // disabled because it must only be applied to the original test // process. Otherwise, we could filter out death tests we intended to execute. GTEST_API_ bool ShouldShard(const char* total_shards_str, const char* shard_index_str, bool in_subprocess_for_death_test); // Parses the environment variable var as an Int32. If it is unset, // returns default_val. If it is not an Int32, prints an error and // and aborts. GTEST_API_ Int32 Int32FromEnvOrDie(const char* env_var, Int32 default_val); // Given the total number of shards, the shard index, and the test id, // returns true iff the test should be run on this shard. The test id is // some arbitrary but unique non-negative integer assigned to each test // method. Assumes that 0 <= shard_index < total_shards. GTEST_API_ bool ShouldRunTestOnShard( int total_shards, int shard_index, int test_id); // STL container utilities. // Returns the number of elements in the given container that satisfy // the given predicate. template inline int CountIf(const Container& c, Predicate predicate) { // Implemented as an explicit loop since std::count_if() in libCstd on // Solaris has a non-standard signature. int count = 0; for (typename Container::const_iterator it = c.begin(); it != c.end(); ++it) { if (predicate(*it)) ++count; } return count; } // Applies a function/functor to each element in the container. template void ForEach(const Container& c, Functor functor) { std::for_each(c.begin(), c.end(), functor); } // Returns the i-th element of the vector, or default_value if i is not // in range [0, v.size()). template inline E GetElementOr(const std::vector& v, int i, E default_value) { return (i < 0 || i >= static_cast(v.size())) ? default_value : v[i]; } // Performs an in-place shuffle of a range of the vector's elements. // 'begin' and 'end' are element indices as an STL-style range; // i.e. [begin, end) are shuffled, where 'end' == size() means to // shuffle to the end of the vector. template void ShuffleRange(internal::Random* random, int begin, int end, std::vector* v) { const int size = static_cast(v->size()); GTEST_CHECK_(0 <= begin && begin <= size) << "Invalid shuffle range start " << begin << ": must be in range [0, " << size << "]."; GTEST_CHECK_(begin <= end && end <= size) << "Invalid shuffle range finish " << end << ": must be in range [" << begin << ", " << size << "]."; // Fisher-Yates shuffle, from // http://en.wikipedia.org/wiki/Fisher-Yates_shuffle for (int range_width = end - begin; range_width >= 2; range_width--) { const int last_in_range = begin + range_width - 1; const int selected = begin + random->Generate(range_width); std::swap((*v)[selected], (*v)[last_in_range]); } } // Performs an in-place shuffle of the vector's elements. template inline void Shuffle(internal::Random* random, std::vector* v) { ShuffleRange(random, 0, static_cast(v->size()), v); } // A function for deleting an object. Handy for being used as a // functor. template static void Delete(T* x) { delete x; } // A predicate that checks the key of a TestProperty against a known key. // // TestPropertyKeyIs is copyable. class TestPropertyKeyIs { public: // Constructor. // // TestPropertyKeyIs has NO default constructor. explicit TestPropertyKeyIs(const std::string& key) : key_(key) {} // Returns true iff the test name of test property matches on key_. bool operator()(const TestProperty& test_property) const { return test_property.key() == key_; } private: std::string key_; }; // Class UnitTestOptions. // // This class contains functions for processing options the user // specifies when running the tests. It has only static members. // // In most cases, the user can specify an option using either an // environment variable or a command line flag. E.g. you can set the // test filter using either GTEST_FILTER or --gtest_filter. If both // the variable and the flag are present, the latter overrides the // former. class GTEST_API_ UnitTestOptions { public: // Functions for processing the gtest_output flag. // Returns the output format, or "" for normal printed output. static std::string GetOutputFormat(); // Returns the absolute path of the requested output file, or the // default (test_detail.xml in the original working directory) if // none was explicitly specified. static std::string GetAbsolutePathToOutputFile(); // Functions for processing the gtest_filter flag. // Returns true iff the wildcard pattern matches the string. The // first ':' or '\0' character in pattern marks the end of it. // // This recursive algorithm isn't very efficient, but is clear and // works well enough for matching test names, which are short. static bool PatternMatchesString(const char *pattern, const char *str); // Returns true iff the user-specified filter matches the test case // name and the test name. static bool FilterMatchesTest(const std::string &test_case_name, const std::string &test_name); #if GTEST_OS_WINDOWS // Function for supporting the gtest_catch_exception flag. // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. // This function is useful as an __except condition. static int GTestShouldProcessSEH(DWORD exception_code); #endif // GTEST_OS_WINDOWS // Returns true if "name" matches the ':' separated list of glob-style // filters in "filter". static bool MatchesFilter(const std::string& name, const char* filter); }; // Returns the current application's name, removing directory path if that // is present. Used by UnitTestOptions::GetOutputFile. GTEST_API_ FilePath GetCurrentExecutableName(); // The role interface for getting the OS stack trace as a string. class OsStackTraceGetterInterface { public: OsStackTraceGetterInterface() {} virtual ~OsStackTraceGetterInterface() {} // Returns the current OS stack trace as an std::string. Parameters: // // max_depth - the maximum number of stack frames to be included // in the trace. // skip_count - the number of top frames to be skipped; doesn't count // against max_depth. virtual string CurrentStackTrace(int max_depth, int skip_count) = 0; // UponLeavingGTest() should be called immediately before Google Test calls // user code. It saves some information about the current stack that // CurrentStackTrace() will use to find and hide Google Test stack frames. virtual void UponLeavingGTest() = 0; private: GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetterInterface); }; // A working implementation of the OsStackTraceGetterInterface interface. class OsStackTraceGetter : public OsStackTraceGetterInterface { public: OsStackTraceGetter() : caller_frame_(NULL) {} virtual string CurrentStackTrace(int max_depth, int skip_count) GTEST_LOCK_EXCLUDED_(mutex_); virtual void UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_); // This string is inserted in place of stack frames that are part of // Google Test's implementation. static const char* const kElidedFramesMarker; private: Mutex mutex_; // protects all internal state // We save the stack frame below the frame that calls user code. // We do this because the address of the frame immediately below // the user code changes between the call to UponLeavingGTest() // and any calls to CurrentStackTrace() from within the user code. void* caller_frame_; GTEST_DISALLOW_COPY_AND_ASSIGN_(OsStackTraceGetter); }; // Information about a Google Test trace point. struct TraceInfo { const char* file; int line; std::string message; }; // This is the default global test part result reporter used in UnitTestImpl. // This class should only be used by UnitTestImpl. class DefaultGlobalTestPartResultReporter : public TestPartResultReporterInterface { public: explicit DefaultGlobalTestPartResultReporter(UnitTestImpl* unit_test); // Implements the TestPartResultReporterInterface. Reports the test part // result in the current test. virtual void ReportTestPartResult(const TestPartResult& result); private: UnitTestImpl* const unit_test_; GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultGlobalTestPartResultReporter); }; // This is the default per thread test part result reporter used in // UnitTestImpl. This class should only be used by UnitTestImpl. class DefaultPerThreadTestPartResultReporter : public TestPartResultReporterInterface { public: explicit DefaultPerThreadTestPartResultReporter(UnitTestImpl* unit_test); // Implements the TestPartResultReporterInterface. The implementation just // delegates to the current global test part result reporter of *unit_test_. virtual void ReportTestPartResult(const TestPartResult& result); private: UnitTestImpl* const unit_test_; GTEST_DISALLOW_COPY_AND_ASSIGN_(DefaultPerThreadTestPartResultReporter); }; // The private implementation of the UnitTest class. We don't protect // the methods under a mutex, as this class is not accessible by a // user and the UnitTest class that delegates work to this class does // proper locking. class GTEST_API_ UnitTestImpl { public: explicit UnitTestImpl(UnitTest* parent); virtual ~UnitTestImpl(); // There are two different ways to register your own TestPartResultReporter. // You can register your own repoter to listen either only for test results // from the current thread or for results from all threads. // By default, each per-thread test result repoter just passes a new // TestPartResult to the global test result reporter, which registers the // test part result for the currently running test. // Returns the global test part result reporter. TestPartResultReporterInterface* GetGlobalTestPartResultReporter(); // Sets the global test part result reporter. void SetGlobalTestPartResultReporter( TestPartResultReporterInterface* reporter); // Returns the test part result reporter for the current thread. TestPartResultReporterInterface* GetTestPartResultReporterForCurrentThread(); // Sets the test part result reporter for the current thread. void SetTestPartResultReporterForCurrentThread( TestPartResultReporterInterface* reporter); // Gets the number of successful test cases. int successful_test_case_count() const; // Gets the number of failed test cases. int failed_test_case_count() const; // Gets the number of all test cases. int total_test_case_count() const; // Gets the number of all test cases that contain at least one test // that should run. int test_case_to_run_count() const; // Gets the number of successful tests. int successful_test_count() const; // Gets the number of failed tests. int failed_test_count() const; // Gets the number of disabled tests that will be reported in the XML report. int reportable_disabled_test_count() const; // Gets the number of disabled tests. int disabled_test_count() const; // Gets the number of tests to be printed in the XML report. int reportable_test_count() const; // Gets the number of all tests. int total_test_count() const; // Gets the number of tests that should run. int test_to_run_count() const; // Gets the time of the test program start, in ms from the start of the // UNIX epoch. TimeInMillis start_timestamp() const { return start_timestamp_; } // Gets the elapsed time, in milliseconds. TimeInMillis elapsed_time() const { return elapsed_time_; } // Returns true iff the unit test passed (i.e. all test cases passed). bool Passed() const { return !Failed(); } // Returns true iff the unit test failed (i.e. some test case failed // or something outside of all tests failed). bool Failed() const { return failed_test_case_count() > 0 || ad_hoc_test_result()->Failed(); } // Gets the i-th test case among all the test cases. i can range from 0 to // total_test_case_count() - 1. If i is not in that range, returns NULL. const TestCase* GetTestCase(int i) const { const int index = GetElementOr(test_case_indices_, i, -1); return index < 0 ? NULL : test_cases_[i]; } // Gets the i-th test case among all the test cases. i can range from 0 to // total_test_case_count() - 1. If i is not in that range, returns NULL. TestCase* GetMutableTestCase(int i) { const int index = GetElementOr(test_case_indices_, i, -1); return index < 0 ? NULL : test_cases_[index]; } // Provides access to the event listener list. TestEventListeners* listeners() { return &listeners_; } // Returns the TestResult for the test that's currently running, or // the TestResult for the ad hoc test if no test is running. TestResult* current_test_result(); // Returns the TestResult for the ad hoc test. const TestResult* ad_hoc_test_result() const { return &ad_hoc_test_result_; } // Sets the OS stack trace getter. // // Does nothing if the input and the current OS stack trace getter // are the same; otherwise, deletes the old getter and makes the // input the current getter. void set_os_stack_trace_getter(OsStackTraceGetterInterface* getter); // Returns the current OS stack trace getter if it is not NULL; // otherwise, creates an OsStackTraceGetter, makes it the current // getter, and returns it. OsStackTraceGetterInterface* os_stack_trace_getter(); // Returns the current OS stack trace as an std::string. // // The maximum number of stack frames to be included is specified by // the gtest_stack_trace_depth flag. The skip_count parameter // specifies the number of top frames to be skipped, which doesn't // count against the number of frames to be included. // // For example, if Foo() calls Bar(), which in turn calls // CurrentOsStackTraceExceptTop(1), Foo() will be included in the // trace but Bar() and CurrentOsStackTraceExceptTop() won't. std::string CurrentOsStackTraceExceptTop(int skip_count) GTEST_NO_INLINE_; // Finds and returns a TestCase with the given name. If one doesn't // exist, creates one and returns it. // // Arguments: // // test_case_name: name of the test case // type_param: the name of the test's type parameter, or NULL if // this is not a typed or a type-parameterized test. // set_up_tc: pointer to the function that sets up the test case // tear_down_tc: pointer to the function that tears down the test case TestCase* GetTestCase(const char* test_case_name, const char* type_param, Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc); // Adds a TestInfo to the unit test. // // Arguments: // // set_up_tc: pointer to the function that sets up the test case // tear_down_tc: pointer to the function that tears down the test case // test_info: the TestInfo object void AddTestInfo(Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc, TestInfo* test_info) { // In order to support thread-safe death tests, we need to // remember the original working directory when the test program // was first invoked. We cannot do this in RUN_ALL_TESTS(), as // the user may have changed the current directory before calling // RUN_ALL_TESTS(). Therefore we capture the current directory in // AddTestInfo(), which is called to register a TEST or TEST_F // before main() is reached. if (original_working_dir_.IsEmpty()) { original_working_dir_.Set(FilePath::GetCurrentDir()); GTEST_CHECK_(!original_working_dir_.IsEmpty()) << "Failed to get the current working directory."; } GetTestCase(test_info->test_case_name(), test_info->type_param(), set_up_tc, tear_down_tc)->AddTestInfo(test_info); } #if GTEST_HAS_PARAM_TEST // Returns ParameterizedTestCaseRegistry object used to keep track of // value-parameterized tests and instantiate and register them. internal::ParameterizedTestCaseRegistry& parameterized_test_registry() { return parameterized_test_registry_; } #endif // GTEST_HAS_PARAM_TEST // Sets the TestCase object for the test that's currently running. void set_current_test_case(TestCase* a_current_test_case) { current_test_case_ = a_current_test_case; } // Sets the TestInfo object for the test that's currently running. If // current_test_info is NULL, the assertion results will be stored in // ad_hoc_test_result_. void set_current_test_info(TestInfo* a_current_test_info) { current_test_info_ = a_current_test_info; } // Registers all parameterized tests defined using TEST_P and // INSTANTIATE_TEST_CASE_P, creating regular tests for each test/parameter // combination. This method can be called more then once; it has guards // protecting from registering the tests more then once. If // value-parameterized tests are disabled, RegisterParameterizedTests is // present but does nothing. void RegisterParameterizedTests(); // Runs all tests in this UnitTest object, prints the result, and // returns true if all tests are successful. If any exception is // thrown during a test, this test is considered to be failed, but // the rest of the tests will still be run. bool RunAllTests(); // Clears the results of all tests, except the ad hoc tests. void ClearNonAdHocTestResult() { ForEach(test_cases_, TestCase::ClearTestCaseResult); } // Clears the results of ad-hoc test assertions. void ClearAdHocTestResult() { ad_hoc_test_result_.Clear(); } // Adds a TestProperty to the current TestResult object when invoked in a // context of a test or a test case, or to the global property set. If the // result already contains a property with the same key, the value will be // updated. void RecordProperty(const TestProperty& test_property); enum ReactionToSharding { HONOR_SHARDING_PROTOCOL, IGNORE_SHARDING_PROTOCOL }; // Matches the full name of each test against the user-specified // filter to decide whether the test should run, then records the // result in each TestCase and TestInfo object. // If shard_tests == HONOR_SHARDING_PROTOCOL, further filters tests // based on sharding variables in the environment. // Returns the number of tests that should run. int FilterTests(ReactionToSharding shard_tests); // Prints the names of the tests matching the user-specified filter flag. void ListTestsMatchingFilter(); const TestCase* current_test_case() const { return current_test_case_; } TestInfo* current_test_info() { return current_test_info_; } const TestInfo* current_test_info() const { return current_test_info_; } // Returns the vector of environments that need to be set-up/torn-down // before/after the tests are run. std::vector& environments() { return environments_; } // Getters for the per-thread Google Test trace stack. std::vector& gtest_trace_stack() { return *(gtest_trace_stack_.pointer()); } const std::vector& gtest_trace_stack() const { return gtest_trace_stack_.get(); } #if GTEST_HAS_DEATH_TEST void InitDeathTestSubprocessControlInfo() { internal_run_death_test_flag_.reset(ParseInternalRunDeathTestFlag()); } // Returns a pointer to the parsed --gtest_internal_run_death_test // flag, or NULL if that flag was not specified. // This information is useful only in a death test child process. // Must not be called before a call to InitGoogleTest. const InternalRunDeathTestFlag* internal_run_death_test_flag() const { return internal_run_death_test_flag_.get(); } // Returns a pointer to the current death test factory. internal::DeathTestFactory* death_test_factory() { return death_test_factory_.get(); } void SuppressTestEventsIfInSubprocess(); friend class ReplaceDeathTestFactory; #endif // GTEST_HAS_DEATH_TEST // Initializes the event listener performing XML output as specified by // UnitTestOptions. Must not be called before InitGoogleTest. void ConfigureXmlOutput(); #if GTEST_CAN_STREAM_RESULTS_ // Initializes the event listener for streaming test results to a socket. // Must not be called before InitGoogleTest. void ConfigureStreamingOutput(); #endif // Performs initialization dependent upon flag values obtained in // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest // this function is also called from RunAllTests. Since this function can be // called more than once, it has to be idempotent. void PostFlagParsingInit(); // Gets the random seed used at the start of the current test iteration. int random_seed() const { return random_seed_; } // Gets the random number generator. internal::Random* random() { return &random_; } // Shuffles all test cases, and the tests within each test case, // making sure that death tests are still run first. void ShuffleTests(); // Restores the test cases and tests to their order before the first shuffle. void UnshuffleTests(); // Returns the value of GTEST_FLAG(catch_exceptions) at the moment // UnitTest::Run() starts. bool catch_exceptions() const { return catch_exceptions_; } private: friend class ::testing::UnitTest; // Used by UnitTest::Run() to capture the state of // GTEST_FLAG(catch_exceptions) at the moment it starts. void set_catch_exceptions(bool value) { catch_exceptions_ = value; } // The UnitTest object that owns this implementation object. UnitTest* const parent_; // The working directory when the first TEST() or TEST_F() was // executed. internal::FilePath original_working_dir_; // The default test part result reporters. DefaultGlobalTestPartResultReporter default_global_test_part_result_reporter_; DefaultPerThreadTestPartResultReporter default_per_thread_test_part_result_reporter_; // Points to (but doesn't own) the global test part result reporter. TestPartResultReporterInterface* global_test_part_result_repoter_; // Protects read and write access to global_test_part_result_reporter_. internal::Mutex global_test_part_result_reporter_mutex_; // Points to (but doesn't own) the per-thread test part result reporter. internal::ThreadLocal per_thread_test_part_result_reporter_; // The vector of environments that need to be set-up/torn-down // before/after the tests are run. std::vector environments_; // The vector of TestCases in their original order. It owns the // elements in the vector. std::vector test_cases_; // Provides a level of indirection for the test case list to allow // easy shuffling and restoring the test case order. The i-th // element of this vector is the index of the i-th test case in the // shuffled order. std::vector test_case_indices_; #if GTEST_HAS_PARAM_TEST // ParameterizedTestRegistry object used to register value-parameterized // tests. internal::ParameterizedTestCaseRegistry parameterized_test_registry_; // Indicates whether RegisterParameterizedTests() has been called already. bool parameterized_tests_registered_; #endif // GTEST_HAS_PARAM_TEST // Index of the last death test case registered. Initially -1. int last_death_test_case_; // This points to the TestCase for the currently running test. It // changes as Google Test goes through one test case after another. // When no test is running, this is set to NULL and Google Test // stores assertion results in ad_hoc_test_result_. Initially NULL. TestCase* current_test_case_; // This points to the TestInfo for the currently running test. It // changes as Google Test goes through one test after another. When // no test is running, this is set to NULL and Google Test stores // assertion results in ad_hoc_test_result_. Initially NULL. TestInfo* current_test_info_; // Normally, a user only writes assertions inside a TEST or TEST_F, // or inside a function called by a TEST or TEST_F. Since Google // Test keeps track of which test is current running, it can // associate such an assertion with the test it belongs to. // // If an assertion is encountered when no TEST or TEST_F is running, // Google Test attributes the assertion result to an imaginary "ad hoc" // test, and records the result in ad_hoc_test_result_. TestResult ad_hoc_test_result_; // The list of event listeners that can be used to track events inside // Google Test. TestEventListeners listeners_; // The OS stack trace getter. Will be deleted when the UnitTest // object is destructed. By default, an OsStackTraceGetter is used, // but the user can set this field to use a custom getter if that is // desired. OsStackTraceGetterInterface* os_stack_trace_getter_; // True iff PostFlagParsingInit() has been called. bool post_flag_parse_init_performed_; // The random number seed used at the beginning of the test run. int random_seed_; // Our random number generator. internal::Random random_; // The time of the test program start, in ms from the start of the // UNIX epoch. TimeInMillis start_timestamp_; // How long the test took to run, in milliseconds. TimeInMillis elapsed_time_; #if GTEST_HAS_DEATH_TEST // The decomposed components of the gtest_internal_run_death_test flag, // parsed when RUN_ALL_TESTS is called. internal::scoped_ptr internal_run_death_test_flag_; internal::scoped_ptr death_test_factory_; #endif // GTEST_HAS_DEATH_TEST // A per-thread stack of traces created by the SCOPED_TRACE() macro. internal::ThreadLocal > gtest_trace_stack_; // The value of GTEST_FLAG(catch_exceptions) at the moment RunAllTests() // starts. bool catch_exceptions_; GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTestImpl); }; // class UnitTestImpl // Convenience function for accessing the global UnitTest // implementation object. inline UnitTestImpl* GetUnitTestImpl() { return UnitTest::GetInstance()->impl(); } #if GTEST_USES_SIMPLE_RE // Internal helper functions for implementing the simple regular // expression matcher. GTEST_API_ bool IsInSet(char ch, const char* str); GTEST_API_ bool IsAsciiDigit(char ch); GTEST_API_ bool IsAsciiPunct(char ch); GTEST_API_ bool IsRepeat(char ch); GTEST_API_ bool IsAsciiWhiteSpace(char ch); GTEST_API_ bool IsAsciiWordChar(char ch); GTEST_API_ bool IsValidEscape(char ch); GTEST_API_ bool AtomMatchesChar(bool escaped, char pattern, char ch); GTEST_API_ bool ValidateRegex(const char* regex); GTEST_API_ bool MatchRegexAtHead(const char* regex, const char* str); GTEST_API_ bool MatchRepetitionAndRegexAtHead( bool escaped, char ch, char repeat, const char* regex, const char* str); GTEST_API_ bool MatchRegexAnywhere(const char* regex, const char* str); #endif // GTEST_USES_SIMPLE_RE // Parses the command line for Google Test flags, without initializing // other parts of Google Test. GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, char** argv); GTEST_API_ void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv); #if GTEST_HAS_DEATH_TEST // Returns the message describing the last system error, regardless of the // platform. GTEST_API_ std::string GetLastErrnoDescription(); # if GTEST_OS_WINDOWS // Provides leak-safe Windows kernel handle ownership. class AutoHandle { public: AutoHandle() : handle_(INVALID_HANDLE_VALUE) {} explicit AutoHandle(HANDLE handle) : handle_(handle) {} ~AutoHandle() { Reset(); } HANDLE Get() const { return handle_; } void Reset() { Reset(INVALID_HANDLE_VALUE); } void Reset(HANDLE handle) { if (handle != handle_) { if (handle_ != INVALID_HANDLE_VALUE) ::CloseHandle(handle_); handle_ = handle; } } private: HANDLE handle_; GTEST_DISALLOW_COPY_AND_ASSIGN_(AutoHandle); }; # endif // GTEST_OS_WINDOWS // Attempts to parse a string into a positive integer pointed to by the // number parameter. Returns true if that is possible. // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we can use // it here. template bool ParseNaturalNumber(const ::std::string& str, Integer* number) { // Fail fast if the given string does not begin with a digit; // this bypasses strtoXXX's "optional leading whitespace and plus // or minus sign" semantics, which are undesirable here. if (str.empty() || !IsDigit(str[0])) { return false; } errno = 0; char* end; // BiggestConvertible is the largest integer type that system-provided // string-to-number conversion routines can return. # if GTEST_OS_WINDOWS && !defined(__GNUC__) // MSVC and C++ Builder define __int64 instead of the standard long long. typedef unsigned __int64 BiggestConvertible; const BiggestConvertible parsed = _strtoui64(str.c_str(), &end, 10); # else typedef unsigned long long BiggestConvertible; // NOLINT const BiggestConvertible parsed = strtoull(str.c_str(), &end, 10); # endif // GTEST_OS_WINDOWS && !defined(__GNUC__) const bool parse_success = *end == '\0' && errno == 0; // TODO(vladl@google.com): Convert this to compile time assertion when it is // available. GTEST_CHECK_(sizeof(Integer) <= sizeof(parsed)); const Integer result = static_cast(parsed); if (parse_success && static_cast(result) == parsed) { *number = result; return true; } return false; } #endif // GTEST_HAS_DEATH_TEST // TestResult contains some private methods that should be hidden from // Google Test user but are required for testing. This class allow our tests // to access them. // // This class is supplied only for the purpose of testing Google Test's own // constructs. Do not use it in user tests, either directly or indirectly. class TestResultAccessor { public: static void RecordProperty(TestResult* test_result, const std::string& xml_element, const TestProperty& property) { test_result->RecordProperty(xml_element, property); } static void ClearTestPartResults(TestResult* test_result) { test_result->ClearTestPartResults(); } static const std::vector& test_part_results( const TestResult& test_result) { return test_result.test_part_results(); } }; #if GTEST_CAN_STREAM_RESULTS_ // Streams test results to the given port on the given host machine. class StreamingListener : public EmptyTestEventListener { public: // Abstract base class for writing strings to a socket. class AbstractSocketWriter { public: virtual ~AbstractSocketWriter() {} // Sends a string to the socket. virtual void Send(const string& message) = 0; // Closes the socket. virtual void CloseConnection() {} // Sends a string and a newline to the socket. void SendLn(const string& message) { Send(message + "\n"); } }; // Concrete class for actually writing strings to a socket. class SocketWriter : public AbstractSocketWriter { public: SocketWriter(const string& host, const string& port) : sockfd_(-1), host_name_(host), port_num_(port) { MakeConnection(); } virtual ~SocketWriter() { if (sockfd_ != -1) CloseConnection(); } // Sends a string to the socket. virtual void Send(const string& message) { GTEST_CHECK_(sockfd_ != -1) << "Send() can be called only when there is a connection."; const int len = static_cast(message.length()); if (write(sockfd_, message.c_str(), len) != len) { GTEST_LOG_(WARNING) << "stream_result_to: failed to stream to " << host_name_ << ":" << port_num_; } } private: // Creates a client socket and connects to the server. void MakeConnection(); // Closes the socket. void CloseConnection() { GTEST_CHECK_(sockfd_ != -1) << "CloseConnection() can be called only when there is a connection."; close(sockfd_); sockfd_ = -1; } int sockfd_; // socket file descriptor const string host_name_; const string port_num_; GTEST_DISALLOW_COPY_AND_ASSIGN_(SocketWriter); }; // class SocketWriter // Escapes '=', '&', '%', and '\n' characters in str as "%xx". static string UrlEncode(const char* str); StreamingListener(const string& host, const string& port) : socket_writer_(new SocketWriter(host, port)) { Start(); } explicit StreamingListener(AbstractSocketWriter* socket_writer) : socket_writer_(socket_writer) { Start(); } void OnTestProgramStart(const UnitTest& /* unit_test */) { SendLn("event=TestProgramStart"); } void OnTestProgramEnd(const UnitTest& unit_test) { // Note that Google Test current only report elapsed time for each // test iteration, not for the entire test program. SendLn("event=TestProgramEnd&passed=" + FormatBool(unit_test.Passed())); // Notify the streaming server to stop. socket_writer_->CloseConnection(); } void OnTestIterationStart(const UnitTest& /* unit_test */, int iteration) { SendLn("event=TestIterationStart&iteration=" + StreamableToString(iteration)); } void OnTestIterationEnd(const UnitTest& unit_test, int /* iteration */) { SendLn("event=TestIterationEnd&passed=" + FormatBool(unit_test.Passed()) + "&elapsed_time=" + StreamableToString(unit_test.elapsed_time()) + "ms"); } void OnTestCaseStart(const TestCase& test_case) { SendLn(std::string("event=TestCaseStart&name=") + test_case.name()); } void OnTestCaseEnd(const TestCase& test_case) { SendLn("event=TestCaseEnd&passed=" + FormatBool(test_case.Passed()) + "&elapsed_time=" + StreamableToString(test_case.elapsed_time()) + "ms"); } void OnTestStart(const TestInfo& test_info) { SendLn(std::string("event=TestStart&name=") + test_info.name()); } void OnTestEnd(const TestInfo& test_info) { SendLn("event=TestEnd&passed=" + FormatBool((test_info.result())->Passed()) + "&elapsed_time=" + StreamableToString((test_info.result())->elapsed_time()) + "ms"); } void OnTestPartResult(const TestPartResult& test_part_result) { const char* file_name = test_part_result.file_name(); if (file_name == NULL) file_name = ""; SendLn("event=TestPartResult&file=" + UrlEncode(file_name) + "&line=" + StreamableToString(test_part_result.line_number()) + "&message=" + UrlEncode(test_part_result.message())); } private: // Sends the given message and a newline to the socket. void SendLn(const string& message) { socket_writer_->SendLn(message); } // Called at the start of streaming to notify the receiver what // protocol we are using. void Start() { SendLn("gtest_streaming_protocol_version=1.0"); } string FormatBool(bool value) { return value ? "1" : "0"; } const scoped_ptr socket_writer_; GTEST_DISALLOW_COPY_AND_ASSIGN_(StreamingListener); }; // class StreamingListener #endif // GTEST_CAN_STREAM_RESULTS_ } // namespace internal } // namespace testing #endif // GTEST_SRC_GTEST_INTERNAL_INL_H_ #undef GTEST_IMPLEMENTATION_ #if GTEST_OS_WINDOWS # define vsnprintf _vsnprintf #endif // GTEST_OS_WINDOWS namespace testing { using internal::CountIf; using internal::ForEach; using internal::GetElementOr; using internal::Shuffle; // Constants. // A test whose test case name or test name matches this filter is // disabled and not run. static const char kDisableTestFilter[] = "DISABLED_*:*/DISABLED_*"; // A test case whose name matches this filter is considered a death // test case and will be run before test cases whose name doesn't // match this filter. static const char kDeathTestCaseFilter[] = "*DeathTest:*DeathTest/*"; // A test filter that matches everything. static const char kUniversalFilter[] = "*"; // The default output file for XML output. static const char kDefaultOutputFile[] = "test_detail.xml"; // The environment variable name for the test shard index. static const char kTestShardIndex[] = "GTEST_SHARD_INDEX"; // The environment variable name for the total number of test shards. static const char kTestTotalShards[] = "GTEST_TOTAL_SHARDS"; // The environment variable name for the test shard status file. static const char kTestShardStatusFile[] = "GTEST_SHARD_STATUS_FILE"; namespace internal { // The text used in failure messages to indicate the start of the // stack trace. const char kStackTraceMarker[] = "\nStack trace:\n"; // g_help_flag is true iff the --help flag or an equivalent form is // specified on the command line. bool g_help_flag = false; } // namespace internal static const char* GetDefaultFilter() { return kUniversalFilter; } GTEST_DEFINE_bool_( also_run_disabled_tests, internal::BoolFromGTestEnv("also_run_disabled_tests", false), "Run disabled tests too, in addition to the tests normally being run."); GTEST_DEFINE_bool_( break_on_failure, internal::BoolFromGTestEnv("break_on_failure", false), "True iff a failed assertion should be a debugger break-point."); GTEST_DEFINE_bool_( catch_exceptions, internal::BoolFromGTestEnv("catch_exceptions", true), "True iff " GTEST_NAME_ " should catch exceptions and treat them as test failures."); GTEST_DEFINE_string_( color, internal::StringFromGTestEnv("color", "auto"), "Whether to use colors in the output. Valid values: yes, no, " "and auto. 'auto' means to use colors if the output is " "being sent to a terminal and the TERM environment variable " "is set to a terminal type that supports colors."); GTEST_DEFINE_string_( filter, internal::StringFromGTestEnv("filter", GetDefaultFilter()), "A colon-separated list of glob (not regex) patterns " "for filtering the tests to run, optionally followed by a " "'-' and a : separated list of negative patterns (tests to " "exclude). A test is run if it matches one of the positive " "patterns and does not match any of the negative patterns."); GTEST_DEFINE_bool_(list_tests, false, "List all tests without running them."); GTEST_DEFINE_string_( output, internal::StringFromGTestEnv("output", ""), "A format (currently must be \"xml\"), optionally followed " "by a colon and an output file name or directory. A directory " "is indicated by a trailing pathname separator. " "Examples: \"xml:filename.xml\", \"xml::directoryname/\". " "If a directory is specified, output files will be created " "within that directory, with file-names based on the test " "executable's name and, if necessary, made unique by adding " "digits."); GTEST_DEFINE_bool_( print_time, internal::BoolFromGTestEnv("print_time", true), "True iff " GTEST_NAME_ " should display elapsed time in text output."); GTEST_DEFINE_int32_( random_seed, internal::Int32FromGTestEnv("random_seed", 0), "Random number seed to use when shuffling test orders. Must be in range " "[1, 99999], or 0 to use a seed based on the current time."); GTEST_DEFINE_int32_( repeat, internal::Int32FromGTestEnv("repeat", 1), "How many times to repeat each test. Specify a negative number " "for repeating forever. Useful for shaking out flaky tests."); GTEST_DEFINE_bool_( show_internal_stack_frames, false, "True iff " GTEST_NAME_ " should include internal stack frames when " "printing test failure stack traces."); GTEST_DEFINE_bool_( shuffle, internal::BoolFromGTestEnv("shuffle", false), "True iff " GTEST_NAME_ " should randomize tests' order on every run."); GTEST_DEFINE_int32_( stack_trace_depth, internal::Int32FromGTestEnv("stack_trace_depth", kMaxStackTraceDepth), "The maximum number of stack frames to print when an " "assertion fails. The valid range is 0 through 100, inclusive."); GTEST_DEFINE_string_( stream_result_to, internal::StringFromGTestEnv("stream_result_to", ""), "This flag specifies the host name and the port number on which to stream " "test results. Example: \"localhost:555\". The flag is effective only on " "Linux."); GTEST_DEFINE_bool_( throw_on_failure, internal::BoolFromGTestEnv("throw_on_failure", false), "When this flag is specified, a failed assertion will throw an exception " "if exceptions are enabled or exit the program with a non-zero code " "otherwise."); namespace internal { // Generates a random number from [0, range), using a Linear // Congruential Generator (LCG). Crashes if 'range' is 0 or greater // than kMaxRange. UInt32 Random::Generate(UInt32 range) { // These constants are the same as are used in glibc's rand(3). state_ = (1103515245U*state_ + 12345U) % kMaxRange; GTEST_CHECK_(range > 0) << "Cannot generate a number in the range [0, 0)."; GTEST_CHECK_(range <= kMaxRange) << "Generation of a number in [0, " << range << ") was requested, " << "but this can only generate numbers in [0, " << kMaxRange << ")."; // Converting via modulus introduces a bit of downward bias, but // it's simple, and a linear congruential generator isn't too good // to begin with. return state_ % range; } // GTestIsInitialized() returns true iff the user has initialized // Google Test. Useful for catching the user mistake of not initializing // Google Test before calling RUN_ALL_TESTS(). // // A user must call testing::InitGoogleTest() to initialize Google // Test. g_init_gtest_count is set to the number of times // InitGoogleTest() has been called. We don't protect this variable // under a mutex as it is only accessed in the main thread. GTEST_API_ int g_init_gtest_count = 0; static bool GTestIsInitialized() { return g_init_gtest_count != 0; } // Iterates over a vector of TestCases, keeping a running sum of the // results of calling a given int-returning method on each. // Returns the sum. static int SumOverTestCaseList(const std::vector& case_list, int (TestCase::*method)() const) { int sum = 0; for (size_t i = 0; i < case_list.size(); i++) { sum += (case_list[i]->*method)(); } return sum; } // Returns true iff the test case passed. static bool TestCasePassed(const TestCase* test_case) { return test_case->should_run() && test_case->Passed(); } // Returns true iff the test case failed. static bool TestCaseFailed(const TestCase* test_case) { return test_case->should_run() && test_case->Failed(); } // Returns true iff test_case contains at least one test that should // run. static bool ShouldRunTestCase(const TestCase* test_case) { return test_case->should_run(); } // AssertHelper constructor. AssertHelper::AssertHelper(TestPartResult::Type type, const char* file, int line, const char* message) : data_(new AssertHelperData(type, file, line, message)) { } AssertHelper::~AssertHelper() { delete data_; } // Message assignment, for assertion streaming support. void AssertHelper::operator=(const Message& message) const { UnitTest::GetInstance()-> AddTestPartResult(data_->type, data_->file, data_->line, AppendUserMessage(data_->message, message), UnitTest::GetInstance()->impl() ->CurrentOsStackTraceExceptTop(1) // Skips the stack frame for this function itself. ); // NOLINT } // Mutex for linked pointers. GTEST_API_ GTEST_DEFINE_STATIC_MUTEX_(g_linked_ptr_mutex); // Application pathname gotten in InitGoogleTest. std::string g_executable_path; // Returns the current application's name, removing directory path if that // is present. FilePath GetCurrentExecutableName() { FilePath result; #if GTEST_OS_WINDOWS result.Set(FilePath(g_executable_path).RemoveExtension("exe")); #else result.Set(FilePath(g_executable_path)); #endif // GTEST_OS_WINDOWS return result.RemoveDirectoryName(); } // Functions for processing the gtest_output flag. // Returns the output format, or "" for normal printed output. std::string UnitTestOptions::GetOutputFormat() { const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); if (gtest_output_flag == NULL) return std::string(""); const char* const colon = strchr(gtest_output_flag, ':'); return (colon == NULL) ? std::string(gtest_output_flag) : std::string(gtest_output_flag, colon - gtest_output_flag); } // Returns the name of the requested output file, or the default if none // was explicitly specified. std::string UnitTestOptions::GetAbsolutePathToOutputFile() { const char* const gtest_output_flag = GTEST_FLAG(output).c_str(); if (gtest_output_flag == NULL) return ""; const char* const colon = strchr(gtest_output_flag, ':'); if (colon == NULL) return internal::FilePath::ConcatPaths( internal::FilePath( UnitTest::GetInstance()->original_working_dir()), internal::FilePath(kDefaultOutputFile)).string(); internal::FilePath output_name(colon + 1); if (!output_name.IsAbsolutePath()) // TODO(wan@google.com): on Windows \some\path is not an absolute // path (as its meaning depends on the current drive), yet the // following logic for turning it into an absolute path is wrong. // Fix it. output_name = internal::FilePath::ConcatPaths( internal::FilePath(UnitTest::GetInstance()->original_working_dir()), internal::FilePath(colon + 1)); if (!output_name.IsDirectory()) return output_name.string(); internal::FilePath result(internal::FilePath::GenerateUniqueFileName( output_name, internal::GetCurrentExecutableName(), GetOutputFormat().c_str())); return result.string(); } // Returns true iff the wildcard pattern matches the string. The // first ':' or '\0' character in pattern marks the end of it. // // This recursive algorithm isn't very efficient, but is clear and // works well enough for matching test names, which are short. bool UnitTestOptions::PatternMatchesString(const char *pattern, const char *str) { switch (*pattern) { case '\0': case ':': // Either ':' or '\0' marks the end of the pattern. return *str == '\0'; case '?': // Matches any single character. return *str != '\0' && PatternMatchesString(pattern + 1, str + 1); case '*': // Matches any string (possibly empty) of characters. return (*str != '\0' && PatternMatchesString(pattern, str + 1)) || PatternMatchesString(pattern + 1, str); default: // Non-special character. Matches itself. return *pattern == *str && PatternMatchesString(pattern + 1, str + 1); } } bool UnitTestOptions::MatchesFilter( const std::string& name, const char* filter) { const char *cur_pattern = filter; for (;;) { if (PatternMatchesString(cur_pattern, name.c_str())) { return true; } // Finds the next pattern in the filter. cur_pattern = strchr(cur_pattern, ':'); // Returns if no more pattern can be found. if (cur_pattern == NULL) { return false; } // Skips the pattern separater (the ':' character). cur_pattern++; } } // Returns true iff the user-specified filter matches the test case // name and the test name. bool UnitTestOptions::FilterMatchesTest(const std::string &test_case_name, const std::string &test_name) { const std::string& full_name = test_case_name + "." + test_name.c_str(); // Split --gtest_filter at '-', if there is one, to separate into // positive filter and negative filter portions const char* const p = GTEST_FLAG(filter).c_str(); const char* const dash = strchr(p, '-'); std::string positive; std::string negative; if (dash == NULL) { positive = GTEST_FLAG(filter).c_str(); // Whole string is a positive filter negative = ""; } else { positive = std::string(p, dash); // Everything up to the dash negative = std::string(dash + 1); // Everything after the dash if (positive.empty()) { // Treat '-test1' as the same as '*-test1' positive = kUniversalFilter; } } // A filter is a colon-separated list of patterns. It matches a // test if any pattern in it matches the test. return (MatchesFilter(full_name, positive.c_str()) && !MatchesFilter(full_name, negative.c_str())); } #if GTEST_HAS_SEH // Returns EXCEPTION_EXECUTE_HANDLER if Google Test should handle the // given SEH exception, or EXCEPTION_CONTINUE_SEARCH otherwise. // This function is useful as an __except condition. int UnitTestOptions::GTestShouldProcessSEH(DWORD exception_code) { // Google Test should handle a SEH exception if: // 1. the user wants it to, AND // 2. this is not a breakpoint exception, AND // 3. this is not a C++ exception (VC++ implements them via SEH, // apparently). // // SEH exception code for C++ exceptions. // (see http://support.microsoft.com/kb/185294 for more information). const DWORD kCxxExceptionCode = 0xe06d7363; bool should_handle = true; if (!GTEST_FLAG(catch_exceptions)) should_handle = false; else if (exception_code == EXCEPTION_BREAKPOINT) should_handle = false; else if (exception_code == kCxxExceptionCode) should_handle = false; return should_handle ? EXCEPTION_EXECUTE_HANDLER : EXCEPTION_CONTINUE_SEARCH; } #endif // GTEST_HAS_SEH } // namespace internal // The c'tor sets this object as the test part result reporter used by // Google Test. The 'result' parameter specifies where to report the // results. Intercepts only failures from the current thread. ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( TestPartResultArray* result) : intercept_mode_(INTERCEPT_ONLY_CURRENT_THREAD), result_(result) { Init(); } // The c'tor sets this object as the test part result reporter used by // Google Test. The 'result' parameter specifies where to report the // results. ScopedFakeTestPartResultReporter::ScopedFakeTestPartResultReporter( InterceptMode intercept_mode, TestPartResultArray* result) : intercept_mode_(intercept_mode), result_(result) { Init(); } void ScopedFakeTestPartResultReporter::Init() { internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); if (intercept_mode_ == INTERCEPT_ALL_THREADS) { old_reporter_ = impl->GetGlobalTestPartResultReporter(); impl->SetGlobalTestPartResultReporter(this); } else { old_reporter_ = impl->GetTestPartResultReporterForCurrentThread(); impl->SetTestPartResultReporterForCurrentThread(this); } } // The d'tor restores the test part result reporter used by Google Test // before. ScopedFakeTestPartResultReporter::~ScopedFakeTestPartResultReporter() { internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); if (intercept_mode_ == INTERCEPT_ALL_THREADS) { impl->SetGlobalTestPartResultReporter(old_reporter_); } else { impl->SetTestPartResultReporterForCurrentThread(old_reporter_); } } // Increments the test part result count and remembers the result. // This method is from the TestPartResultReporterInterface interface. void ScopedFakeTestPartResultReporter::ReportTestPartResult( const TestPartResult& result) { result_->Append(result); } namespace internal { // Returns the type ID of ::testing::Test. We should always call this // instead of GetTypeId< ::testing::Test>() to get the type ID of // testing::Test. This is to work around a suspected linker bug when // using Google Test as a framework on Mac OS X. The bug causes // GetTypeId< ::testing::Test>() to return different values depending // on whether the call is from the Google Test framework itself or // from user test code. GetTestTypeId() is guaranteed to always // return the same value, as it always calls GetTypeId<>() from the // gtest.cc, which is within the Google Test framework. TypeId GetTestTypeId() { return GetTypeId(); } // The value of GetTestTypeId() as seen from within the Google Test // library. This is solely for testing GetTestTypeId(). extern const TypeId kTestTypeIdInGoogleTest = GetTestTypeId(); // This predicate-formatter checks that 'results' contains a test part // failure of the given type and that the failure message contains the // given substring. AssertionResult HasOneFailure(const char* /* results_expr */, const char* /* type_expr */, const char* /* substr_expr */, const TestPartResultArray& results, TestPartResult::Type type, const string& substr) { const std::string expected(type == TestPartResult::kFatalFailure ? "1 fatal failure" : "1 non-fatal failure"); Message msg; if (results.size() != 1) { msg << "Expected: " << expected << "\n" << " Actual: " << results.size() << " failures"; for (int i = 0; i < results.size(); i++) { msg << "\n" << results.GetTestPartResult(i); } return AssertionFailure() << msg; } const TestPartResult& r = results.GetTestPartResult(0); if (r.type() != type) { return AssertionFailure() << "Expected: " << expected << "\n" << " Actual:\n" << r; } if (strstr(r.message(), substr.c_str()) == NULL) { return AssertionFailure() << "Expected: " << expected << " containing \"" << substr << "\"\n" << " Actual:\n" << r; } return AssertionSuccess(); } // The constructor of SingleFailureChecker remembers where to look up // test part results, what type of failure we expect, and what // substring the failure message should contain. SingleFailureChecker:: SingleFailureChecker( const TestPartResultArray* results, TestPartResult::Type type, const string& substr) : results_(results), type_(type), substr_(substr) {} // The destructor of SingleFailureChecker verifies that the given // TestPartResultArray contains exactly one failure that has the given // type and contains the given substring. If that's not the case, a // non-fatal failure will be generated. SingleFailureChecker::~SingleFailureChecker() { EXPECT_PRED_FORMAT3(HasOneFailure, *results_, type_, substr_); } DefaultGlobalTestPartResultReporter::DefaultGlobalTestPartResultReporter( UnitTestImpl* unit_test) : unit_test_(unit_test) {} void DefaultGlobalTestPartResultReporter::ReportTestPartResult( const TestPartResult& result) { unit_test_->current_test_result()->AddTestPartResult(result); unit_test_->listeners()->repeater()->OnTestPartResult(result); } DefaultPerThreadTestPartResultReporter::DefaultPerThreadTestPartResultReporter( UnitTestImpl* unit_test) : unit_test_(unit_test) {} void DefaultPerThreadTestPartResultReporter::ReportTestPartResult( const TestPartResult& result) { unit_test_->GetGlobalTestPartResultReporter()->ReportTestPartResult(result); } // Returns the global test part result reporter. TestPartResultReporterInterface* UnitTestImpl::GetGlobalTestPartResultReporter() { internal::MutexLock lock(&global_test_part_result_reporter_mutex_); return global_test_part_result_repoter_; } // Sets the global test part result reporter. void UnitTestImpl::SetGlobalTestPartResultReporter( TestPartResultReporterInterface* reporter) { internal::MutexLock lock(&global_test_part_result_reporter_mutex_); global_test_part_result_repoter_ = reporter; } // Returns the test part result reporter for the current thread. TestPartResultReporterInterface* UnitTestImpl::GetTestPartResultReporterForCurrentThread() { return per_thread_test_part_result_reporter_.get(); } // Sets the test part result reporter for the current thread. void UnitTestImpl::SetTestPartResultReporterForCurrentThread( TestPartResultReporterInterface* reporter) { per_thread_test_part_result_reporter_.set(reporter); } // Gets the number of successful test cases. int UnitTestImpl::successful_test_case_count() const { return CountIf(test_cases_, TestCasePassed); } // Gets the number of failed test cases. int UnitTestImpl::failed_test_case_count() const { return CountIf(test_cases_, TestCaseFailed); } // Gets the number of all test cases. int UnitTestImpl::total_test_case_count() const { return static_cast(test_cases_.size()); } // Gets the number of all test cases that contain at least one test // that should run. int UnitTestImpl::test_case_to_run_count() const { return CountIf(test_cases_, ShouldRunTestCase); } // Gets the number of successful tests. int UnitTestImpl::successful_test_count() const { return SumOverTestCaseList(test_cases_, &TestCase::successful_test_count); } // Gets the number of failed tests. int UnitTestImpl::failed_test_count() const { return SumOverTestCaseList(test_cases_, &TestCase::failed_test_count); } // Gets the number of disabled tests that will be reported in the XML report. int UnitTestImpl::reportable_disabled_test_count() const { return SumOverTestCaseList(test_cases_, &TestCase::reportable_disabled_test_count); } // Gets the number of disabled tests. int UnitTestImpl::disabled_test_count() const { return SumOverTestCaseList(test_cases_, &TestCase::disabled_test_count); } // Gets the number of tests to be printed in the XML report. int UnitTestImpl::reportable_test_count() const { return SumOverTestCaseList(test_cases_, &TestCase::reportable_test_count); } // Gets the number of all tests. int UnitTestImpl::total_test_count() const { return SumOverTestCaseList(test_cases_, &TestCase::total_test_count); } // Gets the number of tests that should run. int UnitTestImpl::test_to_run_count() const { return SumOverTestCaseList(test_cases_, &TestCase::test_to_run_count); } // Returns the current OS stack trace as an std::string. // // The maximum number of stack frames to be included is specified by // the gtest_stack_trace_depth flag. The skip_count parameter // specifies the number of top frames to be skipped, which doesn't // count against the number of frames to be included. // // For example, if Foo() calls Bar(), which in turn calls // CurrentOsStackTraceExceptTop(1), Foo() will be included in the // trace but Bar() and CurrentOsStackTraceExceptTop() won't. std::string UnitTestImpl::CurrentOsStackTraceExceptTop(int skip_count) { (void)skip_count; return ""; } // Returns the current time in milliseconds. TimeInMillis GetTimeInMillis() { #if GTEST_OS_WINDOWS_MOBILE || defined(__BORLANDC__) // Difference between 1970-01-01 and 1601-01-01 in milliseconds. // http://analogous.blogspot.com/2005/04/epoch.html const TimeInMillis kJavaEpochToWinFileTimeDelta = static_cast(116444736UL) * 100000UL; const DWORD kTenthMicrosInMilliSecond = 10000; SYSTEMTIME now_systime; FILETIME now_filetime; ULARGE_INTEGER now_int64; // TODO(kenton@google.com): Shouldn't this just use // GetSystemTimeAsFileTime()? GetSystemTime(&now_systime); if (SystemTimeToFileTime(&now_systime, &now_filetime)) { now_int64.LowPart = now_filetime.dwLowDateTime; now_int64.HighPart = now_filetime.dwHighDateTime; now_int64.QuadPart = (now_int64.QuadPart / kTenthMicrosInMilliSecond) - kJavaEpochToWinFileTimeDelta; return now_int64.QuadPart; } return 0; #elif GTEST_OS_WINDOWS && !GTEST_HAS_GETTIMEOFDAY_ __timeb64 now; # ifdef _MSC_VER // MSVC 8 deprecates _ftime64(), so we want to suppress warning 4996 // (deprecated function) there. // TODO(kenton@google.com): Use GetTickCount()? Or use // SystemTimeToFileTime() # pragma warning(push) // Saves the current warning state. # pragma warning(disable:4996) // Temporarily disables warning 4996. _ftime64(&now); # pragma warning(pop) // Restores the warning state. # else _ftime64(&now); # endif // _MSC_VER return static_cast(now.time) * 1000 + now.millitm; #elif GTEST_HAS_GETTIMEOFDAY_ struct timeval now; gettimeofday(&now, NULL); return static_cast(now.tv_sec) * 1000 + now.tv_usec / 1000; #else # error "Don't know how to get the current time on your system." #endif } // Utilities // class String. #if GTEST_OS_WINDOWS_MOBILE // Creates a UTF-16 wide string from the given ANSI string, allocating // memory using new. The caller is responsible for deleting the return // value using delete[]. Returns the wide string, or NULL if the // input is NULL. LPCWSTR String::AnsiToUtf16(const char* ansi) { if (!ansi) return NULL; const int length = strlen(ansi); const int unicode_length = MultiByteToWideChar(CP_ACP, 0, ansi, length, NULL, 0); WCHAR* unicode = new WCHAR[unicode_length + 1]; MultiByteToWideChar(CP_ACP, 0, ansi, length, unicode, unicode_length); unicode[unicode_length] = 0; return unicode; } // Creates an ANSI string from the given wide string, allocating // memory using new. The caller is responsible for deleting the return // value using delete[]. Returns the ANSI string, or NULL if the // input is NULL. const char* String::Utf16ToAnsi(LPCWSTR utf16_str) { if (!utf16_str) return NULL; const int ansi_length = WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, NULL, 0, NULL, NULL); char* ansi = new char[ansi_length + 1]; WideCharToMultiByte(CP_ACP, 0, utf16_str, -1, ansi, ansi_length, NULL, NULL); ansi[ansi_length] = 0; return ansi; } #endif // GTEST_OS_WINDOWS_MOBILE // Compares two C strings. Returns true iff they have the same content. // // Unlike strcmp(), this function can handle NULL argument(s). A NULL // C string is considered different to any non-NULL C string, // including the empty string. bool String::CStringEquals(const char * lhs, const char * rhs) { if ( lhs == NULL ) return rhs == NULL; if ( rhs == NULL ) return false; return strcmp(lhs, rhs) == 0; } #if GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING // Converts an array of wide chars to a narrow string using the UTF-8 // encoding, and streams the result to the given Message object. static void StreamWideCharsToMessage(const wchar_t* wstr, size_t length, Message* msg) { for (size_t i = 0; i != length; ) { // NOLINT if (wstr[i] != L'\0') { *msg << WideStringToUtf8(wstr + i, static_cast(length - i)); while (i != length && wstr[i] != L'\0') i++; } else { *msg << '\0'; i++; } } } #endif // GTEST_HAS_STD_WSTRING || GTEST_HAS_GLOBAL_WSTRING } // namespace internal // Constructs an empty Message. // We allocate the stringstream separately because otherwise each use of // ASSERT/EXPECT in a procedure adds over 200 bytes to the procedure's // stack frame leading to huge stack frames in some cases; gcc does not reuse // the stack space. Message::Message() : ss_(new ::std::stringstream) { // By default, we want there to be enough precision when printing // a double to a Message. *ss_ << std::setprecision(std::numeric_limits::digits10 + 2); } // These two overloads allow streaming a wide C string to a Message // using the UTF-8 encoding. Message& Message::operator <<(const wchar_t* wide_c_str) { return *this << internal::String::ShowWideCString(wide_c_str); } Message& Message::operator <<(wchar_t* wide_c_str) { return *this << internal::String::ShowWideCString(wide_c_str); } #if GTEST_HAS_STD_WSTRING // Converts the given wide string to a narrow string using the UTF-8 // encoding, and streams the result to this Message object. Message& Message::operator <<(const ::std::wstring& wstr) { internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); return *this; } #endif // GTEST_HAS_STD_WSTRING #if GTEST_HAS_GLOBAL_WSTRING // Converts the given wide string to a narrow string using the UTF-8 // encoding, and streams the result to this Message object. Message& Message::operator <<(const ::wstring& wstr) { internal::StreamWideCharsToMessage(wstr.c_str(), wstr.length(), this); return *this; } #endif // GTEST_HAS_GLOBAL_WSTRING // Gets the text streamed to this object so far as an std::string. // Each '\0' character in the buffer is replaced with "\\0". std::string Message::GetString() const { return internal::StringStreamToString(ss_.get()); } // AssertionResult constructors. // Used in EXPECT_TRUE/FALSE(assertion_result). AssertionResult::AssertionResult(const AssertionResult& other) : success_(other.success_), message_(other.message_.get() != NULL ? new ::std::string(*other.message_) : static_cast< ::std::string*>(NULL)) { } // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. AssertionResult AssertionResult::operator!() const { AssertionResult negation(!success_); if (message_.get() != NULL) negation << *message_; return negation; } // Makes a successful assertion result. AssertionResult AssertionSuccess() { return AssertionResult(true); } // Makes a failed assertion result. AssertionResult AssertionFailure() { return AssertionResult(false); } // Makes a failed assertion result with the given failure message. // Deprecated; use AssertionFailure() << message. AssertionResult AssertionFailure(const Message& message) { return AssertionFailure() << message; } namespace internal { // Constructs and returns the message for an equality assertion // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. // // The first four parameters are the expressions used in the assertion // and their values, as strings. For example, for ASSERT_EQ(foo, bar) // where foo is 5 and bar is 6, we have: // // expected_expression: "foo" // actual_expression: "bar" // expected_value: "5" // actual_value: "6" // // The ignoring_case parameter is true iff the assertion is a // *_STRCASEEQ*. When it's true, the string " (ignoring case)" will // be inserted into the message. AssertionResult EqFailure(const char* expected_expression, const char* actual_expression, const std::string& expected_value, const std::string& actual_value, bool ignoring_case) { Message msg; msg << "Value of: " << actual_expression; if (actual_value != actual_expression) { msg << "\n Actual: " << actual_value; } msg << "\nExpected: " << expected_expression; if (ignoring_case) { msg << " (ignoring case)"; } if (expected_value != expected_expression) { msg << "\nWhich is: " << expected_value; } return AssertionFailure() << msg; } // Constructs a failure message for Boolean assertions such as EXPECT_TRUE. std::string GetBoolAssertionFailureMessage( const AssertionResult& assertion_result, const char* expression_text, const char* actual_predicate_value, const char* expected_predicate_value) { const char* actual_message = assertion_result.message(); Message msg; msg << "Value of: " << expression_text << "\n Actual: " << actual_predicate_value; if (actual_message[0] != '\0') msg << " (" << actual_message << ")"; msg << "\nExpected: " << expected_predicate_value; return msg.GetString(); } // Helper function for implementing ASSERT_NEAR. AssertionResult DoubleNearPredFormat(const char* expr1, const char* expr2, const char* abs_error_expr, double val1, double val2, double abs_error) { const double diff = fabs(val1 - val2); if (diff <= abs_error) return AssertionSuccess(); // TODO(wan): do not print the value of an expression if it's // already a literal. return AssertionFailure() << "The difference between " << expr1 << " and " << expr2 << " is " << diff << ", which exceeds " << abs_error_expr << ", where\n" << expr1 << " evaluates to " << val1 << ",\n" << expr2 << " evaluates to " << val2 << ", and\n" << abs_error_expr << " evaluates to " << abs_error << "."; } // Helper template for implementing FloatLE() and DoubleLE(). template AssertionResult FloatingPointLE(const char* expr1, const char* expr2, RawType val1, RawType val2) { // Returns success if val1 is less than val2, if (val1 < val2) { return AssertionSuccess(); } // or if val1 is almost equal to val2. const FloatingPoint lhs(val1), rhs(val2); if (lhs.AlmostEquals(rhs)) { return AssertionSuccess(); } // Note that the above two checks will both fail if either val1 or // val2 is NaN, as the IEEE floating-point standard requires that // any predicate involving a NaN must return false. ::std::stringstream val1_ss; val1_ss << std::setprecision(std::numeric_limits::digits10 + 2) << val1; ::std::stringstream val2_ss; val2_ss << std::setprecision(std::numeric_limits::digits10 + 2) << val2; return AssertionFailure() << "Expected: (" << expr1 << ") <= (" << expr2 << ")\n" << " Actual: " << StringStreamToString(&val1_ss) << " vs " << StringStreamToString(&val2_ss); } } // namespace internal // Asserts that val1 is less than, or almost equal to, val2. Fails // otherwise. In particular, it fails if either val1 or val2 is NaN. AssertionResult FloatLE(const char* expr1, const char* expr2, float val1, float val2) { return internal::FloatingPointLE(expr1, expr2, val1, val2); } // Asserts that val1 is less than, or almost equal to, val2. Fails // otherwise. In particular, it fails if either val1 or val2 is NaN. AssertionResult DoubleLE(const char* expr1, const char* expr2, double val1, double val2) { return internal::FloatingPointLE(expr1, expr2, val1, val2); } namespace internal { // The helper function for {ASSERT|EXPECT}_EQ with int or enum // arguments. AssertionResult CmpHelperEQ(const char* expected_expression, const char* actual_expression, BiggestInt expected, BiggestInt actual) { if (expected == actual) { return AssertionSuccess(); } return EqFailure(expected_expression, actual_expression, FormatForComparisonFailureMessage(expected, actual), FormatForComparisonFailureMessage(actual, expected), false); } // A macro for implementing the helper functions needed to implement // ASSERT_?? and EXPECT_?? with integer or enum arguments. It is here // just to avoid copy-and-paste of similar code. #define GTEST_IMPL_CMP_HELPER_(op_name, op)\ AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ BiggestInt val1, BiggestInt val2) {\ if (val1 op val2) {\ return AssertionSuccess();\ } else {\ return AssertionFailure() \ << "Expected: (" << expr1 << ") " #op " (" << expr2\ << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ << " vs " << FormatForComparisonFailureMessage(val2, val1);\ }\ } // Implements the helper function for {ASSERT|EXPECT}_NE with int or // enum arguments. GTEST_IMPL_CMP_HELPER_(NE, !=) // Implements the helper function for {ASSERT|EXPECT}_LE with int or // enum arguments. GTEST_IMPL_CMP_HELPER_(LE, <=) // Implements the helper function for {ASSERT|EXPECT}_LT with int or // enum arguments. GTEST_IMPL_CMP_HELPER_(LT, < ) // Implements the helper function for {ASSERT|EXPECT}_GE with int or // enum arguments. GTEST_IMPL_CMP_HELPER_(GE, >=) // Implements the helper function for {ASSERT|EXPECT}_GT with int or // enum arguments. GTEST_IMPL_CMP_HELPER_(GT, > ) #undef GTEST_IMPL_CMP_HELPER_ // The helper function for {ASSERT|EXPECT}_STREQ. AssertionResult CmpHelperSTREQ(const char* expected_expression, const char* actual_expression, const char* expected, const char* actual) { if (String::CStringEquals(expected, actual)) { return AssertionSuccess(); } return EqFailure(expected_expression, actual_expression, PrintToString(expected), PrintToString(actual), false); } // The helper function for {ASSERT|EXPECT}_STRCASEEQ. AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, const char* actual_expression, const char* expected, const char* actual) { if (String::CaseInsensitiveCStringEquals(expected, actual)) { return AssertionSuccess(); } return EqFailure(expected_expression, actual_expression, PrintToString(expected), PrintToString(actual), true); } // The helper function for {ASSERT|EXPECT}_STRNE. AssertionResult CmpHelperSTRNE(const char* s1_expression, const char* s2_expression, const char* s1, const char* s2) { if (!String::CStringEquals(s1, s2)) { return AssertionSuccess(); } else { return AssertionFailure() << "Expected: (" << s1_expression << ") != (" << s2_expression << "), actual: \"" << s1 << "\" vs \"" << s2 << "\""; } } // The helper function for {ASSERT|EXPECT}_STRCASENE. AssertionResult CmpHelperSTRCASENE(const char* s1_expression, const char* s2_expression, const char* s1, const char* s2) { if (!String::CaseInsensitiveCStringEquals(s1, s2)) { return AssertionSuccess(); } else { return AssertionFailure() << "Expected: (" << s1_expression << ") != (" << s2_expression << ") (ignoring case), actual: \"" << s1 << "\" vs \"" << s2 << "\""; } } } // namespace internal namespace { // Helper functions for implementing IsSubString() and IsNotSubstring(). // This group of overloaded functions return true iff needle is a // substring of haystack. NULL is considered a substring of itself // only. bool IsSubstringPred(const char* needle, const char* haystack) { if (needle == NULL || haystack == NULL) return needle == haystack; return strstr(haystack, needle) != NULL; } bool IsSubstringPred(const wchar_t* needle, const wchar_t* haystack) { if (needle == NULL || haystack == NULL) return needle == haystack; return wcsstr(haystack, needle) != NULL; } // StringType here can be either ::std::string or ::std::wstring. template bool IsSubstringPred(const StringType& needle, const StringType& haystack) { return haystack.find(needle) != StringType::npos; } // This function implements either IsSubstring() or IsNotSubstring(), // depending on the value of the expected_to_be_substring parameter. // StringType here can be const char*, const wchar_t*, ::std::string, // or ::std::wstring. template AssertionResult IsSubstringImpl( bool expected_to_be_substring, const char* needle_expr, const char* haystack_expr, const StringType& needle, const StringType& haystack) { if (IsSubstringPred(needle, haystack) == expected_to_be_substring) return AssertionSuccess(); const bool is_wide_string = sizeof(needle[0]) > 1; const char* const begin_string_quote = is_wide_string ? "L\"" : "\""; return AssertionFailure() << "Value of: " << needle_expr << "\n" << " Actual: " << begin_string_quote << needle << "\"\n" << "Expected: " << (expected_to_be_substring ? "" : "not ") << "a substring of " << haystack_expr << "\n" << "Which is: " << begin_string_quote << haystack << "\""; } } // namespace // IsSubstring() and IsNotSubstring() check whether needle is a // substring of haystack (NULL is considered a substring of itself // only), and return an appropriate error message when they fail. AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const char* needle, const char* haystack) { return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); } AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack) { return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); } AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const char* needle, const char* haystack) { return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); } AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack) { return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); } AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack) { return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); } AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack) { return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); } #if GTEST_HAS_STD_WSTRING AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack) { return IsSubstringImpl(true, needle_expr, haystack_expr, needle, haystack); } AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack) { return IsSubstringImpl(false, needle_expr, haystack_expr, needle, haystack); } #endif // GTEST_HAS_STD_WSTRING namespace internal { #if GTEST_OS_WINDOWS namespace { // Helper function for IsHRESULT{SuccessFailure} predicates AssertionResult HRESULTFailureHelper(const char* expr, const char* expected, long hr) { // NOLINT # if GTEST_OS_WINDOWS_MOBILE // Windows CE doesn't support FormatMessage. const char error_text[] = ""; # else // Looks up the human-readable system message for the HRESULT code // and since we're not passing any params to FormatMessage, we don't // want inserts expanded. const DWORD kFlags = FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS; const DWORD kBufSize = 4096; // Gets the system's human readable message string for this HRESULT. char error_text[kBufSize] = { '\0' }; DWORD message_length = ::FormatMessageA(kFlags, 0, // no source, we're asking system hr, // the error 0, // no line width restrictions error_text, // output buffer kBufSize, // buf size NULL); // no arguments for inserts // Trims tailing white space (FormatMessage leaves a trailing CR-LF) for (; message_length && IsSpace(error_text[message_length - 1]); --message_length) { error_text[message_length - 1] = '\0'; } # endif // GTEST_OS_WINDOWS_MOBILE const std::string error_hex("0x" + String::FormatHexInt(hr)); return ::testing::AssertionFailure() << "Expected: " << expr << " " << expected << ".\n" << " Actual: " << error_hex << " " << error_text << "\n"; } } // namespace AssertionResult IsHRESULTSuccess(const char* expr, long hr) { // NOLINT if (SUCCEEDED(hr)) { return AssertionSuccess(); } return HRESULTFailureHelper(expr, "succeeds", hr); } AssertionResult IsHRESULTFailure(const char* expr, long hr) { // NOLINT if (FAILED(hr)) { return AssertionSuccess(); } return HRESULTFailureHelper(expr, "fails", hr); } #endif // GTEST_OS_WINDOWS // Utility functions for encoding Unicode text (wide strings) in // UTF-8. // A Unicode code-point can have upto 21 bits, and is encoded in UTF-8 // like this: // // Code-point length Encoding // 0 - 7 bits 0xxxxxxx // 8 - 11 bits 110xxxxx 10xxxxxx // 12 - 16 bits 1110xxxx 10xxxxxx 10xxxxxx // 17 - 21 bits 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx // The maximum code-point a one-byte UTF-8 sequence can represent. const UInt32 kMaxCodePoint1 = (static_cast(1) << 7) - 1; // The maximum code-point a two-byte UTF-8 sequence can represent. const UInt32 kMaxCodePoint2 = (static_cast(1) << (5 + 6)) - 1; // The maximum code-point a three-byte UTF-8 sequence can represent. const UInt32 kMaxCodePoint3 = (static_cast(1) << (4 + 2*6)) - 1; // The maximum code-point a four-byte UTF-8 sequence can represent. const UInt32 kMaxCodePoint4 = (static_cast(1) << (3 + 3*6)) - 1; // Chops off the n lowest bits from a bit pattern. Returns the n // lowest bits. As a side effect, the original bit pattern will be // shifted to the right by n bits. inline UInt32 ChopLowBits(UInt32* bits, int n) { const UInt32 low_bits = *bits & ((static_cast(1) << n) - 1); *bits >>= n; return low_bits; } // Converts a Unicode code point to a narrow string in UTF-8 encoding. // code_point parameter is of type UInt32 because wchar_t may not be // wide enough to contain a code point. // If the code_point is not a valid Unicode code point // (i.e. outside of Unicode range U+0 to U+10FFFF) it will be converted // to "(Invalid Unicode 0xXXXXXXXX)". std::string CodePointToUtf8(UInt32 code_point) { if (code_point > kMaxCodePoint4) { return "(Invalid Unicode 0x" + String::FormatHexInt(code_point) + ")"; } char str[5]; // Big enough for the largest valid code point. if (code_point <= kMaxCodePoint1) { str[1] = '\0'; str[0] = static_cast(code_point); // 0xxxxxxx } else if (code_point <= kMaxCodePoint2) { str[2] = '\0'; str[1] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx str[0] = static_cast(0xC0 | code_point); // 110xxxxx } else if (code_point <= kMaxCodePoint3) { str[3] = '\0'; str[2] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx str[1] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx str[0] = static_cast(0xE0 | code_point); // 1110xxxx } else { // code_point <= kMaxCodePoint4 str[4] = '\0'; str[3] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx str[2] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx str[1] = static_cast(0x80 | ChopLowBits(&code_point, 6)); // 10xxxxxx str[0] = static_cast(0xF0 | code_point); // 11110xxx } return str; } // The following two functions only make sense if the the system // uses UTF-16 for wide string encoding. All supported systems // with 16 bit wchar_t (Windows, Cygwin, Symbian OS) do use UTF-16. // Determines if the arguments constitute UTF-16 surrogate pair // and thus should be combined into a single Unicode code point // using CreateCodePointFromUtf16SurrogatePair. inline bool IsUtf16SurrogatePair(wchar_t first, wchar_t second) { return sizeof(wchar_t) == 2 && (first & 0xFC00) == 0xD800 && (second & 0xFC00) == 0xDC00; } // Creates a Unicode code point from UTF16 surrogate pair. inline UInt32 CreateCodePointFromUtf16SurrogatePair(wchar_t first, wchar_t second) { const UInt32 mask = (1 << 10) - 1; return (sizeof(wchar_t) == 2) ? (((first & mask) << 10) | (second & mask)) + 0x10000 : // This function should not be called when the condition is // false, but we provide a sensible default in case it is. static_cast(first); } // Converts a wide string to a narrow string in UTF-8 encoding. // The wide string is assumed to have the following encoding: // UTF-16 if sizeof(wchar_t) == 2 (on Windows, Cygwin, Symbian OS) // UTF-32 if sizeof(wchar_t) == 4 (on Linux) // Parameter str points to a null-terminated wide string. // Parameter num_chars may additionally limit the number // of wchar_t characters processed. -1 is used when the entire string // should be processed. // If the string contains code points that are not valid Unicode code points // (i.e. outside of Unicode range U+0 to U+10FFFF) they will be output // as '(Invalid Unicode 0xXXXXXXXX)'. If the string is in UTF16 encoding // and contains invalid UTF-16 surrogate pairs, values in those pairs // will be encoded as individual Unicode characters from Basic Normal Plane. std::string WideStringToUtf8(const wchar_t* str, int num_chars) { if (num_chars == -1) num_chars = static_cast(wcslen(str)); ::std::stringstream stream; for (int i = 0; i < num_chars; ++i) { UInt32 unicode_code_point; if (str[i] == L'\0') { break; } else if (i + 1 < num_chars && IsUtf16SurrogatePair(str[i], str[i + 1])) { unicode_code_point = CreateCodePointFromUtf16SurrogatePair(str[i], str[i + 1]); i++; } else { unicode_code_point = static_cast(str[i]); } stream << CodePointToUtf8(unicode_code_point); } return StringStreamToString(&stream); } // Converts a wide C string to an std::string using the UTF-8 encoding. // NULL will be converted to "(null)". std::string String::ShowWideCString(const wchar_t * wide_c_str) { if (wide_c_str == NULL) return "(null)"; return internal::WideStringToUtf8(wide_c_str, -1); } // Compares two wide C strings. Returns true iff they have the same // content. // // Unlike wcscmp(), this function can handle NULL argument(s). A NULL // C string is considered different to any non-NULL C string, // including the empty string. bool String::WideCStringEquals(const wchar_t * lhs, const wchar_t * rhs) { if (lhs == NULL) return rhs == NULL; if (rhs == NULL) return false; return wcscmp(lhs, rhs) == 0; } // Helper function for *_STREQ on wide strings. AssertionResult CmpHelperSTREQ(const char* expected_expression, const char* actual_expression, const wchar_t* expected, const wchar_t* actual) { if (String::WideCStringEquals(expected, actual)) { return AssertionSuccess(); } return EqFailure(expected_expression, actual_expression, PrintToString(expected), PrintToString(actual), false); } // Helper function for *_STRNE on wide strings. AssertionResult CmpHelperSTRNE(const char* s1_expression, const char* s2_expression, const wchar_t* s1, const wchar_t* s2) { if (!String::WideCStringEquals(s1, s2)) { return AssertionSuccess(); } return AssertionFailure() << "Expected: (" << s1_expression << ") != (" << s2_expression << "), actual: " << PrintToString(s1) << " vs " << PrintToString(s2); } // Compares two C strings, ignoring case. Returns true iff they have // the same content. // // Unlike strcasecmp(), this function can handle NULL argument(s). A // NULL C string is considered different to any non-NULL C string, // including the empty string. bool String::CaseInsensitiveCStringEquals(const char * lhs, const char * rhs) { if (lhs == NULL) return rhs == NULL; if (rhs == NULL) return false; return posix::StrCaseCmp(lhs, rhs) == 0; } // Compares two wide C strings, ignoring case. Returns true iff they // have the same content. // // Unlike wcscasecmp(), this function can handle NULL argument(s). // A NULL C string is considered different to any non-NULL wide C string, // including the empty string. // NB: The implementations on different platforms slightly differ. // On windows, this method uses _wcsicmp which compares according to LC_CTYPE // environment variable. On GNU platform this method uses wcscasecmp // which compares according to LC_CTYPE category of the current locale. // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the // current locale. bool String::CaseInsensitiveWideCStringEquals(const wchar_t* lhs, const wchar_t* rhs) { if (lhs == NULL) return rhs == NULL; if (rhs == NULL) return false; #if GTEST_OS_WINDOWS return _wcsicmp(lhs, rhs) == 0; #elif GTEST_OS_LINUX && !GTEST_OS_LINUX_ANDROID return wcscasecmp(lhs, rhs) == 0; #else // Android, Mac OS X and Cygwin don't define wcscasecmp. // Other unknown OSes may not define it either. wint_t left, right; do { left = towlower(*lhs++); right = towlower(*rhs++); } while (left && left == right); return left == right; #endif // OS selector } // Returns true iff str ends with the given suffix, ignoring case. // Any string is considered to end with an empty suffix. bool String::EndsWithCaseInsensitive( const std::string& str, const std::string& suffix) { const size_t str_len = str.length(); const size_t suffix_len = suffix.length(); return (str_len >= suffix_len) && CaseInsensitiveCStringEquals(str.c_str() + str_len - suffix_len, suffix.c_str()); } // Formats an int value as "%02d". std::string String::FormatIntWidth2(int value) { std::stringstream ss; ss << std::setfill('0') << std::setw(2) << value; return ss.str(); } // Formats an int value as "%X". std::string String::FormatHexInt(int value) { std::stringstream ss; ss << std::hex << std::uppercase << value; return ss.str(); } // Formats a byte as "%02X". std::string String::FormatByte(unsigned char value) { std::stringstream ss; ss << std::setfill('0') << std::setw(2) << std::hex << std::uppercase << static_cast(value); return ss.str(); } // Converts the buffer in a stringstream to an std::string, converting NUL // bytes to "\\0" along the way. std::string StringStreamToString(::std::stringstream* ss) { const ::std::string& str = ss->str(); const char* const start = str.c_str(); const char* const end = start + str.length(); std::string result; result.reserve(2 * (end - start)); for (const char* ch = start; ch != end; ++ch) { if (*ch == '\0') { result += "\\0"; // Replaces NUL with "\\0"; } else { result += *ch; } } return result; } // Appends the user-supplied message to the Google-Test-generated message. std::string AppendUserMessage(const std::string& gtest_msg, const Message& user_msg) { // Appends the user message if it's non-empty. const std::string user_msg_string = user_msg.GetString(); if (user_msg_string.empty()) { return gtest_msg; } return gtest_msg + "\n" + user_msg_string; } } // namespace internal // class TestResult // Creates an empty TestResult. TestResult::TestResult() : death_test_count_(0), elapsed_time_(0) { } // D'tor. TestResult::~TestResult() { } // Returns the i-th test part result among all the results. i can // range from 0 to total_part_count() - 1. If i is not in that range, // aborts the program. const TestPartResult& TestResult::GetTestPartResult(int i) const { if (i < 0 || i >= total_part_count()) internal::posix::Abort(); return test_part_results_.at(i); } // Returns the i-th test property. i can range from 0 to // test_property_count() - 1. If i is not in that range, aborts the // program. const TestProperty& TestResult::GetTestProperty(int i) const { if (i < 0 || i >= test_property_count()) internal::posix::Abort(); return test_properties_.at(i); } // Clears the test part results. void TestResult::ClearTestPartResults() { test_part_results_.clear(); } // Adds a test part result to the list. void TestResult::AddTestPartResult(const TestPartResult& test_part_result) { test_part_results_.push_back(test_part_result); } // Adds a test property to the list. If a property with the same key as the // supplied property is already represented, the value of this test_property // replaces the old value for that key. void TestResult::RecordProperty(const std::string& xml_element, const TestProperty& test_property) { if (!ValidateTestProperty(xml_element, test_property)) { return; } internal::MutexLock lock(&test_properites_mutex_); const std::vector::iterator property_with_matching_key = std::find_if(test_properties_.begin(), test_properties_.end(), internal::TestPropertyKeyIs(test_property.key())); if (property_with_matching_key == test_properties_.end()) { test_properties_.push_back(test_property); return; } property_with_matching_key->SetValue(test_property.value()); } // The list of reserved attributes used in the element of XML // output. static const char* const kReservedTestSuitesAttributes[] = { "disabled", "errors", "failures", "name", "random_seed", "tests", "time", "timestamp" }; // The list of reserved attributes used in the element of XML // output. static const char* const kReservedTestSuiteAttributes[] = { "disabled", "errors", "failures", "name", "tests", "time" }; // The list of reserved attributes used in the element of XML output. static const char* const kReservedTestCaseAttributes[] = { "classname", "name", "status", "time", "type_param", "value_param" }; template std::vector ArrayAsVector(const char* const (&array)[kSize]) { return std::vector(array, array + kSize); } static std::vector GetReservedAttributesForElement( const std::string& xml_element) { if (xml_element == "testsuites") { return ArrayAsVector(kReservedTestSuitesAttributes); } else if (xml_element == "testsuite") { return ArrayAsVector(kReservedTestSuiteAttributes); } else if (xml_element == "testcase") { return ArrayAsVector(kReservedTestCaseAttributes); } else { GTEST_CHECK_(false) << "Unrecognized xml_element provided: " << xml_element; } // This code is unreachable but some compilers may not realizes that. return std::vector(); } static std::string FormatWordList(const std::vector& words) { Message word_list; for (size_t i = 0; i < words.size(); ++i) { if (i > 0 && words.size() > 2) { word_list << ", "; } if (i == words.size() - 1) { word_list << "and "; } word_list << "'" << words[i] << "'"; } return word_list.GetString(); } bool ValidateTestPropertyName(const std::string& property_name, const std::vector& reserved_names) { if (std::find(reserved_names.begin(), reserved_names.end(), property_name) != reserved_names.end()) { ADD_FAILURE() << "Reserved key used in RecordProperty(): " << property_name << " (" << FormatWordList(reserved_names) << " are reserved by " << GTEST_NAME_ << ")"; return false; } return true; } // Adds a failure if the key is a reserved attribute of the element named // xml_element. Returns true if the property is valid. bool TestResult::ValidateTestProperty(const std::string& xml_element, const TestProperty& test_property) { return ValidateTestPropertyName(test_property.key(), GetReservedAttributesForElement(xml_element)); } // Clears the object. void TestResult::Clear() { test_part_results_.clear(); test_properties_.clear(); death_test_count_ = 0; elapsed_time_ = 0; } // Returns true iff the test failed. bool TestResult::Failed() const { for (int i = 0; i < total_part_count(); ++i) { if (GetTestPartResult(i).failed()) return true; } return false; } // Returns true iff the test part fatally failed. static bool TestPartFatallyFailed(const TestPartResult& result) { return result.fatally_failed(); } // Returns true iff the test fatally failed. bool TestResult::HasFatalFailure() const { return CountIf(test_part_results_, TestPartFatallyFailed) > 0; } // Returns true iff the test part non-fatally failed. static bool TestPartNonfatallyFailed(const TestPartResult& result) { return result.nonfatally_failed(); } // Returns true iff the test has a non-fatal failure. bool TestResult::HasNonfatalFailure() const { return CountIf(test_part_results_, TestPartNonfatallyFailed) > 0; } // Gets the number of all test parts. This is the sum of the number // of successful test parts and the number of failed test parts. int TestResult::total_part_count() const { return static_cast(test_part_results_.size()); } // Returns the number of the test properties. int TestResult::test_property_count() const { return static_cast(test_properties_.size()); } // class Test // Creates a Test object. // The c'tor saves the values of all Google Test flags. Test::Test() : gtest_flag_saver_(new internal::GTestFlagSaver) { } // The d'tor restores the values of all Google Test flags. Test::~Test() { delete gtest_flag_saver_; } // Sets up the test fixture. // // A sub-class may override this. void Test::SetUp() { } // Tears down the test fixture. // // A sub-class may override this. void Test::TearDown() { } // Allows user supplied key value pairs to be recorded for later output. void Test::RecordProperty(const std::string& key, const std::string& value) { UnitTest::GetInstance()->RecordProperty(key, value); } // Allows user supplied key value pairs to be recorded for later output. void Test::RecordProperty(const std::string& key, int value) { Message value_message; value_message << value; RecordProperty(key, value_message.GetString().c_str()); } namespace internal { void ReportFailureInUnknownLocation(TestPartResult::Type result_type, const std::string& message) { // This function is a friend of UnitTest and as such has access to // AddTestPartResult. UnitTest::GetInstance()->AddTestPartResult( result_type, NULL, // No info about the source file where the exception occurred. -1, // We have no info on which line caused the exception. message, ""); // No stack trace, either. } } // namespace internal // Google Test requires all tests in the same test case to use the same test // fixture class. This function checks if the current test has the // same fixture class as the first test in the current test case. If // yes, it returns true; otherwise it generates a Google Test failure and // returns false. bool Test::HasSameFixtureClass() { internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); const TestCase* const test_case = impl->current_test_case(); // Info about the first test in the current test case. const TestInfo* const first_test_info = test_case->test_info_list()[0]; const internal::TypeId first_fixture_id = first_test_info->fixture_class_id_; const char* const first_test_name = first_test_info->name(); // Info about the current test. const TestInfo* const this_test_info = impl->current_test_info(); const internal::TypeId this_fixture_id = this_test_info->fixture_class_id_; const char* const this_test_name = this_test_info->name(); if (this_fixture_id != first_fixture_id) { // Is the first test defined using TEST? const bool first_is_TEST = first_fixture_id == internal::GetTestTypeId(); // Is this test defined using TEST? const bool this_is_TEST = this_fixture_id == internal::GetTestTypeId(); if (first_is_TEST || this_is_TEST) { // The user mixed TEST and TEST_F in this test case - we'll tell // him/her how to fix it. // Gets the name of the TEST and the name of the TEST_F. Note // that first_is_TEST and this_is_TEST cannot both be true, as // the fixture IDs are different for the two tests. const char* const TEST_name = first_is_TEST ? first_test_name : this_test_name; const char* const TEST_F_name = first_is_TEST ? this_test_name : first_test_name; ADD_FAILURE() << "All tests in the same test case must use the same test fixture\n" << "class, so mixing TEST_F and TEST in the same test case is\n" << "illegal. In test case " << this_test_info->test_case_name() << ",\n" << "test " << TEST_F_name << " is defined using TEST_F but\n" << "test " << TEST_name << " is defined using TEST. You probably\n" << "want to change the TEST to TEST_F or move it to another test\n" << "case."; } else { // The user defined two fixture classes with the same name in // two namespaces - we'll tell him/her how to fix it. ADD_FAILURE() << "All tests in the same test case must use the same test fixture\n" << "class. However, in test case " << this_test_info->test_case_name() << ",\n" << "you defined test " << first_test_name << " and test " << this_test_name << "\n" << "using two different test fixture classes. This can happen if\n" << "the two classes are from different namespaces or translation\n" << "units and have the same name. You should probably rename one\n" << "of the classes to put the tests into different test cases."; } return false; } return true; } #if GTEST_HAS_SEH // Adds an "exception thrown" fatal failure to the current test. This // function returns its result via an output parameter pointer because VC++ // prohibits creation of objects with destructors on stack in functions // using __try (see error C2712). static std::string* FormatSehExceptionMessage(DWORD exception_code, const char* location) { Message message; message << "SEH exception with code 0x" << std::setbase(16) << exception_code << std::setbase(10) << " thrown in " << location << "."; return new std::string(message.GetString()); } #endif // GTEST_HAS_SEH namespace internal { #if GTEST_HAS_EXCEPTIONS // Adds an "exception thrown" fatal failure to the current test. static std::string FormatCxxExceptionMessage(const char* description, const char* location) { Message message; if (description != NULL) { message << "C++ exception with description \"" << description << "\""; } else { message << "Unknown C++ exception"; } message << " thrown in " << location << "."; return message.GetString(); } static std::string PrintTestPartResultToString( const TestPartResult& test_part_result); GoogleTestFailureException::GoogleTestFailureException( const TestPartResult& failure) : ::std::runtime_error(PrintTestPartResultToString(failure).c_str()) {} #endif // GTEST_HAS_EXCEPTIONS // We put these helper functions in the internal namespace as IBM's xlC // compiler rejects the code if they were declared static. // Runs the given method and handles SEH exceptions it throws, when // SEH is supported; returns the 0-value for type Result in case of an // SEH exception. (Microsoft compilers cannot handle SEH and C++ // exceptions in the same function. Therefore, we provide a separate // wrapper function for handling SEH exceptions.) template Result HandleSehExceptionsInMethodIfSupported( T* object, Result (T::*method)(), const char* location) { #if GTEST_HAS_SEH __try { return (object->*method)(); } __except (internal::UnitTestOptions::GTestShouldProcessSEH( // NOLINT GetExceptionCode())) { // We create the exception message on the heap because VC++ prohibits // creation of objects with destructors on stack in functions using __try // (see error C2712). std::string* exception_message = FormatSehExceptionMessage( GetExceptionCode(), location); internal::ReportFailureInUnknownLocation(TestPartResult::kFatalFailure, *exception_message); delete exception_message; return static_cast(0); } #else (void)location; return (object->*method)(); #endif // GTEST_HAS_SEH } // Runs the given method and catches and reports C++ and/or SEH-style // exceptions, if they are supported; returns the 0-value for type // Result in case of an SEH exception. template Result HandleExceptionsInMethodIfSupported( T* object, Result (T::*method)(), const char* location) { // NOTE: The user code can affect the way in which Google Test handles // exceptions by setting GTEST_FLAG(catch_exceptions), but only before // RUN_ALL_TESTS() starts. It is technically possible to check the flag // after the exception is caught and either report or re-throw the // exception based on the flag's value: // // try { // // Perform the test method. // } catch (...) { // if (GTEST_FLAG(catch_exceptions)) // // Report the exception as failure. // else // throw; // Re-throws the original exception. // } // // However, the purpose of this flag is to allow the program to drop into // the debugger when the exception is thrown. On most platforms, once the // control enters the catch block, the exception origin information is // lost and the debugger will stop the program at the point of the // re-throw in this function -- instead of at the point of the original // throw statement in the code under test. For this reason, we perform // the check early, sacrificing the ability to affect Google Test's // exception handling in the method where the exception is thrown. if (internal::GetUnitTestImpl()->catch_exceptions()) { #if GTEST_HAS_EXCEPTIONS try { return HandleSehExceptionsInMethodIfSupported(object, method, location); } catch (const internal::GoogleTestFailureException&) { // NOLINT // This exception type can only be thrown by a failed Google // Test assertion with the intention of letting another testing // framework catch it. Therefore we just re-throw it. throw; } catch (const std::exception& e) { // NOLINT internal::ReportFailureInUnknownLocation( TestPartResult::kFatalFailure, FormatCxxExceptionMessage(e.what(), location)); } catch (...) { // NOLINT internal::ReportFailureInUnknownLocation( TestPartResult::kFatalFailure, FormatCxxExceptionMessage(NULL, location)); } return static_cast(0); #else return HandleSehExceptionsInMethodIfSupported(object, method, location); #endif // GTEST_HAS_EXCEPTIONS } else { return (object->*method)(); } } } // namespace internal // Runs the test and updates the test result. void Test::Run() { if (!HasSameFixtureClass()) return; internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported(this, &Test::SetUp, "SetUp()"); // We will run the test only if SetUp() was successful. if (!HasFatalFailure()) { impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported( this, &Test::TestBody, "the test body"); } // However, we want to clean up as much as possible. Hence we will // always call TearDown(), even if SetUp() or the test body has // failed. impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported( this, &Test::TearDown, "TearDown()"); } // Returns true iff the current test has a fatal failure. bool Test::HasFatalFailure() { return internal::GetUnitTestImpl()->current_test_result()->HasFatalFailure(); } // Returns true iff the current test has a non-fatal failure. bool Test::HasNonfatalFailure() { return internal::GetUnitTestImpl()->current_test_result()-> HasNonfatalFailure(); } // class TestInfo // Constructs a TestInfo object. It assumes ownership of the test factory // object. TestInfo::TestInfo(const std::string& a_test_case_name, const std::string& a_name, const char* a_type_param, const char* a_value_param, internal::TypeId fixture_class_id, internal::TestFactoryBase* factory) : test_case_name_(a_test_case_name), name_(a_name), type_param_(a_type_param ? new std::string(a_type_param) : NULL), value_param_(a_value_param ? new std::string(a_value_param) : NULL), fixture_class_id_(fixture_class_id), should_run_(false), is_disabled_(false), matches_filter_(false), factory_(factory), result_() {} // Destructs a TestInfo object. TestInfo::~TestInfo() { delete factory_; } namespace internal { // Creates a new TestInfo object and registers it with Google Test; // returns the created object. // // Arguments: // // test_case_name: name of the test case // name: name of the test // type_param: the name of the test's type parameter, or NULL if // this is not a typed or a type-parameterized test. // value_param: text representation of the test's value parameter, // or NULL if this is not a value-parameterized test. // fixture_class_id: ID of the test fixture class // set_up_tc: pointer to the function that sets up the test case // tear_down_tc: pointer to the function that tears down the test case // factory: pointer to the factory that creates a test object. // The newly created TestInfo instance will assume // ownership of the factory object. TestInfo* MakeAndRegisterTestInfo( const char* test_case_name, const char* name, const char* type_param, const char* value_param, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase* factory) { TestInfo* const test_info = new TestInfo(test_case_name, name, type_param, value_param, fixture_class_id, factory); GetUnitTestImpl()->AddTestInfo(set_up_tc, tear_down_tc, test_info); return test_info; } #if GTEST_HAS_PARAM_TEST void ReportInvalidTestCaseType(const char* test_case_name, const char* file, int line) { Message errors; errors << "Attempted redefinition of test case " << test_case_name << ".\n" << "All tests in the same test case must use the same test fixture\n" << "class. However, in test case " << test_case_name << ", you tried\n" << "to define a test using a fixture class different from the one\n" << "used earlier. This can happen if the two fixture classes are\n" << "from different namespaces and have the same name. You should\n" << "probably rename one of the classes to put the tests into different\n" << "test cases."; fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), errors.GetString().c_str()); } #endif // GTEST_HAS_PARAM_TEST } // namespace internal namespace { // A predicate that checks the test name of a TestInfo against a known // value. // // This is used for implementation of the TestCase class only. We put // it in the anonymous namespace to prevent polluting the outer // namespace. // // TestNameIs is copyable. class TestNameIs { public: // Constructor. // // TestNameIs has NO default constructor. explicit TestNameIs(const char* name) : name_(name) {} // Returns true iff the test name of test_info matches name_. bool operator()(const TestInfo * test_info) const { return test_info && test_info->name() == name_; } private: std::string name_; }; } // namespace namespace internal { // This method expands all parameterized tests registered with macros TEST_P // and INSTANTIATE_TEST_CASE_P into regular tests and registers those. // This will be done just once during the program runtime. void UnitTestImpl::RegisterParameterizedTests() { #if GTEST_HAS_PARAM_TEST if (!parameterized_tests_registered_) { parameterized_test_registry_.RegisterTests(); parameterized_tests_registered_ = true; } #endif } } // namespace internal // Creates the test object, runs it, records its result, and then // deletes it. void TestInfo::Run() { if (!should_run_) return; // Tells UnitTest where to store test result. internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); impl->set_current_test_info(this); TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); // Notifies the unit test event listeners that a test is about to start. repeater->OnTestStart(*this); const TimeInMillis start = internal::GetTimeInMillis(); impl->os_stack_trace_getter()->UponLeavingGTest(); // Creates the test object. Test* const test = internal::HandleExceptionsInMethodIfSupported( factory_, &internal::TestFactoryBase::CreateTest, "the test fixture's constructor"); // Runs the test only if the test object was created and its // constructor didn't generate a fatal failure. if ((test != NULL) && !Test::HasFatalFailure()) { // This doesn't throw as all user code that can throw are wrapped into // exception handling code. test->Run(); } // Deletes the test object. impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported( test, &Test::DeleteSelf_, "the test fixture's destructor"); result_.set_elapsed_time(internal::GetTimeInMillis() - start); // Notifies the unit test event listener that a test has just finished. repeater->OnTestEnd(*this); // Tells UnitTest to stop associating assertion results to this // test. impl->set_current_test_info(NULL); } // class TestCase // Gets the number of successful tests in this test case. int TestCase::successful_test_count() const { return CountIf(test_info_list_, TestPassed); } // Gets the number of failed tests in this test case. int TestCase::failed_test_count() const { return CountIf(test_info_list_, TestFailed); } // Gets the number of disabled tests that will be reported in the XML report. int TestCase::reportable_disabled_test_count() const { return CountIf(test_info_list_, TestReportableDisabled); } // Gets the number of disabled tests in this test case. int TestCase::disabled_test_count() const { return CountIf(test_info_list_, TestDisabled); } // Gets the number of tests to be printed in the XML report. int TestCase::reportable_test_count() const { return CountIf(test_info_list_, TestReportable); } // Get the number of tests in this test case that should run. int TestCase::test_to_run_count() const { return CountIf(test_info_list_, ShouldRunTest); } // Gets the number of all tests. int TestCase::total_test_count() const { return static_cast(test_info_list_.size()); } // Creates a TestCase with the given name. // // Arguments: // // name: name of the test case // a_type_param: the name of the test case's type parameter, or NULL if // this is not a typed or a type-parameterized test case. // set_up_tc: pointer to the function that sets up the test case // tear_down_tc: pointer to the function that tears down the test case TestCase::TestCase(const char* a_name, const char* a_type_param, Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc) : name_(a_name), type_param_(a_type_param ? new std::string(a_type_param) : NULL), set_up_tc_(set_up_tc), tear_down_tc_(tear_down_tc), should_run_(false), elapsed_time_(0) { } // Destructor of TestCase. TestCase::~TestCase() { // Deletes every Test in the collection. ForEach(test_info_list_, internal::Delete); } // Returns the i-th test among all the tests. i can range from 0 to // total_test_count() - 1. If i is not in that range, returns NULL. const TestInfo* TestCase::GetTestInfo(int i) const { const int index = GetElementOr(test_indices_, i, -1); return index < 0 ? NULL : test_info_list_[index]; } // Returns the i-th test among all the tests. i can range from 0 to // total_test_count() - 1. If i is not in that range, returns NULL. TestInfo* TestCase::GetMutableTestInfo(int i) { const int index = GetElementOr(test_indices_, i, -1); return index < 0 ? NULL : test_info_list_[index]; } // Adds a test to this test case. Will delete the test upon // destruction of the TestCase object. void TestCase::AddTestInfo(TestInfo * test_info) { test_info_list_.push_back(test_info); test_indices_.push_back(static_cast(test_indices_.size())); } // Runs every test in this TestCase. void TestCase::Run() { if (!should_run_) return; internal::UnitTestImpl* const impl = internal::GetUnitTestImpl(); impl->set_current_test_case(this); TestEventListener* repeater = UnitTest::GetInstance()->listeners().repeater(); repeater->OnTestCaseStart(*this); impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported( this, &TestCase::RunSetUpTestCase, "SetUpTestCase()"); const internal::TimeInMillis start = internal::GetTimeInMillis(); for (int i = 0; i < total_test_count(); i++) { GetMutableTestInfo(i)->Run(); } elapsed_time_ = internal::GetTimeInMillis() - start; impl->os_stack_trace_getter()->UponLeavingGTest(); internal::HandleExceptionsInMethodIfSupported( this, &TestCase::RunTearDownTestCase, "TearDownTestCase()"); repeater->OnTestCaseEnd(*this); impl->set_current_test_case(NULL); } // Clears the results of all tests in this test case. void TestCase::ClearResult() { ad_hoc_test_result_.Clear(); ForEach(test_info_list_, TestInfo::ClearTestResult); } // Shuffles the tests in this test case. void TestCase::ShuffleTests(internal::Random* random) { Shuffle(random, &test_indices_); } // Restores the test order to before the first shuffle. void TestCase::UnshuffleTests() { for (size_t i = 0; i < test_indices_.size(); i++) { test_indices_[i] = static_cast(i); } } // Formats a countable noun. Depending on its quantity, either the // singular form or the plural form is used. e.g. // // FormatCountableNoun(1, "formula", "formuli") returns "1 formula". // FormatCountableNoun(5, "book", "books") returns "5 books". static std::string FormatCountableNoun(int count, const char * singular_form, const char * plural_form) { return internal::StreamableToString(count) + " " + (count == 1 ? singular_form : plural_form); } // Formats the count of tests. static std::string FormatTestCount(int test_count) { return FormatCountableNoun(test_count, "test", "tests"); } // Formats the count of test cases. static std::string FormatTestCaseCount(int test_case_count) { return FormatCountableNoun(test_case_count, "test case", "test cases"); } // Converts a TestPartResult::Type enum to human-friendly string // representation. Both kNonFatalFailure and kFatalFailure are translated // to "Failure", as the user usually doesn't care about the difference // between the two when viewing the test result. static const char * TestPartResultTypeToString(TestPartResult::Type type) { switch (type) { case TestPartResult::kSuccess: return "Success"; case TestPartResult::kNonFatalFailure: case TestPartResult::kFatalFailure: #ifdef _MSC_VER return "error: "; #else return "Failure\n"; #endif default: return "Unknown result type"; } } namespace internal { // Prints a TestPartResult to an std::string. static std::string PrintTestPartResultToString( const TestPartResult& test_part_result) { return (Message() << internal::FormatFileLocation(test_part_result.file_name(), test_part_result.line_number()) << " " << TestPartResultTypeToString(test_part_result.type()) << test_part_result.message()).GetString(); } // Prints a TestPartResult. static void PrintTestPartResult(const TestPartResult& test_part_result) { const std::string& result = PrintTestPartResultToString(test_part_result); printf("%s\n", result.c_str()); fflush(stdout); // If the test program runs in Visual Studio or a debugger, the // following statements add the test part result message to the Output // window such that the user can double-click on it to jump to the // corresponding source code location; otherwise they do nothing. #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE // We don't call OutputDebugString*() on Windows Mobile, as printing // to stdout is done by OutputDebugString() there already - we don't // want the same message printed twice. ::OutputDebugStringA(result.c_str()); ::OutputDebugStringA("\n"); #endif } // class PrettyUnitTestResultPrinter enum GTestColor { COLOR_DEFAULT, COLOR_RED, COLOR_GREEN, COLOR_YELLOW }; #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE // Returns the character attribute for the given color. WORD GetColorAttribute(GTestColor color) { switch (color) { case COLOR_RED: return FOREGROUND_RED; case COLOR_GREEN: return FOREGROUND_GREEN; case COLOR_YELLOW: return FOREGROUND_RED | FOREGROUND_GREEN; default: return 0; } } #else // Returns the ANSI color code for the given color. COLOR_DEFAULT is // an invalid input. const char* GetAnsiColorCode(GTestColor color) { switch (color) { case COLOR_RED: return "1"; case COLOR_GREEN: return "2"; case COLOR_YELLOW: return "3"; default: return NULL; }; } #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE // Returns true iff Google Test should use colors in the output. bool ShouldUseColor(bool stdout_is_tty) { const char* const gtest_color = GTEST_FLAG(color).c_str(); if (String::CaseInsensitiveCStringEquals(gtest_color, "auto")) { #if GTEST_OS_WINDOWS // On Windows the TERM variable is usually not set, but the // console there does support colors. return stdout_is_tty; #else // On non-Windows platforms, we rely on the TERM variable. const char* const term = posix::GetEnv("TERM"); const bool term_supports_color = String::CStringEquals(term, "xterm") || String::CStringEquals(term, "xterm-color") || String::CStringEquals(term, "xterm-256color") || String::CStringEquals(term, "screen") || String::CStringEquals(term, "screen-256color") || String::CStringEquals(term, "linux") || String::CStringEquals(term, "cygwin"); return stdout_is_tty && term_supports_color; #endif // GTEST_OS_WINDOWS } return String::CaseInsensitiveCStringEquals(gtest_color, "yes") || String::CaseInsensitiveCStringEquals(gtest_color, "true") || String::CaseInsensitiveCStringEquals(gtest_color, "t") || String::CStringEquals(gtest_color, "1"); // We take "yes", "true", "t", and "1" as meaning "yes". If the // value is neither one of these nor "auto", we treat it as "no" to // be conservative. } // Helpers for printing colored strings to stdout. Note that on Windows, we // cannot simply emit special characters and have the terminal change colors. // This routine must actually emit the characters rather than return a string // that would be colored when printed, as can be done on Linux. void ColoredPrintf(GTestColor color, const char* fmt, ...) { va_list args; va_start(args, fmt); #if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS || GTEST_OS_IOS const bool use_color = false; #else static const bool in_color_mode = ShouldUseColor(posix::IsATTY(posix::FileNo(stdout)) != 0); const bool use_color = in_color_mode && (color != COLOR_DEFAULT); #endif // GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN || GTEST_OS_ZOS // The '!= 0' comparison is necessary to satisfy MSVC 7.1. if (!use_color) { vprintf(fmt, args); va_end(args); return; } #if GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE const HANDLE stdout_handle = GetStdHandle(STD_OUTPUT_HANDLE); // Gets the current text color. CONSOLE_SCREEN_BUFFER_INFO buffer_info; GetConsoleScreenBufferInfo(stdout_handle, &buffer_info); const WORD old_color_attrs = buffer_info.wAttributes; // We need to flush the stream buffers into the console before each // SetConsoleTextAttribute call lest it affect the text that is already // printed but has not yet reached the console. fflush(stdout); SetConsoleTextAttribute(stdout_handle, GetColorAttribute(color) | FOREGROUND_INTENSITY); vprintf(fmt, args); fflush(stdout); // Restores the text color. SetConsoleTextAttribute(stdout_handle, old_color_attrs); #else printf("\033[0;3%sm", GetAnsiColorCode(color)); vprintf(fmt, args); printf("\033[m"); // Resets the terminal to default. #endif // GTEST_OS_WINDOWS && !GTEST_OS_WINDOWS_MOBILE va_end(args); } // Text printed in Google Test's text output and --gunit_list_tests // output to label the type parameter and value parameter for a test. static const char kTypeParamLabel[] = "TypeParam"; static const char kValueParamLabel[] = "GetParam()"; void PrintFullTestCommentIfPresent(const TestInfo& test_info) { const char* const type_param = test_info.type_param(); const char* const value_param = test_info.value_param(); if (type_param != NULL || value_param != NULL) { printf(", where "); if (type_param != NULL) { printf("%s = %s", kTypeParamLabel, type_param); if (value_param != NULL) printf(" and "); } if (value_param != NULL) { printf("%s = %s", kValueParamLabel, value_param); } } } // This class implements the TestEventListener interface. // // Class PrettyUnitTestResultPrinter is copyable. class PrettyUnitTestResultPrinter : public TestEventListener { public: PrettyUnitTestResultPrinter() {} static void PrintTestName(const char * test_case, const char * test) { printf("%s.%s", test_case, test); } // The following methods override what's in the TestEventListener class. virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} virtual void OnTestCaseStart(const TestCase& test_case); virtual void OnTestStart(const TestInfo& test_info); virtual void OnTestPartResult(const TestPartResult& result); virtual void OnTestEnd(const TestInfo& test_info); virtual void OnTestCaseEnd(const TestCase& test_case); virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} private: static void PrintFailedTests(const UnitTest& unit_test); }; // Fired before each iteration of tests starts. void PrettyUnitTestResultPrinter::OnTestIterationStart( const UnitTest& unit_test, int iteration) { if (GTEST_FLAG(repeat) != 1) printf("\nRepeating all tests (iteration %d) . . .\n\n", iteration + 1); const char* const filter = GTEST_FLAG(filter).c_str(); // Prints the filter if it's not *. This reminds the user that some // tests may be skipped. if (!String::CStringEquals(filter, kUniversalFilter)) { ColoredPrintf(COLOR_YELLOW, "Note: %s filter = %s\n", GTEST_NAME_, filter); } if (internal::ShouldShard(kTestTotalShards, kTestShardIndex, false)) { const Int32 shard_index = Int32FromEnvOrDie(kTestShardIndex, -1); ColoredPrintf(COLOR_YELLOW, "Note: This is test shard %d of %s.\n", static_cast(shard_index) + 1, internal::posix::GetEnv(kTestTotalShards)); } if (GTEST_FLAG(shuffle)) { ColoredPrintf(COLOR_YELLOW, "Note: Randomizing tests' orders with a seed of %d .\n", unit_test.random_seed()); } ColoredPrintf(COLOR_GREEN, "[==========] "); printf("Running %s from %s.\n", FormatTestCount(unit_test.test_to_run_count()).c_str(), FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); fflush(stdout); } void PrettyUnitTestResultPrinter::OnEnvironmentsSetUpStart( const UnitTest& /*unit_test*/) { ColoredPrintf(COLOR_GREEN, "[----------] "); printf("Global test environment set-up.\n"); fflush(stdout); } void PrettyUnitTestResultPrinter::OnTestCaseStart(const TestCase& test_case) { const std::string counts = FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); ColoredPrintf(COLOR_GREEN, "[----------] "); printf("%s from %s", counts.c_str(), test_case.name()); if (test_case.type_param() == NULL) { printf("\n"); } else { printf(", where %s = %s\n", kTypeParamLabel, test_case.type_param()); } fflush(stdout); } void PrettyUnitTestResultPrinter::OnTestStart(const TestInfo& test_info) { ColoredPrintf(COLOR_GREEN, "[ RUN ] "); PrintTestName(test_info.test_case_name(), test_info.name()); printf("\n"); fflush(stdout); } // Called after an assertion failure. void PrettyUnitTestResultPrinter::OnTestPartResult( const TestPartResult& result) { // If the test part succeeded, we don't need to do anything. if (result.type() == TestPartResult::kSuccess) return; // Print failure message from the assertion (e.g. expected this and got that). PrintTestPartResult(result); fflush(stdout); } void PrettyUnitTestResultPrinter::OnTestEnd(const TestInfo& test_info) { if (test_info.result()->Passed()) { ColoredPrintf(COLOR_GREEN, "[ OK ] "); } else { ColoredPrintf(COLOR_RED, "[ FAILED ] "); } PrintTestName(test_info.test_case_name(), test_info.name()); if (test_info.result()->Failed()) PrintFullTestCommentIfPresent(test_info); if (GTEST_FLAG(print_time)) { printf(" (%s ms)\n", internal::StreamableToString( test_info.result()->elapsed_time()).c_str()); } else { printf("\n"); } fflush(stdout); } void PrettyUnitTestResultPrinter::OnTestCaseEnd(const TestCase& test_case) { if (!GTEST_FLAG(print_time)) return; const std::string counts = FormatCountableNoun(test_case.test_to_run_count(), "test", "tests"); ColoredPrintf(COLOR_GREEN, "[----------] "); printf("%s from %s (%s ms total)\n\n", counts.c_str(), test_case.name(), internal::StreamableToString(test_case.elapsed_time()).c_str()); fflush(stdout); } void PrettyUnitTestResultPrinter::OnEnvironmentsTearDownStart( const UnitTest& /*unit_test*/) { ColoredPrintf(COLOR_GREEN, "[----------] "); printf("Global test environment tear-down\n"); fflush(stdout); } // Internal helper for printing the list of failed tests. void PrettyUnitTestResultPrinter::PrintFailedTests(const UnitTest& unit_test) { const int failed_test_count = unit_test.failed_test_count(); if (failed_test_count == 0) { return; } for (int i = 0; i < unit_test.total_test_case_count(); ++i) { const TestCase& test_case = *unit_test.GetTestCase(i); if (!test_case.should_run() || (test_case.failed_test_count() == 0)) { continue; } for (int j = 0; j < test_case.total_test_count(); ++j) { const TestInfo& test_info = *test_case.GetTestInfo(j); if (!test_info.should_run() || test_info.result()->Passed()) { continue; } ColoredPrintf(COLOR_RED, "[ FAILED ] "); printf("%s.%s", test_case.name(), test_info.name()); PrintFullTestCommentIfPresent(test_info); printf("\n"); } } } void PrettyUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, int /*iteration*/) { ColoredPrintf(COLOR_GREEN, "[==========] "); printf("%s from %s ran.", FormatTestCount(unit_test.test_to_run_count()).c_str(), FormatTestCaseCount(unit_test.test_case_to_run_count()).c_str()); if (GTEST_FLAG(print_time)) { printf(" (%s ms total)", internal::StreamableToString(unit_test.elapsed_time()).c_str()); } printf("\n"); ColoredPrintf(COLOR_GREEN, "[ PASSED ] "); printf("%s.\n", FormatTestCount(unit_test.successful_test_count()).c_str()); int num_failures = unit_test.failed_test_count(); if (!unit_test.Passed()) { const int failed_test_count = unit_test.failed_test_count(); ColoredPrintf(COLOR_RED, "[ FAILED ] "); printf("%s, listed below:\n", FormatTestCount(failed_test_count).c_str()); PrintFailedTests(unit_test); printf("\n%2d FAILED %s\n", num_failures, num_failures == 1 ? "TEST" : "TESTS"); } int num_disabled = unit_test.reportable_disabled_test_count(); if (num_disabled && !GTEST_FLAG(also_run_disabled_tests)) { if (!num_failures) { printf("\n"); // Add a spacer if no FAILURE banner is displayed. } ColoredPrintf(COLOR_YELLOW, " YOU HAVE %d DISABLED %s\n\n", num_disabled, num_disabled == 1 ? "TEST" : "TESTS"); } // Ensure that Google Test output is printed before, e.g., heapchecker output. fflush(stdout); } // End PrettyUnitTestResultPrinter // class TestEventRepeater // // This class forwards events to other event listeners. class TestEventRepeater : public TestEventListener { public: TestEventRepeater() : forwarding_enabled_(true) {} virtual ~TestEventRepeater(); void Append(TestEventListener *listener); TestEventListener* Release(TestEventListener* listener); // Controls whether events will be forwarded to listeners_. Set to false // in death test child processes. bool forwarding_enabled() const { return forwarding_enabled_; } void set_forwarding_enabled(bool enable) { forwarding_enabled_ = enable; } virtual void OnTestProgramStart(const UnitTest& unit_test); virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration); virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test); virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test); virtual void OnTestCaseStart(const TestCase& test_case); virtual void OnTestStart(const TestInfo& test_info); virtual void OnTestPartResult(const TestPartResult& result); virtual void OnTestEnd(const TestInfo& test_info); virtual void OnTestCaseEnd(const TestCase& test_case); virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test); virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test); virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); virtual void OnTestProgramEnd(const UnitTest& unit_test); private: // Controls whether events will be forwarded to listeners_. Set to false // in death test child processes. bool forwarding_enabled_; // The list of listeners that receive events. std::vector listeners_; GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventRepeater); }; TestEventRepeater::~TestEventRepeater() { ForEach(listeners_, Delete); } void TestEventRepeater::Append(TestEventListener *listener) { listeners_.push_back(listener); } // TODO(vladl@google.com): Factor the search functionality into Vector::Find. TestEventListener* TestEventRepeater::Release(TestEventListener *listener) { for (size_t i = 0; i < listeners_.size(); ++i) { if (listeners_[i] == listener) { listeners_.erase(listeners_.begin() + i); return listener; } } return NULL; } // Since most methods are very similar, use macros to reduce boilerplate. // This defines a member that forwards the call to all listeners. #define GTEST_REPEATER_METHOD_(Name, Type) \ void TestEventRepeater::Name(const Type& parameter) { \ if (forwarding_enabled_) { \ for (size_t i = 0; i < listeners_.size(); i++) { \ listeners_[i]->Name(parameter); \ } \ } \ } // This defines a member that forwards the call to all listeners in reverse // order. #define GTEST_REVERSE_REPEATER_METHOD_(Name, Type) \ void TestEventRepeater::Name(const Type& parameter) { \ if (forwarding_enabled_) { \ for (int i = static_cast(listeners_.size()) - 1; i >= 0; i--) { \ listeners_[i]->Name(parameter); \ } \ } \ } GTEST_REPEATER_METHOD_(OnTestProgramStart, UnitTest) GTEST_REPEATER_METHOD_(OnEnvironmentsSetUpStart, UnitTest) GTEST_REPEATER_METHOD_(OnTestCaseStart, TestCase) GTEST_REPEATER_METHOD_(OnTestStart, TestInfo) GTEST_REPEATER_METHOD_(OnTestPartResult, TestPartResult) GTEST_REPEATER_METHOD_(OnEnvironmentsTearDownStart, UnitTest) GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsSetUpEnd, UnitTest) GTEST_REVERSE_REPEATER_METHOD_(OnEnvironmentsTearDownEnd, UnitTest) GTEST_REVERSE_REPEATER_METHOD_(OnTestEnd, TestInfo) GTEST_REVERSE_REPEATER_METHOD_(OnTestCaseEnd, TestCase) GTEST_REVERSE_REPEATER_METHOD_(OnTestProgramEnd, UnitTest) #undef GTEST_REPEATER_METHOD_ #undef GTEST_REVERSE_REPEATER_METHOD_ void TestEventRepeater::OnTestIterationStart(const UnitTest& unit_test, int iteration) { if (forwarding_enabled_) { for (size_t i = 0; i < listeners_.size(); i++) { listeners_[i]->OnTestIterationStart(unit_test, iteration); } } } void TestEventRepeater::OnTestIterationEnd(const UnitTest& unit_test, int iteration) { if (forwarding_enabled_) { for (int i = static_cast(listeners_.size()) - 1; i >= 0; i--) { listeners_[i]->OnTestIterationEnd(unit_test, iteration); } } } // End TestEventRepeater // This class generates an XML output file. class XmlUnitTestResultPrinter : public EmptyTestEventListener { public: explicit XmlUnitTestResultPrinter(const char* output_file); virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration); private: // Is c a whitespace character that is normalized to a space character // when it appears in an XML attribute value? static bool IsNormalizableWhitespace(char c) { return c == 0x9 || c == 0xA || c == 0xD; } // May c appear in a well-formed XML document? static bool IsValidXmlCharacter(char c) { return IsNormalizableWhitespace(c) || c >= 0x20; } // Returns an XML-escaped copy of the input string str. If // is_attribute is true, the text is meant to appear as an attribute // value, and normalizable whitespace is preserved by replacing it // with character references. static std::string EscapeXml(const std::string& str, bool is_attribute); // Returns the given string with all characters invalid in XML removed. static std::string RemoveInvalidXmlCharacters(const std::string& str); // Convenience wrapper around EscapeXml when str is an attribute value. static std::string EscapeXmlAttribute(const std::string& str) { return EscapeXml(str, true); } // Convenience wrapper around EscapeXml when str is not an attribute value. static std::string EscapeXmlText(const char* str) { return EscapeXml(str, false); } // Verifies that the given attribute belongs to the given element and // streams the attribute as XML. static void OutputXmlAttribute(std::ostream* stream, const std::string& element_name, const std::string& name, const std::string& value); // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. static void OutputXmlCDataSection(::std::ostream* stream, const char* data); // Streams an XML representation of a TestInfo object. static void OutputXmlTestInfo(::std::ostream* stream, const char* test_case_name, const TestInfo& test_info); // Prints an XML representation of a TestCase object static void PrintXmlTestCase(::std::ostream* stream, const TestCase& test_case); // Prints an XML summary of unit_test to output stream out. static void PrintXmlUnitTest(::std::ostream* stream, const UnitTest& unit_test); // Produces a string representing the test properties in a result as space // delimited XML attributes based on the property key="value" pairs. // When the std::string is not empty, it includes a space at the beginning, // to delimit this attribute from prior attributes. static std::string TestPropertiesAsXmlAttributes(const TestResult& result); // The output file. const std::string output_file_; GTEST_DISALLOW_COPY_AND_ASSIGN_(XmlUnitTestResultPrinter); }; // Creates a new XmlUnitTestResultPrinter. XmlUnitTestResultPrinter::XmlUnitTestResultPrinter(const char* output_file) : output_file_(output_file) { if (output_file_.c_str() == NULL || output_file_.empty()) { fprintf(stderr, "XML output file may not be null\n"); fflush(stderr); exit(EXIT_FAILURE); } } // Called after the unit test ends. void XmlUnitTestResultPrinter::OnTestIterationEnd(const UnitTest& unit_test, int /*iteration*/) { FILE* xmlout = NULL; FilePath output_file(output_file_); FilePath output_dir(output_file.RemoveFileName()); if (output_dir.CreateDirectoriesRecursively()) { xmlout = posix::FOpen(output_file_.c_str(), "w"); } if (xmlout == NULL) { // TODO(wan): report the reason of the failure. // // We don't do it for now as: // // 1. There is no urgent need for it. // 2. It's a bit involved to make the errno variable thread-safe on // all three operating systems (Linux, Windows, and Mac OS). // 3. To interpret the meaning of errno in a thread-safe way, // we need the strerror_r() function, which is not available on // Windows. fprintf(stderr, "Unable to open file \"%s\"\n", output_file_.c_str()); fflush(stderr); exit(EXIT_FAILURE); } std::stringstream stream; PrintXmlUnitTest(&stream, unit_test); fprintf(xmlout, "%s", StringStreamToString(&stream).c_str()); fclose(xmlout); } // Returns an XML-escaped copy of the input string str. If is_attribute // is true, the text is meant to appear as an attribute value, and // normalizable whitespace is preserved by replacing it with character // references. // // Invalid XML characters in str, if any, are stripped from the output. // It is expected that most, if not all, of the text processed by this // module will consist of ordinary English text. // If this module is ever modified to produce version 1.1 XML output, // most invalid characters can be retained using character references. // TODO(wan): It might be nice to have a minimally invasive, human-readable // escaping scheme for invalid characters, rather than dropping them. std::string XmlUnitTestResultPrinter::EscapeXml( const std::string& str, bool is_attribute) { Message m; for (size_t i = 0; i < str.size(); ++i) { const char ch = str[i]; switch (ch) { case '<': m << "<"; break; case '>': m << ">"; break; case '&': m << "&"; break; case '\'': if (is_attribute) m << "'"; else m << '\''; break; case '"': if (is_attribute) m << """; else m << '"'; break; default: if (IsValidXmlCharacter(ch)) { if (is_attribute && IsNormalizableWhitespace(ch)) m << "&#x" << String::FormatByte(static_cast(ch)) << ";"; else m << ch; } break; } } return m.GetString(); } // Returns the given string with all characters invalid in XML removed. // Currently invalid characters are dropped from the string. An // alternative is to replace them with certain characters such as . or ?. std::string XmlUnitTestResultPrinter::RemoveInvalidXmlCharacters( const std::string& str) { std::string output; output.reserve(str.size()); for (std::string::const_iterator it = str.begin(); it != str.end(); ++it) if (IsValidXmlCharacter(*it)) output.push_back(*it); return output; } // The following routines generate an XML representation of a UnitTest // object. // // This is how Google Test concepts map to the DTD: // // <-- corresponds to a UnitTest object // <-- corresponds to a TestCase object // <-- corresponds to a TestInfo object // ... // ... // ... // <-- individual assertion failures // // // // Formats the given time in milliseconds as seconds. std::string FormatTimeInMillisAsSeconds(TimeInMillis ms) { ::std::stringstream ss; ss << ms/1000.0; return ss.str(); } // Converts the given epoch time in milliseconds to a date string in the ISO // 8601 format, without the timezone information. std::string FormatEpochTimeInMillisAsIso8601(TimeInMillis ms) { // Using non-reentrant version as localtime_r is not portable. time_t seconds = static_cast(ms / 1000); #ifdef _MSC_VER # pragma warning(push) // Saves the current warning state. # pragma warning(disable:4996) // Temporarily disables warning 4996 // (function or variable may be unsafe). const struct tm* const time_struct = localtime(&seconds); // NOLINT # pragma warning(pop) // Restores the warning state again. #else const struct tm* const time_struct = localtime(&seconds); // NOLINT #endif if (time_struct == NULL) return ""; // Invalid ms value // YYYY-MM-DDThh:mm:ss return StreamableToString(time_struct->tm_year + 1900) + "-" + String::FormatIntWidth2(time_struct->tm_mon + 1) + "-" + String::FormatIntWidth2(time_struct->tm_mday) + "T" + String::FormatIntWidth2(time_struct->tm_hour) + ":" + String::FormatIntWidth2(time_struct->tm_min) + ":" + String::FormatIntWidth2(time_struct->tm_sec); } // Streams an XML CDATA section, escaping invalid CDATA sequences as needed. void XmlUnitTestResultPrinter::OutputXmlCDataSection(::std::ostream* stream, const char* data) { const char* segment = data; *stream << ""); if (next_segment != NULL) { stream->write( segment, static_cast(next_segment - segment)); *stream << "]]>]]>"); } else { *stream << segment; break; } } *stream << "]]>"; } void XmlUnitTestResultPrinter::OutputXmlAttribute( std::ostream* stream, const std::string& element_name, const std::string& name, const std::string& value) { const std::vector& allowed_names = GetReservedAttributesForElement(element_name); GTEST_CHECK_(std::find(allowed_names.begin(), allowed_names.end(), name) != allowed_names.end()) << "Attribute " << name << " is not allowed for element <" << element_name << ">."; *stream << " " << name << "=\"" << EscapeXmlAttribute(value) << "\""; } // Prints an XML representation of a TestInfo object. // TODO(wan): There is also value in printing properties with the plain printer. void XmlUnitTestResultPrinter::OutputXmlTestInfo(::std::ostream* stream, const char* test_case_name, const TestInfo& test_info) { const TestResult& result = *test_info.result(); const std::string kTestcase = "testcase"; *stream << " \n"; } const string location = internal::FormatCompilerIndependentFileLocation( part.file_name(), part.line_number()); const string summary = location + "\n" + part.summary(); *stream << " "; const string detail = location + "\n" + part.message(); OutputXmlCDataSection(stream, RemoveInvalidXmlCharacters(detail).c_str()); *stream << "\n"; } } if (failures == 0) *stream << " />\n"; else *stream << " \n"; } // Prints an XML representation of a TestCase object void XmlUnitTestResultPrinter::PrintXmlTestCase(std::ostream* stream, const TestCase& test_case) { const std::string kTestsuite = "testsuite"; *stream << " <" << kTestsuite; OutputXmlAttribute(stream, kTestsuite, "name", test_case.name()); OutputXmlAttribute(stream, kTestsuite, "tests", StreamableToString(test_case.reportable_test_count())); OutputXmlAttribute(stream, kTestsuite, "failures", StreamableToString(test_case.failed_test_count())); OutputXmlAttribute( stream, kTestsuite, "disabled", StreamableToString(test_case.reportable_disabled_test_count())); OutputXmlAttribute(stream, kTestsuite, "errors", "0"); OutputXmlAttribute(stream, kTestsuite, "time", FormatTimeInMillisAsSeconds(test_case.elapsed_time())); *stream << TestPropertiesAsXmlAttributes(test_case.ad_hoc_test_result()) << ">\n"; for (int i = 0; i < test_case.total_test_count(); ++i) { if (test_case.GetTestInfo(i)->is_reportable()) OutputXmlTestInfo(stream, test_case.name(), *test_case.GetTestInfo(i)); } *stream << " \n"; } // Prints an XML summary of unit_test to output stream out. void XmlUnitTestResultPrinter::PrintXmlUnitTest(std::ostream* stream, const UnitTest& unit_test) { const std::string kTestsuites = "testsuites"; *stream << "\n"; *stream << "<" << kTestsuites; OutputXmlAttribute(stream, kTestsuites, "tests", StreamableToString(unit_test.reportable_test_count())); OutputXmlAttribute(stream, kTestsuites, "failures", StreamableToString(unit_test.failed_test_count())); OutputXmlAttribute( stream, kTestsuites, "disabled", StreamableToString(unit_test.reportable_disabled_test_count())); OutputXmlAttribute(stream, kTestsuites, "errors", "0"); OutputXmlAttribute( stream, kTestsuites, "timestamp", FormatEpochTimeInMillisAsIso8601(unit_test.start_timestamp())); OutputXmlAttribute(stream, kTestsuites, "time", FormatTimeInMillisAsSeconds(unit_test.elapsed_time())); if (GTEST_FLAG(shuffle)) { OutputXmlAttribute(stream, kTestsuites, "random_seed", StreamableToString(unit_test.random_seed())); } *stream << TestPropertiesAsXmlAttributes(unit_test.ad_hoc_test_result()); OutputXmlAttribute(stream, kTestsuites, "name", "AllTests"); *stream << ">\n"; for (int i = 0; i < unit_test.total_test_case_count(); ++i) { if (unit_test.GetTestCase(i)->reportable_test_count() > 0) PrintXmlTestCase(stream, *unit_test.GetTestCase(i)); } *stream << "\n"; } // Produces a string representing the test properties in a result as space // delimited XML attributes based on the property key="value" pairs. std::string XmlUnitTestResultPrinter::TestPropertiesAsXmlAttributes( const TestResult& result) { Message attributes; for (int i = 0; i < result.test_property_count(); ++i) { const TestProperty& property = result.GetTestProperty(i); attributes << " " << property.key() << "=" << "\"" << EscapeXmlAttribute(property.value()) << "\""; } return attributes.GetString(); } // End XmlUnitTestResultPrinter #if GTEST_CAN_STREAM_RESULTS_ // Checks if str contains '=', '&', '%' or '\n' characters. If yes, // replaces them by "%xx" where xx is their hexadecimal value. For // example, replaces "=" with "%3D". This algorithm is O(strlen(str)) // in both time and space -- important as the input str may contain an // arbitrarily long test failure message and stack trace. string StreamingListener::UrlEncode(const char* str) { string result; result.reserve(strlen(str) + 1); for (char ch = *str; ch != '\0'; ch = *++str) { switch (ch) { case '%': case '=': case '&': case '\n': result.append("%" + String::FormatByte(static_cast(ch))); break; default: result.push_back(ch); break; } } return result; } void StreamingListener::SocketWriter::MakeConnection() { GTEST_CHECK_(sockfd_ == -1) << "MakeConnection() can't be called when there is already a connection."; addrinfo hints; memset(&hints, 0, sizeof(hints)); hints.ai_family = AF_UNSPEC; // To allow both IPv4 and IPv6 addresses. hints.ai_socktype = SOCK_STREAM; addrinfo* servinfo = NULL; // Use the getaddrinfo() to get a linked list of IP addresses for // the given host name. const int error_num = getaddrinfo( host_name_.c_str(), port_num_.c_str(), &hints, &servinfo); if (error_num != 0) { GTEST_LOG_(WARNING) << "stream_result_to: getaddrinfo() failed: " << gai_strerror(error_num); } // Loop through all the results and connect to the first we can. for (addrinfo* cur_addr = servinfo; sockfd_ == -1 && cur_addr != NULL; cur_addr = cur_addr->ai_next) { sockfd_ = socket( cur_addr->ai_family, cur_addr->ai_socktype, cur_addr->ai_protocol); if (sockfd_ != -1) { // Connect the client socket to the server socket. if (connect(sockfd_, cur_addr->ai_addr, cur_addr->ai_addrlen) == -1) { close(sockfd_); sockfd_ = -1; } } } freeaddrinfo(servinfo); // all done with this structure if (sockfd_ == -1) { GTEST_LOG_(WARNING) << "stream_result_to: failed to connect to " << host_name_ << ":" << port_num_; } } // End of class Streaming Listener #endif // GTEST_CAN_STREAM_RESULTS__ // Class ScopedTrace // Pushes the given source file location and message onto a per-thread // trace stack maintained by Google Test. ScopedTrace::ScopedTrace(const char* file, int line, const Message& message) GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { TraceInfo trace; trace.file = file; trace.line = line; trace.message = message.GetString(); UnitTest::GetInstance()->PushGTestTrace(trace); } // Pops the info pushed by the c'tor. ScopedTrace::~ScopedTrace() GTEST_LOCK_EXCLUDED_(&UnitTest::mutex_) { UnitTest::GetInstance()->PopGTestTrace(); } // class OsStackTraceGetter // Returns the current OS stack trace as an std::string. Parameters: // // max_depth - the maximum number of stack frames to be included // in the trace. // skip_count - the number of top frames to be skipped; doesn't count // against max_depth. // string OsStackTraceGetter::CurrentStackTrace(int /* max_depth */, int /* skip_count */) GTEST_LOCK_EXCLUDED_(mutex_) { return ""; } void OsStackTraceGetter::UponLeavingGTest() GTEST_LOCK_EXCLUDED_(mutex_) { } const char* const OsStackTraceGetter::kElidedFramesMarker = "... " GTEST_NAME_ " internal frames ..."; // A helper class that creates the premature-exit file in its // constructor and deletes the file in its destructor. class ScopedPrematureExitFile { public: explicit ScopedPrematureExitFile(const char* premature_exit_filepath) : premature_exit_filepath_(premature_exit_filepath) { // If a path to the premature-exit file is specified... if (premature_exit_filepath != NULL && *premature_exit_filepath != '\0') { // create the file with a single "0" character in it. I/O // errors are ignored as there's nothing better we can do and we // don't want to fail the test because of this. FILE* pfile = posix::FOpen(premature_exit_filepath, "w"); fwrite("0", 1, 1, pfile); fclose(pfile); } } ~ScopedPrematureExitFile() { if (premature_exit_filepath_ != NULL && *premature_exit_filepath_ != '\0') { remove(premature_exit_filepath_); } } private: const char* const premature_exit_filepath_; GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedPrematureExitFile); }; } // namespace internal // class TestEventListeners TestEventListeners::TestEventListeners() : repeater_(new internal::TestEventRepeater()), default_result_printer_(NULL), default_xml_generator_(NULL) { } TestEventListeners::~TestEventListeners() { delete repeater_; } // Returns the standard listener responsible for the default console // output. Can be removed from the listeners list to shut down default // console output. Note that removing this object from the listener list // with Release transfers its ownership to the user. void TestEventListeners::Append(TestEventListener* listener) { repeater_->Append(listener); } // Removes the given event listener from the list and returns it. It then // becomes the caller's responsibility to delete the listener. Returns // NULL if the listener is not found in the list. TestEventListener* TestEventListeners::Release(TestEventListener* listener) { if (listener == default_result_printer_) default_result_printer_ = NULL; else if (listener == default_xml_generator_) default_xml_generator_ = NULL; return repeater_->Release(listener); } // Returns repeater that broadcasts the TestEventListener events to all // subscribers. TestEventListener* TestEventListeners::repeater() { return repeater_; } // Sets the default_result_printer attribute to the provided listener. // The listener is also added to the listener list and previous // default_result_printer is removed from it and deleted. The listener can // also be NULL in which case it will not be added to the list. Does // nothing if the previous and the current listener objects are the same. void TestEventListeners::SetDefaultResultPrinter(TestEventListener* listener) { if (default_result_printer_ != listener) { // It is an error to pass this method a listener that is already in the // list. delete Release(default_result_printer_); default_result_printer_ = listener; if (listener != NULL) Append(listener); } } // Sets the default_xml_generator attribute to the provided listener. The // listener is also added to the listener list and previous // default_xml_generator is removed from it and deleted. The listener can // also be NULL in which case it will not be added to the list. Does // nothing if the previous and the current listener objects are the same. void TestEventListeners::SetDefaultXmlGenerator(TestEventListener* listener) { if (default_xml_generator_ != listener) { // It is an error to pass this method a listener that is already in the // list. delete Release(default_xml_generator_); default_xml_generator_ = listener; if (listener != NULL) Append(listener); } } // Controls whether events will be forwarded by the repeater to the // listeners in the list. bool TestEventListeners::EventForwardingEnabled() const { return repeater_->forwarding_enabled(); } void TestEventListeners::SuppressEventForwarding() { repeater_->set_forwarding_enabled(false); } // class UnitTest // Gets the singleton UnitTest object. The first time this method is // called, a UnitTest object is constructed and returned. Consecutive // calls will return the same object. // // We don't protect this under mutex_ as a user is not supposed to // call this before main() starts, from which point on the return // value will never change. UnitTest* UnitTest::GetInstance() { // When compiled with MSVC 7.1 in optimized mode, destroying the // UnitTest object upon exiting the program messes up the exit code, // causing successful tests to appear failed. We have to use a // different implementation in this case to bypass the compiler bug. // This implementation makes the compiler happy, at the cost of // leaking the UnitTest object. // CodeGear C++Builder insists on a public destructor for the // default implementation. Use this implementation to keep good OO // design with private destructor. #if (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) static UnitTest* const instance = new UnitTest; return instance; #else static UnitTest instance; return &instance; #endif // (_MSC_VER == 1310 && !defined(_DEBUG)) || defined(__BORLANDC__) } // Gets the number of successful test cases. int UnitTest::successful_test_case_count() const { return impl()->successful_test_case_count(); } // Gets the number of failed test cases. int UnitTest::failed_test_case_count() const { return impl()->failed_test_case_count(); } // Gets the number of all test cases. int UnitTest::total_test_case_count() const { return impl()->total_test_case_count(); } // Gets the number of all test cases that contain at least one test // that should run. int UnitTest::test_case_to_run_count() const { return impl()->test_case_to_run_count(); } // Gets the number of successful tests. int UnitTest::successful_test_count() const { return impl()->successful_test_count(); } // Gets the number of failed tests. int UnitTest::failed_test_count() const { return impl()->failed_test_count(); } // Gets the number of disabled tests that will be reported in the XML report. int UnitTest::reportable_disabled_test_count() const { return impl()->reportable_disabled_test_count(); } // Gets the number of disabled tests. int UnitTest::disabled_test_count() const { return impl()->disabled_test_count(); } // Gets the number of tests to be printed in the XML report. int UnitTest::reportable_test_count() const { return impl()->reportable_test_count(); } // Gets the number of all tests. int UnitTest::total_test_count() const { return impl()->total_test_count(); } // Gets the number of tests that should run. int UnitTest::test_to_run_count() const { return impl()->test_to_run_count(); } // Gets the time of the test program start, in ms from the start of the // UNIX epoch. internal::TimeInMillis UnitTest::start_timestamp() const { return impl()->start_timestamp(); } // Gets the elapsed time, in milliseconds. internal::TimeInMillis UnitTest::elapsed_time() const { return impl()->elapsed_time(); } // Returns true iff the unit test passed (i.e. all test cases passed). bool UnitTest::Passed() const { return impl()->Passed(); } // Returns true iff the unit test failed (i.e. some test case failed // or something outside of all tests failed). bool UnitTest::Failed() const { return impl()->Failed(); } // Gets the i-th test case among all the test cases. i can range from 0 to // total_test_case_count() - 1. If i is not in that range, returns NULL. const TestCase* UnitTest::GetTestCase(int i) const { return impl()->GetTestCase(i); } // Returns the TestResult containing information on test failures and // properties logged outside of individual test cases. const TestResult& UnitTest::ad_hoc_test_result() const { return *impl()->ad_hoc_test_result(); } // Gets the i-th test case among all the test cases. i can range from 0 to // total_test_case_count() - 1. If i is not in that range, returns NULL. TestCase* UnitTest::GetMutableTestCase(int i) { return impl()->GetMutableTestCase(i); } // Returns the list of event listeners that can be used to track events // inside Google Test. TestEventListeners& UnitTest::listeners() { return *impl()->listeners(); } // Registers and returns a global test environment. When a test // program is run, all global test environments will be set-up in the // order they were registered. After all tests in the program have // finished, all global test environments will be torn-down in the // *reverse* order they were registered. // // The UnitTest object takes ownership of the given environment. // // We don't protect this under mutex_, as we only support calling it // from the main thread. Environment* UnitTest::AddEnvironment(Environment* env) { if (env == NULL) { return NULL; } impl_->environments().push_back(env); return env; } // Adds a TestPartResult to the current TestResult object. All Google Test // assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) eventually call // this to report their results. The user code should use the // assertion macros instead of calling this directly. void UnitTest::AddTestPartResult( TestPartResult::Type result_type, const char* file_name, int line_number, const std::string& message, const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_) { Message msg; msg << message; internal::MutexLock lock(&mutex_); if (impl_->gtest_trace_stack().size() > 0) { msg << "\n" << GTEST_NAME_ << " trace:"; for (int i = static_cast(impl_->gtest_trace_stack().size()); i > 0; --i) { const internal::TraceInfo& trace = impl_->gtest_trace_stack()[i - 1]; msg << "\n" << internal::FormatFileLocation(trace.file, trace.line) << " " << trace.message; } } if (os_stack_trace.c_str() != NULL && !os_stack_trace.empty()) { msg << internal::kStackTraceMarker << os_stack_trace; } const TestPartResult result = TestPartResult(result_type, file_name, line_number, msg.GetString().c_str()); impl_->GetTestPartResultReporterForCurrentThread()-> ReportTestPartResult(result); if (result_type != TestPartResult::kSuccess) { // gtest_break_on_failure takes precedence over // gtest_throw_on_failure. This allows a user to set the latter // in the code (perhaps in order to use Google Test assertions // with another testing framework) and specify the former on the // command line for debugging. if (GTEST_FLAG(break_on_failure)) { #if GTEST_OS_WINDOWS // Using DebugBreak on Windows allows gtest to still break into a debugger // when a failure happens and both the --gtest_break_on_failure and // the --gtest_catch_exceptions flags are specified. DebugBreak(); #else // Dereference NULL through a volatile pointer to prevent the compiler // from removing. We use this rather than abort() or __builtin_trap() for // portability: Symbian doesn't implement abort() well, and some debuggers // don't correctly trap abort(). *static_cast(NULL) = 1; #endif // GTEST_OS_WINDOWS } else if (GTEST_FLAG(throw_on_failure)) { #if GTEST_HAS_EXCEPTIONS throw internal::GoogleTestFailureException(result); #else // We cannot call abort() as it generates a pop-up in debug mode // that cannot be suppressed in VC 7.1 or below. exit(1); #endif } } } // Adds a TestProperty to the current TestResult object when invoked from // inside a test, to current TestCase's ad_hoc_test_result_ when invoked // from SetUpTestCase or TearDownTestCase, or to the global property set // when invoked elsewhere. If the result already contains a property with // the same key, the value will be updated. void UnitTest::RecordProperty(const std::string& key, const std::string& value) { impl_->RecordProperty(TestProperty(key, value)); } // Runs all tests in this UnitTest object and prints the result. // Returns 0 if successful, or 1 otherwise. // // We don't protect this under mutex_, as we only support calling it // from the main thread. int UnitTest::Run() { const bool in_death_test_child_process = internal::GTEST_FLAG(internal_run_death_test).length() > 0; // Google Test implements this protocol for catching that a test // program exits before returning control to Google Test: // // 1. Upon start, Google Test creates a file whose absolute path // is specified by the environment variable // TEST_PREMATURE_EXIT_FILE. // 2. When Google Test has finished its work, it deletes the file. // // This allows a test runner to set TEST_PREMATURE_EXIT_FILE before // running a Google-Test-based test program and check the existence // of the file at the end of the test execution to see if it has // exited prematurely. // If we are in the child process of a death test, don't // create/delete the premature exit file, as doing so is unnecessary // and will confuse the parent process. Otherwise, create/delete // the file upon entering/leaving this function. If the program // somehow exits before this function has a chance to return, the // premature-exit file will be left undeleted, causing a test runner // that understands the premature-exit-file protocol to report the // test as having failed. const internal::ScopedPrematureExitFile premature_exit_file( in_death_test_child_process ? NULL : internal::posix::GetEnv("TEST_PREMATURE_EXIT_FILE")); // Captures the value of GTEST_FLAG(catch_exceptions). This value will be // used for the duration of the program. impl()->set_catch_exceptions(GTEST_FLAG(catch_exceptions)); #if GTEST_HAS_SEH // Either the user wants Google Test to catch exceptions thrown by the // tests or this is executing in the context of death test child // process. In either case the user does not want to see pop-up dialogs // about crashes - they are expected. if (impl()->catch_exceptions() || in_death_test_child_process) { # if !GTEST_OS_WINDOWS_MOBILE // SetErrorMode doesn't exist on CE. SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOALIGNMENTFAULTEXCEPT | SEM_NOGPFAULTERRORBOX | SEM_NOOPENFILEERRORBOX); # endif // !GTEST_OS_WINDOWS_MOBILE # if (defined(_MSC_VER) || GTEST_OS_WINDOWS_MINGW) && !GTEST_OS_WINDOWS_MOBILE // Death test children can be terminated with _abort(). On Windows, // _abort() can show a dialog with a warning message. This forces the // abort message to go to stderr instead. _set_error_mode(_OUT_TO_STDERR); # endif # if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE // In the debug version, Visual Studio pops up a separate dialog // offering a choice to debug the aborted program. We need to suppress // this dialog or it will pop up for every EXPECT/ASSERT_DEATH statement // executed. Google Test will notify the user of any unexpected // failure via stderr. // // VC++ doesn't define _set_abort_behavior() prior to the version 8.0. // Users of prior VC versions shall suffer the agony and pain of // clicking through the countless debug dialogs. // TODO(vladl@google.com): find a way to suppress the abort dialog() in the // debug mode when compiled with VC 7.1 or lower. if (!GTEST_FLAG(break_on_failure)) _set_abort_behavior( 0x0, // Clear the following flags: _WRITE_ABORT_MSG | _CALL_REPORTFAULT); // pop-up window, core dump. # endif } #endif // GTEST_HAS_SEH return internal::HandleExceptionsInMethodIfSupported( impl(), &internal::UnitTestImpl::RunAllTests, "auxiliary test code (environments or event listeners)") ? 0 : 1; } // Returns the working directory when the first TEST() or TEST_F() was // executed. const char* UnitTest::original_working_dir() const { return impl_->original_working_dir_.c_str(); } // Returns the TestCase object for the test that's currently running, // or NULL if no test is running. const TestCase* UnitTest::current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_) { internal::MutexLock lock(&mutex_); return impl_->current_test_case(); } // Returns the TestInfo object for the test that's currently running, // or NULL if no test is running. const TestInfo* UnitTest::current_test_info() const GTEST_LOCK_EXCLUDED_(mutex_) { internal::MutexLock lock(&mutex_); return impl_->current_test_info(); } // Returns the random seed used at the start of the current test run. int UnitTest::random_seed() const { return impl_->random_seed(); } #if GTEST_HAS_PARAM_TEST // Returns ParameterizedTestCaseRegistry object used to keep track of // value-parameterized tests and instantiate and register them. internal::ParameterizedTestCaseRegistry& UnitTest::parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_) { return impl_->parameterized_test_registry(); } #endif // GTEST_HAS_PARAM_TEST // Creates an empty UnitTest. UnitTest::UnitTest() { impl_ = new internal::UnitTestImpl(this); } // Destructor of UnitTest. UnitTest::~UnitTest() { delete impl_; } // Pushes a trace defined by SCOPED_TRACE() on to the per-thread // Google Test trace stack. void UnitTest::PushGTestTrace(const internal::TraceInfo& trace) GTEST_LOCK_EXCLUDED_(mutex_) { internal::MutexLock lock(&mutex_); impl_->gtest_trace_stack().push_back(trace); } // Pops a trace from the per-thread Google Test trace stack. void UnitTest::PopGTestTrace() GTEST_LOCK_EXCLUDED_(mutex_) { internal::MutexLock lock(&mutex_); impl_->gtest_trace_stack().pop_back(); } namespace internal { UnitTestImpl::UnitTestImpl(UnitTest* parent) : parent_(parent), #ifdef _MSC_VER # pragma warning(push) // Saves the current warning state. # pragma warning(disable:4355) // Temporarily disables warning 4355 // (using this in initializer). default_global_test_part_result_reporter_(this), default_per_thread_test_part_result_reporter_(this), # pragma warning(pop) // Restores the warning state again. #else default_global_test_part_result_reporter_(this), default_per_thread_test_part_result_reporter_(this), #endif // _MSC_VER global_test_part_result_repoter_( &default_global_test_part_result_reporter_), per_thread_test_part_result_reporter_( &default_per_thread_test_part_result_reporter_), #if GTEST_HAS_PARAM_TEST parameterized_test_registry_(), parameterized_tests_registered_(false), #endif // GTEST_HAS_PARAM_TEST last_death_test_case_(-1), current_test_case_(NULL), current_test_info_(NULL), ad_hoc_test_result_(), os_stack_trace_getter_(NULL), post_flag_parse_init_performed_(false), random_seed_(0), // Will be overridden by the flag before first use. random_(0), // Will be reseeded before first use. start_timestamp_(0), elapsed_time_(0), #if GTEST_HAS_DEATH_TEST death_test_factory_(new DefaultDeathTestFactory), #endif // Will be overridden by the flag before first use. catch_exceptions_(false) { listeners()->SetDefaultResultPrinter(new PrettyUnitTestResultPrinter); } UnitTestImpl::~UnitTestImpl() { // Deletes every TestCase. ForEach(test_cases_, internal::Delete); // Deletes every Environment. ForEach(environments_, internal::Delete); delete os_stack_trace_getter_; } // Adds a TestProperty to the current TestResult object when invoked in a // context of a test, to current test case's ad_hoc_test_result when invoke // from SetUpTestCase/TearDownTestCase, or to the global property set // otherwise. If the result already contains a property with the same key, // the value will be updated. void UnitTestImpl::RecordProperty(const TestProperty& test_property) { std::string xml_element; TestResult* test_result; // TestResult appropriate for property recording. if (current_test_info_ != NULL) { xml_element = "testcase"; test_result = &(current_test_info_->result_); } else if (current_test_case_ != NULL) { xml_element = "testsuite"; test_result = &(current_test_case_->ad_hoc_test_result_); } else { xml_element = "testsuites"; test_result = &ad_hoc_test_result_; } test_result->RecordProperty(xml_element, test_property); } #if GTEST_HAS_DEATH_TEST // Disables event forwarding if the control is currently in a death test // subprocess. Must not be called before InitGoogleTest. void UnitTestImpl::SuppressTestEventsIfInSubprocess() { if (internal_run_death_test_flag_.get() != NULL) listeners()->SuppressEventForwarding(); } #endif // GTEST_HAS_DEATH_TEST // Initializes event listeners performing XML output as specified by // UnitTestOptions. Must not be called before InitGoogleTest. void UnitTestImpl::ConfigureXmlOutput() { const std::string& output_format = UnitTestOptions::GetOutputFormat(); if (output_format == "xml") { listeners()->SetDefaultXmlGenerator(new XmlUnitTestResultPrinter( UnitTestOptions::GetAbsolutePathToOutputFile().c_str())); } else if (output_format != "") { printf("WARNING: unrecognized output format \"%s\" ignored.\n", output_format.c_str()); fflush(stdout); } } #if GTEST_CAN_STREAM_RESULTS_ // Initializes event listeners for streaming test results in string form. // Must not be called before InitGoogleTest. void UnitTestImpl::ConfigureStreamingOutput() { const std::string& target = GTEST_FLAG(stream_result_to); if (!target.empty()) { const size_t pos = target.find(':'); if (pos != std::string::npos) { listeners()->Append(new StreamingListener(target.substr(0, pos), target.substr(pos+1))); } else { printf("WARNING: unrecognized streaming target \"%s\" ignored.\n", target.c_str()); fflush(stdout); } } } #endif // GTEST_CAN_STREAM_RESULTS_ // Performs initialization dependent upon flag values obtained in // ParseGoogleTestFlagsOnly. Is called from InitGoogleTest after the call to // ParseGoogleTestFlagsOnly. In case a user neglects to call InitGoogleTest // this function is also called from RunAllTests. Since this function can be // called more than once, it has to be idempotent. void UnitTestImpl::PostFlagParsingInit() { // Ensures that this function does not execute more than once. if (!post_flag_parse_init_performed_) { post_flag_parse_init_performed_ = true; #if GTEST_HAS_DEATH_TEST InitDeathTestSubprocessControlInfo(); SuppressTestEventsIfInSubprocess(); #endif // GTEST_HAS_DEATH_TEST // Registers parameterized tests. This makes parameterized tests // available to the UnitTest reflection API without running // RUN_ALL_TESTS. RegisterParameterizedTests(); // Configures listeners for XML output. This makes it possible for users // to shut down the default XML output before invoking RUN_ALL_TESTS. ConfigureXmlOutput(); #if GTEST_CAN_STREAM_RESULTS_ // Configures listeners for streaming test results to the specified server. ConfigureStreamingOutput(); #endif // GTEST_CAN_STREAM_RESULTS_ } } // A predicate that checks the name of a TestCase against a known // value. // // This is used for implementation of the UnitTest class only. We put // it in the anonymous namespace to prevent polluting the outer // namespace. // // TestCaseNameIs is copyable. class TestCaseNameIs { public: // Constructor. explicit TestCaseNameIs(const std::string& name) : name_(name) {} // Returns true iff the name of test_case matches name_. bool operator()(const TestCase* test_case) const { return test_case != NULL && strcmp(test_case->name(), name_.c_str()) == 0; } private: std::string name_; }; // Finds and returns a TestCase with the given name. If one doesn't // exist, creates one and returns it. It's the CALLER'S // RESPONSIBILITY to ensure that this function is only called WHEN THE // TESTS ARE NOT SHUFFLED. // // Arguments: // // test_case_name: name of the test case // type_param: the name of the test case's type parameter, or NULL if // this is not a typed or a type-parameterized test case. // set_up_tc: pointer to the function that sets up the test case // tear_down_tc: pointer to the function that tears down the test case TestCase* UnitTestImpl::GetTestCase(const char* test_case_name, const char* type_param, Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc) { // Can we find a TestCase with the given name? const std::vector::const_iterator test_case = std::find_if(test_cases_.begin(), test_cases_.end(), TestCaseNameIs(test_case_name)); if (test_case != test_cases_.end()) return *test_case; // No. Let's create one. TestCase* const new_test_case = new TestCase(test_case_name, type_param, set_up_tc, tear_down_tc); // Is this a death test case? if (internal::UnitTestOptions::MatchesFilter(test_case_name, kDeathTestCaseFilter)) { // Yes. Inserts the test case after the last death test case // defined so far. This only works when the test cases haven't // been shuffled. Otherwise we may end up running a death test // after a non-death test. ++last_death_test_case_; test_cases_.insert(test_cases_.begin() + last_death_test_case_, new_test_case); } else { // No. Appends to the end of the list. test_cases_.push_back(new_test_case); } test_case_indices_.push_back(static_cast(test_case_indices_.size())); return new_test_case; } // Helpers for setting up / tearing down the given environment. They // are for use in the ForEach() function. static void SetUpEnvironment(Environment* env) { env->SetUp(); } static void TearDownEnvironment(Environment* env) { env->TearDown(); } // Runs all tests in this UnitTest object, prints the result, and // returns true if all tests are successful. If any exception is // thrown during a test, the test is considered to be failed, but the // rest of the tests will still be run. // // When parameterized tests are enabled, it expands and registers // parameterized tests first in RegisterParameterizedTests(). // All other functions called from RunAllTests() may safely assume that // parameterized tests are ready to be counted and run. bool UnitTestImpl::RunAllTests() { // Makes sure InitGoogleTest() was called. if (!GTestIsInitialized()) { printf("%s", "\nThis test program did NOT call ::testing::InitGoogleTest " "before calling RUN_ALL_TESTS(). Please fix it.\n"); return false; } // Do not run any test if the --help flag was specified. if (g_help_flag) return true; // Repeats the call to the post-flag parsing initialization in case the // user didn't call InitGoogleTest. PostFlagParsingInit(); // Even if sharding is not on, test runners may want to use the // GTEST_SHARD_STATUS_FILE to query whether the test supports the sharding // protocol. internal::WriteToShardStatusFileIfNeeded(); // True iff we are in a subprocess for running a thread-safe-style // death test. bool in_subprocess_for_death_test = false; #if GTEST_HAS_DEATH_TEST in_subprocess_for_death_test = (internal_run_death_test_flag_.get() != NULL); #endif // GTEST_HAS_DEATH_TEST const bool should_shard = ShouldShard(kTestTotalShards, kTestShardIndex, in_subprocess_for_death_test); // Compares the full test names with the filter to decide which // tests to run. const bool has_tests_to_run = FilterTests(should_shard ? HONOR_SHARDING_PROTOCOL : IGNORE_SHARDING_PROTOCOL) > 0; // Lists the tests and exits if the --gtest_list_tests flag was specified. if (GTEST_FLAG(list_tests)) { // This must be called *after* FilterTests() has been called. ListTestsMatchingFilter(); return true; } random_seed_ = GTEST_FLAG(shuffle) ? GetRandomSeedFromFlag(GTEST_FLAG(random_seed)) : 0; // True iff at least one test has failed. bool failed = false; TestEventListener* repeater = listeners()->repeater(); start_timestamp_ = GetTimeInMillis(); repeater->OnTestProgramStart(*parent_); // How many times to repeat the tests? We don't want to repeat them // when we are inside the subprocess of a death test. const int repeat = in_subprocess_for_death_test ? 1 : GTEST_FLAG(repeat); // Repeats forever if the repeat count is negative. const bool forever = repeat < 0; for (int i = 0; forever || i != repeat; i++) { // We want to preserve failures generated by ad-hoc test // assertions executed before RUN_ALL_TESTS(). ClearNonAdHocTestResult(); const TimeInMillis start = GetTimeInMillis(); // Shuffles test cases and tests if requested. if (has_tests_to_run && GTEST_FLAG(shuffle)) { random()->Reseed(random_seed_); // This should be done before calling OnTestIterationStart(), // such that a test event listener can see the actual test order // in the event. ShuffleTests(); } // Tells the unit test event listeners that the tests are about to start. repeater->OnTestIterationStart(*parent_, i); // Runs each test case if there is at least one test to run. if (has_tests_to_run) { // Sets up all environments beforehand. repeater->OnEnvironmentsSetUpStart(*parent_); ForEach(environments_, SetUpEnvironment); repeater->OnEnvironmentsSetUpEnd(*parent_); // Runs the tests only if there was no fatal failure during global // set-up. if (!Test::HasFatalFailure()) { for (int test_index = 0; test_index < total_test_case_count(); test_index++) { GetMutableTestCase(test_index)->Run(); } } // Tears down all environments in reverse order afterwards. repeater->OnEnvironmentsTearDownStart(*parent_); std::for_each(environments_.rbegin(), environments_.rend(), TearDownEnvironment); repeater->OnEnvironmentsTearDownEnd(*parent_); } elapsed_time_ = GetTimeInMillis() - start; // Tells the unit test event listener that the tests have just finished. repeater->OnTestIterationEnd(*parent_, i); // Gets the result and clears it. if (!Passed()) { failed = true; } // Restores the original test order after the iteration. This // allows the user to quickly repro a failure that happens in the // N-th iteration without repeating the first (N - 1) iterations. // This is not enclosed in "if (GTEST_FLAG(shuffle)) { ... }", in // case the user somehow changes the value of the flag somewhere // (it's always safe to unshuffle the tests). UnshuffleTests(); if (GTEST_FLAG(shuffle)) { // Picks a new random seed for each iteration. random_seed_ = GetNextRandomSeed(random_seed_); } } repeater->OnTestProgramEnd(*parent_); return !failed; } // Reads the GTEST_SHARD_STATUS_FILE environment variable, and creates the file // if the variable is present. If a file already exists at this location, this // function will write over it. If the variable is present, but the file cannot // be created, prints an error and exits. void WriteToShardStatusFileIfNeeded() { const char* const test_shard_file = posix::GetEnv(kTestShardStatusFile); if (test_shard_file != NULL) { FILE* const file = posix::FOpen(test_shard_file, "w"); if (file == NULL) { ColoredPrintf(COLOR_RED, "Could not write to the test shard status file \"%s\" " "specified by the %s environment variable.\n", test_shard_file, kTestShardStatusFile); fflush(stdout); exit(EXIT_FAILURE); } fclose(file); } } // Checks whether sharding is enabled by examining the relevant // environment variable values. If the variables are present, // but inconsistent (i.e., shard_index >= total_shards), prints // an error and exits. If in_subprocess_for_death_test, sharding is // disabled because it must only be applied to the original test // process. Otherwise, we could filter out death tests we intended to execute. bool ShouldShard(const char* total_shards_env, const char* shard_index_env, bool in_subprocess_for_death_test) { if (in_subprocess_for_death_test) { return false; } const Int32 total_shards = Int32FromEnvOrDie(total_shards_env, -1); const Int32 shard_index = Int32FromEnvOrDie(shard_index_env, -1); if (total_shards == -1 && shard_index == -1) { return false; } else if (total_shards == -1 && shard_index != -1) { const Message msg = Message() << "Invalid environment variables: you have " << kTestShardIndex << " = " << shard_index << ", but have left " << kTestTotalShards << " unset.\n"; ColoredPrintf(COLOR_RED, msg.GetString().c_str()); fflush(stdout); exit(EXIT_FAILURE); } else if (total_shards != -1 && shard_index == -1) { const Message msg = Message() << "Invalid environment variables: you have " << kTestTotalShards << " = " << total_shards << ", but have left " << kTestShardIndex << " unset.\n"; ColoredPrintf(COLOR_RED, msg.GetString().c_str()); fflush(stdout); exit(EXIT_FAILURE); } else if (shard_index < 0 || shard_index >= total_shards) { const Message msg = Message() << "Invalid environment variables: we require 0 <= " << kTestShardIndex << " < " << kTestTotalShards << ", but you have " << kTestShardIndex << "=" << shard_index << ", " << kTestTotalShards << "=" << total_shards << ".\n"; ColoredPrintf(COLOR_RED, msg.GetString().c_str()); fflush(stdout); exit(EXIT_FAILURE); } return total_shards > 1; } // Parses the environment variable var as an Int32. If it is unset, // returns default_val. If it is not an Int32, prints an error // and aborts. Int32 Int32FromEnvOrDie(const char* var, Int32 default_val) { const char* str_val = posix::GetEnv(var); if (str_val == NULL) { return default_val; } Int32 result; if (!ParseInt32(Message() << "The value of environment variable " << var, str_val, &result)) { exit(EXIT_FAILURE); } return result; } // Given the total number of shards, the shard index, and the test id, // returns true iff the test should be run on this shard. The test id is // some arbitrary but unique non-negative integer assigned to each test // method. Assumes that 0 <= shard_index < total_shards. bool ShouldRunTestOnShard(int total_shards, int shard_index, int test_id) { return (test_id % total_shards) == shard_index; } // Compares the name of each test with the user-specified filter to // decide whether the test should be run, then records the result in // each TestCase and TestInfo object. // If shard_tests == true, further filters tests based on sharding // variables in the environment - see // http://code.google.com/p/googletest/wiki/GoogleTestAdvancedGuide. // Returns the number of tests that should run. int UnitTestImpl::FilterTests(ReactionToSharding shard_tests) { const Int32 total_shards = shard_tests == HONOR_SHARDING_PROTOCOL ? Int32FromEnvOrDie(kTestTotalShards, -1) : -1; const Int32 shard_index = shard_tests == HONOR_SHARDING_PROTOCOL ? Int32FromEnvOrDie(kTestShardIndex, -1) : -1; // num_runnable_tests are the number of tests that will // run across all shards (i.e., match filter and are not disabled). // num_selected_tests are the number of tests to be run on // this shard. int num_runnable_tests = 0; int num_selected_tests = 0; for (size_t i = 0; i < test_cases_.size(); i++) { TestCase* const test_case = test_cases_[i]; const std::string &test_case_name = test_case->name(); test_case->set_should_run(false); for (size_t j = 0; j < test_case->test_info_list().size(); j++) { TestInfo* const test_info = test_case->test_info_list()[j]; const std::string test_name(test_info->name()); // A test is disabled if test case name or test name matches // kDisableTestFilter. const bool is_disabled = internal::UnitTestOptions::MatchesFilter(test_case_name, kDisableTestFilter) || internal::UnitTestOptions::MatchesFilter(test_name, kDisableTestFilter); test_info->is_disabled_ = is_disabled; const bool matches_filter = internal::UnitTestOptions::FilterMatchesTest(test_case_name, test_name); test_info->matches_filter_ = matches_filter; const bool is_runnable = (GTEST_FLAG(also_run_disabled_tests) || !is_disabled) && matches_filter; const bool is_selected = is_runnable && (shard_tests == IGNORE_SHARDING_PROTOCOL || ShouldRunTestOnShard(total_shards, shard_index, num_runnable_tests)); num_runnable_tests += is_runnable; num_selected_tests += is_selected; test_info->should_run_ = is_selected; test_case->set_should_run(test_case->should_run() || is_selected); } } return num_selected_tests; } // Prints the given C-string on a single line by replacing all '\n' // characters with string "\\n". If the output takes more than // max_length characters, only prints the first max_length characters // and "...". static void PrintOnOneLine(const char* str, int max_length) { if (str != NULL) { for (int i = 0; *str != '\0'; ++str) { if (i >= max_length) { printf("..."); break; } if (*str == '\n') { printf("\\n"); i += 2; } else { printf("%c", *str); ++i; } } } } // Prints the names of the tests matching the user-specified filter flag. void UnitTestImpl::ListTestsMatchingFilter() { // Print at most this many characters for each type/value parameter. const int kMaxParamLength = 250; for (size_t i = 0; i < test_cases_.size(); i++) { const TestCase* const test_case = test_cases_[i]; bool printed_test_case_name = false; for (size_t j = 0; j < test_case->test_info_list().size(); j++) { const TestInfo* const test_info = test_case->test_info_list()[j]; if (test_info->matches_filter_) { if (!printed_test_case_name) { printed_test_case_name = true; printf("%s.", test_case->name()); if (test_case->type_param() != NULL) { printf(" # %s = ", kTypeParamLabel); // We print the type parameter on a single line to make // the output easy to parse by a program. PrintOnOneLine(test_case->type_param(), kMaxParamLength); } printf("\n"); } printf(" %s", test_info->name()); if (test_info->value_param() != NULL) { printf(" # %s = ", kValueParamLabel); // We print the value parameter on a single line to make the // output easy to parse by a program. PrintOnOneLine(test_info->value_param(), kMaxParamLength); } printf("\n"); } } } fflush(stdout); } // Sets the OS stack trace getter. // // Does nothing if the input and the current OS stack trace getter are // the same; otherwise, deletes the old getter and makes the input the // current getter. void UnitTestImpl::set_os_stack_trace_getter( OsStackTraceGetterInterface* getter) { if (os_stack_trace_getter_ != getter) { delete os_stack_trace_getter_; os_stack_trace_getter_ = getter; } } // Returns the current OS stack trace getter if it is not NULL; // otherwise, creates an OsStackTraceGetter, makes it the current // getter, and returns it. OsStackTraceGetterInterface* UnitTestImpl::os_stack_trace_getter() { if (os_stack_trace_getter_ == NULL) { os_stack_trace_getter_ = new OsStackTraceGetter; } return os_stack_trace_getter_; } // Returns the TestResult for the test that's currently running, or // the TestResult for the ad hoc test if no test is running. TestResult* UnitTestImpl::current_test_result() { return current_test_info_ ? &(current_test_info_->result_) : &ad_hoc_test_result_; } // Shuffles all test cases, and the tests within each test case, // making sure that death tests are still run first. void UnitTestImpl::ShuffleTests() { // Shuffles the death test cases. ShuffleRange(random(), 0, last_death_test_case_ + 1, &test_case_indices_); // Shuffles the non-death test cases. ShuffleRange(random(), last_death_test_case_ + 1, static_cast(test_cases_.size()), &test_case_indices_); // Shuffles the tests inside each test case. for (size_t i = 0; i < test_cases_.size(); i++) { test_cases_[i]->ShuffleTests(random()); } } // Restores the test cases and tests to their order before the first shuffle. void UnitTestImpl::UnshuffleTests() { for (size_t i = 0; i < test_cases_.size(); i++) { // Unshuffles the tests in each test case. test_cases_[i]->UnshuffleTests(); // Resets the index of each test case. test_case_indices_[i] = static_cast(i); } } // Returns the current OS stack trace as an std::string. // // The maximum number of stack frames to be included is specified by // the gtest_stack_trace_depth flag. The skip_count parameter // specifies the number of top frames to be skipped, which doesn't // count against the number of frames to be included. // // For example, if Foo() calls Bar(), which in turn calls // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. std::string GetCurrentOsStackTraceExceptTop(UnitTest* /*unit_test*/, int skip_count) { // We pass skip_count + 1 to skip this wrapper function in addition // to what the user really wants to skip. return GetUnitTestImpl()->CurrentOsStackTraceExceptTop(skip_count + 1); } // Used by the GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_ macro to // suppress unreachable code warnings. namespace { class ClassUniqueToAlwaysTrue {}; } bool IsTrue(bool condition) { return condition; } bool AlwaysTrue() { #if GTEST_HAS_EXCEPTIONS // This condition is always false so AlwaysTrue() never actually throws, // but it makes the compiler think that it may throw. if (IsTrue(false)) throw ClassUniqueToAlwaysTrue(); #endif // GTEST_HAS_EXCEPTIONS return true; } // If *pstr starts with the given prefix, modifies *pstr to be right // past the prefix and returns true; otherwise leaves *pstr unchanged // and returns false. None of pstr, *pstr, and prefix can be NULL. bool SkipPrefix(const char* prefix, const char** pstr) { const size_t prefix_len = strlen(prefix); if (strncmp(*pstr, prefix, prefix_len) == 0) { *pstr += prefix_len; return true; } return false; } // Parses a string as a command line flag. The string should have // the format "--flag=value". When def_optional is true, the "=value" // part can be omitted. // // Returns the value of the flag, or NULL if the parsing failed. const char* ParseFlagValue(const char* str, const char* flag, bool def_optional) { // str and flag must not be NULL. if (str == NULL || flag == NULL) return NULL; // The flag must start with "--" followed by GTEST_FLAG_PREFIX_. const std::string flag_str = std::string("--") + GTEST_FLAG_PREFIX_ + flag; const size_t flag_len = flag_str.length(); if (strncmp(str, flag_str.c_str(), flag_len) != 0) return NULL; // Skips the flag name. const char* flag_end = str + flag_len; // When def_optional is true, it's OK to not have a "=value" part. if (def_optional && (flag_end[0] == '\0')) { return flag_end; } // If def_optional is true and there are more characters after the // flag name, or if def_optional is false, there must be a '=' after // the flag name. if (flag_end[0] != '=') return NULL; // Returns the string after "=". return flag_end + 1; } // Parses a string for a bool flag, in the form of either // "--flag=value" or "--flag". // // In the former case, the value is taken as true as long as it does // not start with '0', 'f', or 'F'. // // In the latter case, the value is taken as true. // // On success, stores the value of the flag in *value, and returns // true. On failure, returns false without changing *value. bool ParseBoolFlag(const char* str, const char* flag, bool* value) { // Gets the value of the flag as a string. const char* const value_str = ParseFlagValue(str, flag, true); // Aborts if the parsing failed. if (value_str == NULL) return false; // Converts the string value to a bool. *value = !(*value_str == '0' || *value_str == 'f' || *value_str == 'F'); return true; } // Parses a string for an Int32 flag, in the form of // "--flag=value". // // On success, stores the value of the flag in *value, and returns // true. On failure, returns false without changing *value. bool ParseInt32Flag(const char* str, const char* flag, Int32* value) { // Gets the value of the flag as a string. const char* const value_str = ParseFlagValue(str, flag, false); // Aborts if the parsing failed. if (value_str == NULL) return false; // Sets *value to the value of the flag. return ParseInt32(Message() << "The value of flag --" << flag, value_str, value); } // Parses a string for a string flag, in the form of // "--flag=value". // // On success, stores the value of the flag in *value, and returns // true. On failure, returns false without changing *value. bool ParseStringFlag(const char* str, const char* flag, std::string* value) { // Gets the value of the flag as a string. const char* const value_str = ParseFlagValue(str, flag, false); // Aborts if the parsing failed. if (value_str == NULL) return false; // Sets *value to the value of the flag. *value = value_str; return true; } // Determines whether a string has a prefix that Google Test uses for its // flags, i.e., starts with GTEST_FLAG_PREFIX_ or GTEST_FLAG_PREFIX_DASH_. // If Google Test detects that a command line flag has its prefix but is not // recognized, it will print its help message. Flags starting with // GTEST_INTERNAL_PREFIX_ followed by "internal_" are considered Google Test // internal flags and do not trigger the help message. static bool HasGoogleTestFlagPrefix(const char* str) { return (SkipPrefix("--", &str) || SkipPrefix("-", &str) || SkipPrefix("/", &str)) && !SkipPrefix(GTEST_FLAG_PREFIX_ "internal_", &str) && (SkipPrefix(GTEST_FLAG_PREFIX_, &str) || SkipPrefix(GTEST_FLAG_PREFIX_DASH_, &str)); } // Prints a string containing code-encoded text. The following escape // sequences can be used in the string to control the text color: // // @@ prints a single '@' character. // @R changes the color to red. // @G changes the color to green. // @Y changes the color to yellow. // @D changes to the default terminal text color. // // TODO(wan@google.com): Write tests for this once we add stdout // capturing to Google Test. static void PrintColorEncoded(const char* str) { GTestColor color = COLOR_DEFAULT; // The current color. // Conceptually, we split the string into segments divided by escape // sequences. Then we print one segment at a time. At the end of // each iteration, the str pointer advances to the beginning of the // next segment. for (;;) { const char* p = strchr(str, '@'); if (p == NULL) { ColoredPrintf(color, "%s", str); return; } ColoredPrintf(color, "%s", std::string(str, p).c_str()); const char ch = p[1]; str = p + 2; if (ch == '@') { ColoredPrintf(color, "@"); } else if (ch == 'D') { color = COLOR_DEFAULT; } else if (ch == 'R') { color = COLOR_RED; } else if (ch == 'G') { color = COLOR_GREEN; } else if (ch == 'Y') { color = COLOR_YELLOW; } else { --str; } } } static const char kColorEncodedHelpMessage[] = "This program contains tests written using " GTEST_NAME_ ". You can use the\n" "following command line flags to control its behavior:\n" "\n" "Test Selection:\n" " @G--" GTEST_FLAG_PREFIX_ "list_tests@D\n" " List the names of all tests instead of running them. The name of\n" " TEST(Foo, Bar) is \"Foo.Bar\".\n" " @G--" GTEST_FLAG_PREFIX_ "filter=@YPOSTIVE_PATTERNS" "[@G-@YNEGATIVE_PATTERNS]@D\n" " Run only the tests whose name matches one of the positive patterns but\n" " none of the negative patterns. '?' matches any single character; '*'\n" " matches any substring; ':' separates two patterns.\n" " @G--" GTEST_FLAG_PREFIX_ "also_run_disabled_tests@D\n" " Run all disabled tests too.\n" "\n" "Test Execution:\n" " @G--" GTEST_FLAG_PREFIX_ "repeat=@Y[COUNT]@D\n" " Run the tests repeatedly; use a negative count to repeat forever.\n" " @G--" GTEST_FLAG_PREFIX_ "shuffle@D\n" " Randomize tests' orders on every iteration.\n" " @G--" GTEST_FLAG_PREFIX_ "random_seed=@Y[NUMBER]@D\n" " Random number seed to use for shuffling test orders (between 1 and\n" " 99999, or 0 to use a seed based on the current time).\n" "\n" "Test Output:\n" " @G--" GTEST_FLAG_PREFIX_ "color=@Y(@Gyes@Y|@Gno@Y|@Gauto@Y)@D\n" " Enable/disable colored output. The default is @Gauto@D.\n" " -@G-" GTEST_FLAG_PREFIX_ "print_time=0@D\n" " Don't print the elapsed time of each test.\n" " @G--" GTEST_FLAG_PREFIX_ "output=xml@Y[@G:@YDIRECTORY_PATH@G" GTEST_PATH_SEP_ "@Y|@G:@YFILE_PATH]@D\n" " Generate an XML report in the given directory or with the given file\n" " name. @YFILE_PATH@D defaults to @Gtest_details.xml@D.\n" #if GTEST_CAN_STREAM_RESULTS_ " @G--" GTEST_FLAG_PREFIX_ "stream_result_to=@YHOST@G:@YPORT@D\n" " Stream test results to the given server.\n" #endif // GTEST_CAN_STREAM_RESULTS_ "\n" "Assertion Behavior:\n" #if GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS " @G--" GTEST_FLAG_PREFIX_ "death_test_style=@Y(@Gfast@Y|@Gthreadsafe@Y)@D\n" " Set the default death test style.\n" #endif // GTEST_HAS_DEATH_TEST && !GTEST_OS_WINDOWS " @G--" GTEST_FLAG_PREFIX_ "break_on_failure@D\n" " Turn assertion failures into debugger break-points.\n" " @G--" GTEST_FLAG_PREFIX_ "throw_on_failure@D\n" " Turn assertion failures into C++ exceptions.\n" " @G--" GTEST_FLAG_PREFIX_ "catch_exceptions=0@D\n" " Do not report exceptions as test failures. Instead, allow them\n" " to crash the program or throw a pop-up (on Windows).\n" "\n" "Except for @G--" GTEST_FLAG_PREFIX_ "list_tests@D, you can alternatively set " "the corresponding\n" "environment variable of a flag (all letters in upper-case). For example, to\n" "disable colored text output, you can either specify @G--" GTEST_FLAG_PREFIX_ "color=no@D or set\n" "the @G" GTEST_FLAG_PREFIX_UPPER_ "COLOR@D environment variable to @Gno@D.\n" "\n" "For more information, please read the " GTEST_NAME_ " documentation at\n" "@G" GTEST_PROJECT_URL_ "@D. If you find a bug in " GTEST_NAME_ "\n" "(not one in your own code or tests), please report it to\n" "@G<" GTEST_DEV_EMAIL_ ">@D.\n"; // Parses the command line for Google Test flags, without initializing // other parts of Google Test. The type parameter CharType can be // instantiated to either char or wchar_t. template void ParseGoogleTestFlagsOnlyImpl(int* argc, CharType** argv) { for (int i = 1; i < *argc; i++) { const std::string arg_string = StreamableToString(argv[i]); const char* const arg = arg_string.c_str(); using internal::ParseBoolFlag; using internal::ParseInt32Flag; using internal::ParseStringFlag; // Do we see a Google Test flag? if (ParseBoolFlag(arg, kAlsoRunDisabledTestsFlag, >EST_FLAG(also_run_disabled_tests)) || ParseBoolFlag(arg, kBreakOnFailureFlag, >EST_FLAG(break_on_failure)) || ParseBoolFlag(arg, kCatchExceptionsFlag, >EST_FLAG(catch_exceptions)) || ParseStringFlag(arg, kColorFlag, >EST_FLAG(color)) || ParseStringFlag(arg, kDeathTestStyleFlag, >EST_FLAG(death_test_style)) || ParseBoolFlag(arg, kDeathTestUseFork, >EST_FLAG(death_test_use_fork)) || ParseStringFlag(arg, kFilterFlag, >EST_FLAG(filter)) || ParseStringFlag(arg, kInternalRunDeathTestFlag, >EST_FLAG(internal_run_death_test)) || ParseBoolFlag(arg, kListTestsFlag, >EST_FLAG(list_tests)) || ParseStringFlag(arg, kOutputFlag, >EST_FLAG(output)) || ParseBoolFlag(arg, kPrintTimeFlag, >EST_FLAG(print_time)) || ParseInt32Flag(arg, kRandomSeedFlag, >EST_FLAG(random_seed)) || ParseInt32Flag(arg, kRepeatFlag, >EST_FLAG(repeat)) || ParseBoolFlag(arg, kShuffleFlag, >EST_FLAG(shuffle)) || ParseInt32Flag(arg, kStackTraceDepthFlag, >EST_FLAG(stack_trace_depth)) || ParseStringFlag(arg, kStreamResultToFlag, >EST_FLAG(stream_result_to)) || ParseBoolFlag(arg, kThrowOnFailureFlag, >EST_FLAG(throw_on_failure)) ) { // Yes. Shift the remainder of the argv list left by one. Note // that argv has (*argc + 1) elements, the last one always being // NULL. The following loop moves the trailing NULL element as // well. for (int j = i; j != *argc; j++) { argv[j] = argv[j + 1]; } // Decrements the argument count. (*argc)--; // We also need to decrement the iterator as we just removed // an element. i--; } else if (arg_string == "--help" || arg_string == "-h" || arg_string == "-?" || arg_string == "/?" || HasGoogleTestFlagPrefix(arg)) { // Both help flag and unrecognized Google Test flags (excluding // internal ones) trigger help display. g_help_flag = true; } } if (g_help_flag) { // We print the help here instead of in RUN_ALL_TESTS(), as the // latter may not be called at all if the user is using Google // Test with another testing framework. PrintColorEncoded(kColorEncodedHelpMessage); } } // Parses the command line for Google Test flags, without initializing // other parts of Google Test. void ParseGoogleTestFlagsOnly(int* argc, char** argv) { ParseGoogleTestFlagsOnlyImpl(argc, argv); } void ParseGoogleTestFlagsOnly(int* argc, wchar_t** argv) { ParseGoogleTestFlagsOnlyImpl(argc, argv); } // The internal implementation of InitGoogleTest(). // // The type parameter CharType can be instantiated to either char or // wchar_t. template void InitGoogleTestImpl(int* argc, CharType** argv) { g_init_gtest_count++; // We don't want to run the initialization code twice. if (g_init_gtest_count != 1) return; if (*argc <= 0) return; internal::g_executable_path = internal::StreamableToString(argv[0]); #if GTEST_HAS_DEATH_TEST g_argvs.clear(); for (int i = 0; i != *argc; i++) { g_argvs.push_back(StreamableToString(argv[i])); } #endif // GTEST_HAS_DEATH_TEST ParseGoogleTestFlagsOnly(argc, argv); GetUnitTestImpl()->PostFlagParsingInit(); } } // namespace internal // Initializes Google Test. This must be called before calling // RUN_ALL_TESTS(). In particular, it parses a command line for the // flags that Google Test recognizes. Whenever a Google Test flag is // seen, it is removed from argv, and *argc is decremented. // // No value is returned. Instead, the Google Test flag variables are // updated. // // Calling the function for the second time has no user-visible effect. void InitGoogleTest(int* argc, char** argv) { internal::InitGoogleTestImpl(argc, argv); } // This overloaded version can be used in Windows programs compiled in // UNICODE mode. void InitGoogleTest(int* argc, wchar_t** argv) { internal::InitGoogleTestImpl(argc, argv); } } // namespace testing // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan), vladl@google.com (Vlad Losev) // // This file implements death tests. #if GTEST_HAS_DEATH_TEST # if GTEST_OS_MAC # include # endif // GTEST_OS_MAC # include # include # include # if GTEST_OS_LINUX # include # endif // GTEST_OS_LINUX # include # if GTEST_OS_WINDOWS # include # else # include # include # endif // GTEST_OS_WINDOWS # if GTEST_OS_QNX # include # endif // GTEST_OS_QNX #endif // GTEST_HAS_DEATH_TEST // Indicates that this translation unit is part of Google Test's // implementation. It must come before gtest-internal-inl.h is // included, or there will be a compiler error. This trick is to // prevent a user from accidentally including gtest-internal-inl.h in // his code. #define GTEST_IMPLEMENTATION_ 1 #undef GTEST_IMPLEMENTATION_ namespace testing { // Constants. // The default death test style. static const char kDefaultDeathTestStyle[] = "fast"; GTEST_DEFINE_string_( death_test_style, internal::StringFromGTestEnv("death_test_style", kDefaultDeathTestStyle), "Indicates how to run a death test in a forked child process: " "\"threadsafe\" (child process re-executes the test binary " "from the beginning, running only the specific death test) or " "\"fast\" (child process runs the death test immediately " "after forking)."); GTEST_DEFINE_bool_( death_test_use_fork, internal::BoolFromGTestEnv("death_test_use_fork", false), "Instructs to use fork()/_exit() instead of clone() in death tests. " "Ignored and always uses fork() on POSIX systems where clone() is not " "implemented. Useful when running under valgrind or similar tools if " "those do not support clone(). Valgrind 3.3.1 will just fail if " "it sees an unsupported combination of clone() flags. " "It is not recommended to use this flag w/o valgrind though it will " "work in 99% of the cases. Once valgrind is fixed, this flag will " "most likely be removed."); namespace internal { GTEST_DEFINE_string_( internal_run_death_test, "", "Indicates the file, line number, temporal index of " "the single death test to run, and a file descriptor to " "which a success code may be sent, all separated by " "the '|' characters. This flag is specified if and only if the current " "process is a sub-process launched for running a thread-safe " "death test. FOR INTERNAL USE ONLY."); } // namespace internal #if GTEST_HAS_DEATH_TEST namespace internal { // Valid only for fast death tests. Indicates the code is running in the // child process of a fast style death test. static bool g_in_fast_death_test_child = false; // Returns a Boolean value indicating whether the caller is currently // executing in the context of the death test child process. Tools such as // Valgrind heap checkers may need this to modify their behavior in death // tests. IMPORTANT: This is an internal utility. Using it may break the // implementation of death tests. User code MUST NOT use it. bool InDeathTestChild() { # if GTEST_OS_WINDOWS // On Windows, death tests are thread-safe regardless of the value of the // death_test_style flag. return !GTEST_FLAG(internal_run_death_test).empty(); # else if (GTEST_FLAG(death_test_style) == "threadsafe") return !GTEST_FLAG(internal_run_death_test).empty(); else return g_in_fast_death_test_child; #endif } } // namespace internal // ExitedWithCode constructor. ExitedWithCode::ExitedWithCode(int exit_code) : exit_code_(exit_code) { } // ExitedWithCode function-call operator. bool ExitedWithCode::operator()(int exit_status) const { # if GTEST_OS_WINDOWS return exit_status == exit_code_; # else return WIFEXITED(exit_status) && WEXITSTATUS(exit_status) == exit_code_; # endif // GTEST_OS_WINDOWS } # if !GTEST_OS_WINDOWS // KilledBySignal constructor. KilledBySignal::KilledBySignal(int signum) : signum_(signum) { } // KilledBySignal function-call operator. bool KilledBySignal::operator()(int exit_status) const { return WIFSIGNALED(exit_status) && WTERMSIG(exit_status) == signum_; } # endif // !GTEST_OS_WINDOWS namespace internal { // Utilities needed for death tests. // Generates a textual description of a given exit code, in the format // specified by wait(2). static std::string ExitSummary(int exit_code) { Message m; # if GTEST_OS_WINDOWS m << "Exited with exit status " << exit_code; # else if (WIFEXITED(exit_code)) { m << "Exited with exit status " << WEXITSTATUS(exit_code); } else if (WIFSIGNALED(exit_code)) { m << "Terminated by signal " << WTERMSIG(exit_code); } # ifdef WCOREDUMP if (WCOREDUMP(exit_code)) { m << " (core dumped)"; } # endif # endif // GTEST_OS_WINDOWS return m.GetString(); } // Returns true if exit_status describes a process that was terminated // by a signal, or exited normally with a nonzero exit code. bool ExitedUnsuccessfully(int exit_status) { return !ExitedWithCode(0)(exit_status); } # if !GTEST_OS_WINDOWS // Generates a textual failure message when a death test finds more than // one thread running, or cannot determine the number of threads, prior // to executing the given statement. It is the responsibility of the // caller not to pass a thread_count of 1. static std::string DeathTestThreadWarning(size_t thread_count) { Message msg; msg << "Death tests use fork(), which is unsafe particularly" << " in a threaded context. For this test, " << GTEST_NAME_ << " "; if (thread_count == 0) msg << "couldn't detect the number of threads."; else msg << "detected " << thread_count << " threads."; return msg.GetString(); } # endif // !GTEST_OS_WINDOWS // Flag characters for reporting a death test that did not die. static const char kDeathTestLived = 'L'; static const char kDeathTestReturned = 'R'; static const char kDeathTestThrew = 'T'; static const char kDeathTestInternalError = 'I'; // An enumeration describing all of the possible ways that a death test can // conclude. DIED means that the process died while executing the test // code; LIVED means that process lived beyond the end of the test code; // RETURNED means that the test statement attempted to execute a return // statement, which is not allowed; THREW means that the test statement // returned control by throwing an exception. IN_PROGRESS means the test // has not yet concluded. // TODO(vladl@google.com): Unify names and possibly values for // AbortReason, DeathTestOutcome, and flag characters above. enum DeathTestOutcome { IN_PROGRESS, DIED, LIVED, RETURNED, THREW }; // Routine for aborting the program which is safe to call from an // exec-style death test child process, in which case the error // message is propagated back to the parent process. Otherwise, the // message is simply printed to stderr. In either case, the program // then exits with status 1. void DeathTestAbort(const std::string& message) { // On a POSIX system, this function may be called from a threadsafe-style // death test child process, which operates on a very small stack. Use // the heap for any additional non-minuscule memory requirements. const InternalRunDeathTestFlag* const flag = GetUnitTestImpl()->internal_run_death_test_flag(); if (flag != NULL) { FILE* parent = posix::FDOpen(flag->write_fd(), "w"); fputc(kDeathTestInternalError, parent); fprintf(parent, "%s", message.c_str()); fflush(parent); _exit(1); } else { fprintf(stderr, "%s", message.c_str()); fflush(stderr); posix::Abort(); } } // A replacement for CHECK that calls DeathTestAbort if the assertion // fails. # define GTEST_DEATH_TEST_CHECK_(expression) \ do { \ if (!::testing::internal::IsTrue(expression)) { \ DeathTestAbort( \ ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ + ::testing::internal::StreamableToString(__LINE__) + ": " \ + #expression); \ } \ } while (::testing::internal::AlwaysFalse()) // This macro is similar to GTEST_DEATH_TEST_CHECK_, but it is meant for // evaluating any system call that fulfills two conditions: it must return // -1 on failure, and set errno to EINTR when it is interrupted and // should be tried again. The macro expands to a loop that repeatedly // evaluates the expression as long as it evaluates to -1 and sets // errno to EINTR. If the expression evaluates to -1 but errno is // something other than EINTR, DeathTestAbort is called. # define GTEST_DEATH_TEST_CHECK_SYSCALL_(expression) \ do { \ int gtest_retval; \ do { \ gtest_retval = (expression); \ } while (gtest_retval == -1 && errno == EINTR); \ if (gtest_retval == -1) { \ DeathTestAbort( \ ::std::string("CHECK failed: File ") + __FILE__ + ", line " \ + ::testing::internal::StreamableToString(__LINE__) + ": " \ + #expression + " != -1"); \ } \ } while (::testing::internal::AlwaysFalse()) // Returns the message describing the last system error in errno. std::string GetLastErrnoDescription() { return errno == 0 ? "" : posix::StrError(errno); } // This is called from a death test parent process to read a failure // message from the death test child process and log it with the FATAL // severity. On Windows, the message is read from a pipe handle. On other // platforms, it is read from a file descriptor. static void FailFromInternalError(int fd) { Message error; char buffer[256]; int num_read; do { while ((num_read = posix::Read(fd, buffer, 255)) > 0) { buffer[num_read] = '\0'; error << buffer; } } while (num_read == -1 && errno == EINTR); if (num_read == 0) { GTEST_LOG_(FATAL) << error.GetString(); } else { const int last_error = errno; GTEST_LOG_(FATAL) << "Error while reading death test internal: " << GetLastErrnoDescription() << " [" << last_error << "]"; } } // Death test constructor. Increments the running death test count // for the current test. DeathTest::DeathTest() { TestInfo* const info = GetUnitTestImpl()->current_test_info(); if (info == NULL) { DeathTestAbort("Cannot run a death test outside of a TEST or " "TEST_F construct"); } } // Creates and returns a death test by dispatching to the current // death test factory. bool DeathTest::Create(const char* statement, const RE* regex, const char* file, int line, DeathTest** test) { return GetUnitTestImpl()->death_test_factory()->Create( statement, regex, file, line, test); } const char* DeathTest::LastMessage() { return last_death_test_message_.c_str(); } void DeathTest::set_last_death_test_message(const std::string& message) { last_death_test_message_ = message; } std::string DeathTest::last_death_test_message_; // Provides cross platform implementation for some death functionality. class DeathTestImpl : public DeathTest { protected: DeathTestImpl(const char* a_statement, const RE* a_regex) : statement_(a_statement), regex_(a_regex), spawned_(false), status_(-1), outcome_(IN_PROGRESS), read_fd_(-1), write_fd_(-1) {} // read_fd_ is expected to be closed and cleared by a derived class. ~DeathTestImpl() { GTEST_DEATH_TEST_CHECK_(read_fd_ == -1); } void Abort(AbortReason reason); virtual bool Passed(bool status_ok); const char* statement() const { return statement_; } const RE* regex() const { return regex_; } bool spawned() const { return spawned_; } void set_spawned(bool is_spawned) { spawned_ = is_spawned; } int status() const { return status_; } void set_status(int a_status) { status_ = a_status; } DeathTestOutcome outcome() const { return outcome_; } void set_outcome(DeathTestOutcome an_outcome) { outcome_ = an_outcome; } int read_fd() const { return read_fd_; } void set_read_fd(int fd) { read_fd_ = fd; } int write_fd() const { return write_fd_; } void set_write_fd(int fd) { write_fd_ = fd; } // Called in the parent process only. Reads the result code of the death // test child process via a pipe, interprets it to set the outcome_ // member, and closes read_fd_. Outputs diagnostics and terminates in // case of unexpected codes. void ReadAndInterpretStatusByte(); private: // The textual content of the code this object is testing. This class // doesn't own this string and should not attempt to delete it. const char* const statement_; // The regular expression which test output must match. DeathTestImpl // doesn't own this object and should not attempt to delete it. const RE* const regex_; // True if the death test child process has been successfully spawned. bool spawned_; // The exit status of the child process. int status_; // How the death test concluded. DeathTestOutcome outcome_; // Descriptor to the read end of the pipe to the child process. It is // always -1 in the child process. The child keeps its write end of the // pipe in write_fd_. int read_fd_; // Descriptor to the child's write end of the pipe to the parent process. // It is always -1 in the parent process. The parent keeps its end of the // pipe in read_fd_. int write_fd_; }; // Called in the parent process only. Reads the result code of the death // test child process via a pipe, interprets it to set the outcome_ // member, and closes read_fd_. Outputs diagnostics and terminates in // case of unexpected codes. void DeathTestImpl::ReadAndInterpretStatusByte() { char flag; int bytes_read; // The read() here blocks until data is available (signifying the // failure of the death test) or until the pipe is closed (signifying // its success), so it's okay to call this in the parent before // the child process has exited. do { bytes_read = posix::Read(read_fd(), &flag, 1); } while (bytes_read == -1 && errno == EINTR); if (bytes_read == 0) { set_outcome(DIED); } else if (bytes_read == 1) { switch (flag) { case kDeathTestReturned: set_outcome(RETURNED); break; case kDeathTestThrew: set_outcome(THREW); break; case kDeathTestLived: set_outcome(LIVED); break; case kDeathTestInternalError: FailFromInternalError(read_fd()); // Does not return. break; default: GTEST_LOG_(FATAL) << "Death test child process reported " << "unexpected status byte (" << static_cast(flag) << ")"; } } else { GTEST_LOG_(FATAL) << "Read from death test child process failed: " << GetLastErrnoDescription(); } GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Close(read_fd())); set_read_fd(-1); } // Signals that the death test code which should have exited, didn't. // Should be called only in a death test child process. // Writes a status byte to the child's status file descriptor, then // calls _exit(1). void DeathTestImpl::Abort(AbortReason reason) { // The parent process considers the death test to be a failure if // it finds any data in our pipe. So, here we write a single flag byte // to the pipe, then exit. const char status_ch = reason == TEST_DID_NOT_DIE ? kDeathTestLived : reason == TEST_THREW_EXCEPTION ? kDeathTestThrew : kDeathTestReturned; GTEST_DEATH_TEST_CHECK_SYSCALL_(posix::Write(write_fd(), &status_ch, 1)); // We are leaking the descriptor here because on some platforms (i.e., // when built as Windows DLL), destructors of global objects will still // run after calling _exit(). On such systems, write_fd_ will be // indirectly closed from the destructor of UnitTestImpl, causing double // close if it is also closed here. On debug configurations, double close // may assert. As there are no in-process buffers to flush here, we are // relying on the OS to close the descriptor after the process terminates // when the destructors are not run. _exit(1); // Exits w/o any normal exit hooks (we were supposed to crash) } // Returns an indented copy of stderr output for a death test. // This makes distinguishing death test output lines from regular log lines // much easier. static ::std::string FormatDeathTestOutput(const ::std::string& output) { ::std::string ret; for (size_t at = 0; ; ) { const size_t line_end = output.find('\n', at); ret += "[ DEATH ] "; if (line_end == ::std::string::npos) { ret += output.substr(at); break; } ret += output.substr(at, line_end + 1 - at); at = line_end + 1; } return ret; } // Assesses the success or failure of a death test, using both private // members which have previously been set, and one argument: // // Private data members: // outcome: An enumeration describing how the death test // concluded: DIED, LIVED, THREW, or RETURNED. The death test // fails in the latter three cases. // status: The exit status of the child process. On *nix, it is in the // in the format specified by wait(2). On Windows, this is the // value supplied to the ExitProcess() API or a numeric code // of the exception that terminated the program. // regex: A regular expression object to be applied to // the test's captured standard error output; the death test // fails if it does not match. // // Argument: // status_ok: true if exit_status is acceptable in the context of // this particular death test, which fails if it is false // // Returns true iff all of the above conditions are met. Otherwise, the // first failing condition, in the order given above, is the one that is // reported. Also sets the last death test message string. bool DeathTestImpl::Passed(bool status_ok) { if (!spawned()) return false; const std::string error_message = GetCapturedStderr(); bool success = false; Message buffer; buffer << "Death test: " << statement() << "\n"; switch (outcome()) { case LIVED: buffer << " Result: failed to die.\n" << " Error msg:\n" << FormatDeathTestOutput(error_message); break; case THREW: buffer << " Result: threw an exception.\n" << " Error msg:\n" << FormatDeathTestOutput(error_message); break; case RETURNED: buffer << " Result: illegal return in test statement.\n" << " Error msg:\n" << FormatDeathTestOutput(error_message); break; case DIED: if (status_ok) { const bool matched = RE::PartialMatch(error_message.c_str(), *regex()); if (matched) { success = true; } else { buffer << " Result: died but not with expected error.\n" << " Expected: " << regex()->pattern() << "\n" << "Actual msg:\n" << FormatDeathTestOutput(error_message); } } else { buffer << " Result: died but not with expected exit code:\n" << " " << ExitSummary(status()) << "\n" << "Actual msg:\n" << FormatDeathTestOutput(error_message); } break; case IN_PROGRESS: default: GTEST_LOG_(FATAL) << "DeathTest::Passed somehow called before conclusion of test"; } DeathTest::set_last_death_test_message(buffer.GetString()); return success; } # if GTEST_OS_WINDOWS // WindowsDeathTest implements death tests on Windows. Due to the // specifics of starting new processes on Windows, death tests there are // always threadsafe, and Google Test considers the // --gtest_death_test_style=fast setting to be equivalent to // --gtest_death_test_style=threadsafe there. // // A few implementation notes: Like the Linux version, the Windows // implementation uses pipes for child-to-parent communication. But due to // the specifics of pipes on Windows, some extra steps are required: // // 1. The parent creates a communication pipe and stores handles to both // ends of it. // 2. The parent starts the child and provides it with the information // necessary to acquire the handle to the write end of the pipe. // 3. The child acquires the write end of the pipe and signals the parent // using a Windows event. // 4. Now the parent can release the write end of the pipe on its side. If // this is done before step 3, the object's reference count goes down to // 0 and it is destroyed, preventing the child from acquiring it. The // parent now has to release it, or read operations on the read end of // the pipe will not return when the child terminates. // 5. The parent reads child's output through the pipe (outcome code and // any possible error messages) from the pipe, and its stderr and then // determines whether to fail the test. // // Note: to distinguish Win32 API calls from the local method and function // calls, the former are explicitly resolved in the global namespace. // class WindowsDeathTest : public DeathTestImpl { public: WindowsDeathTest(const char* a_statement, const RE* a_regex, const char* file, int line) : DeathTestImpl(a_statement, a_regex), file_(file), line_(line) {} // All of these virtual functions are inherited from DeathTest. virtual int Wait(); virtual TestRole AssumeRole(); private: // The name of the file in which the death test is located. const char* const file_; // The line number on which the death test is located. const int line_; // Handle to the write end of the pipe to the child process. AutoHandle write_handle_; // Child process handle. AutoHandle child_handle_; // Event the child process uses to signal the parent that it has // acquired the handle to the write end of the pipe. After seeing this // event the parent can release its own handles to make sure its // ReadFile() calls return when the child terminates. AutoHandle event_handle_; }; // Waits for the child in a death test to exit, returning its exit // status, or 0 if no child process exists. As a side effect, sets the // outcome data member. int WindowsDeathTest::Wait() { if (!spawned()) return 0; // Wait until the child either signals that it has acquired the write end // of the pipe or it dies. const HANDLE wait_handles[2] = { child_handle_.Get(), event_handle_.Get() }; switch (::WaitForMultipleObjects(2, wait_handles, FALSE, // Waits for any of the handles. INFINITE)) { case WAIT_OBJECT_0: case WAIT_OBJECT_0 + 1: break; default: GTEST_DEATH_TEST_CHECK_(false); // Should not get here. } // The child has acquired the write end of the pipe or exited. // We release the handle on our side and continue. write_handle_.Reset(); event_handle_.Reset(); ReadAndInterpretStatusByte(); // Waits for the child process to exit if it haven't already. This // returns immediately if the child has already exited, regardless of // whether previous calls to WaitForMultipleObjects synchronized on this // handle or not. GTEST_DEATH_TEST_CHECK_( WAIT_OBJECT_0 == ::WaitForSingleObject(child_handle_.Get(), INFINITE)); DWORD status_code; GTEST_DEATH_TEST_CHECK_( ::GetExitCodeProcess(child_handle_.Get(), &status_code) != FALSE); child_handle_.Reset(); set_status(static_cast(status_code)); return status(); } // The AssumeRole process for a Windows death test. It creates a child // process with the same executable as the current process to run the // death test. The child process is given the --gtest_filter and // --gtest_internal_run_death_test flags such that it knows to run the // current death test only. DeathTest::TestRole WindowsDeathTest::AssumeRole() { const UnitTestImpl* const impl = GetUnitTestImpl(); const InternalRunDeathTestFlag* const flag = impl->internal_run_death_test_flag(); const TestInfo* const info = impl->current_test_info(); const int death_test_index = info->result()->death_test_count(); if (flag != NULL) { // ParseInternalRunDeathTestFlag() has performed all the necessary // processing. set_write_fd(flag->write_fd()); return EXECUTE_TEST; } // WindowsDeathTest uses an anonymous pipe to communicate results of // a death test. SECURITY_ATTRIBUTES handles_are_inheritable = { sizeof(SECURITY_ATTRIBUTES), NULL, TRUE }; HANDLE read_handle, write_handle; GTEST_DEATH_TEST_CHECK_( ::CreatePipe(&read_handle, &write_handle, &handles_are_inheritable, 0) // Default buffer size. != FALSE); set_read_fd(::_open_osfhandle(reinterpret_cast(read_handle), O_RDONLY)); write_handle_.Reset(write_handle); event_handle_.Reset(::CreateEvent( &handles_are_inheritable, TRUE, // The event will automatically reset to non-signaled state. FALSE, // The initial state is non-signalled. NULL)); // The even is unnamed. GTEST_DEATH_TEST_CHECK_(event_handle_.Get() != NULL); const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" + info->test_case_name() + "." + info->name(); const std::string internal_flag = std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "=" + file_ + "|" + StreamableToString(line_) + "|" + StreamableToString(death_test_index) + "|" + StreamableToString(static_cast(::GetCurrentProcessId())) + // size_t has the same width as pointers on both 32-bit and 64-bit // Windows platforms. // See http://msdn.microsoft.com/en-us/library/tcxf1dw6.aspx. "|" + StreamableToString(reinterpret_cast(write_handle)) + "|" + StreamableToString(reinterpret_cast(event_handle_.Get())); char executable_path[_MAX_PATH + 1]; // NOLINT GTEST_DEATH_TEST_CHECK_( _MAX_PATH + 1 != ::GetModuleFileNameA(NULL, executable_path, _MAX_PATH)); std::string command_line = std::string(::GetCommandLineA()) + " " + filter_flag + " \"" + internal_flag + "\""; DeathTest::set_last_death_test_message(""); CaptureStderr(); // Flush the log buffers since the log streams are shared with the child. FlushInfoLog(); // The child process will share the standard handles with the parent. STARTUPINFOA startup_info; memset(&startup_info, 0, sizeof(STARTUPINFO)); startup_info.dwFlags = STARTF_USESTDHANDLES; startup_info.hStdInput = ::GetStdHandle(STD_INPUT_HANDLE); startup_info.hStdOutput = ::GetStdHandle(STD_OUTPUT_HANDLE); startup_info.hStdError = ::GetStdHandle(STD_ERROR_HANDLE); PROCESS_INFORMATION process_info; GTEST_DEATH_TEST_CHECK_(::CreateProcessA( executable_path, const_cast(command_line.c_str()), NULL, // Retuned process handle is not inheritable. NULL, // Retuned thread handle is not inheritable. TRUE, // Child inherits all inheritable handles (for write_handle_). 0x0, // Default creation flags. NULL, // Inherit the parent's environment. UnitTest::GetInstance()->original_working_dir(), &startup_info, &process_info) != FALSE); child_handle_.Reset(process_info.hProcess); ::CloseHandle(process_info.hThread); set_spawned(true); return OVERSEE_TEST; } # else // We are not on Windows. // ForkingDeathTest provides implementations for most of the abstract // methods of the DeathTest interface. Only the AssumeRole method is // left undefined. class ForkingDeathTest : public DeathTestImpl { public: ForkingDeathTest(const char* statement, const RE* regex); // All of these virtual functions are inherited from DeathTest. virtual int Wait(); protected: void set_child_pid(pid_t child_pid) { child_pid_ = child_pid; } private: // PID of child process during death test; 0 in the child process itself. pid_t child_pid_; }; // Constructs a ForkingDeathTest. ForkingDeathTest::ForkingDeathTest(const char* a_statement, const RE* a_regex) : DeathTestImpl(a_statement, a_regex), child_pid_(-1) {} // Waits for the child in a death test to exit, returning its exit // status, or 0 if no child process exists. As a side effect, sets the // outcome data member. int ForkingDeathTest::Wait() { if (!spawned()) return 0; ReadAndInterpretStatusByte(); int status_value; GTEST_DEATH_TEST_CHECK_SYSCALL_(waitpid(child_pid_, &status_value, 0)); set_status(status_value); return status_value; } // A concrete death test class that forks, then immediately runs the test // in the child process. class NoExecDeathTest : public ForkingDeathTest { public: NoExecDeathTest(const char* a_statement, const RE* a_regex) : ForkingDeathTest(a_statement, a_regex) { } virtual TestRole AssumeRole(); }; // The AssumeRole process for a fork-and-run death test. It implements a // straightforward fork, with a simple pipe to transmit the status byte. DeathTest::TestRole NoExecDeathTest::AssumeRole() { const size_t thread_count = GetThreadCount(); if (thread_count != 1) { GTEST_LOG_(WARNING) << DeathTestThreadWarning(thread_count); } int pipe_fd[2]; GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); DeathTest::set_last_death_test_message(""); CaptureStderr(); // When we fork the process below, the log file buffers are copied, but the // file descriptors are shared. We flush all log files here so that closing // the file descriptors in the child process doesn't throw off the // synchronization between descriptors and buffers in the parent process. // This is as close to the fork as possible to avoid a race condition in case // there are multiple threads running before the death test, and another // thread writes to the log file. FlushInfoLog(); const pid_t child_pid = fork(); GTEST_DEATH_TEST_CHECK_(child_pid != -1); set_child_pid(child_pid); if (child_pid == 0) { GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[0])); set_write_fd(pipe_fd[1]); // Redirects all logging to stderr in the child process to prevent // concurrent writes to the log files. We capture stderr in the parent // process and append the child process' output to a log. LogToStderr(); // Event forwarding to the listeners of event listener API mush be shut // down in death test subprocesses. GetUnitTestImpl()->listeners()->SuppressEventForwarding(); g_in_fast_death_test_child = true; return EXECUTE_TEST; } else { GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); set_read_fd(pipe_fd[0]); set_spawned(true); return OVERSEE_TEST; } } // A concrete death test class that forks and re-executes the main // program from the beginning, with command-line flags set that cause // only this specific death test to be run. class ExecDeathTest : public ForkingDeathTest { public: ExecDeathTest(const char* a_statement, const RE* a_regex, const char* file, int line) : ForkingDeathTest(a_statement, a_regex), file_(file), line_(line) { } virtual TestRole AssumeRole(); private: static ::std::vector GetArgvsForDeathTestChildProcess() { ::std::vector args = GetInjectableArgvs(); return args; } // The name of the file in which the death test is located. const char* const file_; // The line number on which the death test is located. const int line_; }; // Utility class for accumulating command-line arguments. class Arguments { public: Arguments() { args_.push_back(NULL); } ~Arguments() { for (std::vector::iterator i = args_.begin(); i != args_.end(); ++i) { free(*i); } } void AddArgument(const char* argument) { args_.insert(args_.end() - 1, posix::StrDup(argument)); } template void AddArguments(const ::std::vector& arguments) { for (typename ::std::vector::const_iterator i = arguments.begin(); i != arguments.end(); ++i) { args_.insert(args_.end() - 1, posix::StrDup(i->c_str())); } } char* const* Argv() { return &args_[0]; } private: std::vector args_; }; // A struct that encompasses the arguments to the child process of a // threadsafe-style death test process. struct ExecDeathTestArgs { char* const* argv; // Command-line arguments for the child's call to exec int close_fd; // File descriptor to close; the read end of a pipe }; # if GTEST_OS_MAC inline char** GetEnviron() { // When Google Test is built as a framework on MacOS X, the environ variable // is unavailable. Apple's documentation (man environ) recommends using // _NSGetEnviron() instead. return *_NSGetEnviron(); } # else // Some POSIX platforms expect you to declare environ. extern "C" makes // it reside in the global namespace. extern "C" char** environ; inline char** GetEnviron() { return environ; } # endif // GTEST_OS_MAC # if !GTEST_OS_QNX // The main function for a threadsafe-style death test child process. // This function is called in a clone()-ed process and thus must avoid // any potentially unsafe operations like malloc or libc functions. static int ExecDeathTestChildMain(void* child_arg) { ExecDeathTestArgs* const args = static_cast(child_arg); GTEST_DEATH_TEST_CHECK_SYSCALL_(close(args->close_fd)); // We need to execute the test program in the same environment where // it was originally invoked. Therefore we change to the original // working directory first. const char* const original_dir = UnitTest::GetInstance()->original_working_dir(); // We can safely call chdir() as it's a direct system call. if (chdir(original_dir) != 0) { DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + GetLastErrnoDescription()); return EXIT_FAILURE; } // We can safely call execve() as it's a direct system call. We // cannot use execvp() as it's a libc function and thus potentially // unsafe. Since execve() doesn't search the PATH, the user must // invoke the test program via a valid path that contains at least // one path separator. execve(args->argv[0], args->argv, GetEnviron()); DeathTestAbort(std::string("execve(") + args->argv[0] + ", ...) in " + original_dir + " failed: " + GetLastErrnoDescription()); return EXIT_FAILURE; } # endif // !GTEST_OS_QNX // Two utility routines that together determine the direction the stack // grows. // This could be accomplished more elegantly by a single recursive // function, but we want to guard against the unlikely possibility of // a smart compiler optimizing the recursion away. // // GTEST_NO_INLINE_ is required to prevent GCC 4.6 from inlining // StackLowerThanAddress into StackGrowsDown, which then doesn't give // correct answer. void StackLowerThanAddress(const void* ptr, bool* result) GTEST_NO_INLINE_; void StackLowerThanAddress(const void* ptr, bool* result) { int dummy; *result = (&dummy < ptr); } bool StackGrowsDown() { int dummy; bool result; StackLowerThanAddress(&dummy, &result); return result; } // Spawns a child process with the same executable as the current process in // a thread-safe manner and instructs it to run the death test. The // implementation uses fork(2) + exec. On systems where clone(2) is // available, it is used instead, being slightly more thread-safe. On QNX, // fork supports only single-threaded environments, so this function uses // spawn(2) there instead. The function dies with an error message if // anything goes wrong. static pid_t ExecDeathTestSpawnChild(char* const* argv, int close_fd) { ExecDeathTestArgs args = { argv, close_fd }; pid_t child_pid = -1; # if GTEST_OS_QNX // Obtains the current directory and sets it to be closed in the child // process. const int cwd_fd = open(".", O_RDONLY); GTEST_DEATH_TEST_CHECK_(cwd_fd != -1); GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(cwd_fd, F_SETFD, FD_CLOEXEC)); // We need to execute the test program in the same environment where // it was originally invoked. Therefore we change to the original // working directory first. const char* const original_dir = UnitTest::GetInstance()->original_working_dir(); // We can safely call chdir() as it's a direct system call. if (chdir(original_dir) != 0) { DeathTestAbort(std::string("chdir(\"") + original_dir + "\") failed: " + GetLastErrnoDescription()); return EXIT_FAILURE; } int fd_flags; // Set close_fd to be closed after spawn. GTEST_DEATH_TEST_CHECK_SYSCALL_(fd_flags = fcntl(close_fd, F_GETFD)); GTEST_DEATH_TEST_CHECK_SYSCALL_(fcntl(close_fd, F_SETFD, fd_flags | FD_CLOEXEC)); struct inheritance inherit = {0}; // spawn is a system call. child_pid = spawn(args.argv[0], 0, NULL, &inherit, args.argv, GetEnviron()); // Restores the current working directory. GTEST_DEATH_TEST_CHECK_(fchdir(cwd_fd) != -1); GTEST_DEATH_TEST_CHECK_SYSCALL_(close(cwd_fd)); # else // GTEST_OS_QNX # if GTEST_OS_LINUX // When a SIGPROF signal is received while fork() or clone() are executing, // the process may hang. To avoid this, we ignore SIGPROF here and re-enable // it after the call to fork()/clone() is complete. struct sigaction saved_sigprof_action; struct sigaction ignore_sigprof_action; memset(&ignore_sigprof_action, 0, sizeof(ignore_sigprof_action)); sigemptyset(&ignore_sigprof_action.sa_mask); ignore_sigprof_action.sa_handler = SIG_IGN; GTEST_DEATH_TEST_CHECK_SYSCALL_(sigaction( SIGPROF, &ignore_sigprof_action, &saved_sigprof_action)); # endif // GTEST_OS_LINUX # if GTEST_HAS_CLONE const bool use_fork = GTEST_FLAG(death_test_use_fork); if (!use_fork) { static const bool stack_grows_down = StackGrowsDown(); const size_t stack_size = getpagesize(); // MMAP_ANONYMOUS is not defined on Mac, so we use MAP_ANON instead. void* const stack = mmap(NULL, stack_size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0); GTEST_DEATH_TEST_CHECK_(stack != MAP_FAILED); // Maximum stack alignment in bytes: For a downward-growing stack, this // amount is subtracted from size of the stack space to get an address // that is within the stack space and is aligned on all systems we care // about. As far as I know there is no ABI with stack alignment greater // than 64. We assume stack and stack_size already have alignment of // kMaxStackAlignment. const size_t kMaxStackAlignment = 64; void* const stack_top = static_cast(stack) + (stack_grows_down ? stack_size - kMaxStackAlignment : 0); GTEST_DEATH_TEST_CHECK_(stack_size > kMaxStackAlignment && reinterpret_cast(stack_top) % kMaxStackAlignment == 0); child_pid = clone(&ExecDeathTestChildMain, stack_top, SIGCHLD, &args); GTEST_DEATH_TEST_CHECK_(munmap(stack, stack_size) != -1); } # else const bool use_fork = true; # endif // GTEST_HAS_CLONE if (use_fork && (child_pid = fork()) == 0) { ExecDeathTestChildMain(&args); _exit(0); } # endif // GTEST_OS_QNX # if GTEST_OS_LINUX GTEST_DEATH_TEST_CHECK_SYSCALL_( sigaction(SIGPROF, &saved_sigprof_action, NULL)); # endif // GTEST_OS_LINUX GTEST_DEATH_TEST_CHECK_(child_pid != -1); return child_pid; } // The AssumeRole process for a fork-and-exec death test. It re-executes the // main program from the beginning, setting the --gtest_filter // and --gtest_internal_run_death_test flags to cause only the current // death test to be re-run. DeathTest::TestRole ExecDeathTest::AssumeRole() { const UnitTestImpl* const impl = GetUnitTestImpl(); const InternalRunDeathTestFlag* const flag = impl->internal_run_death_test_flag(); const TestInfo* const info = impl->current_test_info(); const int death_test_index = info->result()->death_test_count(); if (flag != NULL) { set_write_fd(flag->write_fd()); return EXECUTE_TEST; } int pipe_fd[2]; GTEST_DEATH_TEST_CHECK_(pipe(pipe_fd) != -1); // Clear the close-on-exec flag on the write end of the pipe, lest // it be closed when the child process does an exec: GTEST_DEATH_TEST_CHECK_(fcntl(pipe_fd[1], F_SETFD, 0) != -1); const std::string filter_flag = std::string("--") + GTEST_FLAG_PREFIX_ + kFilterFlag + "=" + info->test_case_name() + "." + info->name(); const std::string internal_flag = std::string("--") + GTEST_FLAG_PREFIX_ + kInternalRunDeathTestFlag + "=" + file_ + "|" + StreamableToString(line_) + "|" + StreamableToString(death_test_index) + "|" + StreamableToString(pipe_fd[1]); Arguments args; args.AddArguments(GetArgvsForDeathTestChildProcess()); args.AddArgument(filter_flag.c_str()); args.AddArgument(internal_flag.c_str()); DeathTest::set_last_death_test_message(""); CaptureStderr(); // See the comment in NoExecDeathTest::AssumeRole for why the next line // is necessary. FlushInfoLog(); const pid_t child_pid = ExecDeathTestSpawnChild(args.Argv(), pipe_fd[0]); GTEST_DEATH_TEST_CHECK_SYSCALL_(close(pipe_fd[1])); set_child_pid(child_pid); set_read_fd(pipe_fd[0]); set_spawned(true); return OVERSEE_TEST; } # endif // !GTEST_OS_WINDOWS // Creates a concrete DeathTest-derived class that depends on the // --gtest_death_test_style flag, and sets the pointer pointed to // by the "test" argument to its address. If the test should be // skipped, sets that pointer to NULL. Returns true, unless the // flag is set to an invalid value. bool DefaultDeathTestFactory::Create(const char* statement, const RE* regex, const char* file, int line, DeathTest** test) { UnitTestImpl* const impl = GetUnitTestImpl(); const InternalRunDeathTestFlag* const flag = impl->internal_run_death_test_flag(); const int death_test_index = impl->current_test_info() ->increment_death_test_count(); if (flag != NULL) { if (death_test_index > flag->index()) { DeathTest::set_last_death_test_message( "Death test count (" + StreamableToString(death_test_index) + ") somehow exceeded expected maximum (" + StreamableToString(flag->index()) + ")"); return false; } if (!(flag->file() == file && flag->line() == line && flag->index() == death_test_index)) { *test = NULL; return true; } } # if GTEST_OS_WINDOWS if (GTEST_FLAG(death_test_style) == "threadsafe" || GTEST_FLAG(death_test_style) == "fast") { *test = new WindowsDeathTest(statement, regex, file, line); } # else if (GTEST_FLAG(death_test_style) == "threadsafe") { *test = new ExecDeathTest(statement, regex, file, line); } else if (GTEST_FLAG(death_test_style) == "fast") { *test = new NoExecDeathTest(statement, regex); } # endif // GTEST_OS_WINDOWS else { // NOLINT - this is more readable than unbalanced brackets inside #if. DeathTest::set_last_death_test_message( "Unknown death test style \"" + GTEST_FLAG(death_test_style) + "\" encountered"); return false; } return true; } // Splits a given string on a given delimiter, populating a given // vector with the fields. GTEST_HAS_DEATH_TEST implies that we have // ::std::string, so we can use it here. static void SplitString(const ::std::string& str, char delimiter, ::std::vector< ::std::string>* dest) { ::std::vector< ::std::string> parsed; ::std::string::size_type pos = 0; while (::testing::internal::AlwaysTrue()) { const ::std::string::size_type colon = str.find(delimiter, pos); if (colon == ::std::string::npos) { parsed.push_back(str.substr(pos)); break; } else { parsed.push_back(str.substr(pos, colon - pos)); pos = colon + 1; } } dest->swap(parsed); } # if GTEST_OS_WINDOWS // Recreates the pipe and event handles from the provided parameters, // signals the event, and returns a file descriptor wrapped around the pipe // handle. This function is called in the child process only. int GetStatusFileDescriptor(unsigned int parent_process_id, size_t write_handle_as_size_t, size_t event_handle_as_size_t) { AutoHandle parent_process_handle(::OpenProcess(PROCESS_DUP_HANDLE, FALSE, // Non-inheritable. parent_process_id)); if (parent_process_handle.Get() == INVALID_HANDLE_VALUE) { DeathTestAbort("Unable to open parent process " + StreamableToString(parent_process_id)); } // TODO(vladl@google.com): Replace the following check with a // compile-time assertion when available. GTEST_CHECK_(sizeof(HANDLE) <= sizeof(size_t)); const HANDLE write_handle = reinterpret_cast(write_handle_as_size_t); HANDLE dup_write_handle; // The newly initialized handle is accessible only in in the parent // process. To obtain one accessible within the child, we need to use // DuplicateHandle. if (!::DuplicateHandle(parent_process_handle.Get(), write_handle, ::GetCurrentProcess(), &dup_write_handle, 0x0, // Requested privileges ignored since // DUPLICATE_SAME_ACCESS is used. FALSE, // Request non-inheritable handler. DUPLICATE_SAME_ACCESS)) { DeathTestAbort("Unable to duplicate the pipe handle " + StreamableToString(write_handle_as_size_t) + " from the parent process " + StreamableToString(parent_process_id)); } const HANDLE event_handle = reinterpret_cast(event_handle_as_size_t); HANDLE dup_event_handle; if (!::DuplicateHandle(parent_process_handle.Get(), event_handle, ::GetCurrentProcess(), &dup_event_handle, 0x0, FALSE, DUPLICATE_SAME_ACCESS)) { DeathTestAbort("Unable to duplicate the event handle " + StreamableToString(event_handle_as_size_t) + " from the parent process " + StreamableToString(parent_process_id)); } const int write_fd = ::_open_osfhandle(reinterpret_cast(dup_write_handle), O_APPEND); if (write_fd == -1) { DeathTestAbort("Unable to convert pipe handle " + StreamableToString(write_handle_as_size_t) + " to a file descriptor"); } // Signals the parent that the write end of the pipe has been acquired // so the parent can release its own write end. ::SetEvent(dup_event_handle); return write_fd; } # endif // GTEST_OS_WINDOWS // Returns a newly created InternalRunDeathTestFlag object with fields // initialized from the GTEST_FLAG(internal_run_death_test) flag if // the flag is specified; otherwise returns NULL. InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag() { if (GTEST_FLAG(internal_run_death_test) == "") return NULL; // GTEST_HAS_DEATH_TEST implies that we have ::std::string, so we // can use it here. int line = -1; int index = -1; ::std::vector< ::std::string> fields; SplitString(GTEST_FLAG(internal_run_death_test).c_str(), '|', &fields); int write_fd = -1; # if GTEST_OS_WINDOWS unsigned int parent_process_id = 0; size_t write_handle_as_size_t = 0; size_t event_handle_as_size_t = 0; if (fields.size() != 6 || !ParseNaturalNumber(fields[1], &line) || !ParseNaturalNumber(fields[2], &index) || !ParseNaturalNumber(fields[3], &parent_process_id) || !ParseNaturalNumber(fields[4], &write_handle_as_size_t) || !ParseNaturalNumber(fields[5], &event_handle_as_size_t)) { DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + GTEST_FLAG(internal_run_death_test)); } write_fd = GetStatusFileDescriptor(parent_process_id, write_handle_as_size_t, event_handle_as_size_t); # else if (fields.size() != 4 || !ParseNaturalNumber(fields[1], &line) || !ParseNaturalNumber(fields[2], &index) || !ParseNaturalNumber(fields[3], &write_fd)) { DeathTestAbort("Bad --gtest_internal_run_death_test flag: " + GTEST_FLAG(internal_run_death_test)); } # endif // GTEST_OS_WINDOWS return new InternalRunDeathTestFlag(fields[0], line, index, write_fd); } } // namespace internal #endif // GTEST_HAS_DEATH_TEST } // namespace testing // Copyright 2008, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Authors: keith.ray@gmail.com (Keith Ray) #include #if GTEST_OS_WINDOWS_MOBILE # include #elif GTEST_OS_WINDOWS # include # include #elif GTEST_OS_SYMBIAN // Symbian OpenC has PATH_MAX in sys/syslimits.h # include #else # include # include // Some Linux distributions define PATH_MAX here. #endif // GTEST_OS_WINDOWS_MOBILE #if GTEST_OS_WINDOWS # define GTEST_PATH_MAX_ _MAX_PATH #elif defined(PATH_MAX) # define GTEST_PATH_MAX_ PATH_MAX #elif defined(_XOPEN_PATH_MAX) # define GTEST_PATH_MAX_ _XOPEN_PATH_MAX #else # define GTEST_PATH_MAX_ _POSIX_PATH_MAX #endif // GTEST_OS_WINDOWS namespace testing { namespace internal { #if GTEST_OS_WINDOWS // On Windows, '\\' is the standard path separator, but many tools and the // Windows API also accept '/' as an alternate path separator. Unless otherwise // noted, a file path can contain either kind of path separators, or a mixture // of them. const char kPathSeparator = '\\'; const char kAlternatePathSeparator = '/'; const char kPathSeparatorString[] = "\\"; const char kAlternatePathSeparatorString[] = "/"; # if GTEST_OS_WINDOWS_MOBILE // Windows CE doesn't have a current directory. You should not use // the current directory in tests on Windows CE, but this at least // provides a reasonable fallback. const char kCurrentDirectoryString[] = "\\"; // Windows CE doesn't define INVALID_FILE_ATTRIBUTES const DWORD kInvalidFileAttributes = 0xffffffff; # else const char kCurrentDirectoryString[] = ".\\"; # endif // GTEST_OS_WINDOWS_MOBILE #else const char kPathSeparator = '/'; const char kPathSeparatorString[] = "/"; const char kCurrentDirectoryString[] = "./"; #endif // GTEST_OS_WINDOWS // Returns whether the given character is a valid path separator. static bool IsPathSeparator(char c) { #if GTEST_HAS_ALT_PATH_SEP_ return (c == kPathSeparator) || (c == kAlternatePathSeparator); #else return c == kPathSeparator; #endif } // Returns the current working directory, or "" if unsuccessful. FilePath FilePath::GetCurrentDir() { #if GTEST_OS_WINDOWS_MOBILE // Windows CE doesn't have a current directory, so we just return // something reasonable. return FilePath(kCurrentDirectoryString); #elif GTEST_OS_WINDOWS char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; return FilePath(_getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd); #else char cwd[GTEST_PATH_MAX_ + 1] = { '\0' }; return FilePath(getcwd(cwd, sizeof(cwd)) == NULL ? "" : cwd); #endif // GTEST_OS_WINDOWS_MOBILE } // Returns a copy of the FilePath with the case-insensitive extension removed. // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns // FilePath("dir/file"). If a case-insensitive extension is not // found, returns a copy of the original FilePath. FilePath FilePath::RemoveExtension(const char* extension) const { const std::string dot_extension = std::string(".") + extension; if (String::EndsWithCaseInsensitive(pathname_, dot_extension)) { return FilePath(pathname_.substr( 0, pathname_.length() - dot_extension.length())); } return *this; } // Returns a pointer to the last occurence of a valid path separator in // the FilePath. On Windows, for example, both '/' and '\' are valid path // separators. Returns NULL if no path separator was found. const char* FilePath::FindLastPathSeparator() const { const char* const last_sep = strrchr(c_str(), kPathSeparator); #if GTEST_HAS_ALT_PATH_SEP_ const char* const last_alt_sep = strrchr(c_str(), kAlternatePathSeparator); // Comparing two pointers of which only one is NULL is undefined. if (last_alt_sep != NULL && (last_sep == NULL || last_alt_sep > last_sep)) { return last_alt_sep; } #endif return last_sep; } // Returns a copy of the FilePath with the directory part removed. // Example: FilePath("path/to/file").RemoveDirectoryName() returns // FilePath("file"). If there is no directory part ("just_a_file"), it returns // the FilePath unmodified. If there is no file part ("just_a_dir/") it // returns an empty FilePath (""). // On Windows platform, '\' is the path separator, otherwise it is '/'. FilePath FilePath::RemoveDirectoryName() const { const char* const last_sep = FindLastPathSeparator(); return last_sep ? FilePath(last_sep + 1) : *this; } // RemoveFileName returns the directory path with the filename removed. // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". // If the FilePath is "a_file" or "/a_file", RemoveFileName returns // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does // not have a file, like "just/a/dir/", it returns the FilePath unmodified. // On Windows platform, '\' is the path separator, otherwise it is '/'. FilePath FilePath::RemoveFileName() const { const char* const last_sep = FindLastPathSeparator(); std::string dir; if (last_sep) { dir = std::string(c_str(), last_sep + 1 - c_str()); } else { dir = kCurrentDirectoryString; } return FilePath(dir); } // Helper functions for naming files in a directory for xml output. // Given directory = "dir", base_name = "test", number = 0, // extension = "xml", returns "dir/test.xml". If number is greater // than zero (e.g., 12), returns "dir/test_12.xml". // On Windows platform, uses \ as the separator rather than /. FilePath FilePath::MakeFileName(const FilePath& directory, const FilePath& base_name, int number, const char* extension) { std::string file; if (number == 0) { file = base_name.string() + "." + extension; } else { file = base_name.string() + "_" + StreamableToString(number) + "." + extension; } return ConcatPaths(directory, FilePath(file)); } // Given directory = "dir", relative_path = "test.xml", returns "dir/test.xml". // On Windows, uses \ as the separator rather than /. FilePath FilePath::ConcatPaths(const FilePath& directory, const FilePath& relative_path) { if (directory.IsEmpty()) return relative_path; const FilePath dir(directory.RemoveTrailingPathSeparator()); return FilePath(dir.string() + kPathSeparator + relative_path.string()); } // Returns true if pathname describes something findable in the file-system, // either a file, directory, or whatever. bool FilePath::FileOrDirectoryExists() const { #if GTEST_OS_WINDOWS_MOBILE LPCWSTR unicode = String::AnsiToUtf16(pathname_.c_str()); const DWORD attributes = GetFileAttributes(unicode); delete [] unicode; return attributes != kInvalidFileAttributes; #else posix::StatStruct file_stat; return posix::Stat(pathname_.c_str(), &file_stat) == 0; #endif // GTEST_OS_WINDOWS_MOBILE } // Returns true if pathname describes a directory in the file-system // that exists. bool FilePath::DirectoryExists() const { bool result = false; #if GTEST_OS_WINDOWS // Don't strip off trailing separator if path is a root directory on // Windows (like "C:\\"). const FilePath& path(IsRootDirectory() ? *this : RemoveTrailingPathSeparator()); #else const FilePath& path(*this); #endif #if GTEST_OS_WINDOWS_MOBILE LPCWSTR unicode = String::AnsiToUtf16(path.c_str()); const DWORD attributes = GetFileAttributes(unicode); delete [] unicode; if ((attributes != kInvalidFileAttributes) && (attributes & FILE_ATTRIBUTE_DIRECTORY)) { result = true; } #else posix::StatStruct file_stat; result = posix::Stat(path.c_str(), &file_stat) == 0 && posix::IsDir(file_stat); #endif // GTEST_OS_WINDOWS_MOBILE return result; } // Returns true if pathname describes a root directory. (Windows has one // root directory per disk drive.) bool FilePath::IsRootDirectory() const { #if GTEST_OS_WINDOWS // TODO(wan@google.com): on Windows a network share like // \\server\share can be a root directory, although it cannot be the // current directory. Handle this properly. return pathname_.length() == 3 && IsAbsolutePath(); #else return pathname_.length() == 1 && IsPathSeparator(pathname_.c_str()[0]); #endif } // Returns true if pathname describes an absolute path. bool FilePath::IsAbsolutePath() const { const char* const name = pathname_.c_str(); #if GTEST_OS_WINDOWS return pathname_.length() >= 3 && ((name[0] >= 'a' && name[0] <= 'z') || (name[0] >= 'A' && name[0] <= 'Z')) && name[1] == ':' && IsPathSeparator(name[2]); #else return IsPathSeparator(name[0]); #endif } // Returns a pathname for a file that does not currently exist. The pathname // will be directory/base_name.extension or // directory/base_name_.extension if directory/base_name.extension // already exists. The number will be incremented until a pathname is found // that does not already exist. // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. // There could be a race condition if two or more processes are calling this // function at the same time -- they could both pick the same filename. FilePath FilePath::GenerateUniqueFileName(const FilePath& directory, const FilePath& base_name, const char* extension) { FilePath full_pathname; int number = 0; do { full_pathname.Set(MakeFileName(directory, base_name, number++, extension)); } while (full_pathname.FileOrDirectoryExists()); return full_pathname; } // Returns true if FilePath ends with a path separator, which indicates that // it is intended to represent a directory. Returns false otherwise. // This does NOT check that a directory (or file) actually exists. bool FilePath::IsDirectory() const { return !pathname_.empty() && IsPathSeparator(pathname_.c_str()[pathname_.length() - 1]); } // Create directories so that path exists. Returns true if successful or if // the directories already exist; returns false if unable to create directories // for any reason. bool FilePath::CreateDirectoriesRecursively() const { if (!this->IsDirectory()) { return false; } if (pathname_.length() == 0 || this->DirectoryExists()) { return true; } const FilePath parent(this->RemoveTrailingPathSeparator().RemoveFileName()); return parent.CreateDirectoriesRecursively() && this->CreateFolder(); } // Create the directory so that path exists. Returns true if successful or // if the directory already exists; returns false if unable to create the // directory for any reason, including if the parent directory does not // exist. Not named "CreateDirectory" because that's a macro on Windows. bool FilePath::CreateFolder() const { #if GTEST_OS_WINDOWS_MOBILE FilePath removed_sep(this->RemoveTrailingPathSeparator()); LPCWSTR unicode = String::AnsiToUtf16(removed_sep.c_str()); int result = CreateDirectory(unicode, NULL) ? 0 : -1; delete [] unicode; #elif GTEST_OS_WINDOWS int result = _mkdir(pathname_.c_str()); #else int result = mkdir(pathname_.c_str(), 0777); #endif // GTEST_OS_WINDOWS_MOBILE if (result == -1) { return this->DirectoryExists(); // An error is OK if the directory exists. } return true; // No error. } // If input name has a trailing separator character, remove it and return the // name, otherwise return the name string unmodified. // On Windows platform, uses \ as the separator, other platforms use /. FilePath FilePath::RemoveTrailingPathSeparator() const { return IsDirectory() ? FilePath(pathname_.substr(0, pathname_.length() - 1)) : *this; } // Removes any redundant separators that might be in the pathname. // For example, "bar///foo" becomes "bar/foo". Does not eliminate other // redundancies that might be in a pathname involving "." or "..". // TODO(wan@google.com): handle Windows network shares (e.g. \\server\share). void FilePath::Normalize() { if (pathname_.c_str() == NULL) { pathname_ = ""; return; } const char* src = pathname_.c_str(); char* const dest = new char[pathname_.length() + 1]; char* dest_ptr = dest; memset(dest_ptr, 0, pathname_.length() + 1); while (*src != '\0') { *dest_ptr = *src; if (!IsPathSeparator(*src)) { src++; } else { #if GTEST_HAS_ALT_PATH_SEP_ if (*dest_ptr == kAlternatePathSeparator) { *dest_ptr = kPathSeparator; } #endif while (IsPathSeparator(*src)) src++; } dest_ptr++; } *dest_ptr = '\0'; pathname_ = dest; delete[] dest; } } // namespace internal } // namespace testing // Copyright 2008, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) #include #include #include #include #if GTEST_OS_WINDOWS_MOBILE # include // For TerminateProcess() #elif GTEST_OS_WINDOWS # include # include #else # include #endif // GTEST_OS_WINDOWS_MOBILE #if GTEST_OS_MAC # include # include # include #endif // GTEST_OS_MAC #if GTEST_OS_QNX # include # include #endif // GTEST_OS_QNX // Indicates that this translation unit is part of Google Test's // implementation. It must come before gtest-internal-inl.h is // included, or there will be a compiler error. This trick is to // prevent a user from accidentally including gtest-internal-inl.h in // his code. #define GTEST_IMPLEMENTATION_ 1 #undef GTEST_IMPLEMENTATION_ namespace testing { namespace internal { #if defined(_MSC_VER) || defined(__BORLANDC__) // MSVC and C++Builder do not provide a definition of STDERR_FILENO. const int kStdOutFileno = 1; const int kStdErrFileno = 2; #else const int kStdOutFileno = STDOUT_FILENO; const int kStdErrFileno = STDERR_FILENO; #endif // _MSC_VER #if GTEST_OS_MAC // Returns the number of threads running in the process, or 0 to indicate that // we cannot detect it. size_t GetThreadCount() { const task_t task = mach_task_self(); mach_msg_type_number_t thread_count; thread_act_array_t thread_list; const kern_return_t status = task_threads(task, &thread_list, &thread_count); if (status == KERN_SUCCESS) { // task_threads allocates resources in thread_list and we need to free them // to avoid leaks. vm_deallocate(task, reinterpret_cast(thread_list), sizeof(thread_t) * thread_count); return static_cast(thread_count); } else { return 0; } } #elif GTEST_OS_QNX // Returns the number of threads running in the process, or 0 to indicate that // we cannot detect it. size_t GetThreadCount() { const int fd = open("/proc/self/as", O_RDONLY); if (fd < 0) { return 0; } procfs_info process_info; const int status = devctl(fd, DCMD_PROC_INFO, &process_info, sizeof(process_info), NULL); close(fd); if (status == EOK) { return static_cast(process_info.num_threads); } else { return 0; } } #else size_t GetThreadCount() { // There's no portable way to detect the number of threads, so we just // return 0 to indicate that we cannot detect it. return 0; } #endif // GTEST_OS_MAC #if GTEST_USES_POSIX_RE // Implements RE. Currently only needed for death tests. RE::~RE() { if (is_valid_) { // regfree'ing an invalid regex might crash because the content // of the regex is undefined. Since the regex's are essentially // the same, one cannot be valid (or invalid) without the other // being so too. regfree(&partial_regex_); regfree(&full_regex_); } free(const_cast(pattern_)); } // Returns true iff regular expression re matches the entire str. bool RE::FullMatch(const char* str, const RE& re) { if (!re.is_valid_) return false; regmatch_t match; return regexec(&re.full_regex_, str, 1, &match, 0) == 0; } // Returns true iff regular expression re matches a substring of str // (including str itself). bool RE::PartialMatch(const char* str, const RE& re) { if (!re.is_valid_) return false; regmatch_t match; return regexec(&re.partial_regex_, str, 1, &match, 0) == 0; } // Initializes an RE from its string representation. void RE::Init(const char* regex) { pattern_ = posix::StrDup(regex); // Reserves enough bytes to hold the regular expression used for a // full match. const size_t full_regex_len = strlen(regex) + 10; char* const full_pattern = new char[full_regex_len]; snprintf(full_pattern, full_regex_len, "^(%s)$", regex); is_valid_ = regcomp(&full_regex_, full_pattern, REG_EXTENDED) == 0; // We want to call regcomp(&partial_regex_, ...) even if the // previous expression returns false. Otherwise partial_regex_ may // not be properly initialized can may cause trouble when it's // freed. // // Some implementation of POSIX regex (e.g. on at least some // versions of Cygwin) doesn't accept the empty string as a valid // regex. We change it to an equivalent form "()" to be safe. if (is_valid_) { const char* const partial_regex = (*regex == '\0') ? "()" : regex; is_valid_ = regcomp(&partial_regex_, partial_regex, REG_EXTENDED) == 0; } EXPECT_TRUE(is_valid_) << "Regular expression \"" << regex << "\" is not a valid POSIX Extended regular expression."; delete[] full_pattern; } #elif GTEST_USES_SIMPLE_RE // Returns true iff ch appears anywhere in str (excluding the // terminating '\0' character). bool IsInSet(char ch, const char* str) { return ch != '\0' && strchr(str, ch) != NULL; } // Returns true iff ch belongs to the given classification. Unlike // similar functions in , these aren't affected by the // current locale. bool IsAsciiDigit(char ch) { return '0' <= ch && ch <= '9'; } bool IsAsciiPunct(char ch) { return IsInSet(ch, "^-!\"#$%&'()*+,./:;<=>?@[\\]_`{|}~"); } bool IsRepeat(char ch) { return IsInSet(ch, "?*+"); } bool IsAsciiWhiteSpace(char ch) { return IsInSet(ch, " \f\n\r\t\v"); } bool IsAsciiWordChar(char ch) { return ('a' <= ch && ch <= 'z') || ('A' <= ch && ch <= 'Z') || ('0' <= ch && ch <= '9') || ch == '_'; } // Returns true iff "\\c" is a supported escape sequence. bool IsValidEscape(char c) { return (IsAsciiPunct(c) || IsInSet(c, "dDfnrsStvwW")); } // Returns true iff the given atom (specified by escaped and pattern) // matches ch. The result is undefined if the atom is invalid. bool AtomMatchesChar(bool escaped, char pattern_char, char ch) { if (escaped) { // "\\p" where p is pattern_char. switch (pattern_char) { case 'd': return IsAsciiDigit(ch); case 'D': return !IsAsciiDigit(ch); case 'f': return ch == '\f'; case 'n': return ch == '\n'; case 'r': return ch == '\r'; case 's': return IsAsciiWhiteSpace(ch); case 'S': return !IsAsciiWhiteSpace(ch); case 't': return ch == '\t'; case 'v': return ch == '\v'; case 'w': return IsAsciiWordChar(ch); case 'W': return !IsAsciiWordChar(ch); } return IsAsciiPunct(pattern_char) && pattern_char == ch; } return (pattern_char == '.' && ch != '\n') || pattern_char == ch; } // Helper function used by ValidateRegex() to format error messages. std::string FormatRegexSyntaxError(const char* regex, int index) { return (Message() << "Syntax error at index " << index << " in simple regular expression \"" << regex << "\": ").GetString(); } // Generates non-fatal failures and returns false if regex is invalid; // otherwise returns true. bool ValidateRegex(const char* regex) { if (regex == NULL) { // TODO(wan@google.com): fix the source file location in the // assertion failures to match where the regex is used in user // code. ADD_FAILURE() << "NULL is not a valid simple regular expression."; return false; } bool is_valid = true; // True iff ?, *, or + can follow the previous atom. bool prev_repeatable = false; for (int i = 0; regex[i]; i++) { if (regex[i] == '\\') { // An escape sequence i++; if (regex[i] == '\0') { ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) << "'\\' cannot appear at the end."; return false; } if (!IsValidEscape(regex[i])) { ADD_FAILURE() << FormatRegexSyntaxError(regex, i - 1) << "invalid escape sequence \"\\" << regex[i] << "\"."; is_valid = false; } prev_repeatable = true; } else { // Not an escape sequence. const char ch = regex[i]; if (ch == '^' && i > 0) { ADD_FAILURE() << FormatRegexSyntaxError(regex, i) << "'^' can only appear at the beginning."; is_valid = false; } else if (ch == '$' && regex[i + 1] != '\0') { ADD_FAILURE() << FormatRegexSyntaxError(regex, i) << "'$' can only appear at the end."; is_valid = false; } else if (IsInSet(ch, "()[]{}|")) { ADD_FAILURE() << FormatRegexSyntaxError(regex, i) << "'" << ch << "' is unsupported."; is_valid = false; } else if (IsRepeat(ch) && !prev_repeatable) { ADD_FAILURE() << FormatRegexSyntaxError(regex, i) << "'" << ch << "' can only follow a repeatable token."; is_valid = false; } prev_repeatable = !IsInSet(ch, "^$?*+"); } } return is_valid; } // Matches a repeated regex atom followed by a valid simple regular // expression. The regex atom is defined as c if escaped is false, // or \c otherwise. repeat is the repetition meta character (?, *, // or +). The behavior is undefined if str contains too many // characters to be indexable by size_t, in which case the test will // probably time out anyway. We are fine with this limitation as // std::string has it too. bool MatchRepetitionAndRegexAtHead( bool escaped, char c, char repeat, const char* regex, const char* str) { const size_t min_count = (repeat == '+') ? 1 : 0; const size_t max_count = (repeat == '?') ? 1 : static_cast(-1) - 1; // We cannot call numeric_limits::max() as it conflicts with the // max() macro on Windows. for (size_t i = 0; i <= max_count; ++i) { // We know that the atom matches each of the first i characters in str. if (i >= min_count && MatchRegexAtHead(regex, str + i)) { // We have enough matches at the head, and the tail matches too. // Since we only care about *whether* the pattern matches str // (as opposed to *how* it matches), there is no need to find a // greedy match. return true; } if (str[i] == '\0' || !AtomMatchesChar(escaped, c, str[i])) return false; } return false; } // Returns true iff regex matches a prefix of str. regex must be a // valid simple regular expression and not start with "^", or the // result is undefined. bool MatchRegexAtHead(const char* regex, const char* str) { if (*regex == '\0') // An empty regex matches a prefix of anything. return true; // "$" only matches the end of a string. Note that regex being // valid guarantees that there's nothing after "$" in it. if (*regex == '$') return *str == '\0'; // Is the first thing in regex an escape sequence? const bool escaped = *regex == '\\'; if (escaped) ++regex; if (IsRepeat(regex[1])) { // MatchRepetitionAndRegexAtHead() calls MatchRegexAtHead(), so // here's an indirect recursion. It terminates as the regex gets // shorter in each recursion. return MatchRepetitionAndRegexAtHead( escaped, regex[0], regex[1], regex + 2, str); } else { // regex isn't empty, isn't "$", and doesn't start with a // repetition. We match the first atom of regex with the first // character of str and recurse. return (*str != '\0') && AtomMatchesChar(escaped, *regex, *str) && MatchRegexAtHead(regex + 1, str + 1); } } // Returns true iff regex matches any substring of str. regex must be // a valid simple regular expression, or the result is undefined. // // The algorithm is recursive, but the recursion depth doesn't exceed // the regex length, so we won't need to worry about running out of // stack space normally. In rare cases the time complexity can be // exponential with respect to the regex length + the string length, // but usually it's must faster (often close to linear). bool MatchRegexAnywhere(const char* regex, const char* str) { if (regex == NULL || str == NULL) return false; if (*regex == '^') return MatchRegexAtHead(regex + 1, str); // A successful match can be anywhere in str. do { if (MatchRegexAtHead(regex, str)) return true; } while (*str++ != '\0'); return false; } // Implements the RE class. RE::~RE() { free(const_cast(pattern_)); free(const_cast(full_pattern_)); } // Returns true iff regular expression re matches the entire str. bool RE::FullMatch(const char* str, const RE& re) { return re.is_valid_ && MatchRegexAnywhere(re.full_pattern_, str); } // Returns true iff regular expression re matches a substring of str // (including str itself). bool RE::PartialMatch(const char* str, const RE& re) { return re.is_valid_ && MatchRegexAnywhere(re.pattern_, str); } // Initializes an RE from its string representation. void RE::Init(const char* regex) { pattern_ = full_pattern_ = NULL; if (regex != NULL) { pattern_ = posix::StrDup(regex); } is_valid_ = ValidateRegex(regex); if (!is_valid_) { // No need to calculate the full pattern when the regex is invalid. return; } const size_t len = strlen(regex); // Reserves enough bytes to hold the regular expression used for a // full match: we need space to prepend a '^', append a '$', and // terminate the string with '\0'. char* buffer = static_cast(malloc(len + 3)); full_pattern_ = buffer; if (*regex != '^') *buffer++ = '^'; // Makes sure full_pattern_ starts with '^'. // We don't use snprintf or strncpy, as they trigger a warning when // compiled with VC++ 8.0. memcpy(buffer, regex, len); buffer += len; if (len == 0 || regex[len - 1] != '$') *buffer++ = '$'; // Makes sure full_pattern_ ends with '$'. *buffer = '\0'; } #endif // GTEST_USES_POSIX_RE const char kUnknownFile[] = "unknown file"; // Formats a source file path and a line number as they would appear // in an error message from the compiler used to compile this code. GTEST_API_ ::std::string FormatFileLocation(const char* file, int line) { const std::string file_name(file == NULL ? kUnknownFile : file); if (line < 0) { return file_name + ":"; } #ifdef _MSC_VER return file_name + "(" + StreamableToString(line) + "):"; #else return file_name + ":" + StreamableToString(line) + ":"; #endif // _MSC_VER } // Formats a file location for compiler-independent XML output. // Although this function is not platform dependent, we put it next to // FormatFileLocation in order to contrast the two functions. // Note that FormatCompilerIndependentFileLocation() does NOT append colon // to the file location it produces, unlike FormatFileLocation(). GTEST_API_ ::std::string FormatCompilerIndependentFileLocation( const char* file, int line) { const std::string file_name(file == NULL ? kUnknownFile : file); if (line < 0) return file_name; else return file_name + ":" + StreamableToString(line); } GTestLog::GTestLog(GTestLogSeverity severity, const char* file, int line) : severity_(severity) { const char* const marker = severity == GTEST_INFO ? "[ INFO ]" : severity == GTEST_WARNING ? "[WARNING]" : severity == GTEST_ERROR ? "[ ERROR ]" : "[ FATAL ]"; GetStream() << ::std::endl << marker << " " << FormatFileLocation(file, line).c_str() << ": "; } // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. GTestLog::~GTestLog() { GetStream() << ::std::endl; if (severity_ == GTEST_FATAL) { fflush(stderr); posix::Abort(); } } // Disable Microsoft deprecation warnings for POSIX functions called from // this class (creat, dup, dup2, and close) #ifdef _MSC_VER # pragma warning(push) # pragma warning(disable: 4996) #endif // _MSC_VER #if GTEST_HAS_STREAM_REDIRECTION // Object that captures an output stream (stdout/stderr). class CapturedStream { public: // The ctor redirects the stream to a temporary file. explicit CapturedStream(int fd) : fd_(fd), uncaptured_fd_(dup(fd)) { # if GTEST_OS_WINDOWS char temp_dir_path[MAX_PATH + 1] = { '\0' }; // NOLINT char temp_file_path[MAX_PATH + 1] = { '\0' }; // NOLINT ::GetTempPathA(sizeof(temp_dir_path), temp_dir_path); const UINT success = ::GetTempFileNameA(temp_dir_path, "gtest_redir", 0, // Generate unique file name. temp_file_path); GTEST_CHECK_(success != 0) << "Unable to create a temporary file in " << temp_dir_path; const int captured_fd = creat(temp_file_path, _S_IREAD | _S_IWRITE); GTEST_CHECK_(captured_fd != -1) << "Unable to open temporary file " << temp_file_path; filename_ = temp_file_path; # else // There's no guarantee that a test has write access to the current // directory, so we create the temporary file in the /tmp directory // instead. We use /tmp on most systems, and /sdcard on Android. // That's because Android doesn't have /tmp. # if GTEST_OS_LINUX_ANDROID // Note: Android applications are expected to call the framework's // Context.getExternalStorageDirectory() method through JNI to get // the location of the world-writable SD Card directory. However, // this requires a Context handle, which cannot be retrieved // globally from native code. Doing so also precludes running the // code as part of a regular standalone executable, which doesn't // run in a Dalvik process (e.g. when running it through 'adb shell'). // // The location /sdcard is directly accessible from native code // and is the only location (unofficially) supported by the Android // team. It's generally a symlink to the real SD Card mount point // which can be /mnt/sdcard, /mnt/sdcard0, /system/media/sdcard, or // other OEM-customized locations. Never rely on these, and always // use /sdcard. char name_template[] = "/sdcard/gtest_captured_stream.XXXXXX"; # else char name_template[] = "/tmp/captured_stream.XXXXXX"; # endif // GTEST_OS_LINUX_ANDROID const int captured_fd = mkstemp(name_template); filename_ = name_template; # endif // GTEST_OS_WINDOWS fflush(NULL); dup2(captured_fd, fd_); close(captured_fd); } ~CapturedStream() { remove(filename_.c_str()); } std::string GetCapturedString() { if (uncaptured_fd_ != -1) { // Restores the original stream. fflush(NULL); dup2(uncaptured_fd_, fd_); close(uncaptured_fd_); uncaptured_fd_ = -1; } FILE* const file = posix::FOpen(filename_.c_str(), "r"); const std::string content = ReadEntireFile(file); posix::FClose(file); return content; } private: // Reads the entire content of a file as an std::string. static std::string ReadEntireFile(FILE* file); // Returns the size (in bytes) of a file. static size_t GetFileSize(FILE* file); const int fd_; // A stream to capture. int uncaptured_fd_; // Name of the temporary file holding the stderr output. ::std::string filename_; GTEST_DISALLOW_COPY_AND_ASSIGN_(CapturedStream); }; // Returns the size (in bytes) of a file. size_t CapturedStream::GetFileSize(FILE* file) { fseek(file, 0, SEEK_END); return static_cast(ftell(file)); } // Reads the entire content of a file as a string. std::string CapturedStream::ReadEntireFile(FILE* file) { const size_t file_size = GetFileSize(file); char* const buffer = new char[file_size]; size_t bytes_last_read = 0; // # of bytes read in the last fread() size_t bytes_read = 0; // # of bytes read so far fseek(file, 0, SEEK_SET); // Keeps reading the file until we cannot read further or the // pre-determined file size is reached. do { bytes_last_read = fread(buffer+bytes_read, 1, file_size-bytes_read, file); bytes_read += bytes_last_read; } while (bytes_last_read > 0 && bytes_read < file_size); const std::string content(buffer, bytes_read); delete[] buffer; return content; } # ifdef _MSC_VER # pragma warning(pop) # endif // _MSC_VER static CapturedStream* g_captured_stderr = NULL; static CapturedStream* g_captured_stdout = NULL; // Starts capturing an output stream (stdout/stderr). void CaptureStream(int fd, const char* stream_name, CapturedStream** stream) { if (*stream != NULL) { GTEST_LOG_(FATAL) << "Only one " << stream_name << " capturer can exist at a time."; } *stream = new CapturedStream(fd); } // Stops capturing the output stream and returns the captured string. std::string GetCapturedStream(CapturedStream** captured_stream) { const std::string content = (*captured_stream)->GetCapturedString(); delete *captured_stream; *captured_stream = NULL; return content; } // Starts capturing stdout. void CaptureStdout() { CaptureStream(kStdOutFileno, "stdout", &g_captured_stdout); } // Starts capturing stderr. void CaptureStderr() { CaptureStream(kStdErrFileno, "stderr", &g_captured_stderr); } // Stops capturing stdout and returns the captured string. std::string GetCapturedStdout() { return GetCapturedStream(&g_captured_stdout); } // Stops capturing stderr and returns the captured string. std::string GetCapturedStderr() { return GetCapturedStream(&g_captured_stderr); } #endif // GTEST_HAS_STREAM_REDIRECTION #if GTEST_HAS_DEATH_TEST // A copy of all command line arguments. Set by InitGoogleTest(). ::std::vector g_argvs; static const ::std::vector* g_injected_test_argvs = NULL; // Owned. void SetInjectableArgvs(const ::std::vector* argvs) { if (g_injected_test_argvs != argvs) delete g_injected_test_argvs; g_injected_test_argvs = argvs; } const ::std::vector& GetInjectableArgvs() { if (g_injected_test_argvs != NULL) { return *g_injected_test_argvs; } return g_argvs; } #endif // GTEST_HAS_DEATH_TEST #if GTEST_OS_WINDOWS_MOBILE namespace posix { void Abort() { DebugBreak(); TerminateProcess(GetCurrentProcess(), 1); } } // namespace posix #endif // GTEST_OS_WINDOWS_MOBILE // Returns the name of the environment variable corresponding to the // given flag. For example, FlagToEnvVar("foo") will return // "GTEST_FOO" in the open-source version. static std::string FlagToEnvVar(const char* flag) { const std::string full_flag = (Message() << GTEST_FLAG_PREFIX_ << flag).GetString(); Message env_var; for (size_t i = 0; i != full_flag.length(); i++) { env_var << ToUpper(full_flag.c_str()[i]); } return env_var.GetString(); } // Parses 'str' for a 32-bit signed integer. If successful, writes // the result to *value and returns true; otherwise leaves *value // unchanged and returns false. bool ParseInt32(const Message& src_text, const char* str, Int32* value) { // Parses the environment variable as a decimal integer. char* end = NULL; const long long_value = strtol(str, &end, 10); // NOLINT // Has strtol() consumed all characters in the string? if (*end != '\0') { // No - an invalid character was encountered. Message msg; msg << "WARNING: " << src_text << " is expected to be a 32-bit integer, but actually" << " has value \"" << str << "\".\n"; printf("%s", msg.GetString().c_str()); fflush(stdout); return false; } // Is the parsed value in the range of an Int32? const Int32 result = static_cast(long_value); if (long_value == LONG_MAX || long_value == LONG_MIN || // The parsed value overflows as a long. (strtol() returns // LONG_MAX or LONG_MIN when the input overflows.) result != long_value // The parsed value overflows as an Int32. ) { Message msg; msg << "WARNING: " << src_text << " is expected to be a 32-bit integer, but actually" << " has value " << str << ", which overflows.\n"; printf("%s", msg.GetString().c_str()); fflush(stdout); return false; } *value = result; return true; } // Reads and returns the Boolean environment variable corresponding to // the given flag; if it's not set, returns default_value. // // The value is considered true iff it's not "0". bool BoolFromGTestEnv(const char* flag, bool default_value) { const std::string env_var = FlagToEnvVar(flag); const char* const string_value = posix::GetEnv(env_var.c_str()); return string_value == NULL ? default_value : strcmp(string_value, "0") != 0; } // Reads and returns a 32-bit integer stored in the environment // variable corresponding to the given flag; if it isn't set or // doesn't represent a valid 32-bit integer, returns default_value. Int32 Int32FromGTestEnv(const char* flag, Int32 default_value) { const std::string env_var = FlagToEnvVar(flag); const char* const string_value = posix::GetEnv(env_var.c_str()); if (string_value == NULL) { // The environment variable is not set. return default_value; } Int32 result = default_value; if (!ParseInt32(Message() << "Environment variable " << env_var, string_value, &result)) { printf("The default value %s is used.\n", (Message() << default_value).GetString().c_str()); fflush(stdout); return default_value; } return result; } // Reads and returns the string environment variable corresponding to // the given flag; if it's not set, returns default_value. const char* StringFromGTestEnv(const char* flag, const char* default_value) { const std::string env_var = FlagToEnvVar(flag); const char* const value = posix::GetEnv(env_var.c_str()); return value == NULL ? default_value : value; } } // namespace internal } // namespace testing // Copyright 2007, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // Google Test - The Google C++ Testing Framework // // This file implements a universal value printer that can print a // value of any type T: // // void ::testing::internal::UniversalPrinter::Print(value, ostream_ptr); // // It uses the << operator when possible, and prints the bytes in the // object otherwise. A user can override its behavior for a class // type Foo by defining either operator<<(::std::ostream&, const Foo&) // or void PrintTo(const Foo&, ::std::ostream*) in the namespace that // defines Foo. #include #include #include // NOLINT #include namespace testing { namespace { using ::std::ostream; // Prints a segment of bytes in the given object. void PrintByteSegmentInObjectTo(const unsigned char* obj_bytes, size_t start, size_t count, ostream* os) { char text[5] = ""; for (size_t i = 0; i != count; i++) { const size_t j = start + i; if (i != 0) { // Organizes the bytes into groups of 2 for easy parsing by // human. if ((j % 2) == 0) *os << ' '; else *os << '-'; } GTEST_SNPRINTF_(text, sizeof(text), "%02X", obj_bytes[j]); *os << text; } } // Prints the bytes in the given value to the given ostream. void PrintBytesInObjectToImpl(const unsigned char* obj_bytes, size_t count, ostream* os) { // Tells the user how big the object is. *os << count << "-byte object <"; const size_t kThreshold = 132; const size_t kChunkSize = 64; // If the object size is bigger than kThreshold, we'll have to omit // some details by printing only the first and the last kChunkSize // bytes. // TODO(wan): let the user control the threshold using a flag. if (count < kThreshold) { PrintByteSegmentInObjectTo(obj_bytes, 0, count, os); } else { PrintByteSegmentInObjectTo(obj_bytes, 0, kChunkSize, os); *os << " ... "; // Rounds up to 2-byte boundary. const size_t resume_pos = (count - kChunkSize + 1)/2*2; PrintByteSegmentInObjectTo(obj_bytes, resume_pos, count - resume_pos, os); } *os << ">"; } } // namespace namespace internal2 { // Delegates to PrintBytesInObjectToImpl() to print the bytes in the // given object. The delegation simplifies the implementation, which // uses the << operator and thus is easier done outside of the // ::testing::internal namespace, which contains a << operator that // sometimes conflicts with the one in STL. void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count, ostream* os) { PrintBytesInObjectToImpl(obj_bytes, count, os); } } // namespace internal2 namespace internal { // Depending on the value of a char (or wchar_t), we print it in one // of three formats: // - as is if it's a printable ASCII (e.g. 'a', '2', ' '), // - as a hexidecimal escape sequence (e.g. '\x7F'), or // - as a special escape sequence (e.g. '\r', '\n'). enum CharFormat { kAsIs, kHexEscape, kSpecialEscape }; // Returns true if c is a printable ASCII character. We test the // value of c directly instead of calling isprint(), which is buggy on // Windows Mobile. inline bool IsPrintableAscii(wchar_t c) { return 0x20 <= c && c <= 0x7E; } // Prints a wide or narrow char c as a character literal without the // quotes, escaping it when necessary; returns how c was formatted. // The template argument UnsignedChar is the unsigned version of Char, // which is the type of c. template static CharFormat PrintAsCharLiteralTo(Char c, ostream* os) { switch (static_cast(c)) { case L'\0': *os << "\\0"; break; case L'\'': *os << "\\'"; break; case L'\\': *os << "\\\\"; break; case L'\a': *os << "\\a"; break; case L'\b': *os << "\\b"; break; case L'\f': *os << "\\f"; break; case L'\n': *os << "\\n"; break; case L'\r': *os << "\\r"; break; case L'\t': *os << "\\t"; break; case L'\v': *os << "\\v"; break; default: if (IsPrintableAscii(c)) { *os << static_cast(c); return kAsIs; } else { *os << "\\x" + String::FormatHexInt(static_cast(c)); return kHexEscape; } } return kSpecialEscape; } // Prints a wchar_t c as if it's part of a string literal, escaping it when // necessary; returns how c was formatted. static CharFormat PrintAsStringLiteralTo(wchar_t c, ostream* os) { switch (c) { case L'\'': *os << "'"; return kAsIs; case L'"': *os << "\\\""; return kSpecialEscape; default: return PrintAsCharLiteralTo(c, os); } } // Prints a char c as if it's part of a string literal, escaping it when // necessary; returns how c was formatted. static CharFormat PrintAsStringLiteralTo(char c, ostream* os) { return PrintAsStringLiteralTo( static_cast(static_cast(c)), os); } // Prints a wide or narrow character c and its code. '\0' is printed // as "'\\0'", other unprintable characters are also properly escaped // using the standard C++ escape sequence. The template argument // UnsignedChar is the unsigned version of Char, which is the type of c. template void PrintCharAndCodeTo(Char c, ostream* os) { // First, print c as a literal in the most readable form we can find. *os << ((sizeof(c) > 1) ? "L'" : "'"); const CharFormat format = PrintAsCharLiteralTo(c, os); *os << "'"; // To aid user debugging, we also print c's code in decimal, unless // it's 0 (in which case c was printed as '\\0', making the code // obvious). if (c == 0) return; *os << " (" << static_cast(c); // For more convenience, we print c's code again in hexidecimal, // unless c was already printed in the form '\x##' or the code is in // [1, 9]. if (format == kHexEscape || (1 <= c && c <= 9)) { // Do nothing. } else { *os << ", 0x" << String::FormatHexInt(static_cast(c)); } *os << ")"; } void PrintTo(unsigned char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); } void PrintTo(signed char c, ::std::ostream* os) { PrintCharAndCodeTo(c, os); } // Prints a wchar_t as a symbol if it is printable or as its internal // code otherwise and also as its code. L'\0' is printed as "L'\\0'". void PrintTo(wchar_t wc, ostream* os) { PrintCharAndCodeTo(wc, os); } // Prints the given array of characters to the ostream. CharType must be either // char or wchar_t. // The array starts at begin, the length is len, it may include '\0' characters // and may not be NUL-terminated. template static void PrintCharsAsStringTo( const CharType* begin, size_t len, ostream* os) { const char* const kQuoteBegin = sizeof(CharType) == 1 ? "\"" : "L\""; *os << kQuoteBegin; bool is_previous_hex = false; for (size_t index = 0; index < len; ++index) { const CharType cur = begin[index]; if (is_previous_hex && IsXDigit(cur)) { // Previous character is of '\x..' form and this character can be // interpreted as another hexadecimal digit in its number. Break string to // disambiguate. *os << "\" " << kQuoteBegin; } is_previous_hex = PrintAsStringLiteralTo(cur, os) == kHexEscape; } *os << "\""; } // Prints a (const) char/wchar_t array of 'len' elements, starting at address // 'begin'. CharType must be either char or wchar_t. template static void UniversalPrintCharArray( const CharType* begin, size_t len, ostream* os) { // The code // const char kFoo[] = "foo"; // generates an array of 4, not 3, elements, with the last one being '\0'. // // Therefore when printing a char array, we don't print the last element if // it's '\0', such that the output matches the string literal as it's // written in the source code. if (len > 0 && begin[len - 1] == '\0') { PrintCharsAsStringTo(begin, len - 1, os); return; } // If, however, the last element in the array is not '\0', e.g. // const char kFoo[] = { 'f', 'o', 'o' }; // we must print the entire array. We also print a message to indicate // that the array is not NUL-terminated. PrintCharsAsStringTo(begin, len, os); *os << " (no terminating NUL)"; } // Prints a (const) char array of 'len' elements, starting at address 'begin'. void UniversalPrintArray(const char* begin, size_t len, ostream* os) { UniversalPrintCharArray(begin, len, os); } // Prints a (const) wchar_t array of 'len' elements, starting at address // 'begin'. void UniversalPrintArray(const wchar_t* begin, size_t len, ostream* os) { UniversalPrintCharArray(begin, len, os); } // Prints the given C string to the ostream. void PrintTo(const char* s, ostream* os) { if (s == NULL) { *os << "NULL"; } else { *os << ImplicitCast_(s) << " pointing to "; PrintCharsAsStringTo(s, strlen(s), os); } } // MSVC compiler can be configured to define whar_t as a typedef // of unsigned short. Defining an overload for const wchar_t* in that case // would cause pointers to unsigned shorts be printed as wide strings, // possibly accessing more memory than intended and causing invalid // memory accesses. MSVC defines _NATIVE_WCHAR_T_DEFINED symbol when // wchar_t is implemented as a native type. #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) // Prints the given wide C string to the ostream. void PrintTo(const wchar_t* s, ostream* os) { if (s == NULL) { *os << "NULL"; } else { *os << ImplicitCast_(s) << " pointing to "; PrintCharsAsStringTo(s, wcslen(s), os); } } #endif // wchar_t is native // Prints a ::string object. #if GTEST_HAS_GLOBAL_STRING void PrintStringTo(const ::string& s, ostream* os) { PrintCharsAsStringTo(s.data(), s.size(), os); } #endif // GTEST_HAS_GLOBAL_STRING void PrintStringTo(const ::std::string& s, ostream* os) { PrintCharsAsStringTo(s.data(), s.size(), os); } // Prints a ::wstring object. #if GTEST_HAS_GLOBAL_WSTRING void PrintWideStringTo(const ::wstring& s, ostream* os) { PrintCharsAsStringTo(s.data(), s.size(), os); } #endif // GTEST_HAS_GLOBAL_WSTRING #if GTEST_HAS_STD_WSTRING void PrintWideStringTo(const ::std::wstring& s, ostream* os) { PrintCharsAsStringTo(s.data(), s.size(), os); } #endif // GTEST_HAS_STD_WSTRING } // namespace internal } // namespace testing // Copyright 2008, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: mheule@google.com (Markus Heule) // // The Google C++ Testing Framework (Google Test) // Indicates that this translation unit is part of Google Test's // implementation. It must come before gtest-internal-inl.h is // included, or there will be a compiler error. This trick is to // prevent a user from accidentally including gtest-internal-inl.h in // his code. #define GTEST_IMPLEMENTATION_ 1 #undef GTEST_IMPLEMENTATION_ namespace testing { using internal::GetUnitTestImpl; // Gets the summary of the failure message by omitting the stack trace // in it. std::string TestPartResult::ExtractSummary(const char* message) { const char* const stack_trace = strstr(message, internal::kStackTraceMarker); return stack_trace == NULL ? message : std::string(message, stack_trace); } // Prints a TestPartResult object. std::ostream& operator<<(std::ostream& os, const TestPartResult& result) { return os << result.file_name() << ":" << result.line_number() << ": " << (result.type() == TestPartResult::kSuccess ? "Success" : result.type() == TestPartResult::kFatalFailure ? "Fatal failure" : "Non-fatal failure") << ":\n" << result.message() << std::endl; } // Appends a TestPartResult to the array. void TestPartResultArray::Append(const TestPartResult& result) { array_.push_back(result); } // Returns the TestPartResult at the given index (0-based). const TestPartResult& TestPartResultArray::GetTestPartResult(int index) const { if (index < 0 || index >= size()) { printf("\nInvalid index (%d) into TestPartResultArray.\n", index); internal::posix::Abort(); } return array_[index]; } // Returns the number of TestPartResult objects in the array. int TestPartResultArray::size() const { return static_cast(array_.size()); } namespace internal { HasNewFatalFailureHelper::HasNewFatalFailureHelper() : has_new_fatal_failure_(false), original_reporter_(GetUnitTestImpl()-> GetTestPartResultReporterForCurrentThread()) { GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread(this); } HasNewFatalFailureHelper::~HasNewFatalFailureHelper() { GetUnitTestImpl()->SetTestPartResultReporterForCurrentThread( original_reporter_); } void HasNewFatalFailureHelper::ReportTestPartResult( const TestPartResult& result) { if (result.fatally_failed()) has_new_fatal_failure_ = true; original_reporter_->ReportTestPartResult(result); } } // namespace internal } // namespace testing // Copyright 2008 Google Inc. // All Rights Reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) namespace testing { namespace internal { #if GTEST_HAS_TYPED_TEST_P // Skips to the first non-space char in str. Returns an empty string if str // contains only whitespace characters. static const char* SkipSpaces(const char* str) { while (IsSpace(*str)) str++; return str; } // Verifies that registered_tests match the test names in // defined_test_names_; returns registered_tests if successful, or // aborts the program otherwise. const char* TypedTestCasePState::VerifyRegisteredTestNames( const char* file, int line, const char* registered_tests) { typedef ::std::set::const_iterator DefinedTestIter; registered_ = true; // Skip initial whitespace in registered_tests since some // preprocessors prefix stringizied literals with whitespace. registered_tests = SkipSpaces(registered_tests); Message errors; ::std::set tests; for (const char* names = registered_tests; names != NULL; names = SkipComma(names)) { const std::string name = GetPrefixUntilComma(names); if (tests.count(name) != 0) { errors << "Test " << name << " is listed more than once.\n"; continue; } bool found = false; for (DefinedTestIter it = defined_test_names_.begin(); it != defined_test_names_.end(); ++it) { if (name == *it) { found = true; break; } } if (found) { tests.insert(name); } else { errors << "No test named " << name << " can be found in this test case.\n"; } } for (DefinedTestIter it = defined_test_names_.begin(); it != defined_test_names_.end(); ++it) { if (tests.count(*it) == 0) { errors << "You forgot to list test " << *it << ".\n"; } } const std::string& errors_str = errors.GetString(); if (errors_str != "") { fprintf(stderr, "%s %s", FormatFileLocation(file, line).c_str(), errors_str.c_str()); fflush(stderr); posix::Abort(); } return registered_tests; } #endif // GTEST_HAS_TYPED_TEST_P } // namespace internal } // namespace testing hyperscan-4.4.1/unit/gtest/gtest.h0000644000175000017500000312614313055426554017715 0ustar sleuthkidsleuthkid// Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // // The Google C++ Testing Framework (Google Test) // // This header file defines the public API for Google Test. It should be // included by any test program that uses Google Test. // // IMPORTANT NOTE: Due to limitation of the C++ language, we have to // leave some internal implementation details in this header file. // They are clearly marked by comments like this: // // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // // Such code is NOT meant to be used by a user directly, and is subject // to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user // program! // // Acknowledgment: Google Test borrowed the idea of automatic test // registration from Barthelemy Dagenais' (barthelemy@prologique.com) // easyUnit framework. #ifndef GTEST_INCLUDE_GTEST_GTEST_H_ #define GTEST_INCLUDE_GTEST_GTEST_H_ #include #include #include // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) // // The Google C++ Testing Framework (Google Test) // // This header file declares functions and macros used internally by // Google Test. They are subject to change without notice. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Authors: wan@google.com (Zhanyong Wan) // // Low-level types and utilities for porting Google Test to various // platforms. They are subject to change without notice. DO NOT USE // THEM IN USER CODE. // // This file is fundamental to Google Test. All other Google Test source // files are expected to #include this. Therefore, it cannot #include // any other Google Test header. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ // The user can define the following macros in the build script to // control Google Test's behavior. If the user doesn't define a macro // in this list, Google Test will define it. // // GTEST_HAS_CLONE - Define it to 1/0 to indicate that clone(2) // is/isn't available. // GTEST_HAS_EXCEPTIONS - Define it to 1/0 to indicate that exceptions // are enabled. // GTEST_HAS_GLOBAL_STRING - Define it to 1/0 to indicate that ::string // is/isn't available (some systems define // ::string, which is different to std::string). // GTEST_HAS_GLOBAL_WSTRING - Define it to 1/0 to indicate that ::string // is/isn't available (some systems define // ::wstring, which is different to std::wstring). // GTEST_HAS_POSIX_RE - Define it to 1/0 to indicate that POSIX regular // expressions are/aren't available. // GTEST_HAS_PTHREAD - Define it to 1/0 to indicate that // is/isn't available. // GTEST_HAS_RTTI - Define it to 1/0 to indicate that RTTI is/isn't // enabled. // GTEST_HAS_STD_WSTRING - Define it to 1/0 to indicate that // std::wstring does/doesn't work (Google Test can // be used where std::wstring is unavailable). // GTEST_HAS_TR1_TUPLE - Define it to 1/0 to indicate tr1::tuple // is/isn't available. // GTEST_HAS_SEH - Define it to 1/0 to indicate whether the // compiler supports Microsoft's "Structured // Exception Handling". // GTEST_HAS_STREAM_REDIRECTION // - Define it to 1/0 to indicate whether the // platform supports I/O stream redirection using // dup() and dup2(). // GTEST_USE_OWN_TR1_TUPLE - Define it to 1/0 to indicate whether Google // Test's own tr1 tuple implementation should be // used. Unused when the user sets // GTEST_HAS_TR1_TUPLE to 0. // GTEST_LANG_CXX11 - Define it to 1/0 to indicate that Google Test // is building in C++11/C++98 mode. // GTEST_LINKED_AS_SHARED_LIBRARY // - Define to 1 when compiling tests that use // Google Test as a shared library (known as // DLL on Windows). // GTEST_CREATE_SHARED_LIBRARY // - Define to 1 when compiling Google Test itself // as a shared library. // This header defines the following utilities: // // Macros indicating the current platform (defined to 1 if compiled on // the given platform; otherwise undefined): // GTEST_OS_AIX - IBM AIX // GTEST_OS_CYGWIN - Cygwin // GTEST_OS_HPUX - HP-UX // GTEST_OS_LINUX - Linux // GTEST_OS_LINUX_ANDROID - Google Android // GTEST_OS_MAC - Mac OS X // GTEST_OS_IOS - iOS // GTEST_OS_IOS_SIMULATOR - iOS simulator // GTEST_OS_NACL - Google Native Client (NaCl) // GTEST_OS_OPENBSD - OpenBSD // GTEST_OS_QNX - QNX // GTEST_OS_SOLARIS - Sun Solaris // GTEST_OS_SYMBIAN - Symbian // GTEST_OS_WINDOWS - Windows (Desktop, MinGW, or Mobile) // GTEST_OS_WINDOWS_DESKTOP - Windows Desktop // GTEST_OS_WINDOWS_MINGW - MinGW // GTEST_OS_WINDOWS_MOBILE - Windows Mobile // GTEST_OS_ZOS - z/OS // // Among the platforms, Cygwin, Linux, Max OS X, and Windows have the // most stable support. Since core members of the Google Test project // don't have access to other platforms, support for them may be less // stable. If you notice any problems on your platform, please notify // googletestframework@googlegroups.com (patches for fixing them are // even more welcome!). // // Note that it is possible that none of the GTEST_OS_* macros are defined. // // Macros indicating available Google Test features (defined to 1 if // the corresponding feature is supported; otherwise undefined): // GTEST_HAS_COMBINE - the Combine() function (for value-parameterized // tests) // GTEST_HAS_DEATH_TEST - death tests // GTEST_HAS_PARAM_TEST - value-parameterized tests // GTEST_HAS_TYPED_TEST - typed tests // GTEST_HAS_TYPED_TEST_P - type-parameterized tests // GTEST_USES_POSIX_RE - enhanced POSIX regex is used. Do not confuse with // GTEST_HAS_POSIX_RE (see above) which users can // define themselves. // GTEST_USES_SIMPLE_RE - our own simple regex is used; // the above two are mutually exclusive. // GTEST_CAN_COMPARE_NULL - accepts untyped NULL in EXPECT_EQ(). // // Macros for basic C++ coding: // GTEST_AMBIGUOUS_ELSE_BLOCKER_ - for disabling a gcc warning. // GTEST_ATTRIBUTE_UNUSED_ - declares that a class' instances or a // variable don't have to be used. // GTEST_DISALLOW_ASSIGN_ - disables operator=. // GTEST_DISALLOW_COPY_AND_ASSIGN_ - disables copy ctor and operator=. // GTEST_MUST_USE_RESULT_ - declares that a function's result must be used. // // Synchronization: // Mutex, MutexLock, ThreadLocal, GetThreadCount() // - synchronization primitives. // GTEST_IS_THREADSAFE - defined to 1 to indicate that the above // synchronization primitives have real implementations // and Google Test is thread-safe; or 0 otherwise. // // Template meta programming: // is_pointer - as in TR1; needed on Symbian and IBM XL C/C++ only. // IteratorTraits - partial implementation of std::iterator_traits, which // is not available in libCstd when compiled with Sun C++. // // Smart pointers: // scoped_ptr - as in TR2. // // Regular expressions: // RE - a simple regular expression class using the POSIX // Extended Regular Expression syntax on UNIX-like // platforms, or a reduced regular exception syntax on // other platforms, including Windows. // // Logging: // GTEST_LOG_() - logs messages at the specified severity level. // LogToStderr() - directs all log messages to stderr. // FlushInfoLog() - flushes informational log messages. // // Stdout and stderr capturing: // CaptureStdout() - starts capturing stdout. // GetCapturedStdout() - stops capturing stdout and returns the captured // string. // CaptureStderr() - starts capturing stderr. // GetCapturedStderr() - stops capturing stderr and returns the captured // string. // // Integer types: // TypeWithSize - maps an integer to a int type. // Int32, UInt32, Int64, UInt64, TimeInMillis // - integers of known sizes. // BiggestInt - the biggest signed integer type. // // Command-line utilities: // GTEST_FLAG() - references a flag. // GTEST_DECLARE_*() - declares a flag. // GTEST_DEFINE_*() - defines a flag. // GetInjectableArgvs() - returns the command line as a vector of strings. // // Environment variable utilities: // GetEnv() - gets the value of an environment variable. // BoolFromGTestEnv() - parses a bool environment variable. // Int32FromGTestEnv() - parses an Int32 environment variable. // StringFromGTestEnv() - parses a string environment variable. #include // for isspace, etc #include // for ptrdiff_t #include #include #include #ifndef _WIN32_WCE # include # include #endif // !_WIN32_WCE #if defined __APPLE__ # include # include #endif #include // NOLINT #include // NOLINT #include // NOLINT #define GTEST_DEV_EMAIL_ "googletestframework@@googlegroups.com" #define GTEST_FLAG_PREFIX_ "gtest_" #define GTEST_FLAG_PREFIX_DASH_ "gtest-" #define GTEST_FLAG_PREFIX_UPPER_ "GTEST_" #define GTEST_NAME_ "Google Test" #define GTEST_PROJECT_URL_ "http://code.google.com/p/googletest/" // Determines the version of gcc that is used to compile this. #ifdef __GNUC__ // 40302 means version 4.3.2. # define GTEST_GCC_VER_ \ (__GNUC__*10000 + __GNUC_MINOR__*100 + __GNUC_PATCHLEVEL__) #endif // __GNUC__ // Determines the platform on which Google Test is compiled. #ifdef __CYGWIN__ # define GTEST_OS_CYGWIN 1 #elif defined __SYMBIAN32__ # define GTEST_OS_SYMBIAN 1 #elif defined _WIN32 # define GTEST_OS_WINDOWS 1 # ifdef _WIN32_WCE # define GTEST_OS_WINDOWS_MOBILE 1 # elif defined(__MINGW__) || defined(__MINGW32__) # define GTEST_OS_WINDOWS_MINGW 1 # else # define GTEST_OS_WINDOWS_DESKTOP 1 # endif // _WIN32_WCE #elif defined __APPLE__ # define GTEST_OS_MAC 1 # if TARGET_OS_IPHONE # define GTEST_OS_IOS 1 # if TARGET_IPHONE_SIMULATOR # define GTEST_OS_IOS_SIMULATOR 1 # endif # endif #elif defined __linux__ # define GTEST_OS_LINUX 1 # if defined __ANDROID__ # define GTEST_OS_LINUX_ANDROID 1 # endif #elif defined __MVS__ # define GTEST_OS_ZOS 1 #elif defined(__sun) && defined(__SVR4) # define GTEST_OS_SOLARIS 1 #elif defined(_AIX) # define GTEST_OS_AIX 1 #elif defined(__hpux) # define GTEST_OS_HPUX 1 #elif defined __native_client__ # define GTEST_OS_NACL 1 #elif defined __OpenBSD__ # define GTEST_OS_OPENBSD 1 #elif defined __QNX__ # define GTEST_OS_QNX 1 #endif // __CYGWIN__ #ifndef GTEST_LANG_CXX11 // gcc and clang define __GXX_EXPERIMENTAL_CXX0X__ when // -std={c,gnu}++{0x,11} is passed. The C++11 standard specifies a // value for __cplusplus, and recent versions of clang, gcc, and // probably other compilers set that too in C++11 mode. # if __GXX_EXPERIMENTAL_CXX0X__ || __cplusplus >= 201103L // Compiling in at least C++11 mode. # define GTEST_LANG_CXX11 1 # else # define GTEST_LANG_CXX11 0 # endif #endif // Brings in definitions for functions used in the testing::internal::posix // namespace (read, write, close, chdir, isatty, stat). We do not currently // use them on Windows Mobile. #if !GTEST_OS_WINDOWS // This assumes that non-Windows OSes provide unistd.h. For OSes where this // is not the case, we need to include headers that provide the functions // mentioned above. # include # include #elif !GTEST_OS_WINDOWS_MOBILE # include # include #endif #if GTEST_OS_LINUX_ANDROID // Used to define __ANDROID_API__ matching the target NDK API level. # include // NOLINT #endif // Defines this to true iff Google Test can use POSIX regular expressions. #ifndef GTEST_HAS_POSIX_RE # if GTEST_OS_LINUX_ANDROID // On Android, is only available starting with Gingerbread. # define GTEST_HAS_POSIX_RE (__ANDROID_API__ >= 9) # else # define GTEST_HAS_POSIX_RE (!GTEST_OS_WINDOWS) # endif #endif #if GTEST_HAS_POSIX_RE // On some platforms, needs someone to define size_t, and // won't compile otherwise. We can #include it here as we already // included , which is guaranteed to define size_t through // . # include // NOLINT # define GTEST_USES_POSIX_RE 1 #elif GTEST_OS_WINDOWS // is not available on Windows. Use our own simple regex // implementation instead. # define GTEST_USES_SIMPLE_RE 1 #else // may not be available on this platform. Use our own // simple regex implementation instead. # define GTEST_USES_SIMPLE_RE 1 #endif // GTEST_HAS_POSIX_RE #ifndef GTEST_HAS_EXCEPTIONS // The user didn't tell us whether exceptions are enabled, so we need // to figure it out. # if defined(_MSC_VER) || defined(__BORLANDC__) // MSVC's and C++Builder's implementations of the STL use the _HAS_EXCEPTIONS // macro to enable exceptions, so we'll do the same. // Assumes that exceptions are enabled by default. # ifndef _HAS_EXCEPTIONS # define _HAS_EXCEPTIONS 1 # endif // _HAS_EXCEPTIONS # define GTEST_HAS_EXCEPTIONS _HAS_EXCEPTIONS # elif defined(__GNUC__) && __EXCEPTIONS // gcc defines __EXCEPTIONS to 1 iff exceptions are enabled. # define GTEST_HAS_EXCEPTIONS 1 # elif defined(__SUNPRO_CC) // Sun Pro CC supports exceptions. However, there is no compile-time way of // detecting whether they are enabled or not. Therefore, we assume that // they are enabled unless the user tells us otherwise. # define GTEST_HAS_EXCEPTIONS 1 # elif defined(__IBMCPP__) && __EXCEPTIONS // xlC defines __EXCEPTIONS to 1 iff exceptions are enabled. # define GTEST_HAS_EXCEPTIONS 1 # elif defined(__HP_aCC) // Exception handling is in effect by default in HP aCC compiler. It has to // be turned of by +noeh compiler option if desired. # define GTEST_HAS_EXCEPTIONS 1 # else // For other compilers, we assume exceptions are disabled to be // conservative. # define GTEST_HAS_EXCEPTIONS 0 # endif // defined(_MSC_VER) || defined(__BORLANDC__) #endif // GTEST_HAS_EXCEPTIONS #if !defined(GTEST_HAS_STD_STRING) // Even though we don't use this macro any longer, we keep it in case // some clients still depend on it. # define GTEST_HAS_STD_STRING 1 #elif !GTEST_HAS_STD_STRING // The user told us that ::std::string isn't available. # error "Google Test cannot be used where ::std::string isn't available." #endif // !defined(GTEST_HAS_STD_STRING) #ifndef GTEST_HAS_GLOBAL_STRING // The user didn't tell us whether ::string is available, so we need // to figure it out. # define GTEST_HAS_GLOBAL_STRING 0 #endif // GTEST_HAS_GLOBAL_STRING #ifndef GTEST_HAS_STD_WSTRING // The user didn't tell us whether ::std::wstring is available, so we need // to figure it out. // TODO(wan@google.com): uses autoconf to detect whether ::std::wstring // is available. // Cygwin 1.7 and below doesn't support ::std::wstring. // Solaris' libc++ doesn't support it either. Android has // no support for it at least as recent as Froyo (2.2). # define GTEST_HAS_STD_WSTRING \ (!(GTEST_OS_LINUX_ANDROID || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS)) #endif // GTEST_HAS_STD_WSTRING #ifndef GTEST_HAS_GLOBAL_WSTRING // The user didn't tell us whether ::wstring is available, so we need // to figure it out. # define GTEST_HAS_GLOBAL_WSTRING \ (GTEST_HAS_STD_WSTRING && GTEST_HAS_GLOBAL_STRING) #endif // GTEST_HAS_GLOBAL_WSTRING // Determines whether RTTI is available. #ifndef GTEST_HAS_RTTI // The user didn't tell us whether RTTI is enabled, so we need to // figure it out. # ifdef _MSC_VER # ifdef _CPPRTTI // MSVC defines this macro iff RTTI is enabled. # define GTEST_HAS_RTTI 1 # else # define GTEST_HAS_RTTI 0 # endif // Starting with version 4.3.2, gcc defines __GXX_RTTI iff RTTI is enabled. # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40302) # ifdef __GXX_RTTI // When building against STLport with the Android NDK and with // -frtti -fno-exceptions, the build fails at link time with undefined // references to __cxa_bad_typeid. Note sure if STL or toolchain bug, // so disable RTTI when detected. # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) && \ !defined(__EXCEPTIONS) # define GTEST_HAS_RTTI 0 # else # define GTEST_HAS_RTTI 1 # endif // GTEST_OS_LINUX_ANDROID && __STLPORT_MAJOR && !__EXCEPTIONS # else # define GTEST_HAS_RTTI 0 # endif // __GXX_RTTI // Clang defines __GXX_RTTI starting with version 3.0, but its manual recommends // using has_feature instead. has_feature(cxx_rtti) is supported since 2.7, the // first version with C++ support. # elif defined(__clang__) # define GTEST_HAS_RTTI __has_feature(cxx_rtti) // Starting with version 9.0 IBM Visual Age defines __RTTI_ALL__ to 1 if // both the typeid and dynamic_cast features are present. # elif defined(__IBMCPP__) && (__IBMCPP__ >= 900) # ifdef __RTTI_ALL__ # define GTEST_HAS_RTTI 1 # else # define GTEST_HAS_RTTI 0 # endif # else // For all other compilers, we assume RTTI is enabled. # define GTEST_HAS_RTTI 1 # endif // _MSC_VER #endif // GTEST_HAS_RTTI // It's this header's responsibility to #include when RTTI // is enabled. #if GTEST_HAS_RTTI # include #endif // Determines whether Google Test can use the pthreads library. #ifndef GTEST_HAS_PTHREAD // The user didn't tell us explicitly, so we assume pthreads support is // available on Linux and Mac. // // To disable threading support in Google Test, add -DGTEST_HAS_PTHREAD=0 // to your compiler flags. # define GTEST_HAS_PTHREAD (GTEST_OS_LINUX || GTEST_OS_MAC || GTEST_OS_HPUX \ || GTEST_OS_QNX) #endif // GTEST_HAS_PTHREAD #if GTEST_HAS_PTHREAD // gtest-port.h guarantees to #include when GTEST_HAS_PTHREAD is // true. # include // NOLINT // For timespec and nanosleep, used below. # include // NOLINT #endif // Determines whether Google Test can use tr1/tuple. You can define // this macro to 0 to prevent Google Test from using tuple (any // feature depending on tuple with be disabled in this mode). #ifndef GTEST_HAS_TR1_TUPLE # if GTEST_OS_LINUX_ANDROID && defined(_STLPORT_MAJOR) // STLport, provided with the Android NDK, has neither or . # define GTEST_HAS_TR1_TUPLE 0 # else // The user didn't tell us not to do it, so we assume it's OK. # define GTEST_HAS_TR1_TUPLE 1 # endif #endif // GTEST_HAS_TR1_TUPLE // Determines whether Google Test's own tr1 tuple implementation // should be used. #ifndef GTEST_USE_OWN_TR1_TUPLE // The user didn't tell us, so we need to figure it out. // We use our own TR1 tuple if we aren't sure the user has an // implementation of it already. At this time, libstdc++ 4.0.0+ and // MSVC 2010 are the only mainstream standard libraries that come // with a TR1 tuple implementation. NVIDIA's CUDA NVCC compiler // pretends to be GCC by defining __GNUC__ and friends, but cannot // compile GCC's tuple implementation. MSVC 2008 (9.0) provides TR1 // tuple in a 323 MB Feature Pack download, which we cannot assume the // user has. QNX's QCC compiler is a modified GCC but it doesn't // support TR1 tuple. libc++ only provides std::tuple, in C++11 mode, // and it can be used with some compilers that define __GNUC__. # if (defined(__GNUC__) && !defined(__CUDACC__) && (GTEST_GCC_VER_ >= 40000) \ && !GTEST_OS_QNX && !defined(_LIBCPP_VERSION)) || _MSC_VER >= 1600 # define GTEST_ENV_HAS_TR1_TUPLE_ 1 # endif // C++11 specifies that provides std::tuple. Use that if gtest is used // in C++11 mode and libstdc++ isn't very old (binaries targeting OS X 10.6 // can build with clang but need to use gcc4.2's libstdc++). # if GTEST_LANG_CXX11 && (!defined(__GLIBCXX__) || __GLIBCXX__ > 20110325) # define GTEST_ENV_HAS_STD_TUPLE_ 1 # endif # if GTEST_ENV_HAS_TR1_TUPLE_ || GTEST_ENV_HAS_STD_TUPLE_ # define GTEST_USE_OWN_TR1_TUPLE 0 # else # define GTEST_USE_OWN_TR1_TUPLE 1 # endif #endif // GTEST_USE_OWN_TR1_TUPLE // To avoid conditional compilation everywhere, we make it // gtest-port.h's responsibility to #include the header implementing // tr1/tuple. #if GTEST_HAS_TR1_TUPLE # if GTEST_USE_OWN_TR1_TUPLE // This file was GENERATED by command: // pump.py gtest-tuple.h.pump // DO NOT EDIT BY HAND!!! // Copyright 2009 Google Inc. // All Rights Reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // Implements a subset of TR1 tuple needed by Google Test and Google Mock. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ #include // For ::std::pair. // The compiler used in Symbian has a bug that prevents us from declaring the // tuple template as a friend (it complains that tuple is redefined). This // hack bypasses the bug by declaring the members that should otherwise be // private as public. // Sun Studio versions < 12 also have the above bug. #if defined(__SYMBIAN32__) || (defined(__SUNPRO_CC) && __SUNPRO_CC < 0x590) # define GTEST_DECLARE_TUPLE_AS_FRIEND_ public: #else # define GTEST_DECLARE_TUPLE_AS_FRIEND_ \ template friend class tuple; \ private: #endif // GTEST_n_TUPLE_(T) is the type of an n-tuple. #define GTEST_0_TUPLE_(T) tuple<> #define GTEST_1_TUPLE_(T) tuple #define GTEST_2_TUPLE_(T) tuple #define GTEST_3_TUPLE_(T) tuple #define GTEST_4_TUPLE_(T) tuple #define GTEST_5_TUPLE_(T) tuple #define GTEST_6_TUPLE_(T) tuple #define GTEST_7_TUPLE_(T) tuple #define GTEST_8_TUPLE_(T) tuple #define GTEST_9_TUPLE_(T) tuple #define GTEST_10_TUPLE_(T) tuple // GTEST_n_TYPENAMES_(T) declares a list of n typenames. #define GTEST_0_TYPENAMES_(T) #define GTEST_1_TYPENAMES_(T) typename T##0 #define GTEST_2_TYPENAMES_(T) typename T##0, typename T##1 #define GTEST_3_TYPENAMES_(T) typename T##0, typename T##1, typename T##2 #define GTEST_4_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ typename T##3 #define GTEST_5_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ typename T##3, typename T##4 #define GTEST_6_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ typename T##3, typename T##4, typename T##5 #define GTEST_7_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ typename T##3, typename T##4, typename T##5, typename T##6 #define GTEST_8_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ typename T##3, typename T##4, typename T##5, typename T##6, typename T##7 #define GTEST_9_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ typename T##3, typename T##4, typename T##5, typename T##6, \ typename T##7, typename T##8 #define GTEST_10_TYPENAMES_(T) typename T##0, typename T##1, typename T##2, \ typename T##3, typename T##4, typename T##5, typename T##6, \ typename T##7, typename T##8, typename T##9 // In theory, defining stuff in the ::std namespace is undefined // behavior. We can do this as we are playing the role of a standard // library vendor. namespace std { namespace tr1 { template class tuple; // Anything in namespace gtest_internal is Google Test's INTERNAL // IMPLEMENTATION DETAIL and MUST NOT BE USED DIRECTLY in user code. namespace gtest_internal { // ByRef::type is T if T is a reference; otherwise it's const T&. template struct ByRef { typedef const T& type; }; // NOLINT template struct ByRef { typedef T& type; }; // NOLINT // A handy wrapper for ByRef. #define GTEST_BY_REF_(T) typename ::std::tr1::gtest_internal::ByRef::type // AddRef::type is T if T is a reference; otherwise it's T&. This // is the same as tr1::add_reference::type. template struct AddRef { typedef T& type; }; // NOLINT template struct AddRef { typedef T& type; }; // NOLINT // A handy wrapper for AddRef. #define GTEST_ADD_REF_(T) typename ::std::tr1::gtest_internal::AddRef::type // A helper for implementing get(). template class Get; // A helper for implementing tuple_element. kIndexValid is true // iff k < the number of fields in tuple type T. template struct TupleElement; template struct TupleElement { typedef T0 type; }; template struct TupleElement { typedef T1 type; }; template struct TupleElement { typedef T2 type; }; template struct TupleElement { typedef T3 type; }; template struct TupleElement { typedef T4 type; }; template struct TupleElement { typedef T5 type; }; template struct TupleElement { typedef T6 type; }; template struct TupleElement { typedef T7 type; }; template struct TupleElement { typedef T8 type; }; template struct TupleElement { typedef T9 type; }; } // namespace gtest_internal template <> class tuple<> { public: tuple() {} tuple(const tuple& /* t */) {} tuple& operator=(const tuple& /* t */) { return *this; } }; template class GTEST_1_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_() {} explicit tuple(GTEST_BY_REF_(T0) f0) : f0_(f0) {} tuple(const tuple& t) : f0_(t.f0_) {} template tuple(const GTEST_1_TUPLE_(U)& t) : f0_(t.f0_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_1_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_1_TUPLE_(U)& t) { f0_ = t.f0_; return *this; } T0 f0_; }; template class GTEST_2_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1) : f0_(f0), f1_(f1) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_) {} template tuple(const GTEST_2_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_) {} template tuple(const ::std::pair& p) : f0_(p.first), f1_(p.second) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_2_TUPLE_(U)& t) { return CopyFrom(t); } template tuple& operator=(const ::std::pair& p) { f0_ = p.first; f1_ = p.second; return *this; } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_2_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; return *this; } T0 f0_; T1 f1_; }; template class GTEST_3_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_(), f2_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2) : f0_(f0), f1_(f1), f2_(f2) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} template tuple(const GTEST_3_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_3_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_3_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; f2_ = t.f2_; return *this; } T0 f0_; T1 f1_; T2 f2_; }; template class GTEST_4_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_(), f2_(), f3_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3) : f0_(f0), f1_(f1), f2_(f2), f3_(f3) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {} template tuple(const GTEST_4_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_4_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_4_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; f2_ = t.f2_; f3_ = t.f3_; return *this; } T0 f0_; T1 f1_; T2 f2_; T3 f3_; }; template class GTEST_5_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_(), f2_(), f3_(), f4_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_) {} template tuple(const GTEST_5_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_5_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_5_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; f2_ = t.f2_; f3_ = t.f3_; f4_ = t.f4_; return *this; } T0 f0_; T1 f1_; T2 f2_; T3 f3_; T4 f4_; }; template class GTEST_6_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, GTEST_BY_REF_(T5) f5) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), f5_(f5) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {} template tuple(const GTEST_6_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_6_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_6_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; f2_ = t.f2_; f3_ = t.f3_; f4_ = t.f4_; f5_ = t.f5_; return *this; } T0 f0_; T1 f1_; T2 f2_; T3 f3_; T4 f4_; T5 f5_; }; template class GTEST_7_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), f5_(f5), f6_(f6) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} template tuple(const GTEST_7_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_7_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_7_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; f2_ = t.f2_; f3_ = t.f3_; f4_ = t.f4_; f5_ = t.f5_; f6_ = t.f6_; return *this; } T0 f0_; T1 f1_; T2 f2_; T3 f3_; T4 f4_; T5 f5_; T6 f6_; }; template class GTEST_8_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} template tuple(const GTEST_8_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_8_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_8_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; f2_ = t.f2_; f3_ = t.f3_; f4_ = t.f4_; f5_ = t.f5_; f6_ = t.f6_; f7_ = t.f7_; return *this; } T0 f0_; T1 f1_; T2 f2_; T3 f3_; T4 f4_; T5 f5_; T6 f6_; T7 f7_; }; template class GTEST_9_TUPLE_(T) { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, GTEST_BY_REF_(T8) f8) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} template tuple(const GTEST_9_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_9_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_9_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; f2_ = t.f2_; f3_ = t.f3_; f4_ = t.f4_; f5_ = t.f5_; f6_ = t.f6_; f7_ = t.f7_; f8_ = t.f8_; return *this; } T0 f0_; T1 f1_; T2 f2_; T3 f3_; T4 f4_; T5 f5_; T6 f6_; T7 f7_; T8 f8_; }; template class tuple { public: template friend class gtest_internal::Get; tuple() : f0_(), f1_(), f2_(), f3_(), f4_(), f5_(), f6_(), f7_(), f8_(), f9_() {} explicit tuple(GTEST_BY_REF_(T0) f0, GTEST_BY_REF_(T1) f1, GTEST_BY_REF_(T2) f2, GTEST_BY_REF_(T3) f3, GTEST_BY_REF_(T4) f4, GTEST_BY_REF_(T5) f5, GTEST_BY_REF_(T6) f6, GTEST_BY_REF_(T7) f7, GTEST_BY_REF_(T8) f8, GTEST_BY_REF_(T9) f9) : f0_(f0), f1_(f1), f2_(f2), f3_(f3), f4_(f4), f5_(f5), f6_(f6), f7_(f7), f8_(f8), f9_(f9) {} tuple(const tuple& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {} template tuple(const GTEST_10_TUPLE_(U)& t) : f0_(t.f0_), f1_(t.f1_), f2_(t.f2_), f3_(t.f3_), f4_(t.f4_), f5_(t.f5_), f6_(t.f6_), f7_(t.f7_), f8_(t.f8_), f9_(t.f9_) {} tuple& operator=(const tuple& t) { return CopyFrom(t); } template tuple& operator=(const GTEST_10_TUPLE_(U)& t) { return CopyFrom(t); } GTEST_DECLARE_TUPLE_AS_FRIEND_ template tuple& CopyFrom(const GTEST_10_TUPLE_(U)& t) { f0_ = t.f0_; f1_ = t.f1_; f2_ = t.f2_; f3_ = t.f3_; f4_ = t.f4_; f5_ = t.f5_; f6_ = t.f6_; f7_ = t.f7_; f8_ = t.f8_; f9_ = t.f9_; return *this; } T0 f0_; T1 f1_; T2 f2_; T3 f3_; T4 f4_; T5 f5_; T6 f6_; T7 f7_; T8 f8_; T9 f9_; }; // 6.1.3.2 Tuple creation functions. // Known limitations: we don't support passing an // std::tr1::reference_wrapper to make_tuple(). And we don't // implement tie(). inline tuple<> make_tuple() { return tuple<>(); } template inline GTEST_1_TUPLE_(T) make_tuple(const T0& f0) { return GTEST_1_TUPLE_(T)(f0); } template inline GTEST_2_TUPLE_(T) make_tuple(const T0& f0, const T1& f1) { return GTEST_2_TUPLE_(T)(f0, f1); } template inline GTEST_3_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2) { return GTEST_3_TUPLE_(T)(f0, f1, f2); } template inline GTEST_4_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, const T3& f3) { return GTEST_4_TUPLE_(T)(f0, f1, f2, f3); } template inline GTEST_5_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, const T3& f3, const T4& f4) { return GTEST_5_TUPLE_(T)(f0, f1, f2, f3, f4); } template inline GTEST_6_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, const T3& f3, const T4& f4, const T5& f5) { return GTEST_6_TUPLE_(T)(f0, f1, f2, f3, f4, f5); } template inline GTEST_7_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, const T3& f3, const T4& f4, const T5& f5, const T6& f6) { return GTEST_7_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6); } template inline GTEST_8_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7) { return GTEST_8_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7); } template inline GTEST_9_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, const T8& f8) { return GTEST_9_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8); } template inline GTEST_10_TUPLE_(T) make_tuple(const T0& f0, const T1& f1, const T2& f2, const T3& f3, const T4& f4, const T5& f5, const T6& f6, const T7& f7, const T8& f8, const T9& f9) { return GTEST_10_TUPLE_(T)(f0, f1, f2, f3, f4, f5, f6, f7, f8, f9); } // 6.1.3.3 Tuple helper classes. template struct tuple_size; template struct tuple_size { static const int value = 0; }; template struct tuple_size { static const int value = 1; }; template struct tuple_size { static const int value = 2; }; template struct tuple_size { static const int value = 3; }; template struct tuple_size { static const int value = 4; }; template struct tuple_size { static const int value = 5; }; template struct tuple_size { static const int value = 6; }; template struct tuple_size { static const int value = 7; }; template struct tuple_size { static const int value = 8; }; template struct tuple_size { static const int value = 9; }; template struct tuple_size { static const int value = 10; }; template struct tuple_element { typedef typename gtest_internal::TupleElement< k < (tuple_size::value), k, Tuple>::type type; }; #define GTEST_TUPLE_ELEMENT_(k, Tuple) typename tuple_element::type // 6.1.3.4 Element access. namespace gtest_internal { template <> class Get<0> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) Field(Tuple& t) { return t.f0_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(0, Tuple)) ConstField(const Tuple& t) { return t.f0_; } }; template <> class Get<1> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) Field(Tuple& t) { return t.f1_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(1, Tuple)) ConstField(const Tuple& t) { return t.f1_; } }; template <> class Get<2> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) Field(Tuple& t) { return t.f2_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(2, Tuple)) ConstField(const Tuple& t) { return t.f2_; } }; template <> class Get<3> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) Field(Tuple& t) { return t.f3_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(3, Tuple)) ConstField(const Tuple& t) { return t.f3_; } }; template <> class Get<4> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) Field(Tuple& t) { return t.f4_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(4, Tuple)) ConstField(const Tuple& t) { return t.f4_; } }; template <> class Get<5> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) Field(Tuple& t) { return t.f5_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(5, Tuple)) ConstField(const Tuple& t) { return t.f5_; } }; template <> class Get<6> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) Field(Tuple& t) { return t.f6_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(6, Tuple)) ConstField(const Tuple& t) { return t.f6_; } }; template <> class Get<7> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) Field(Tuple& t) { return t.f7_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(7, Tuple)) ConstField(const Tuple& t) { return t.f7_; } }; template <> class Get<8> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) Field(Tuple& t) { return t.f8_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(8, Tuple)) ConstField(const Tuple& t) { return t.f8_; } }; template <> class Get<9> { public: template static GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) Field(Tuple& t) { return t.f9_; } // NOLINT template static GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(9, Tuple)) ConstField(const Tuple& t) { return t.f9_; } }; } // namespace gtest_internal template GTEST_ADD_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) get(GTEST_10_TUPLE_(T)& t) { return gtest_internal::Get::Field(t); } template GTEST_BY_REF_(GTEST_TUPLE_ELEMENT_(k, GTEST_10_TUPLE_(T))) get(const GTEST_10_TUPLE_(T)& t) { return gtest_internal::Get::ConstField(t); } // 6.1.3.5 Relational operators // We only implement == and !=, as we don't have a need for the rest yet. namespace gtest_internal { // SameSizeTuplePrefixComparator::Eq(t1, t2) returns true if the // first k fields of t1 equals the first k fields of t2. // SameSizeTuplePrefixComparator(k1, k2) would be a compiler error if // k1 != k2. template struct SameSizeTuplePrefixComparator; template <> struct SameSizeTuplePrefixComparator<0, 0> { template static bool Eq(const Tuple1& /* t1 */, const Tuple2& /* t2 */) { return true; } }; template struct SameSizeTuplePrefixComparator { template static bool Eq(const Tuple1& t1, const Tuple2& t2) { return SameSizeTuplePrefixComparator::Eq(t1, t2) && ::std::tr1::get(t1) == ::std::tr1::get(t2); } }; } // namespace gtest_internal template inline bool operator==(const GTEST_10_TUPLE_(T)& t, const GTEST_10_TUPLE_(U)& u) { return gtest_internal::SameSizeTuplePrefixComparator< tuple_size::value, tuple_size::value>::Eq(t, u); } template inline bool operator!=(const GTEST_10_TUPLE_(T)& t, const GTEST_10_TUPLE_(U)& u) { return !(t == u); } // 6.1.4 Pairs. // Unimplemented. } // namespace tr1 } // namespace std #undef GTEST_0_TUPLE_ #undef GTEST_1_TUPLE_ #undef GTEST_2_TUPLE_ #undef GTEST_3_TUPLE_ #undef GTEST_4_TUPLE_ #undef GTEST_5_TUPLE_ #undef GTEST_6_TUPLE_ #undef GTEST_7_TUPLE_ #undef GTEST_8_TUPLE_ #undef GTEST_9_TUPLE_ #undef GTEST_10_TUPLE_ #undef GTEST_0_TYPENAMES_ #undef GTEST_1_TYPENAMES_ #undef GTEST_2_TYPENAMES_ #undef GTEST_3_TYPENAMES_ #undef GTEST_4_TYPENAMES_ #undef GTEST_5_TYPENAMES_ #undef GTEST_6_TYPENAMES_ #undef GTEST_7_TYPENAMES_ #undef GTEST_8_TYPENAMES_ #undef GTEST_9_TYPENAMES_ #undef GTEST_10_TYPENAMES_ #undef GTEST_DECLARE_TUPLE_AS_FRIEND_ #undef GTEST_BY_REF_ #undef GTEST_ADD_REF_ #undef GTEST_TUPLE_ELEMENT_ #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TUPLE_H_ # elif GTEST_ENV_HAS_STD_TUPLE_ # include // C++11 puts its tuple into the ::std namespace rather than // ::std::tr1. gtest expects tuple to live in ::std::tr1, so put it there. // This causes undefined behavior, but supported compilers react in // the way we intend. namespace std { namespace tr1 { using ::std::get; using ::std::make_tuple; using ::std::tuple; using ::std::tuple_element; using ::std::tuple_size; } } # elif GTEST_OS_SYMBIAN // On Symbian, BOOST_HAS_TR1_TUPLE causes Boost's TR1 tuple library to // use STLport's tuple implementation, which unfortunately doesn't // work as the copy of STLport distributed with Symbian is incomplete. // By making sure BOOST_HAS_TR1_TUPLE is undefined, we force Boost to // use its own tuple implementation. # ifdef BOOST_HAS_TR1_TUPLE # undef BOOST_HAS_TR1_TUPLE # endif // BOOST_HAS_TR1_TUPLE // This prevents , which defines // BOOST_HAS_TR1_TUPLE, from being #included by Boost's . # define BOOST_TR1_DETAIL_CONFIG_HPP_INCLUDED # include # elif defined(__GNUC__) && (GTEST_GCC_VER_ >= 40000) // GCC 4.0+ implements tr1/tuple in the header. This does // not conform to the TR1 spec, which requires the header to be . # if !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 // Until version 4.3.2, gcc has a bug that causes , // which is #included by , to not compile when RTTI is // disabled. _TR1_FUNCTIONAL is the header guard for // . Hence the following #define is a hack to prevent // from being included. # define _TR1_FUNCTIONAL 1 # include # undef _TR1_FUNCTIONAL // Allows the user to #include // if he chooses to. # else # include // NOLINT # endif // !GTEST_HAS_RTTI && GTEST_GCC_VER_ < 40302 # else // If the compiler is not GCC 4.0+, we assume the user is using a // spec-conforming TR1 implementation. # include // NOLINT # endif // GTEST_USE_OWN_TR1_TUPLE #endif // GTEST_HAS_TR1_TUPLE // Determines whether clone(2) is supported. // Usually it will only be available on Linux, excluding // Linux on the Itanium architecture. // Also see http://linux.die.net/man/2/clone. #ifndef GTEST_HAS_CLONE // The user didn't tell us, so we need to figure it out. # if GTEST_OS_LINUX && !defined(__ia64__) # if GTEST_OS_LINUX_ANDROID // On Android, clone() is only available on ARM starting with Gingerbread. # if defined(__arm__) && __ANDROID_API__ >= 9 # define GTEST_HAS_CLONE 1 # else # define GTEST_HAS_CLONE 0 # endif # else # define GTEST_HAS_CLONE 1 # endif # else # define GTEST_HAS_CLONE 0 # endif // GTEST_OS_LINUX && !defined(__ia64__) #endif // GTEST_HAS_CLONE // Determines whether to support stream redirection. This is used to test // output correctness and to implement death tests. #ifndef GTEST_HAS_STREAM_REDIRECTION // By default, we assume that stream redirection is supported on all // platforms except known mobile ones. # if GTEST_OS_WINDOWS_MOBILE || GTEST_OS_SYMBIAN # define GTEST_HAS_STREAM_REDIRECTION 0 # else # define GTEST_HAS_STREAM_REDIRECTION 1 # endif // !GTEST_OS_WINDOWS_MOBILE && !GTEST_OS_SYMBIAN #endif // GTEST_HAS_STREAM_REDIRECTION // Determines whether to support death tests. // Google Test does not support death tests for VC 7.1 and earlier as // abort() in a VC 7.1 application compiled as GUI in debug config // pops up a dialog window that cannot be suppressed programmatically. #if (GTEST_OS_LINUX || GTEST_OS_CYGWIN || GTEST_OS_SOLARIS || \ (GTEST_OS_MAC && !GTEST_OS_IOS) || GTEST_OS_IOS_SIMULATOR || \ (GTEST_OS_WINDOWS_DESKTOP && _MSC_VER >= 1400) || \ GTEST_OS_WINDOWS_MINGW || GTEST_OS_AIX || GTEST_OS_HPUX || \ GTEST_OS_OPENBSD || GTEST_OS_QNX) # define GTEST_HAS_DEATH_TEST 1 # include // NOLINT #endif // We don't support MSVC 7.1 with exceptions disabled now. Therefore // all the compilers we care about are adequate for supporting // value-parameterized tests. #define GTEST_HAS_PARAM_TEST 1 // Determines whether to support type-driven tests. // Typed tests need and variadic macros, which GCC, VC++ 8.0, // Sun Pro CC, IBM Visual Age, and HP aCC support. #if defined(__GNUC__) || (_MSC_VER >= 1400) || defined(__SUNPRO_CC) || \ defined(__IBMCPP__) || defined(__HP_aCC) # define GTEST_HAS_TYPED_TEST 1 # define GTEST_HAS_TYPED_TEST_P 1 #endif // Determines whether to support Combine(). This only makes sense when // value-parameterized tests are enabled. The implementation doesn't // work on Sun Studio since it doesn't understand templated conversion // operators. #if GTEST_HAS_PARAM_TEST && GTEST_HAS_TR1_TUPLE && !defined(__SUNPRO_CC) # define GTEST_HAS_COMBINE 1 #endif // Determines whether the system compiler uses UTF-16 for encoding wide strings. #define GTEST_WIDE_STRING_USES_UTF16_ \ (GTEST_OS_WINDOWS || GTEST_OS_CYGWIN || GTEST_OS_SYMBIAN || GTEST_OS_AIX) // Determines whether test results can be streamed to a socket. #if GTEST_OS_LINUX # define GTEST_CAN_STREAM_RESULTS_ 1 #endif // Defines some utility macros. // The GNU compiler emits a warning if nested "if" statements are followed by // an "else" statement and braces are not used to explicitly disambiguate the // "else" binding. This leads to problems with code like: // // if (gate) // ASSERT_*(condition) << "Some message"; // // The "switch (0) case 0:" idiom is used to suppress this. #ifdef __INTEL_COMPILER # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ #else # define GTEST_AMBIGUOUS_ELSE_BLOCKER_ switch (0) case 0: default: // NOLINT #endif // Use this annotation at the end of a struct/class definition to // prevent the compiler from optimizing away instances that are never // used. This is useful when all interesting logic happens inside the // c'tor and / or d'tor. Example: // // struct Foo { // Foo() { ... } // } GTEST_ATTRIBUTE_UNUSED_; // // Also use it after a variable or parameter declaration to tell the // compiler the variable/parameter does not have to be used. #if defined(__GNUC__) && !defined(COMPILER_ICC) # define GTEST_ATTRIBUTE_UNUSED_ __attribute__ ((unused)) #else # define GTEST_ATTRIBUTE_UNUSED_ #endif // A macro to disallow operator= // This should be used in the private: declarations for a class. #define GTEST_DISALLOW_ASSIGN_(type)\ void operator=(type const &) // A macro to disallow copy constructor and operator= // This should be used in the private: declarations for a class. #define GTEST_DISALLOW_COPY_AND_ASSIGN_(type)\ type(type const &);\ GTEST_DISALLOW_ASSIGN_(type) // Tell the compiler to warn about unused return values for functions declared // with this macro. The macro should be used on function declarations // following the argument list: // // Sprocket* AllocateSprocket() GTEST_MUST_USE_RESULT_; #if defined(__GNUC__) && (GTEST_GCC_VER_ >= 30400) && !defined(COMPILER_ICC) # define GTEST_MUST_USE_RESULT_ __attribute__ ((warn_unused_result)) #else # define GTEST_MUST_USE_RESULT_ #endif // __GNUC__ && (GTEST_GCC_VER_ >= 30400) && !COMPILER_ICC // Determine whether the compiler supports Microsoft's Structured Exception // Handling. This is supported by several Windows compilers but generally // does not exist on any other system. #ifndef GTEST_HAS_SEH // The user didn't tell us, so we need to figure it out. # if defined(_MSC_VER) || defined(__BORLANDC__) // These two compilers are known to support SEH. # define GTEST_HAS_SEH 1 # else // Assume no SEH. # define GTEST_HAS_SEH 0 # endif #endif // GTEST_HAS_SEH #ifdef _MSC_VER # if GTEST_LINKED_AS_SHARED_LIBRARY # define GTEST_API_ __declspec(dllimport) # elif GTEST_CREATE_SHARED_LIBRARY # define GTEST_API_ __declspec(dllexport) # endif #endif // _MSC_VER #ifndef GTEST_API_ # define GTEST_API_ #endif #ifdef __GNUC__ // Ask the compiler to never inline a given function. # define GTEST_NO_INLINE_ __attribute__((noinline)) #else # define GTEST_NO_INLINE_ #endif // _LIBCPP_VERSION is defined by the libc++ library from the LLVM project. #if defined(__GLIBCXX__) || defined(_LIBCPP_VERSION) # define GTEST_HAS_CXXABI_H_ 1 #else # define GTEST_HAS_CXXABI_H_ 0 #endif namespace testing { class Message; namespace internal { // A secret type that Google Test users don't know about. It has no // definition on purpose. Therefore it's impossible to create a // Secret object, which is what we want. class Secret; // The GTEST_COMPILE_ASSERT_ macro can be used to verify that a compile time // expression is true. For example, you could use it to verify the // size of a static array: // // GTEST_COMPILE_ASSERT_(ARRAYSIZE(content_type_names) == CONTENT_NUM_TYPES, // content_type_names_incorrect_size); // // or to make sure a struct is smaller than a certain size: // // GTEST_COMPILE_ASSERT_(sizeof(foo) < 128, foo_too_large); // // The second argument to the macro is the name of the variable. If // the expression is false, most compilers will issue a warning/error // containing the name of the variable. template struct CompileAssert { }; #define GTEST_COMPILE_ASSERT_(expr, msg) \ typedef ::testing::internal::CompileAssert<(static_cast(expr))> \ msg[static_cast(expr) ? 1 : -1] GTEST_ATTRIBUTE_UNUSED_ // Implementation details of GTEST_COMPILE_ASSERT_: // // - GTEST_COMPILE_ASSERT_ works by defining an array type that has -1 // elements (and thus is invalid) when the expression is false. // // - The simpler definition // // #define GTEST_COMPILE_ASSERT_(expr, msg) typedef char msg[(expr) ? 1 : -1] // // does not work, as gcc supports variable-length arrays whose sizes // are determined at run-time (this is gcc's extension and not part // of the C++ standard). As a result, gcc fails to reject the // following code with the simple definition: // // int foo; // GTEST_COMPILE_ASSERT_(foo, msg); // not supposed to compile as foo is // // not a compile-time constant. // // - By using the type CompileAssert<(bool(expr))>, we ensures that // expr is a compile-time constant. (Template arguments must be // determined at compile-time.) // // - The outter parentheses in CompileAssert<(bool(expr))> are necessary // to work around a bug in gcc 3.4.4 and 4.0.1. If we had written // // CompileAssert // // instead, these compilers will refuse to compile // // GTEST_COMPILE_ASSERT_(5 > 0, some_message); // // (They seem to think the ">" in "5 > 0" marks the end of the // template argument list.) // // - The array size is (bool(expr) ? 1 : -1), instead of simply // // ((expr) ? 1 : -1). // // This is to avoid running into a bug in MS VC 7.1, which // causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1. // StaticAssertTypeEqHelper is used by StaticAssertTypeEq defined in gtest.h. // // This template is declared, but intentionally undefined. template struct StaticAssertTypeEqHelper; template struct StaticAssertTypeEqHelper {}; #if GTEST_HAS_GLOBAL_STRING typedef ::string string; #else typedef ::std::string string; #endif // GTEST_HAS_GLOBAL_STRING #if GTEST_HAS_GLOBAL_WSTRING typedef ::wstring wstring; #elif GTEST_HAS_STD_WSTRING typedef ::std::wstring wstring; #endif // GTEST_HAS_GLOBAL_WSTRING // A helper for suppressing warnings on constant condition. It just // returns 'condition'. GTEST_API_ bool IsTrue(bool condition); // Defines scoped_ptr. // This implementation of scoped_ptr is PARTIAL - it only contains // enough stuff to satisfy Google Test's need. template class scoped_ptr { public: typedef T element_type; explicit scoped_ptr(T* p = NULL) : ptr_(p) {} ~scoped_ptr() { reset(); } T& operator*() const { return *ptr_; } T* operator->() const { return ptr_; } T* get() const { return ptr_; } T* release() { T* const ptr = ptr_; ptr_ = NULL; return ptr; } void reset(T* p = NULL) { if (p != ptr_) { if (IsTrue(sizeof(T) > 0)) { // Makes sure T is a complete type. delete ptr_; } ptr_ = p; } } private: T* ptr_; GTEST_DISALLOW_COPY_AND_ASSIGN_(scoped_ptr); }; // Defines RE. // A simple C++ wrapper for . It uses the POSIX Extended // Regular Expression syntax. class GTEST_API_ RE { public: // A copy constructor is required by the Standard to initialize object // references from r-values. RE(const RE& other) { Init(other.pattern()); } // Constructs an RE from a string. RE(const ::std::string& regex) { Init(regex.c_str()); } // NOLINT #if GTEST_HAS_GLOBAL_STRING RE(const ::string& regex) { Init(regex.c_str()); } // NOLINT #endif // GTEST_HAS_GLOBAL_STRING RE(const char* regex) { Init(regex); } // NOLINT ~RE(); // Returns the string representation of the regex. const char* pattern() const { return pattern_; } // FullMatch(str, re) returns true iff regular expression re matches // the entire str. // PartialMatch(str, re) returns true iff regular expression re // matches a substring of str (including str itself). // // TODO(wan@google.com): make FullMatch() and PartialMatch() work // when str contains NUL characters. static bool FullMatch(const ::std::string& str, const RE& re) { return FullMatch(str.c_str(), re); } static bool PartialMatch(const ::std::string& str, const RE& re) { return PartialMatch(str.c_str(), re); } #if GTEST_HAS_GLOBAL_STRING static bool FullMatch(const ::string& str, const RE& re) { return FullMatch(str.c_str(), re); } static bool PartialMatch(const ::string& str, const RE& re) { return PartialMatch(str.c_str(), re); } #endif // GTEST_HAS_GLOBAL_STRING static bool FullMatch(const char* str, const RE& re); static bool PartialMatch(const char* str, const RE& re); private: void Init(const char* regex); // We use a const char* instead of an std::string, as Google Test used to be // used where std::string is not available. TODO(wan@google.com): change to // std::string. const char* pattern_; bool is_valid_; #if GTEST_USES_POSIX_RE regex_t full_regex_; // For FullMatch(). regex_t partial_regex_; // For PartialMatch(). #else // GTEST_USES_SIMPLE_RE const char* full_pattern_; // For FullMatch(); #endif GTEST_DISALLOW_ASSIGN_(RE); }; // Formats a source file path and a line number as they would appear // in an error message from the compiler used to compile this code. GTEST_API_ ::std::string FormatFileLocation(const char* file, int line); // Formats a file location for compiler-independent XML output. // Although this function is not platform dependent, we put it next to // FormatFileLocation in order to contrast the two functions. GTEST_API_ ::std::string FormatCompilerIndependentFileLocation(const char* file, int line); // Defines logging utilities: // GTEST_LOG_(severity) - logs messages at the specified severity level. The // message itself is streamed into the macro. // LogToStderr() - directs all log messages to stderr. // FlushInfoLog() - flushes informational log messages. enum GTestLogSeverity { GTEST_INFO, GTEST_WARNING, GTEST_ERROR, GTEST_FATAL }; // Formats log entry severity, provides a stream object for streaming the // log message, and terminates the message with a newline when going out of // scope. class GTEST_API_ GTestLog { public: GTestLog(GTestLogSeverity severity, const char* file, int line); // Flushes the buffers and, if severity is GTEST_FATAL, aborts the program. ~GTestLog(); ::std::ostream& GetStream() { return ::std::cerr; } private: const GTestLogSeverity severity_; GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestLog); }; #define GTEST_LOG_(severity) \ ::testing::internal::GTestLog(::testing::internal::GTEST_##severity, \ __FILE__, __LINE__).GetStream() inline void LogToStderr() {} inline void FlushInfoLog() { fflush(NULL); } // INTERNAL IMPLEMENTATION - DO NOT USE. // // GTEST_CHECK_ is an all-mode assert. It aborts the program if the condition // is not satisfied. // Synopsys: // GTEST_CHECK_(boolean_condition); // or // GTEST_CHECK_(boolean_condition) << "Additional message"; // // This checks the condition and if the condition is not satisfied // it prints message about the condition violation, including the // condition itself, plus additional message streamed into it, if any, // and then it aborts the program. It aborts the program irrespective of // whether it is built in the debug mode or not. #define GTEST_CHECK_(condition) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::IsTrue(condition)) \ ; \ else \ GTEST_LOG_(FATAL) << "Condition " #condition " failed. " // An all-mode assert to verify that the given POSIX-style function // call returns 0 (indicating success). Known limitation: this // doesn't expand to a balanced 'if' statement, so enclose the macro // in {} if you need to use it as the only statement in an 'if' // branch. #define GTEST_CHECK_POSIX_SUCCESS_(posix_call) \ if (const int gtest_error = (posix_call)) \ GTEST_LOG_(FATAL) << #posix_call << "failed with error " \ << gtest_error // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Use ImplicitCast_ as a safe version of static_cast for upcasting in // the type hierarchy (e.g. casting a Foo* to a SuperclassOfFoo* or a // const Foo*). When you use ImplicitCast_, the compiler checks that // the cast is safe. Such explicit ImplicitCast_s are necessary in // surprisingly many situations where C++ demands an exact type match // instead of an argument type convertable to a target type. // // The syntax for using ImplicitCast_ is the same as for static_cast: // // ImplicitCast_(expr) // // ImplicitCast_ would have been part of the C++ standard library, // but the proposal was submitted too late. It will probably make // its way into the language in the future. // // This relatively ugly name is intentional. It prevents clashes with // similar functions users may have (e.g., implicit_cast). The internal // namespace alone is not enough because the function can be found by ADL. template inline To ImplicitCast_(To x) { return x; } // When you upcast (that is, cast a pointer from type Foo to type // SuperclassOfFoo), it's fine to use ImplicitCast_<>, since upcasts // always succeed. When you downcast (that is, cast a pointer from // type Foo to type SubclassOfFoo), static_cast<> isn't safe, because // how do you know the pointer is really of type SubclassOfFoo? It // could be a bare Foo, or of type DifferentSubclassOfFoo. Thus, // when you downcast, you should use this macro. In debug mode, we // use dynamic_cast<> to double-check the downcast is legal (we die // if it's not). In normal mode, we do the efficient static_cast<> // instead. Thus, it's important to test in debug mode to make sure // the cast is legal! // This is the only place in the code we should use dynamic_cast<>. // In particular, you SHOULDN'T be using dynamic_cast<> in order to // do RTTI (eg code like this: // if (dynamic_cast(foo)) HandleASubclass1Object(foo); // if (dynamic_cast(foo)) HandleASubclass2Object(foo); // You should design the code some other way not to need this. // // This relatively ugly name is intentional. It prevents clashes with // similar functions users may have (e.g., down_cast). The internal // namespace alone is not enough because the function can be found by ADL. template // use like this: DownCast_(foo); inline To DownCast_(From* f) { // so we only accept pointers // Ensures that To is a sub-type of From *. This test is here only // for compile-time type checking, and has no overhead in an // optimized build at run-time, as it will be optimized away // completely. if (false) { const To to = NULL; ::testing::internal::ImplicitCast_(to); } #if GTEST_HAS_RTTI // RTTI: debug mode only! GTEST_CHECK_(f == NULL || dynamic_cast(f) != NULL); #endif return static_cast(f); } // Downcasts the pointer of type Base to Derived. // Derived must be a subclass of Base. The parameter MUST // point to a class of type Derived, not any subclass of it. // When RTTI is available, the function performs a runtime // check to enforce this. template Derived* CheckedDowncastToActualType(Base* base) { #if GTEST_HAS_RTTI GTEST_CHECK_(typeid(*base) == typeid(Derived)); return dynamic_cast(base); // NOLINT #else return static_cast(base); // Poor man's downcast. #endif } #if GTEST_HAS_STREAM_REDIRECTION // Defines the stderr capturer: // CaptureStdout - starts capturing stdout. // GetCapturedStdout - stops capturing stdout and returns the captured string. // CaptureStderr - starts capturing stderr. // GetCapturedStderr - stops capturing stderr and returns the captured string. // GTEST_API_ void CaptureStdout(); GTEST_API_ std::string GetCapturedStdout(); GTEST_API_ void CaptureStderr(); GTEST_API_ std::string GetCapturedStderr(); #endif // GTEST_HAS_STREAM_REDIRECTION #if GTEST_HAS_DEATH_TEST const ::std::vector& GetInjectableArgvs(); void SetInjectableArgvs(const ::std::vector* new_argvs); // A copy of all command line arguments. Set by InitGoogleTest(). extern ::std::vector g_argvs; #endif // GTEST_HAS_DEATH_TEST // Defines synchronization primitives. #if GTEST_HAS_PTHREAD // Sleeps for (roughly) n milli-seconds. This function is only for // testing Google Test's own constructs. Don't use it in user tests, // either directly or indirectly. inline void SleepMilliseconds(int n) { const timespec time = { 0, // 0 seconds. n * 1000L * 1000L, // And n ms. }; nanosleep(&time, NULL); } // Allows a controller thread to pause execution of newly created // threads until notified. Instances of this class must be created // and destroyed in the controller thread. // // This class is only for testing Google Test's own constructs. Do not // use it in user tests, either directly or indirectly. class Notification { public: Notification() : notified_(false) { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); } ~Notification() { pthread_mutex_destroy(&mutex_); } // Notifies all threads created with this notification to start. Must // be called from the controller thread. void Notify() { pthread_mutex_lock(&mutex_); notified_ = true; pthread_mutex_unlock(&mutex_); } // Blocks until the controller thread notifies. Must be called from a test // thread. void WaitForNotification() { for (;;) { pthread_mutex_lock(&mutex_); const bool notified = notified_; pthread_mutex_unlock(&mutex_); if (notified) break; SleepMilliseconds(10); } } private: pthread_mutex_t mutex_; bool notified_; GTEST_DISALLOW_COPY_AND_ASSIGN_(Notification); }; // As a C-function, ThreadFuncWithCLinkage cannot be templated itself. // Consequently, it cannot select a correct instantiation of ThreadWithParam // in order to call its Run(). Introducing ThreadWithParamBase as a // non-templated base class for ThreadWithParam allows us to bypass this // problem. class ThreadWithParamBase { public: virtual ~ThreadWithParamBase() {} virtual void Run() = 0; }; // pthread_create() accepts a pointer to a function type with the C linkage. // According to the Standard (7.5/1), function types with different linkages // are different even if they are otherwise identical. Some compilers (for // example, SunStudio) treat them as different types. Since class methods // cannot be defined with C-linkage we need to define a free C-function to // pass into pthread_create(). extern "C" inline void* ThreadFuncWithCLinkage(void* thread) { static_cast(thread)->Run(); return NULL; } // Helper class for testing Google Test's multi-threading constructs. // To use it, write: // // void ThreadFunc(int param) { /* Do things with param */ } // Notification thread_can_start; // ... // // The thread_can_start parameter is optional; you can supply NULL. // ThreadWithParam thread(&ThreadFunc, 5, &thread_can_start); // thread_can_start.Notify(); // // These classes are only for testing Google Test's own constructs. Do // not use them in user tests, either directly or indirectly. template class ThreadWithParam : public ThreadWithParamBase { public: typedef void (*UserThreadFunc)(T); ThreadWithParam( UserThreadFunc func, T param, Notification* thread_can_start) : func_(func), param_(param), thread_can_start_(thread_can_start), finished_(false) { ThreadWithParamBase* const base = this; // The thread can be created only after all fields except thread_ // have been initialized. GTEST_CHECK_POSIX_SUCCESS_( pthread_create(&thread_, 0, &ThreadFuncWithCLinkage, base)); } ~ThreadWithParam() { Join(); } void Join() { if (!finished_) { GTEST_CHECK_POSIX_SUCCESS_(pthread_join(thread_, 0)); finished_ = true; } } virtual void Run() { if (thread_can_start_ != NULL) thread_can_start_->WaitForNotification(); func_(param_); } private: const UserThreadFunc func_; // User-supplied thread function. const T param_; // User-supplied parameter to the thread function. // When non-NULL, used to block execution until the controller thread // notifies. Notification* const thread_can_start_; bool finished_; // true iff we know that the thread function has finished. pthread_t thread_; // The native thread object. GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadWithParam); }; // MutexBase and Mutex implement mutex on pthreads-based platforms. They // are used in conjunction with class MutexLock: // // Mutex mutex; // ... // MutexLock lock(&mutex); // Acquires the mutex and releases it at the end // // of the current scope. // // MutexBase implements behavior for both statically and dynamically // allocated mutexes. Do not use MutexBase directly. Instead, write // the following to define a static mutex: // // GTEST_DEFINE_STATIC_MUTEX_(g_some_mutex); // // You can forward declare a static mutex like this: // // GTEST_DECLARE_STATIC_MUTEX_(g_some_mutex); // // To create a dynamic mutex, just define an object of type Mutex. class MutexBase { public: // Acquires this mutex. void Lock() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_lock(&mutex_)); owner_ = pthread_self(); has_owner_ = true; } // Releases this mutex. void Unlock() { // Since the lock is being released the owner_ field should no longer be // considered valid. We don't protect writing to has_owner_ here, as it's // the caller's responsibility to ensure that the current thread holds the // mutex when this is called. has_owner_ = false; GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_unlock(&mutex_)); } // Does nothing if the current thread holds the mutex. Otherwise, crashes // with high probability. void AssertHeld() const { GTEST_CHECK_(has_owner_ && pthread_equal(owner_, pthread_self())) << "The current thread is not holding the mutex @" << this; } // A static mutex may be used before main() is entered. It may even // be used before the dynamic initialization stage. Therefore we // must be able to initialize a static mutex object at link time. // This means MutexBase has to be a POD and its member variables // have to be public. public: pthread_mutex_t mutex_; // The underlying pthread mutex. // has_owner_ indicates whether the owner_ field below contains a valid thread // ID and is therefore safe to inspect (e.g., to use in pthread_equal()). All // accesses to the owner_ field should be protected by a check of this field. // An alternative might be to memset() owner_ to all zeros, but there's no // guarantee that a zero'd pthread_t is necessarily invalid or even different // from pthread_self(). bool has_owner_; pthread_t owner_; // The thread holding the mutex. }; // Forward-declares a static mutex. # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ extern ::testing::internal::MutexBase mutex // Defines and statically (i.e. at link time) initializes a static mutex. // The initialization list here does not explicitly initialize each field, // instead relying on default initialization for the unspecified fields. In // particular, the owner_ field (a pthread_t) is not explicitly initialized. // This allows initialization to work whether pthread_t is a scalar or struct. // The flag -Wmissing-field-initializers must not be specified for this to work. # define GTEST_DEFINE_STATIC_MUTEX_(mutex) \ ::testing::internal::MutexBase mutex = { PTHREAD_MUTEX_INITIALIZER, false } // The Mutex class can only be used for mutexes created at runtime. It // shares its API with MutexBase otherwise. class Mutex : public MutexBase { public: Mutex() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_init(&mutex_, NULL)); has_owner_ = false; } ~Mutex() { GTEST_CHECK_POSIX_SUCCESS_(pthread_mutex_destroy(&mutex_)); } private: GTEST_DISALLOW_COPY_AND_ASSIGN_(Mutex); }; // We cannot name this class MutexLock as the ctor declaration would // conflict with a macro named MutexLock, which is defined on some // platforms. Hence the typedef trick below. class GTestMutexLock { public: explicit GTestMutexLock(MutexBase* mutex) : mutex_(mutex) { mutex_->Lock(); } ~GTestMutexLock() { mutex_->Unlock(); } private: MutexBase* const mutex_; GTEST_DISALLOW_COPY_AND_ASSIGN_(GTestMutexLock); }; typedef GTestMutexLock MutexLock; // Helpers for ThreadLocal. // pthread_key_create() requires DeleteThreadLocalValue() to have // C-linkage. Therefore it cannot be templatized to access // ThreadLocal. Hence the need for class // ThreadLocalValueHolderBase. class ThreadLocalValueHolderBase { public: virtual ~ThreadLocalValueHolderBase() {} }; // Called by pthread to delete thread-local data stored by // pthread_setspecific(). extern "C" inline void DeleteThreadLocalValue(void* value_holder) { delete static_cast(value_holder); } // Implements thread-local storage on pthreads-based systems. // // // Thread 1 // ThreadLocal tl(100); // 100 is the default value for each thread. // // // Thread 2 // tl.set(150); // Changes the value for thread 2 only. // EXPECT_EQ(150, tl.get()); // // // Thread 1 // EXPECT_EQ(100, tl.get()); // In thread 1, tl has the original value. // tl.set(200); // EXPECT_EQ(200, tl.get()); // // The template type argument T must have a public copy constructor. // In addition, the default ThreadLocal constructor requires T to have // a public default constructor. // // An object managed for a thread by a ThreadLocal instance is deleted // when the thread exits. Or, if the ThreadLocal instance dies in // that thread, when the ThreadLocal dies. It's the user's // responsibility to ensure that all other threads using a ThreadLocal // have exited when it dies, or the per-thread objects for those // threads will not be deleted. // // Google Test only uses global ThreadLocal objects. That means they // will die after main() has returned. Therefore, no per-thread // object managed by Google Test will be leaked as long as all threads // using Google Test have exited when main() returns. template class ThreadLocal { public: ThreadLocal() : key_(CreateKey()), default_() {} explicit ThreadLocal(const T& value) : key_(CreateKey()), default_(value) {} ~ThreadLocal() { // Destroys the managed object for the current thread, if any. DeleteThreadLocalValue(pthread_getspecific(key_)); // Releases resources associated with the key. This will *not* // delete managed objects for other threads. GTEST_CHECK_POSIX_SUCCESS_(pthread_key_delete(key_)); } T* pointer() { return GetOrCreateValue(); } const T* pointer() const { return GetOrCreateValue(); } const T& get() const { return *pointer(); } void set(const T& value) { *pointer() = value; } private: // Holds a value of type T. class ValueHolder : public ThreadLocalValueHolderBase { public: explicit ValueHolder(const T& value) : value_(value) {} T* pointer() { return &value_; } private: T value_; GTEST_DISALLOW_COPY_AND_ASSIGN_(ValueHolder); }; static pthread_key_t CreateKey() { pthread_key_t key; // When a thread exits, DeleteThreadLocalValue() will be called on // the object managed for that thread. GTEST_CHECK_POSIX_SUCCESS_( pthread_key_create(&key, &DeleteThreadLocalValue)); return key; } T* GetOrCreateValue() const { ThreadLocalValueHolderBase* const holder = static_cast(pthread_getspecific(key_)); if (holder != NULL) { return CheckedDowncastToActualType(holder)->pointer(); } ValueHolder* const new_holder = new ValueHolder(default_); ThreadLocalValueHolderBase* const holder_base = new_holder; GTEST_CHECK_POSIX_SUCCESS_(pthread_setspecific(key_, holder_base)); return new_holder->pointer(); } // A key pthreads uses for looking up per-thread values. const pthread_key_t key_; const T default_; // The default value for each thread. GTEST_DISALLOW_COPY_AND_ASSIGN_(ThreadLocal); }; # define GTEST_IS_THREADSAFE 1 #else // GTEST_HAS_PTHREAD // A dummy implementation of synchronization primitives (mutex, lock, // and thread-local variable). Necessary for compiling Google Test where // mutex is not supported - using Google Test in multiple threads is not // supported on such platforms. class Mutex { public: Mutex() {} void Lock() {} void Unlock() {} void AssertHeld() const {} }; # define GTEST_DECLARE_STATIC_MUTEX_(mutex) \ extern ::testing::internal::Mutex mutex # define GTEST_DEFINE_STATIC_MUTEX_(mutex) ::testing::internal::Mutex mutex class GTestMutexLock { public: explicit GTestMutexLock(Mutex*) {} // NOLINT }; typedef GTestMutexLock MutexLock; template class ThreadLocal { public: ThreadLocal() : value_() {} explicit ThreadLocal(const T& value) : value_(value) {} T* pointer() { return &value_; } const T* pointer() const { return &value_; } const T& get() const { return value_; } void set(const T& value) { value_ = value; } private: T value_; }; // The above synchronization primitives have dummy implementations. // Therefore Google Test is not thread-safe. # define GTEST_IS_THREADSAFE 0 #endif // GTEST_HAS_PTHREAD // Returns the number of threads running in the process, or 0 to indicate that // we cannot detect it. GTEST_API_ size_t GetThreadCount(); // Passing non-POD classes through ellipsis (...) crashes the ARM // compiler and generates a warning in Sun Studio. The Nokia Symbian // and the IBM XL C/C++ compiler try to instantiate a copy constructor // for objects passed through ellipsis (...), failing for uncopyable // objects. We define this to ensure that only POD is passed through // ellipsis on these systems. #if defined(__SYMBIAN32__) || defined(__IBMCPP__) || defined(__SUNPRO_CC) // We lose support for NULL detection where the compiler doesn't like // passing non-POD classes through ellipsis (...). # define GTEST_ELLIPSIS_NEEDS_POD_ 1 #else # define GTEST_CAN_COMPARE_NULL 1 #endif // The Nokia Symbian and IBM XL C/C++ compilers cannot decide between // const T& and const T* in a function template. These compilers // _can_ decide between class template specializations for T and T*, // so a tr1::type_traits-like is_pointer works. #if defined(__SYMBIAN32__) || defined(__IBMCPP__) # define GTEST_NEEDS_IS_POINTER_ 1 #endif template struct bool_constant { typedef bool_constant type; static const bool value = bool_value; }; template const bool bool_constant::value; typedef bool_constant false_type; typedef bool_constant true_type; template struct is_pointer : public false_type {}; template struct is_pointer : public true_type {}; template struct IteratorTraits { typedef typename Iterator::value_type value_type; }; template struct IteratorTraits { typedef T value_type; }; template struct IteratorTraits { typedef T value_type; }; #if GTEST_OS_WINDOWS # define GTEST_PATH_SEP_ "\\" # define GTEST_HAS_ALT_PATH_SEP_ 1 // The biggest signed integer type the compiler supports. typedef __int64 BiggestInt; #else # define GTEST_PATH_SEP_ "/" # define GTEST_HAS_ALT_PATH_SEP_ 0 typedef long long BiggestInt; // NOLINT #endif // GTEST_OS_WINDOWS // Utilities for char. // isspace(int ch) and friends accept an unsigned char or EOF. char // may be signed, depending on the compiler (or compiler flags). // Therefore we need to cast a char to unsigned char before calling // isspace(), etc. inline bool IsAlpha(char ch) { return isalpha(static_cast(ch)) != 0; } inline bool IsAlNum(char ch) { return isalnum(static_cast(ch)) != 0; } inline bool IsDigit(char ch) { return isdigit(static_cast(ch)) != 0; } inline bool IsLower(char ch) { return islower(static_cast(ch)) != 0; } inline bool IsSpace(char ch) { return isspace(static_cast(ch)) != 0; } inline bool IsUpper(char ch) { return isupper(static_cast(ch)) != 0; } inline bool IsXDigit(char ch) { return isxdigit(static_cast(ch)) != 0; } inline bool IsXDigit(wchar_t ch) { const unsigned char low_byte = static_cast(ch); return ch == low_byte && isxdigit(low_byte) != 0; } inline char ToLower(char ch) { return static_cast(tolower(static_cast(ch))); } inline char ToUpper(char ch) { return static_cast(toupper(static_cast(ch))); } // The testing::internal::posix namespace holds wrappers for common // POSIX functions. These wrappers hide the differences between // Windows/MSVC and POSIX systems. Since some compilers define these // standard functions as macros, the wrapper cannot have the same name // as the wrapped function. namespace posix { // Functions with a different name on Windows. #if GTEST_OS_WINDOWS typedef struct _stat StatStruct; # ifdef __BORLANDC__ inline int IsATTY(int fd) { return isatty(fd); } inline int StrCaseCmp(const char* s1, const char* s2) { return stricmp(s1, s2); } inline char* StrDup(const char* src) { return strdup(src); } # else // !__BORLANDC__ # if GTEST_OS_WINDOWS_MOBILE inline int IsATTY(int /* fd */) { return 0; } # else inline int IsATTY(int fd) { return _isatty(fd); } # endif // GTEST_OS_WINDOWS_MOBILE inline int StrCaseCmp(const char* s1, const char* s2) { return _stricmp(s1, s2); } inline char* StrDup(const char* src) { return _strdup(src); } # endif // __BORLANDC__ # if GTEST_OS_WINDOWS_MOBILE inline int FileNo(FILE* file) { return reinterpret_cast(_fileno(file)); } // Stat(), RmDir(), and IsDir() are not needed on Windows CE at this // time and thus not defined there. # else inline int FileNo(FILE* file) { return _fileno(file); } inline int Stat(const char* path, StatStruct* buf) { return _stat(path, buf); } inline int RmDir(const char* dir) { return _rmdir(dir); } inline bool IsDir(const StatStruct& st) { return (_S_IFDIR & st.st_mode) != 0; } # endif // GTEST_OS_WINDOWS_MOBILE #else typedef struct stat StatStruct; inline int FileNo(FILE* file) { return fileno(file); } inline int IsATTY(int fd) { return isatty(fd); } inline int Stat(const char* path, StatStruct* buf) { return stat(path, buf); } inline int StrCaseCmp(const char* s1, const char* s2) { return strcasecmp(s1, s2); } inline char* StrDup(const char* src) { return strdup(src); } inline int RmDir(const char* dir) { return rmdir(dir); } inline bool IsDir(const StatStruct& st) { return S_ISDIR(st.st_mode); } #endif // GTEST_OS_WINDOWS // Functions deprecated by MSVC 8.0. #ifdef _MSC_VER // Temporarily disable warning 4996 (deprecated function). # pragma warning(push) # pragma warning(disable:4996) #endif inline const char* StrNCpy(char* dest, const char* src, size_t n) { return strncpy(dest, src, n); } // ChDir(), FReopen(), FDOpen(), Read(), Write(), Close(), and // StrError() aren't needed on Windows CE at this time and thus not // defined there. #if !GTEST_OS_WINDOWS_MOBILE inline int ChDir(const char* dir) { return chdir(dir); } #endif inline FILE* FOpen(const char* path, const char* mode) { return fopen(path, mode); } #if !GTEST_OS_WINDOWS_MOBILE inline FILE *FReopen(const char* path, const char* mode, FILE* stream) { return freopen(path, mode, stream); } inline FILE* FDOpen(int fd, const char* mode) { return fdopen(fd, mode); } #endif inline int FClose(FILE* fp) { return fclose(fp); } #if !GTEST_OS_WINDOWS_MOBILE inline int Read(int fd, void* buf, unsigned int count) { return static_cast(read(fd, buf, count)); } inline int Write(int fd, const void* buf, unsigned int count) { return static_cast(write(fd, buf, count)); } inline int Close(int fd) { return close(fd); } inline const char* StrError(int errnum) { return strerror(errnum); } #endif inline const char* GetEnv(const char* name) { #if GTEST_OS_WINDOWS_MOBILE // We are on Windows CE, which has no environment variables. return NULL; #elif defined(__BORLANDC__) || defined(__SunOS_5_8) || defined(__SunOS_5_9) // Environment variables which we programmatically clear will be set to the // empty string rather than unset (NULL). Handle that case. const char* const env = getenv(name); return (env != NULL && env[0] != '\0') ? env : NULL; #else return getenv(name); #endif } #ifdef _MSC_VER # pragma warning(pop) // Restores the warning state. #endif #if GTEST_OS_WINDOWS_MOBILE // Windows CE has no C library. The abort() function is used in // several places in Google Test. This implementation provides a reasonable // imitation of standard behaviour. void Abort(); #else inline void Abort() { abort(); } #endif // GTEST_OS_WINDOWS_MOBILE } // namespace posix // MSVC "deprecates" snprintf and issues warnings wherever it is used. In // order to avoid these warnings, we need to use _snprintf or _snprintf_s on // MSVC-based platforms. We map the GTEST_SNPRINTF_ macro to the appropriate // function in order to achieve that. We use macro definition here because // snprintf is a variadic function. #if _MSC_VER >= 1400 && !GTEST_OS_WINDOWS_MOBILE // MSVC 2005 and above support variadic macros. # define GTEST_SNPRINTF_(buffer, size, format, ...) \ _snprintf_s(buffer, size, size, format, __VA_ARGS__) #elif defined(_MSC_VER) // Windows CE does not define _snprintf_s and MSVC prior to 2005 doesn't // complain about _snprintf. # define GTEST_SNPRINTF_ _snprintf #else # define GTEST_SNPRINTF_ snprintf #endif // The maximum number a BiggestInt can represent. This definition // works no matter BiggestInt is represented in one's complement or // two's complement. // // We cannot rely on numeric_limits in STL, as __int64 and long long // are not part of standard C++ and numeric_limits doesn't need to be // defined for them. const BiggestInt kMaxBiggestInt = ~(static_cast(1) << (8*sizeof(BiggestInt) - 1)); // This template class serves as a compile-time function from size to // type. It maps a size in bytes to a primitive type with that // size. e.g. // // TypeWithSize<4>::UInt // // is typedef-ed to be unsigned int (unsigned integer made up of 4 // bytes). // // Such functionality should belong to STL, but I cannot find it // there. // // Google Test uses this class in the implementation of floating-point // comparison. // // For now it only handles UInt (unsigned int) as that's all Google Test // needs. Other types can be easily added in the future if need // arises. template class TypeWithSize { public: // This prevents the user from using TypeWithSize with incorrect // values of N. typedef void UInt; }; // The specialization for size 4. template <> class TypeWithSize<4> { public: // unsigned int has size 4 in both gcc and MSVC. // // As base/basictypes.h doesn't compile on Windows, we cannot use // uint32, uint64, and etc here. typedef int Int; typedef unsigned int UInt; }; // The specialization for size 8. template <> class TypeWithSize<8> { public: #if GTEST_OS_WINDOWS typedef __int64 Int; typedef unsigned __int64 UInt; #else typedef long long Int; // NOLINT typedef unsigned long long UInt; // NOLINT #endif // GTEST_OS_WINDOWS }; // Integer types of known sizes. typedef TypeWithSize<4>::Int Int32; typedef TypeWithSize<4>::UInt UInt32; typedef TypeWithSize<8>::Int Int64; typedef TypeWithSize<8>::UInt UInt64; typedef TypeWithSize<8>::Int TimeInMillis; // Represents time in milliseconds. // Utilities for command line flags and environment variables. // Macro for referencing flags. #define GTEST_FLAG(name) FLAGS_gtest_##name // Macros for declaring flags. #define GTEST_DECLARE_bool_(name) GTEST_API_ extern bool GTEST_FLAG(name) #define GTEST_DECLARE_int32_(name) \ GTEST_API_ extern ::testing::internal::Int32 GTEST_FLAG(name) #define GTEST_DECLARE_string_(name) \ GTEST_API_ extern ::std::string GTEST_FLAG(name) // Macros for defining flags. #define GTEST_DEFINE_bool_(name, default_val, doc) \ GTEST_API_ bool GTEST_FLAG(name) = (default_val) #define GTEST_DEFINE_int32_(name, default_val, doc) \ GTEST_API_ ::testing::internal::Int32 GTEST_FLAG(name) = (default_val) #define GTEST_DEFINE_string_(name, default_val, doc) \ GTEST_API_ ::std::string GTEST_FLAG(name) = (default_val) // Thread annotations #define GTEST_EXCLUSIVE_LOCK_REQUIRED_(locks) #define GTEST_LOCK_EXCLUDED_(locks) // Parses 'str' for a 32-bit signed integer. If successful, writes the result // to *value and returns true; otherwise leaves *value unchanged and returns // false. // TODO(chandlerc): Find a better way to refactor flag and environment parsing // out of both gtest-port.cc and gtest.cc to avoid exporting this utility // function. bool ParseInt32(const Message& src_text, const char* str, Int32* value); // Parses a bool/Int32/string from the environment variable // corresponding to the given Google Test flag. bool BoolFromGTestEnv(const char* flag, bool default_val); GTEST_API_ Int32 Int32FromGTestEnv(const char* flag, Int32 default_val); const char* StringFromGTestEnv(const char* flag, const char* default_val); } // namespace internal } // namespace testing #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PORT_H_ #if GTEST_OS_LINUX # include # include # include # include #endif // GTEST_OS_LINUX #if GTEST_HAS_EXCEPTIONS # include #endif #include #include #include #include #include #include // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // // The Google C++ Testing Framework (Google Test) // // This header file defines the Message class. // // IMPORTANT NOTE: Due to limitation of the C++ language, we have to // leave some internal implementation details in this header file. // They are clearly marked by comments like this: // // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // // Such code is NOT meant to be used by a user directly, and is subject // to CHANGE WITHOUT NOTICE. Therefore DO NOT DEPEND ON IT in a user // program! #ifndef GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ #define GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ #include // Ensures that there is at least one operator<< in the global namespace. // See Message& operator<<(...) below for why. void operator<<(const testing::internal::Secret&, int); namespace testing { // The Message class works like an ostream repeater. // // Typical usage: // // 1. You stream a bunch of values to a Message object. // It will remember the text in a stringstream. // 2. Then you stream the Message object to an ostream. // This causes the text in the Message to be streamed // to the ostream. // // For example; // // testing::Message foo; // foo << 1 << " != " << 2; // std::cout << foo; // // will print "1 != 2". // // Message is not intended to be inherited from. In particular, its // destructor is not virtual. // // Note that stringstream behaves differently in gcc and in MSVC. You // can stream a NULL char pointer to it in the former, but not in the // latter (it causes an access violation if you do). The Message // class hides this difference by treating a NULL char pointer as // "(null)". class GTEST_API_ Message { private: // The type of basic IO manipulators (endl, ends, and flush) for // narrow streams. typedef std::ostream& (*BasicNarrowIoManip)(std::ostream&); public: // Constructs an empty Message. Message(); // Copy constructor. Message(const Message& msg) : ss_(new ::std::stringstream) { // NOLINT *ss_ << msg.GetString(); } // Constructs a Message from a C-string. explicit Message(const char* str) : ss_(new ::std::stringstream) { *ss_ << str; } #if GTEST_OS_SYMBIAN // Streams a value (either a pointer or not) to this object. template inline Message& operator <<(const T& value) { StreamHelper(typename internal::is_pointer::type(), value); return *this; } #else // Streams a non-pointer value to this object. template inline Message& operator <<(const T& val) { // Some libraries overload << for STL containers. These // overloads are defined in the global namespace instead of ::std. // // C++'s symbol lookup rule (i.e. Koenig lookup) says that these // overloads are visible in either the std namespace or the global // namespace, but not other namespaces, including the testing // namespace which Google Test's Message class is in. // // To allow STL containers (and other types that has a << operator // defined in the global namespace) to be used in Google Test // assertions, testing::Message must access the custom << operator // from the global namespace. With this using declaration, // overloads of << defined in the global namespace and those // visible via Koenig lookup are both exposed in this function. using ::operator <<; *ss_ << val; return *this; } // Streams a pointer value to this object. // // This function is an overload of the previous one. When you // stream a pointer to a Message, this definition will be used as it // is more specialized. (The C++ Standard, section // [temp.func.order].) If you stream a non-pointer, then the // previous definition will be used. // // The reason for this overload is that streaming a NULL pointer to // ostream is undefined behavior. Depending on the compiler, you // may get "0", "(nil)", "(null)", or an access violation. To // ensure consistent result across compilers, we always treat NULL // as "(null)". template inline Message& operator <<(T* const& pointer) { // NOLINT if (pointer == NULL) { *ss_ << "(null)"; } else { *ss_ << pointer; } return *this; } #endif // GTEST_OS_SYMBIAN // Since the basic IO manipulators are overloaded for both narrow // and wide streams, we have to provide this specialized definition // of operator <<, even though its body is the same as the // templatized version above. Without this definition, streaming // endl or other basic IO manipulators to Message will confuse the // compiler. Message& operator <<(BasicNarrowIoManip val) { *ss_ << val; return *this; } // Instead of 1/0, we want to see true/false for bool values. Message& operator <<(bool b) { return *this << (b ? "true" : "false"); } // These two overloads allow streaming a wide C string to a Message // using the UTF-8 encoding. Message& operator <<(const wchar_t* wide_c_str); Message& operator <<(wchar_t* wide_c_str); #if GTEST_HAS_STD_WSTRING // Converts the given wide string to a narrow string using the UTF-8 // encoding, and streams the result to this Message object. Message& operator <<(const ::std::wstring& wstr); #endif // GTEST_HAS_STD_WSTRING #if GTEST_HAS_GLOBAL_WSTRING // Converts the given wide string to a narrow string using the UTF-8 // encoding, and streams the result to this Message object. Message& operator <<(const ::wstring& wstr); #endif // GTEST_HAS_GLOBAL_WSTRING // Gets the text streamed to this object so far as an std::string. // Each '\0' character in the buffer is replaced with "\\0". // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. std::string GetString() const; private: #if GTEST_OS_SYMBIAN // These are needed as the Nokia Symbian Compiler cannot decide between // const T& and const T* in a function template. The Nokia compiler _can_ // decide between class template specializations for T and T*, so a // tr1::type_traits-like is_pointer works, and we can overload on that. template inline void StreamHelper(internal::true_type /*is_pointer*/, T* pointer) { if (pointer == NULL) { *ss_ << "(null)"; } else { *ss_ << pointer; } } template inline void StreamHelper(internal::false_type /*is_pointer*/, const T& value) { // See the comments in Message& operator <<(const T&) above for why // we need this using statement. using ::operator <<; *ss_ << value; } #endif // GTEST_OS_SYMBIAN // We'll hold the text streamed to this object here. const internal::scoped_ptr< ::std::stringstream> ss_; // We declare (but don't implement) this to prevent the compiler // from implementing the assignment operator. void operator=(const Message&); }; // Streams a Message to an ostream. inline std::ostream& operator <<(std::ostream& os, const Message& sb) { return os << sb.GetString(); } namespace internal { // Converts a streamable value to an std::string. A NULL pointer is // converted to "(null)". When the input value is a ::string, // ::std::string, ::wstring, or ::std::wstring object, each NUL // character in it is replaced with "\\0". template std::string StreamableToString(const T& streamable) { return (Message() << streamable).GetString(); } } // namespace internal } // namespace testing #endif // GTEST_INCLUDE_GTEST_GTEST_MESSAGE_H_ // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) // // The Google C++ Testing Framework (Google Test) // // This header file declares the String class and functions used internally by // Google Test. They are subject to change without notice. They should not used // by code external to Google Test. // // This header file is #included by . // It should not be #included by other files. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ #ifdef __BORLANDC__ // string.h is not guaranteed to provide strcpy on C++ Builder. # include #endif #include #include namespace testing { namespace internal { // String - an abstract class holding static string utilities. class GTEST_API_ String { public: // Static utility methods // Clones a 0-terminated C string, allocating memory using new. The // caller is responsible for deleting the return value using // delete[]. Returns the cloned string, or NULL if the input is // NULL. // // This is different from strdup() in string.h, which allocates // memory using malloc(). static const char* CloneCString(const char* c_str); #if GTEST_OS_WINDOWS_MOBILE // Windows CE does not have the 'ANSI' versions of Win32 APIs. To be // able to pass strings to Win32 APIs on CE we need to convert them // to 'Unicode', UTF-16. // Creates a UTF-16 wide string from the given ANSI string, allocating // memory using new. The caller is responsible for deleting the return // value using delete[]. Returns the wide string, or NULL if the // input is NULL. // // The wide string is created using the ANSI codepage (CP_ACP) to // match the behaviour of the ANSI versions of Win32 calls and the // C runtime. static LPCWSTR AnsiToUtf16(const char* c_str); // Creates an ANSI string from the given wide string, allocating // memory using new. The caller is responsible for deleting the return // value using delete[]. Returns the ANSI string, or NULL if the // input is NULL. // // The returned string is created using the ANSI codepage (CP_ACP) to // match the behaviour of the ANSI versions of Win32 calls and the // C runtime. static const char* Utf16ToAnsi(LPCWSTR utf16_str); #endif // Compares two C strings. Returns true iff they have the same content. // // Unlike strcmp(), this function can handle NULL argument(s). A // NULL C string is considered different to any non-NULL C string, // including the empty string. static bool CStringEquals(const char* lhs, const char* rhs); // Converts a wide C string to a String using the UTF-8 encoding. // NULL will be converted to "(null)". If an error occurred during // the conversion, "(failed to convert from wide string)" is // returned. static std::string ShowWideCString(const wchar_t* wide_c_str); // Compares two wide C strings. Returns true iff they have the same // content. // // Unlike wcscmp(), this function can handle NULL argument(s). A // NULL C string is considered different to any non-NULL C string, // including the empty string. static bool WideCStringEquals(const wchar_t* lhs, const wchar_t* rhs); // Compares two C strings, ignoring case. Returns true iff they // have the same content. // // Unlike strcasecmp(), this function can handle NULL argument(s). // A NULL C string is considered different to any non-NULL C string, // including the empty string. static bool CaseInsensitiveCStringEquals(const char* lhs, const char* rhs); // Compares two wide C strings, ignoring case. Returns true iff they // have the same content. // // Unlike wcscasecmp(), this function can handle NULL argument(s). // A NULL C string is considered different to any non-NULL wide C string, // including the empty string. // NB: The implementations on different platforms slightly differ. // On windows, this method uses _wcsicmp which compares according to LC_CTYPE // environment variable. On GNU platform this method uses wcscasecmp // which compares according to LC_CTYPE category of the current locale. // On MacOS X, it uses towlower, which also uses LC_CTYPE category of the // current locale. static bool CaseInsensitiveWideCStringEquals(const wchar_t* lhs, const wchar_t* rhs); // Returns true iff the given string ends with the given suffix, ignoring // case. Any string is considered to end with an empty suffix. static bool EndsWithCaseInsensitive( const std::string& str, const std::string& suffix); // Formats an int value as "%02d". static std::string FormatIntWidth2(int value); // "%02d" for width == 2 // Formats an int value as "%X". static std::string FormatHexInt(int value); // Formats a byte as "%02X". static std::string FormatByte(unsigned char value); private: String(); // Not meant to be instantiated. }; // class String // Gets the content of the stringstream's buffer as an std::string. Each '\0' // character in the buffer is replaced with "\\0". GTEST_API_ std::string StringStreamToString(::std::stringstream* stream); } // namespace internal } // namespace testing #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_STRING_H_ // Copyright 2008, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: keith.ray@gmail.com (Keith Ray) // // Google Test filepath utilities // // This header file declares classes and functions used internally by // Google Test. They are subject to change without notice. // // This file is #included in . // Do not include this header file separately! #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ namespace testing { namespace internal { // FilePath - a class for file and directory pathname manipulation which // handles platform-specific conventions (like the pathname separator). // Used for helper functions for naming files in a directory for xml output. // Except for Set methods, all methods are const or static, which provides an // "immutable value object" -- useful for peace of mind. // A FilePath with a value ending in a path separator ("like/this/") represents // a directory, otherwise it is assumed to represent a file. In either case, // it may or may not represent an actual file or directory in the file system. // Names are NOT checked for syntax correctness -- no checking for illegal // characters, malformed paths, etc. class GTEST_API_ FilePath { public: FilePath() : pathname_("") { } FilePath(const FilePath& rhs) : pathname_(rhs.pathname_) { } explicit FilePath(const std::string& pathname) : pathname_(pathname) { Normalize(); } FilePath& operator=(const FilePath& rhs) { Set(rhs); return *this; } void Set(const FilePath& rhs) { pathname_ = rhs.pathname_; } const std::string& string() const { return pathname_; } const char* c_str() const { return pathname_.c_str(); } // Returns the current working directory, or "" if unsuccessful. static FilePath GetCurrentDir(); // Given directory = "dir", base_name = "test", number = 0, // extension = "xml", returns "dir/test.xml". If number is greater // than zero (e.g., 12), returns "dir/test_12.xml". // On Windows platform, uses \ as the separator rather than /. static FilePath MakeFileName(const FilePath& directory, const FilePath& base_name, int number, const char* extension); // Given directory = "dir", relative_path = "test.xml", // returns "dir/test.xml". // On Windows, uses \ as the separator rather than /. static FilePath ConcatPaths(const FilePath& directory, const FilePath& relative_path); // Returns a pathname for a file that does not currently exist. The pathname // will be directory/base_name.extension or // directory/base_name_.extension if directory/base_name.extension // already exists. The number will be incremented until a pathname is found // that does not already exist. // Examples: 'dir/foo_test.xml' or 'dir/foo_test_1.xml'. // There could be a race condition if two or more processes are calling this // function at the same time -- they could both pick the same filename. static FilePath GenerateUniqueFileName(const FilePath& directory, const FilePath& base_name, const char* extension); // Returns true iff the path is "". bool IsEmpty() const { return pathname_.empty(); } // If input name has a trailing separator character, removes it and returns // the name, otherwise return the name string unmodified. // On Windows platform, uses \ as the separator, other platforms use /. FilePath RemoveTrailingPathSeparator() const; // Returns a copy of the FilePath with the directory part removed. // Example: FilePath("path/to/file").RemoveDirectoryName() returns // FilePath("file"). If there is no directory part ("just_a_file"), it returns // the FilePath unmodified. If there is no file part ("just_a_dir/") it // returns an empty FilePath (""). // On Windows platform, '\' is the path separator, otherwise it is '/'. FilePath RemoveDirectoryName() const; // RemoveFileName returns the directory path with the filename removed. // Example: FilePath("path/to/file").RemoveFileName() returns "path/to/". // If the FilePath is "a_file" or "/a_file", RemoveFileName returns // FilePath("./") or, on Windows, FilePath(".\\"). If the filepath does // not have a file, like "just/a/dir/", it returns the FilePath unmodified. // On Windows platform, '\' is the path separator, otherwise it is '/'. FilePath RemoveFileName() const; // Returns a copy of the FilePath with the case-insensitive extension removed. // Example: FilePath("dir/file.exe").RemoveExtension("EXE") returns // FilePath("dir/file"). If a case-insensitive extension is not // found, returns a copy of the original FilePath. FilePath RemoveExtension(const char* extension) const; // Creates directories so that path exists. Returns true if successful or if // the directories already exist; returns false if unable to create // directories for any reason. Will also return false if the FilePath does // not represent a directory (that is, it doesn't end with a path separator). bool CreateDirectoriesRecursively() const; // Create the directory so that path exists. Returns true if successful or // if the directory already exists; returns false if unable to create the // directory for any reason, including if the parent directory does not // exist. Not named "CreateDirectory" because that's a macro on Windows. bool CreateFolder() const; // Returns true if FilePath describes something in the file-system, // either a file, directory, or whatever, and that something exists. bool FileOrDirectoryExists() const; // Returns true if pathname describes a directory in the file-system // that exists. bool DirectoryExists() const; // Returns true if FilePath ends with a path separator, which indicates that // it is intended to represent a directory. Returns false otherwise. // This does NOT check that a directory (or file) actually exists. bool IsDirectory() const; // Returns true if pathname describes a root directory. (Windows has one // root directory per disk drive.) bool IsRootDirectory() const; // Returns true if pathname describes an absolute path. bool IsAbsolutePath() const; private: // Replaces multiple consecutive separators with a single separator. // For example, "bar///foo" becomes "bar/foo". Does not eliminate other // redundancies that might be in a pathname involving "." or "..". // // A pathname with multiple consecutive separators may occur either through // user error or as a result of some scripts or APIs that generate a pathname // with a trailing separator. On other platforms the same API or script // may NOT generate a pathname with a trailing "/". Then elsewhere that // pathname may have another "/" and pathname components added to it, // without checking for the separator already being there. // The script language and operating system may allow paths like "foo//bar" // but some of the functions in FilePath will not handle that correctly. In // particular, RemoveTrailingPathSeparator() only removes one separator, and // it is called in CreateDirectoriesRecursively() assuming that it will change // a pathname from directory syntax (trailing separator) to filename syntax. // // On Windows this method also replaces the alternate path separator '/' with // the primary path separator '\\', so that for example "bar\\/\\foo" becomes // "bar\\foo". void Normalize(); // Returns a pointer to the last occurence of a valid path separator in // the FilePath. On Windows, for example, both '/' and '\' are valid path // separators. Returns NULL if no path separator was found. const char* FindLastPathSeparator() const; std::string pathname_; }; // class FilePath } // namespace internal } // namespace testing #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_FILEPATH_H_ // This file was GENERATED by command: // pump.py gtest-type-util.h.pump // DO NOT EDIT BY HAND!!! // Copyright 2008 Google Inc. // All Rights Reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // Type utilities needed for implementing typed and type-parameterized // tests. This file is generated by a SCRIPT. DO NOT EDIT BY HAND! // // Currently we support at most 50 types in a list, and at most 50 // type-parameterized tests in one type-parameterized test case. // Please contact googletestframework@googlegroups.com if you need // more. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ // #ifdef __GNUC__ is too general here. It is possible to use gcc without using // libstdc++ (which is where cxxabi.h comes from). # if GTEST_HAS_CXXABI_H_ # include # elif defined(__HP_aCC) # include # endif // GTEST_HASH_CXXABI_H_ namespace testing { namespace internal { // GetTypeName() returns a human-readable name of type T. // NB: This function is also used in Google Mock, so don't move it inside of // the typed-test-only section below. template std::string GetTypeName() { # if GTEST_HAS_RTTI const char* const name = typeid(T).name(); # if GTEST_HAS_CXXABI_H_ || defined(__HP_aCC) int status = 0; // gcc's implementation of typeid(T).name() mangles the type name, // so we have to demangle it. # if GTEST_HAS_CXXABI_H_ using abi::__cxa_demangle; # endif // GTEST_HAS_CXXABI_H_ char* const readable_name = __cxa_demangle(name, 0, 0, &status); const std::string name_str(status == 0 ? readable_name : name); free(readable_name); return name_str; # else return name; # endif // GTEST_HAS_CXXABI_H_ || __HP_aCC # else return ""; # endif // GTEST_HAS_RTTI } #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P // AssertyTypeEq::type is defined iff T1 and T2 are the same // type. This can be used as a compile-time assertion to ensure that // two types are equal. template struct AssertTypeEq; template struct AssertTypeEq { typedef bool type; }; // A unique type used as the default value for the arguments of class // template Types. This allows us to simulate variadic templates // (e.g. Types, Type, and etc), which C++ doesn't // support directly. struct None {}; // The following family of struct and struct templates are used to // represent type lists. In particular, TypesN // represents a type list with N types (T1, T2, ..., and TN) in it. // Except for Types0, every struct in the family has two member types: // Head for the first type in the list, and Tail for the rest of the // list. // The empty type list. struct Types0 {}; // Type lists of length 1, 2, 3, and so on. template struct Types1 { typedef T1 Head; typedef Types0 Tail; }; template struct Types2 { typedef T1 Head; typedef Types1 Tail; }; template struct Types3 { typedef T1 Head; typedef Types2 Tail; }; template struct Types4 { typedef T1 Head; typedef Types3 Tail; }; template struct Types5 { typedef T1 Head; typedef Types4 Tail; }; template struct Types6 { typedef T1 Head; typedef Types5 Tail; }; template struct Types7 { typedef T1 Head; typedef Types6 Tail; }; template struct Types8 { typedef T1 Head; typedef Types7 Tail; }; template struct Types9 { typedef T1 Head; typedef Types8 Tail; }; template struct Types10 { typedef T1 Head; typedef Types9 Tail; }; template struct Types11 { typedef T1 Head; typedef Types10 Tail; }; template struct Types12 { typedef T1 Head; typedef Types11 Tail; }; template struct Types13 { typedef T1 Head; typedef Types12 Tail; }; template struct Types14 { typedef T1 Head; typedef Types13 Tail; }; template struct Types15 { typedef T1 Head; typedef Types14 Tail; }; template struct Types16 { typedef T1 Head; typedef Types15 Tail; }; template struct Types17 { typedef T1 Head; typedef Types16 Tail; }; template struct Types18 { typedef T1 Head; typedef Types17 Tail; }; template struct Types19 { typedef T1 Head; typedef Types18 Tail; }; template struct Types20 { typedef T1 Head; typedef Types19 Tail; }; template struct Types21 { typedef T1 Head; typedef Types20 Tail; }; template struct Types22 { typedef T1 Head; typedef Types21 Tail; }; template struct Types23 { typedef T1 Head; typedef Types22 Tail; }; template struct Types24 { typedef T1 Head; typedef Types23 Tail; }; template struct Types25 { typedef T1 Head; typedef Types24 Tail; }; template struct Types26 { typedef T1 Head; typedef Types25 Tail; }; template struct Types27 { typedef T1 Head; typedef Types26 Tail; }; template struct Types28 { typedef T1 Head; typedef Types27 Tail; }; template struct Types29 { typedef T1 Head; typedef Types28 Tail; }; template struct Types30 { typedef T1 Head; typedef Types29 Tail; }; template struct Types31 { typedef T1 Head; typedef Types30 Tail; }; template struct Types32 { typedef T1 Head; typedef Types31 Tail; }; template struct Types33 { typedef T1 Head; typedef Types32 Tail; }; template struct Types34 { typedef T1 Head; typedef Types33 Tail; }; template struct Types35 { typedef T1 Head; typedef Types34 Tail; }; template struct Types36 { typedef T1 Head; typedef Types35 Tail; }; template struct Types37 { typedef T1 Head; typedef Types36 Tail; }; template struct Types38 { typedef T1 Head; typedef Types37 Tail; }; template struct Types39 { typedef T1 Head; typedef Types38 Tail; }; template struct Types40 { typedef T1 Head; typedef Types39 Tail; }; template struct Types41 { typedef T1 Head; typedef Types40 Tail; }; template struct Types42 { typedef T1 Head; typedef Types41 Tail; }; template struct Types43 { typedef T1 Head; typedef Types42 Tail; }; template struct Types44 { typedef T1 Head; typedef Types43 Tail; }; template struct Types45 { typedef T1 Head; typedef Types44 Tail; }; template struct Types46 { typedef T1 Head; typedef Types45 Tail; }; template struct Types47 { typedef T1 Head; typedef Types46 Tail; }; template struct Types48 { typedef T1 Head; typedef Types47 Tail; }; template struct Types49 { typedef T1 Head; typedef Types48 Tail; }; template struct Types50 { typedef T1 Head; typedef Types49 Tail; }; } // namespace internal // We don't want to require the users to write TypesN<...> directly, // as that would require them to count the length. Types<...> is much // easier to write, but generates horrible messages when there is a // compiler error, as gcc insists on printing out each template // argument, even if it has the default value (this means Types // will appear as Types in the compiler // errors). // // Our solution is to combine the best part of the two approaches: a // user would write Types, and Google Test will translate // that to TypesN internally to make error messages // readable. The translation is done by the 'type' member of the // Types template. template struct Types { typedef internal::Types50 type; }; template <> struct Types { typedef internal::Types0 type; }; template struct Types { typedef internal::Types1 type; }; template struct Types { typedef internal::Types2 type; }; template struct Types { typedef internal::Types3 type; }; template struct Types { typedef internal::Types4 type; }; template struct Types { typedef internal::Types5 type; }; template struct Types { typedef internal::Types6 type; }; template struct Types { typedef internal::Types7 type; }; template struct Types { typedef internal::Types8 type; }; template struct Types { typedef internal::Types9 type; }; template struct Types { typedef internal::Types10 type; }; template struct Types { typedef internal::Types11 type; }; template struct Types { typedef internal::Types12 type; }; template struct Types { typedef internal::Types13 type; }; template struct Types { typedef internal::Types14 type; }; template struct Types { typedef internal::Types15 type; }; template struct Types { typedef internal::Types16 type; }; template struct Types { typedef internal::Types17 type; }; template struct Types { typedef internal::Types18 type; }; template struct Types { typedef internal::Types19 type; }; template struct Types { typedef internal::Types20 type; }; template struct Types { typedef internal::Types21 type; }; template struct Types { typedef internal::Types22 type; }; template struct Types { typedef internal::Types23 type; }; template struct Types { typedef internal::Types24 type; }; template struct Types { typedef internal::Types25 type; }; template struct Types { typedef internal::Types26 type; }; template struct Types { typedef internal::Types27 type; }; template struct Types { typedef internal::Types28 type; }; template struct Types { typedef internal::Types29 type; }; template struct Types { typedef internal::Types30 type; }; template struct Types { typedef internal::Types31 type; }; template struct Types { typedef internal::Types32 type; }; template struct Types { typedef internal::Types33 type; }; template struct Types { typedef internal::Types34 type; }; template struct Types { typedef internal::Types35 type; }; template struct Types { typedef internal::Types36 type; }; template struct Types { typedef internal::Types37 type; }; template struct Types { typedef internal::Types38 type; }; template struct Types { typedef internal::Types39 type; }; template struct Types { typedef internal::Types40 type; }; template struct Types { typedef internal::Types41 type; }; template struct Types { typedef internal::Types42 type; }; template struct Types { typedef internal::Types43 type; }; template struct Types { typedef internal::Types44 type; }; template struct Types { typedef internal::Types45 type; }; template struct Types { typedef internal::Types46 type; }; template struct Types { typedef internal::Types47 type; }; template struct Types { typedef internal::Types48 type; }; template struct Types { typedef internal::Types49 type; }; namespace internal { # define GTEST_TEMPLATE_ template class // The template "selector" struct TemplateSel is used to // represent Tmpl, which must be a class template with one type // parameter, as a type. TemplateSel::Bind::type is defined // as the type Tmpl. This allows us to actually instantiate the // template "selected" by TemplateSel. // // This trick is necessary for simulating typedef for class templates, // which C++ doesn't support directly. template struct TemplateSel { template struct Bind { typedef Tmpl type; }; }; # define GTEST_BIND_(TmplSel, T) \ TmplSel::template Bind::type // A unique struct template used as the default value for the // arguments of class template Templates. This allows us to simulate // variadic templates (e.g. Templates, Templates, // and etc), which C++ doesn't support directly. template struct NoneT {}; // The following family of struct and struct templates are used to // represent template lists. In particular, TemplatesN represents a list of N templates (T1, T2, ..., and TN). Except // for Templates0, every struct in the family has two member types: // Head for the selector of the first template in the list, and Tail // for the rest of the list. // The empty template list. struct Templates0 {}; // Template lists of length 1, 2, 3, and so on. template struct Templates1 { typedef TemplateSel Head; typedef Templates0 Tail; }; template struct Templates2 { typedef TemplateSel Head; typedef Templates1 Tail; }; template struct Templates3 { typedef TemplateSel Head; typedef Templates2 Tail; }; template struct Templates4 { typedef TemplateSel Head; typedef Templates3 Tail; }; template struct Templates5 { typedef TemplateSel Head; typedef Templates4 Tail; }; template struct Templates6 { typedef TemplateSel Head; typedef Templates5 Tail; }; template struct Templates7 { typedef TemplateSel Head; typedef Templates6 Tail; }; template struct Templates8 { typedef TemplateSel Head; typedef Templates7 Tail; }; template struct Templates9 { typedef TemplateSel Head; typedef Templates8 Tail; }; template struct Templates10 { typedef TemplateSel Head; typedef Templates9 Tail; }; template struct Templates11 { typedef TemplateSel Head; typedef Templates10 Tail; }; template struct Templates12 { typedef TemplateSel Head; typedef Templates11 Tail; }; template struct Templates13 { typedef TemplateSel Head; typedef Templates12 Tail; }; template struct Templates14 { typedef TemplateSel Head; typedef Templates13 Tail; }; template struct Templates15 { typedef TemplateSel Head; typedef Templates14 Tail; }; template struct Templates16 { typedef TemplateSel Head; typedef Templates15 Tail; }; template struct Templates17 { typedef TemplateSel Head; typedef Templates16 Tail; }; template struct Templates18 { typedef TemplateSel Head; typedef Templates17 Tail; }; template struct Templates19 { typedef TemplateSel Head; typedef Templates18 Tail; }; template struct Templates20 { typedef TemplateSel Head; typedef Templates19 Tail; }; template struct Templates21 { typedef TemplateSel Head; typedef Templates20 Tail; }; template struct Templates22 { typedef TemplateSel Head; typedef Templates21 Tail; }; template struct Templates23 { typedef TemplateSel Head; typedef Templates22 Tail; }; template struct Templates24 { typedef TemplateSel Head; typedef Templates23 Tail; }; template struct Templates25 { typedef TemplateSel Head; typedef Templates24 Tail; }; template struct Templates26 { typedef TemplateSel Head; typedef Templates25 Tail; }; template struct Templates27 { typedef TemplateSel Head; typedef Templates26 Tail; }; template struct Templates28 { typedef TemplateSel Head; typedef Templates27 Tail; }; template struct Templates29 { typedef TemplateSel Head; typedef Templates28 Tail; }; template struct Templates30 { typedef TemplateSel Head; typedef Templates29 Tail; }; template struct Templates31 { typedef TemplateSel Head; typedef Templates30 Tail; }; template struct Templates32 { typedef TemplateSel Head; typedef Templates31 Tail; }; template struct Templates33 { typedef TemplateSel Head; typedef Templates32 Tail; }; template struct Templates34 { typedef TemplateSel Head; typedef Templates33 Tail; }; template struct Templates35 { typedef TemplateSel Head; typedef Templates34 Tail; }; template struct Templates36 { typedef TemplateSel Head; typedef Templates35 Tail; }; template struct Templates37 { typedef TemplateSel Head; typedef Templates36 Tail; }; template struct Templates38 { typedef TemplateSel Head; typedef Templates37 Tail; }; template struct Templates39 { typedef TemplateSel Head; typedef Templates38 Tail; }; template struct Templates40 { typedef TemplateSel Head; typedef Templates39 Tail; }; template struct Templates41 { typedef TemplateSel Head; typedef Templates40 Tail; }; template struct Templates42 { typedef TemplateSel Head; typedef Templates41 Tail; }; template struct Templates43 { typedef TemplateSel Head; typedef Templates42 Tail; }; template struct Templates44 { typedef TemplateSel Head; typedef Templates43 Tail; }; template struct Templates45 { typedef TemplateSel Head; typedef Templates44 Tail; }; template struct Templates46 { typedef TemplateSel Head; typedef Templates45 Tail; }; template struct Templates47 { typedef TemplateSel Head; typedef Templates46 Tail; }; template struct Templates48 { typedef TemplateSel Head; typedef Templates47 Tail; }; template struct Templates49 { typedef TemplateSel Head; typedef Templates48 Tail; }; template struct Templates50 { typedef TemplateSel Head; typedef Templates49 Tail; }; // We don't want to require the users to write TemplatesN<...> directly, // as that would require them to count the length. Templates<...> is much // easier to write, but generates horrible messages when there is a // compiler error, as gcc insists on printing out each template // argument, even if it has the default value (this means Templates // will appear as Templates in the compiler // errors). // // Our solution is to combine the best part of the two approaches: a // user would write Templates, and Google Test will translate // that to TemplatesN internally to make error messages // readable. The translation is done by the 'type' member of the // Templates template. template struct Templates { typedef Templates50 type; }; template <> struct Templates { typedef Templates0 type; }; template struct Templates { typedef Templates1 type; }; template struct Templates { typedef Templates2 type; }; template struct Templates { typedef Templates3 type; }; template struct Templates { typedef Templates4 type; }; template struct Templates { typedef Templates5 type; }; template struct Templates { typedef Templates6 type; }; template struct Templates { typedef Templates7 type; }; template struct Templates { typedef Templates8 type; }; template struct Templates { typedef Templates9 type; }; template struct Templates { typedef Templates10 type; }; template struct Templates { typedef Templates11 type; }; template struct Templates { typedef Templates12 type; }; template struct Templates { typedef Templates13 type; }; template struct Templates { typedef Templates14 type; }; template struct Templates { typedef Templates15 type; }; template struct Templates { typedef Templates16 type; }; template struct Templates { typedef Templates17 type; }; template struct Templates { typedef Templates18 type; }; template struct Templates { typedef Templates19 type; }; template struct Templates { typedef Templates20 type; }; template struct Templates { typedef Templates21 type; }; template struct Templates { typedef Templates22 type; }; template struct Templates { typedef Templates23 type; }; template struct Templates { typedef Templates24 type; }; template struct Templates { typedef Templates25 type; }; template struct Templates { typedef Templates26 type; }; template struct Templates { typedef Templates27 type; }; template struct Templates { typedef Templates28 type; }; template struct Templates { typedef Templates29 type; }; template struct Templates { typedef Templates30 type; }; template struct Templates { typedef Templates31 type; }; template struct Templates { typedef Templates32 type; }; template struct Templates { typedef Templates33 type; }; template struct Templates { typedef Templates34 type; }; template struct Templates { typedef Templates35 type; }; template struct Templates { typedef Templates36 type; }; template struct Templates { typedef Templates37 type; }; template struct Templates { typedef Templates38 type; }; template struct Templates { typedef Templates39 type; }; template struct Templates { typedef Templates40 type; }; template struct Templates { typedef Templates41 type; }; template struct Templates { typedef Templates42 type; }; template struct Templates { typedef Templates43 type; }; template struct Templates { typedef Templates44 type; }; template struct Templates { typedef Templates45 type; }; template struct Templates { typedef Templates46 type; }; template struct Templates { typedef Templates47 type; }; template struct Templates { typedef Templates48 type; }; template struct Templates { typedef Templates49 type; }; // The TypeList template makes it possible to use either a single type // or a Types<...> list in TYPED_TEST_CASE() and // INSTANTIATE_TYPED_TEST_CASE_P(). template struct TypeList { typedef Types1 type; }; template struct TypeList > { typedef typename Types::type type; }; #endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P } // namespace internal } // namespace testing #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_TYPE_UTIL_H_ // Due to C++ preprocessor weirdness, we need double indirection to // concatenate two tokens when one of them is __LINE__. Writing // // foo ## __LINE__ // // will result in the token foo__LINE__, instead of foo followed by // the current line number. For more details, see // http://www.parashift.com/c++-faq-lite/misc-technical-issues.html#faq-39.6 #define GTEST_CONCAT_TOKEN_(foo, bar) GTEST_CONCAT_TOKEN_IMPL_(foo, bar) #define GTEST_CONCAT_TOKEN_IMPL_(foo, bar) foo ## bar class ProtocolMessage; namespace proto2 { class Message; } namespace testing { // Forward declarations. class AssertionResult; // Result of an assertion. class Message; // Represents a failure message. class Test; // Represents a test. class TestInfo; // Information about a test. class TestPartResult; // Result of a test part. class UnitTest; // A collection of test cases. template ::std::string PrintToString(const T& value); namespace internal { struct TraceInfo; // Information about a trace point. class ScopedTrace; // Implements scoped trace. class TestInfoImpl; // Opaque implementation of TestInfo class UnitTestImpl; // Opaque implementation of UnitTest // How many times InitGoogleTest() has been called. GTEST_API_ extern int g_init_gtest_count; // The text used in failure messages to indicate the start of the // stack trace. GTEST_API_ extern const char kStackTraceMarker[]; // Two overloaded helpers for checking at compile time whether an // expression is a null pointer literal (i.e. NULL or any 0-valued // compile-time integral constant). Their return values have // different sizes, so we can use sizeof() to test which version is // picked by the compiler. These helpers have no implementations, as // we only need their signatures. // // Given IsNullLiteralHelper(x), the compiler will pick the first // version if x can be implicitly converted to Secret*, and pick the // second version otherwise. Since Secret is a secret and incomplete // type, the only expression a user can write that has type Secret* is // a null pointer literal. Therefore, we know that x is a null // pointer literal if and only if the first version is picked by the // compiler. char IsNullLiteralHelper(Secret* p); char (&IsNullLiteralHelper(...))[2]; // NOLINT // A compile-time bool constant that is true if and only if x is a // null pointer literal (i.e. NULL or any 0-valued compile-time // integral constant). #ifdef GTEST_ELLIPSIS_NEEDS_POD_ // We lose support for NULL detection where the compiler doesn't like // passing non-POD classes through ellipsis (...). # define GTEST_IS_NULL_LITERAL_(x) false #else # define GTEST_IS_NULL_LITERAL_(x) \ (sizeof(::testing::internal::IsNullLiteralHelper(x)) == 1) #endif // GTEST_ELLIPSIS_NEEDS_POD_ // Appends the user-supplied message to the Google-Test-generated message. GTEST_API_ std::string AppendUserMessage( const std::string& gtest_msg, const Message& user_msg); #if GTEST_HAS_EXCEPTIONS // This exception is thrown by (and only by) a failed Google Test // assertion when GTEST_FLAG(throw_on_failure) is true (if exceptions // are enabled). We derive it from std::runtime_error, which is for // errors presumably detectable only at run time. Since // std::runtime_error inherits from std::exception, many testing // frameworks know how to extract and print the message inside it. class GTEST_API_ GoogleTestFailureException : public ::std::runtime_error { public: explicit GoogleTestFailureException(const TestPartResult& failure); }; #endif // GTEST_HAS_EXCEPTIONS // A helper class for creating scoped traces in user programs. class GTEST_API_ ScopedTrace { public: // The c'tor pushes the given source file location and message onto // a trace stack maintained by Google Test. ScopedTrace(const char* file, int line, const Message& message); // The d'tor pops the info pushed by the c'tor. // // Note that the d'tor is not virtual in order to be efficient. // Don't inherit from ScopedTrace! ~ScopedTrace(); private: GTEST_DISALLOW_COPY_AND_ASSIGN_(ScopedTrace); } GTEST_ATTRIBUTE_UNUSED_; // A ScopedTrace object does its job in its // c'tor and d'tor. Therefore it doesn't // need to be used otherwise. // Constructs and returns the message for an equality assertion // (e.g. ASSERT_EQ, EXPECT_STREQ, etc) failure. // // The first four parameters are the expressions used in the assertion // and their values, as strings. For example, for ASSERT_EQ(foo, bar) // where foo is 5 and bar is 6, we have: // // expected_expression: "foo" // actual_expression: "bar" // expected_value: "5" // actual_value: "6" // // The ignoring_case parameter is true iff the assertion is a // *_STRCASEEQ*. When it's true, the string " (ignoring case)" will // be inserted into the message. GTEST_API_ AssertionResult EqFailure(const char* expected_expression, const char* actual_expression, const std::string& expected_value, const std::string& actual_value, bool ignoring_case); // Constructs a failure message for Boolean assertions such as EXPECT_TRUE. GTEST_API_ std::string GetBoolAssertionFailureMessage( const AssertionResult& assertion_result, const char* expression_text, const char* actual_predicate_value, const char* expected_predicate_value); // This template class represents an IEEE floating-point number // (either single-precision or double-precision, depending on the // template parameters). // // The purpose of this class is to do more sophisticated number // comparison. (Due to round-off error, etc, it's very unlikely that // two floating-points will be equal exactly. Hence a naive // comparison by the == operation often doesn't work.) // // Format of IEEE floating-point: // // The most-significant bit being the leftmost, an IEEE // floating-point looks like // // sign_bit exponent_bits fraction_bits // // Here, sign_bit is a single bit that designates the sign of the // number. // // For float, there are 8 exponent bits and 23 fraction bits. // // For double, there are 11 exponent bits and 52 fraction bits. // // More details can be found at // http://en.wikipedia.org/wiki/IEEE_floating-point_standard. // // Template parameter: // // RawType: the raw floating-point type (either float or double) template class FloatingPoint { public: // Defines the unsigned integer type that has the same size as the // floating point number. typedef typename TypeWithSize::UInt Bits; // Constants. // # of bits in a number. static const size_t kBitCount = 8*sizeof(RawType); // # of fraction bits in a number. static const size_t kFractionBitCount = std::numeric_limits::digits - 1; // # of exponent bits in a number. static const size_t kExponentBitCount = kBitCount - 1 - kFractionBitCount; // The mask for the sign bit. static const Bits kSignBitMask = static_cast(1) << (kBitCount - 1); // The mask for the fraction bits. static const Bits kFractionBitMask = ~static_cast(0) >> (kExponentBitCount + 1); // The mask for the exponent bits. static const Bits kExponentBitMask = ~(kSignBitMask | kFractionBitMask); // How many ULP's (Units in the Last Place) we want to tolerate when // comparing two numbers. The larger the value, the more error we // allow. A 0 value means that two numbers must be exactly the same // to be considered equal. // // The maximum error of a single floating-point operation is 0.5 // units in the last place. On Intel CPU's, all floating-point // calculations are done with 80-bit precision, while double has 64 // bits. Therefore, 4 should be enough for ordinary use. // // See the following article for more details on ULP: // http://randomascii.wordpress.com/2012/02/25/comparing-floating-point-numbers-2012-edition/ static const size_t kMaxUlps = 4; // Constructs a FloatingPoint from a raw floating-point number. // // On an Intel CPU, passing a non-normalized NAN (Not a Number) // around may change its bits, although the new value is guaranteed // to be also a NAN. Therefore, don't expect this constructor to // preserve the bits in x when x is a NAN. explicit FloatingPoint(const RawType& x) { u_.value_ = x; } // Static methods // Reinterprets a bit pattern as a floating-point number. // // This function is needed to test the AlmostEquals() method. static RawType ReinterpretBits(const Bits bits) { FloatingPoint fp(0); fp.u_.bits_ = bits; return fp.u_.value_; } // Returns the floating-point number that represent positive infinity. static RawType Infinity() { return ReinterpretBits(kExponentBitMask); } // Returns the maximum representable finite floating-point number. static RawType Max(); // Non-static methods // Returns the bits that represents this number. const Bits &bits() const { return u_.bits_; } // Returns the exponent bits of this number. Bits exponent_bits() const { return kExponentBitMask & u_.bits_; } // Returns the fraction bits of this number. Bits fraction_bits() const { return kFractionBitMask & u_.bits_; } // Returns the sign bit of this number. Bits sign_bit() const { return kSignBitMask & u_.bits_; } // Returns true iff this is NAN (not a number). bool is_nan() const { // It's a NAN if the exponent bits are all ones and the fraction // bits are not entirely zeros. return (exponent_bits() == kExponentBitMask) && (fraction_bits() != 0); } // Returns true iff this number is at most kMaxUlps ULP's away from // rhs. In particular, this function: // // - returns false if either number is (or both are) NAN. // - treats really large numbers as almost equal to infinity. // - thinks +0.0 and -0.0 are 0 DLP's apart. bool AlmostEquals(const FloatingPoint& rhs) const { // The IEEE standard says that any comparison operation involving // a NAN must return false. if (is_nan() || rhs.is_nan()) return false; return DistanceBetweenSignAndMagnitudeNumbers(u_.bits_, rhs.u_.bits_) <= kMaxUlps; } private: // The data type used to store the actual floating-point number. union FloatingPointUnion { RawType value_; // The raw floating-point number. Bits bits_; // The bits that represent the number. }; // Converts an integer from the sign-and-magnitude representation to // the biased representation. More precisely, let N be 2 to the // power of (kBitCount - 1), an integer x is represented by the // unsigned number x + N. // // For instance, // // -N + 1 (the most negative number representable using // sign-and-magnitude) is represented by 1; // 0 is represented by N; and // N - 1 (the biggest number representable using // sign-and-magnitude) is represented by 2N - 1. // // Read http://en.wikipedia.org/wiki/Signed_number_representations // for more details on signed number representations. static Bits SignAndMagnitudeToBiased(const Bits &sam) { if (kSignBitMask & sam) { // sam represents a negative number. return ~sam + 1; } else { // sam represents a positive number. return kSignBitMask | sam; } } // Given two numbers in the sign-and-magnitude representation, // returns the distance between them as an unsigned number. static Bits DistanceBetweenSignAndMagnitudeNumbers(const Bits &sam1, const Bits &sam2) { const Bits biased1 = SignAndMagnitudeToBiased(sam1); const Bits biased2 = SignAndMagnitudeToBiased(sam2); return (biased1 >= biased2) ? (biased1 - biased2) : (biased2 - biased1); } FloatingPointUnion u_; }; // We cannot use std::numeric_limits::max() as it clashes with the max() // macro defined by . template <> inline float FloatingPoint::Max() { return FLT_MAX; } template <> inline double FloatingPoint::Max() { return DBL_MAX; } // Typedefs the instances of the FloatingPoint template class that we // care to use. typedef FloatingPoint Float; typedef FloatingPoint Double; // In order to catch the mistake of putting tests that use different // test fixture classes in the same test case, we need to assign // unique IDs to fixture classes and compare them. The TypeId type is // used to hold such IDs. The user should treat TypeId as an opaque // type: the only operation allowed on TypeId values is to compare // them for equality using the == operator. typedef const void* TypeId; template class TypeIdHelper { public: // dummy_ must not have a const type. Otherwise an overly eager // compiler (e.g. MSVC 7.1 & 8.0) may try to merge // TypeIdHelper::dummy_ for different Ts as an "optimization". static bool dummy_; }; template bool TypeIdHelper::dummy_ = false; // GetTypeId() returns the ID of type T. Different values will be // returned for different types. Calling the function twice with the // same type argument is guaranteed to return the same ID. template TypeId GetTypeId() { // The compiler is required to allocate a different // TypeIdHelper::dummy_ variable for each T used to instantiate // the template. Therefore, the address of dummy_ is guaranteed to // be unique. return &(TypeIdHelper::dummy_); } // Returns the type ID of ::testing::Test. Always call this instead // of GetTypeId< ::testing::Test>() to get the type ID of // ::testing::Test, as the latter may give the wrong result due to a // suspected linker bug when compiling Google Test as a Mac OS X // framework. GTEST_API_ TypeId GetTestTypeId(); // Defines the abstract factory interface that creates instances // of a Test object. class TestFactoryBase { public: virtual ~TestFactoryBase() {} // Creates a test instance to run. The instance is both created and destroyed // within TestInfoImpl::Run() virtual Test* CreateTest() = 0; protected: TestFactoryBase() {} private: GTEST_DISALLOW_COPY_AND_ASSIGN_(TestFactoryBase); }; // This class provides implementation of TeastFactoryBase interface. // It is used in TEST and TEST_F macros. template class TestFactoryImpl : public TestFactoryBase { public: virtual Test* CreateTest() { return new TestClass; } }; #if GTEST_OS_WINDOWS // Predicate-formatters for implementing the HRESULT checking macros // {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED} // We pass a long instead of HRESULT to avoid causing an // include dependency for the HRESULT type. GTEST_API_ AssertionResult IsHRESULTSuccess(const char* expr, long hr); // NOLINT GTEST_API_ AssertionResult IsHRESULTFailure(const char* expr, long hr); // NOLINT #endif // GTEST_OS_WINDOWS // Types of SetUpTestCase() and TearDownTestCase() functions. typedef void (*SetUpTestCaseFunc)(); typedef void (*TearDownTestCaseFunc)(); // Creates a new TestInfo object and registers it with Google Test; // returns the created object. // // Arguments: // // test_case_name: name of the test case // name: name of the test // type_param the name of the test's type parameter, or NULL if // this is not a typed or a type-parameterized test. // value_param text representation of the test's value parameter, // or NULL if this is not a type-parameterized test. // fixture_class_id: ID of the test fixture class // set_up_tc: pointer to the function that sets up the test case // tear_down_tc: pointer to the function that tears down the test case // factory: pointer to the factory that creates a test object. // The newly created TestInfo instance will assume // ownership of the factory object. GTEST_API_ TestInfo* MakeAndRegisterTestInfo( const char* test_case_name, const char* name, const char* type_param, const char* value_param, TypeId fixture_class_id, SetUpTestCaseFunc set_up_tc, TearDownTestCaseFunc tear_down_tc, TestFactoryBase* factory); // If *pstr starts with the given prefix, modifies *pstr to be right // past the prefix and returns true; otherwise leaves *pstr unchanged // and returns false. None of pstr, *pstr, and prefix can be NULL. GTEST_API_ bool SkipPrefix(const char* prefix, const char** pstr); #if GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P // State of the definition of a type-parameterized test case. class GTEST_API_ TypedTestCasePState { public: TypedTestCasePState() : registered_(false) {} // Adds the given test name to defined_test_names_ and return true // if the test case hasn't been registered; otherwise aborts the // program. bool AddTestName(const char* file, int line, const char* case_name, const char* test_name) { if (registered_) { fprintf(stderr, "%s Test %s must be defined before " "REGISTER_TYPED_TEST_CASE_P(%s, ...).\n", FormatFileLocation(file, line).c_str(), test_name, case_name); fflush(stderr); posix::Abort(); } defined_test_names_.insert(test_name); return true; } // Verifies that registered_tests match the test names in // defined_test_names_; returns registered_tests if successful, or // aborts the program otherwise. const char* VerifyRegisteredTestNames( const char* file, int line, const char* registered_tests); private: bool registered_; ::std::set defined_test_names_; }; // Skips to the first non-space char after the first comma in 'str'; // returns NULL if no comma is found in 'str'. inline const char* SkipComma(const char* str) { const char* comma = strchr(str, ','); if (comma == NULL) { return NULL; } while (IsSpace(*(++comma))) {} return comma; } // Returns the prefix of 'str' before the first comma in it; returns // the entire string if it contains no comma. inline std::string GetPrefixUntilComma(const char* str) { const char* comma = strchr(str, ','); return comma == NULL ? str : std::string(str, comma); } // TypeParameterizedTest::Register() // registers a list of type-parameterized tests with Google Test. The // return value is insignificant - we just need to return something // such that we can call this function in a namespace scope. // // Implementation note: The GTEST_TEMPLATE_ macro declares a template // template parameter. It's defined in gtest-type-util.h. template class TypeParameterizedTest { public: // 'index' is the index of the test in the type list 'Types' // specified in INSTANTIATE_TYPED_TEST_CASE_P(Prefix, TestCase, // Types). Valid values for 'index' are [0, N - 1] where N is the // length of Types. static bool Register(const char* prefix, const char* case_name, const char* test_names, int index) { typedef typename Types::Head Type; typedef Fixture FixtureClass; typedef typename GTEST_BIND_(TestSel, Type) TestClass; // First, registers the first type-parameterized test in the type // list. MakeAndRegisterTestInfo( (std::string(prefix) + (prefix[0] == '\0' ? "" : "/") + case_name + "/" + StreamableToString(index)).c_str(), GetPrefixUntilComma(test_names).c_str(), GetTypeName().c_str(), NULL, // No value parameter. GetTypeId(), TestClass::SetUpTestCase, TestClass::TearDownTestCase, new TestFactoryImpl); // Next, recurses (at compile time) with the tail of the type list. return TypeParameterizedTest ::Register(prefix, case_name, test_names, index + 1); } }; // The base case for the compile time recursion. template class TypeParameterizedTest { public: static bool Register(const char* /*prefix*/, const char* /*case_name*/, const char* /*test_names*/, int /*index*/) { return true; } }; // TypeParameterizedTestCase::Register() // registers *all combinations* of 'Tests' and 'Types' with Google // Test. The return value is insignificant - we just need to return // something such that we can call this function in a namespace scope. template class TypeParameterizedTestCase { public: static bool Register(const char* prefix, const char* case_name, const char* test_names) { typedef typename Tests::Head Head; // First, register the first test in 'Test' for each type in 'Types'. TypeParameterizedTest::Register( prefix, case_name, test_names, 0); // Next, recurses (at compile time) with the tail of the test list. return TypeParameterizedTestCase ::Register(prefix, case_name, SkipComma(test_names)); } }; // The base case for the compile time recursion. template class TypeParameterizedTestCase { public: static bool Register(const char* /*prefix*/, const char* /*case_name*/, const char* /*test_names*/) { return true; } }; #endif // GTEST_HAS_TYPED_TEST || GTEST_HAS_TYPED_TEST_P // Returns the current OS stack trace as an std::string. // // The maximum number of stack frames to be included is specified by // the gtest_stack_trace_depth flag. The skip_count parameter // specifies the number of top frames to be skipped, which doesn't // count against the number of frames to be included. // // For example, if Foo() calls Bar(), which in turn calls // GetCurrentOsStackTraceExceptTop(..., 1), Foo() will be included in // the trace but Bar() and GetCurrentOsStackTraceExceptTop() won't. GTEST_API_ std::string GetCurrentOsStackTraceExceptTop( UnitTest* unit_test, int skip_count); // Helpers for suppressing warnings on unreachable code or constant // condition. // Always returns true. GTEST_API_ bool AlwaysTrue(); // Always returns false. inline bool AlwaysFalse() { return !AlwaysTrue(); } // Helper for suppressing false warning from Clang on a const char* // variable declared in a conditional expression always being NULL in // the else branch. struct GTEST_API_ ConstCharPtr { ConstCharPtr(const char* str) : value(str) {} operator bool() const { return true; } const char* value; }; // A simple Linear Congruential Generator for generating random // numbers with a uniform distribution. Unlike rand() and srand(), it // doesn't use global state (and therefore can't interfere with user // code). Unlike rand_r(), it's portable. An LCG isn't very random, // but it's good enough for our purposes. class GTEST_API_ Random { public: static const UInt32 kMaxRange = 1u << 31; explicit Random(UInt32 seed) : state_(seed) {} void Reseed(UInt32 seed) { state_ = seed; } // Generates a random number from [0, range). Crashes if 'range' is // 0 or greater than kMaxRange. UInt32 Generate(UInt32 range); private: UInt32 state_; GTEST_DISALLOW_COPY_AND_ASSIGN_(Random); }; // Defining a variable of type CompileAssertTypesEqual will cause a // compiler error iff T1 and T2 are different types. template struct CompileAssertTypesEqual; template struct CompileAssertTypesEqual { }; // Removes the reference from a type if it is a reference type, // otherwise leaves it unchanged. This is the same as // tr1::remove_reference, which is not widely available yet. template struct RemoveReference { typedef T type; }; // NOLINT template struct RemoveReference { typedef T type; }; // NOLINT // A handy wrapper around RemoveReference that works when the argument // T depends on template parameters. #define GTEST_REMOVE_REFERENCE_(T) \ typename ::testing::internal::RemoveReference::type // Removes const from a type if it is a const type, otherwise leaves // it unchanged. This is the same as tr1::remove_const, which is not // widely available yet. template struct RemoveConst { typedef T type; }; // NOLINT template struct RemoveConst { typedef T type; }; // NOLINT // MSVC 8.0, Sun C++, and IBM XL C++ have a bug which causes the above // definition to fail to remove the const in 'const int[3]' and 'const // char[3][4]'. The following specialization works around the bug. template struct RemoveConst { typedef typename RemoveConst::type type[N]; }; #if defined(_MSC_VER) && _MSC_VER < 1400 // This is the only specialization that allows VC++ 7.1 to remove const in // 'const int[3] and 'const int[3][4]'. However, it causes trouble with GCC // and thus needs to be conditionally compiled. template struct RemoveConst { typedef typename RemoveConst::type type[N]; }; #endif // A handy wrapper around RemoveConst that works when the argument // T depends on template parameters. #define GTEST_REMOVE_CONST_(T) \ typename ::testing::internal::RemoveConst::type // Turns const U&, U&, const U, and U all into U. #define GTEST_REMOVE_REFERENCE_AND_CONST_(T) \ GTEST_REMOVE_CONST_(GTEST_REMOVE_REFERENCE_(T)) // Adds reference to a type if it is not a reference type, // otherwise leaves it unchanged. This is the same as // tr1::add_reference, which is not widely available yet. template struct AddReference { typedef T& type; }; // NOLINT template struct AddReference { typedef T& type; }; // NOLINT // A handy wrapper around AddReference that works when the argument T // depends on template parameters. #define GTEST_ADD_REFERENCE_(T) \ typename ::testing::internal::AddReference::type // Adds a reference to const on top of T as necessary. For example, // it transforms // // char ==> const char& // const char ==> const char& // char& ==> const char& // const char& ==> const char& // // The argument T must depend on some template parameters. #define GTEST_REFERENCE_TO_CONST_(T) \ GTEST_ADD_REFERENCE_(const GTEST_REMOVE_REFERENCE_(T)) // ImplicitlyConvertible::value is a compile-time bool // constant that's true iff type From can be implicitly converted to // type To. template class ImplicitlyConvertible { private: // We need the following helper functions only for their types. // They have no implementations. // MakeFrom() is an expression whose type is From. We cannot simply // use From(), as the type From may not have a public default // constructor. static From MakeFrom(); // These two functions are overloaded. Given an expression // Helper(x), the compiler will pick the first version if x can be // implicitly converted to type To; otherwise it will pick the // second version. // // The first version returns a value of size 1, and the second // version returns a value of size 2. Therefore, by checking the // size of Helper(x), which can be done at compile time, we can tell // which version of Helper() is used, and hence whether x can be // implicitly converted to type To. static char Helper(To); static char (&Helper(...))[2]; // NOLINT // We have to put the 'public' section after the 'private' section, // or MSVC refuses to compile the code. public: // MSVC warns about implicitly converting from double to int for // possible loss of data, so we need to temporarily disable the // warning. #ifdef _MSC_VER # pragma warning(push) // Saves the current warning state. # pragma warning(disable:4244) // Temporarily disables warning 4244. static const bool value = sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; # pragma warning(pop) // Restores the warning state. #elif defined(__BORLANDC__) // C++Builder cannot use member overload resolution during template // instantiation. The simplest workaround is to use its C++0x type traits // functions (C++Builder 2009 and above only). static const bool value = __is_convertible(From, To); #else static const bool value = sizeof(Helper(ImplicitlyConvertible::MakeFrom())) == 1; #endif // _MSV_VER }; template const bool ImplicitlyConvertible::value; // IsAProtocolMessage::value is a compile-time bool constant that's // true iff T is type ProtocolMessage, proto2::Message, or a subclass // of those. template struct IsAProtocolMessage : public bool_constant< ImplicitlyConvertible::value || ImplicitlyConvertible::value> { }; // When the compiler sees expression IsContainerTest(0), if C is an // STL-style container class, the first overload of IsContainerTest // will be viable (since both C::iterator* and C::const_iterator* are // valid types and NULL can be implicitly converted to them). It will // be picked over the second overload as 'int' is a perfect match for // the type of argument 0. If C::iterator or C::const_iterator is not // a valid type, the first overload is not viable, and the second // overload will be picked. Therefore, we can determine whether C is // a container class by checking the type of IsContainerTest(0). // The value of the expression is insignificant. // // Note that we look for both C::iterator and C::const_iterator. The // reason is that C++ injects the name of a class as a member of the // class itself (e.g. you can refer to class iterator as either // 'iterator' or 'iterator::iterator'). If we look for C::iterator // only, for example, we would mistakenly think that a class named // iterator is an STL container. // // Also note that the simpler approach of overloading // IsContainerTest(typename C::const_iterator*) and // IsContainerTest(...) doesn't work with Visual Age C++ and Sun C++. typedef int IsContainer; template IsContainer IsContainerTest(int /* dummy */, typename C::iterator* /* it */ = NULL, typename C::const_iterator* /* const_it */ = NULL) { return 0; } typedef char IsNotContainer; template IsNotContainer IsContainerTest(long /* dummy */) { return '\0'; } // EnableIf::type is void when 'Cond' is true, and // undefined when 'Cond' is false. To use SFINAE to make a function // overload only apply when a particular expression is true, add // "typename EnableIf::type* = 0" as the last parameter. template struct EnableIf; template<> struct EnableIf { typedef void type; }; // NOLINT // Utilities for native arrays. // ArrayEq() compares two k-dimensional native arrays using the // elements' operator==, where k can be any integer >= 0. When k is // 0, ArrayEq() degenerates into comparing a single pair of values. template bool ArrayEq(const T* lhs, size_t size, const U* rhs); // This generic version is used when k is 0. template inline bool ArrayEq(const T& lhs, const U& rhs) { return lhs == rhs; } // This overload is used when k >= 1. template inline bool ArrayEq(const T(&lhs)[N], const U(&rhs)[N]) { return internal::ArrayEq(lhs, N, rhs); } // This helper reduces code bloat. If we instead put its logic inside // the previous ArrayEq() function, arrays with different sizes would // lead to different copies of the template code. template bool ArrayEq(const T* lhs, size_t size, const U* rhs) { for (size_t i = 0; i != size; i++) { if (!internal::ArrayEq(lhs[i], rhs[i])) return false; } return true; } // Finds the first element in the iterator range [begin, end) that // equals elem. Element may be a native array type itself. template Iter ArrayAwareFind(Iter begin, Iter end, const Element& elem) { for (Iter it = begin; it != end; ++it) { if (internal::ArrayEq(*it, elem)) return it; } return end; } // CopyArray() copies a k-dimensional native array using the elements' // operator=, where k can be any integer >= 0. When k is 0, // CopyArray() degenerates into copying a single value. template void CopyArray(const T* from, size_t size, U* to); // This generic version is used when k is 0. template inline void CopyArray(const T& from, U* to) { *to = from; } // This overload is used when k >= 1. template inline void CopyArray(const T(&from)[N], U(*to)[N]) { internal::CopyArray(from, N, *to); } // This helper reduces code bloat. If we instead put its logic inside // the previous CopyArray() function, arrays with different sizes // would lead to different copies of the template code. template void CopyArray(const T* from, size_t size, U* to) { for (size_t i = 0; i != size; i++) { internal::CopyArray(from[i], to + i); } } // The relation between an NativeArray object (see below) and the // native array it represents. enum RelationToSource { kReference, // The NativeArray references the native array. kCopy // The NativeArray makes a copy of the native array and // owns the copy. }; // Adapts a native array to a read-only STL-style container. Instead // of the complete STL container concept, this adaptor only implements // members useful for Google Mock's container matchers. New members // should be added as needed. To simplify the implementation, we only // support Element being a raw type (i.e. having no top-level const or // reference modifier). It's the client's responsibility to satisfy // this requirement. Element can be an array type itself (hence // multi-dimensional arrays are supported). template class NativeArray { public: // STL-style container typedefs. typedef Element value_type; typedef Element* iterator; typedef const Element* const_iterator; // Constructs from a native array. NativeArray(const Element* array, size_t count, RelationToSource relation) { Init(array, count, relation); } // Copy constructor. NativeArray(const NativeArray& rhs) { Init(rhs.array_, rhs.size_, rhs.relation_to_source_); } ~NativeArray() { // Ensures that the user doesn't instantiate NativeArray with a // const or reference type. static_cast(StaticAssertTypeEqHelper()); if (relation_to_source_ == kCopy) delete[] array_; } // STL-style container methods. size_t size() const { return size_; } const_iterator begin() const { return array_; } const_iterator end() const { return array_ + size_; } bool operator==(const NativeArray& rhs) const { return size() == rhs.size() && ArrayEq(begin(), size(), rhs.begin()); } private: // Initializes this object; makes a copy of the input array if // 'relation' is kCopy. void Init(const Element* array, size_t a_size, RelationToSource relation) { if (relation == kReference) { array_ = array; } else { Element* const copy = new Element[a_size]; CopyArray(array, a_size, copy); array_ = copy; } size_ = a_size; relation_to_source_ = relation; } const Element* array_; size_t size_; RelationToSource relation_to_source_; GTEST_DISALLOW_ASSIGN_(NativeArray); }; } // namespace internal } // namespace testing #define GTEST_MESSAGE_AT_(file, line, message, result_type) \ ::testing::internal::AssertHelper(result_type, file, line, message) \ = ::testing::Message() #define GTEST_MESSAGE_(message, result_type) \ GTEST_MESSAGE_AT_(__FILE__, __LINE__, message, result_type) #define GTEST_FATAL_FAILURE_(message) \ return GTEST_MESSAGE_(message, ::testing::TestPartResult::kFatalFailure) #define GTEST_NONFATAL_FAILURE_(message) \ GTEST_MESSAGE_(message, ::testing::TestPartResult::kNonFatalFailure) #define GTEST_SUCCESS_(message) \ GTEST_MESSAGE_(message, ::testing::TestPartResult::kSuccess) // Suppresses MSVC warnings 4072 (unreachable code) for the code following // statement if it returns or throws (or doesn't return or throw in some // situations). #define GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) \ if (::testing::internal::AlwaysTrue()) { statement; } #define GTEST_TEST_THROW_(statement, expected_exception, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::ConstCharPtr gtest_msg = "") { \ bool gtest_caught_expected = false; \ try { \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ } \ catch (expected_exception const&) { \ gtest_caught_expected = true; \ } \ catch (...) { \ gtest_msg.value = \ "Expected: " #statement " throws an exception of type " \ #expected_exception ".\n Actual: it throws a different type."; \ goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ } \ if (!gtest_caught_expected) { \ gtest_msg.value = \ "Expected: " #statement " throws an exception of type " \ #expected_exception ".\n Actual: it throws nothing."; \ goto GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__); \ } \ } else \ GTEST_CONCAT_TOKEN_(gtest_label_testthrow_, __LINE__): \ fail(gtest_msg.value) #define GTEST_TEST_NO_THROW_(statement, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::AlwaysTrue()) { \ try { \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ } \ catch (...) { \ goto GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__); \ } \ } else \ GTEST_CONCAT_TOKEN_(gtest_label_testnothrow_, __LINE__): \ fail("Expected: " #statement " doesn't throw an exception.\n" \ " Actual: it throws.") #define GTEST_TEST_ANY_THROW_(statement, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::AlwaysTrue()) { \ bool gtest_caught_any = false; \ try { \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ } \ catch (...) { \ gtest_caught_any = true; \ } \ if (!gtest_caught_any) { \ goto GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__); \ } \ } else \ GTEST_CONCAT_TOKEN_(gtest_label_testanythrow_, __LINE__): \ fail("Expected: " #statement " throws an exception.\n" \ " Actual: it doesn't.") // Implements Boolean test assertions such as EXPECT_TRUE. expression can be // either a boolean expression or an AssertionResult. text is a textual // represenation of expression as it was passed into the EXPECT_TRUE. #define GTEST_TEST_BOOLEAN_(expression, text, actual, expected, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (const ::testing::AssertionResult gtest_ar_ = \ ::testing::AssertionResult(expression)) \ ; \ else \ fail(::testing::internal::GetBoolAssertionFailureMessage(\ gtest_ar_, text, #actual, #expected).c_str()) #define GTEST_TEST_NO_FATAL_FAILURE_(statement, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::AlwaysTrue()) { \ ::testing::internal::HasNewFatalFailureHelper gtest_fatal_failure_checker; \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ if (gtest_fatal_failure_checker.has_new_fatal_failure()) { \ goto GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__); \ } \ } else \ GTEST_CONCAT_TOKEN_(gtest_label_testnofatal_, __LINE__): \ fail("Expected: " #statement " doesn't generate new fatal " \ "failures in the current thread.\n" \ " Actual: it does.") // Expands to the name of the class that implements the given test. #define GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ test_case_name##_##test_name##_Test // Helper macro for defining tests. #define GTEST_TEST_(test_case_name, test_name, parent_class, parent_id)\ class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) : public parent_class {\ public:\ GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {}\ private:\ virtual void TestBody();\ static ::testing::TestInfo* const test_info_ GTEST_ATTRIBUTE_UNUSED_;\ GTEST_DISALLOW_COPY_AND_ASSIGN_(\ GTEST_TEST_CLASS_NAME_(test_case_name, test_name));\ };\ \ ::testing::TestInfo* const GTEST_TEST_CLASS_NAME_(test_case_name, test_name)\ ::test_info_ =\ ::testing::internal::MakeAndRegisterTestInfo(\ #test_case_name, #test_name, NULL, NULL, \ (parent_id), \ parent_class::SetUpTestCase, \ parent_class::TearDownTestCase, \ new ::testing::internal::TestFactoryImpl<\ GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>);\ void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_INTERNAL_H_ // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // // The Google C++ Testing Framework (Google Test) // // This header file defines the public API for death tests. It is // #included by gtest.h so a user doesn't need to include this // directly. #ifndef GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ #define GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ // Copyright 2005, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Authors: wan@google.com (Zhanyong Wan), eefacm@gmail.com (Sean Mcafee) // // The Google C++ Testing Framework (Google Test) // // This header file defines internal utilities needed for implementing // death tests. They are subject to change without notice. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ #include namespace testing { namespace internal { GTEST_DECLARE_string_(internal_run_death_test); // Names of the flags (needed for parsing Google Test flags). const char kDeathTestStyleFlag[] = "death_test_style"; const char kDeathTestUseFork[] = "death_test_use_fork"; const char kInternalRunDeathTestFlag[] = "internal_run_death_test"; #if GTEST_HAS_DEATH_TEST // DeathTest is a class that hides much of the complexity of the // GTEST_DEATH_TEST_ macro. It is abstract; its static Create method // returns a concrete class that depends on the prevailing death test // style, as defined by the --gtest_death_test_style and/or // --gtest_internal_run_death_test flags. // In describing the results of death tests, these terms are used with // the corresponding definitions: // // exit status: The integer exit information in the format specified // by wait(2) // exit code: The integer code passed to exit(3), _exit(2), or // returned from main() class GTEST_API_ DeathTest { public: // Create returns false if there was an error determining the // appropriate action to take for the current death test; for example, // if the gtest_death_test_style flag is set to an invalid value. // The LastMessage method will return a more detailed message in that // case. Otherwise, the DeathTest pointer pointed to by the "test" // argument is set. If the death test should be skipped, the pointer // is set to NULL; otherwise, it is set to the address of a new concrete // DeathTest object that controls the execution of the current test. static bool Create(const char* statement, const RE* regex, const char* file, int line, DeathTest** test); DeathTest(); virtual ~DeathTest() { } // A helper class that aborts a death test when it's deleted. class ReturnSentinel { public: explicit ReturnSentinel(DeathTest* test) : test_(test) { } ~ReturnSentinel() { test_->Abort(TEST_ENCOUNTERED_RETURN_STATEMENT); } private: DeathTest* const test_; GTEST_DISALLOW_COPY_AND_ASSIGN_(ReturnSentinel); } GTEST_ATTRIBUTE_UNUSED_; // An enumeration of possible roles that may be taken when a death // test is encountered. EXECUTE means that the death test logic should // be executed immediately. OVERSEE means that the program should prepare // the appropriate environment for a child process to execute the death // test, then wait for it to complete. enum TestRole { OVERSEE_TEST, EXECUTE_TEST }; // An enumeration of the three reasons that a test might be aborted. enum AbortReason { TEST_ENCOUNTERED_RETURN_STATEMENT, TEST_THREW_EXCEPTION, TEST_DID_NOT_DIE }; // Assumes one of the above roles. virtual TestRole AssumeRole() = 0; // Waits for the death test to finish and returns its status. virtual int Wait() = 0; // Returns true if the death test passed; that is, the test process // exited during the test, its exit status matches a user-supplied // predicate, and its stderr output matches a user-supplied regular // expression. // The user-supplied predicate may be a macro expression rather // than a function pointer or functor, or else Wait and Passed could // be combined. virtual bool Passed(bool exit_status_ok) = 0; // Signals that the death test did not die as expected. virtual void Abort(AbortReason reason) = 0; // Returns a human-readable outcome message regarding the outcome of // the last death test. static const char* LastMessage(); static void set_last_death_test_message(const std::string& message); private: // A string containing a description of the outcome of the last death test. static std::string last_death_test_message_; GTEST_DISALLOW_COPY_AND_ASSIGN_(DeathTest); }; // Factory interface for death tests. May be mocked out for testing. class DeathTestFactory { public: virtual ~DeathTestFactory() { } virtual bool Create(const char* statement, const RE* regex, const char* file, int line, DeathTest** test) = 0; }; // A concrete DeathTestFactory implementation for normal use. class DefaultDeathTestFactory : public DeathTestFactory { public: virtual bool Create(const char* statement, const RE* regex, const char* file, int line, DeathTest** test); }; // Returns true if exit_status describes a process that was terminated // by a signal, or exited normally with a nonzero exit code. GTEST_API_ bool ExitedUnsuccessfully(int exit_status); // Traps C++ exceptions escaping statement and reports them as test // failures. Note that trapping SEH exceptions is not implemented here. # if GTEST_HAS_EXCEPTIONS # define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ try { \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ } catch (const ::std::exception& gtest_exception) { \ fprintf(\ stderr, \ "\n%s: Caught std::exception-derived exception escaping the " \ "death test statement. Exception message: %s\n", \ ::testing::internal::FormatFileLocation(__FILE__, __LINE__).c_str(), \ gtest_exception.what()); \ fflush(stderr); \ death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \ } catch (...) { \ death_test->Abort(::testing::internal::DeathTest::TEST_THREW_EXCEPTION); \ } # else # define GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, death_test) \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement) # endif // This macro is for implementing ASSERT_DEATH*, EXPECT_DEATH*, // ASSERT_EXIT*, and EXPECT_EXIT*. # define GTEST_DEATH_TEST_(statement, predicate, regex, fail) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::AlwaysTrue()) { \ const ::testing::internal::RE& gtest_regex = (regex); \ ::testing::internal::DeathTest* gtest_dt; \ if (!::testing::internal::DeathTest::Create(#statement, >est_regex, \ __FILE__, __LINE__, >est_dt)) { \ goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \ } \ if (gtest_dt != NULL) { \ ::testing::internal::scoped_ptr< ::testing::internal::DeathTest> \ gtest_dt_ptr(gtest_dt); \ switch (gtest_dt->AssumeRole()) { \ case ::testing::internal::DeathTest::OVERSEE_TEST: \ if (!gtest_dt->Passed(predicate(gtest_dt->Wait()))) { \ goto GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__); \ } \ break; \ case ::testing::internal::DeathTest::EXECUTE_TEST: { \ ::testing::internal::DeathTest::ReturnSentinel \ gtest_sentinel(gtest_dt); \ GTEST_EXECUTE_DEATH_TEST_STATEMENT_(statement, gtest_dt); \ gtest_dt->Abort(::testing::internal::DeathTest::TEST_DID_NOT_DIE); \ break; \ } \ default: \ break; \ } \ } \ } else \ GTEST_CONCAT_TOKEN_(gtest_label_, __LINE__): \ fail(::testing::internal::DeathTest::LastMessage()) // The symbol "fail" here expands to something into which a message // can be streamed. // This macro is for implementing ASSERT/EXPECT_DEBUG_DEATH when compiled in // NDEBUG mode. In this case we need the statements to be executed, the regex is // ignored, and the macro must accept a streamed message even though the message // is never printed. # define GTEST_EXECUTE_STATEMENT_(statement, regex) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::AlwaysTrue()) { \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ } else \ ::testing::Message() // A class representing the parsed contents of the // --gtest_internal_run_death_test flag, as it existed when // RUN_ALL_TESTS was called. class InternalRunDeathTestFlag { public: InternalRunDeathTestFlag(const std::string& a_file, int a_line, int an_index, int a_write_fd) : file_(a_file), line_(a_line), index_(an_index), write_fd_(a_write_fd) {} ~InternalRunDeathTestFlag() { if (write_fd_ >= 0) posix::Close(write_fd_); } const std::string& file() const { return file_; } int line() const { return line_; } int index() const { return index_; } int write_fd() const { return write_fd_; } private: std::string file_; int line_; int index_; int write_fd_; GTEST_DISALLOW_COPY_AND_ASSIGN_(InternalRunDeathTestFlag); }; // Returns a newly created InternalRunDeathTestFlag object with fields // initialized from the GTEST_FLAG(internal_run_death_test) flag if // the flag is specified; otherwise returns NULL. InternalRunDeathTestFlag* ParseInternalRunDeathTestFlag(); #else // GTEST_HAS_DEATH_TEST // This macro is used for implementing macros such as // EXPECT_DEATH_IF_SUPPORTED and ASSERT_DEATH_IF_SUPPORTED on systems where // death tests are not supported. Those macros must compile on such systems // iff EXPECT_DEATH and ASSERT_DEATH compile with the same parameters on // systems that support death tests. This allows one to write such a macro // on a system that does not support death tests and be sure that it will // compile on a death-test supporting system. // // Parameters: // statement - A statement that a macro such as EXPECT_DEATH would test // for program termination. This macro has to make sure this // statement is compiled but not executed, to ensure that // EXPECT_DEATH_IF_SUPPORTED compiles with a certain // parameter iff EXPECT_DEATH compiles with it. // regex - A regex that a macro such as EXPECT_DEATH would use to test // the output of statement. This parameter has to be // compiled but not evaluated by this macro, to ensure that // this macro only accepts expressions that a macro such as // EXPECT_DEATH would accept. // terminator - Must be an empty statement for EXPECT_DEATH_IF_SUPPORTED // and a return statement for ASSERT_DEATH_IF_SUPPORTED. // This ensures that ASSERT_DEATH_IF_SUPPORTED will not // compile inside functions where ASSERT_DEATH doesn't // compile. // // The branch that has an always false condition is used to ensure that // statement and regex are compiled (and thus syntactically correct) but // never executed. The unreachable code macro protects the terminator // statement from generating an 'unreachable code' warning in case // statement unconditionally returns or throws. The Message constructor at // the end allows the syntax of streaming additional messages into the // macro, for compilational compatibility with EXPECT_DEATH/ASSERT_DEATH. # define GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, terminator) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (::testing::internal::AlwaysTrue()) { \ GTEST_LOG_(WARNING) \ << "Death tests are not supported on this platform.\n" \ << "Statement '" #statement "' cannot be verified."; \ } else if (::testing::internal::AlwaysFalse()) { \ ::testing::internal::RE::PartialMatch(".*", (regex)); \ GTEST_SUPPRESS_UNREACHABLE_CODE_WARNING_BELOW_(statement); \ terminator; \ } else \ ::testing::Message() #endif // GTEST_HAS_DEATH_TEST } // namespace internal } // namespace testing #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_DEATH_TEST_INTERNAL_H_ namespace testing { // This flag controls the style of death tests. Valid values are "threadsafe", // meaning that the death test child process will re-execute the test binary // from the start, running only a single death test, or "fast", // meaning that the child process will execute the test logic immediately // after forking. GTEST_DECLARE_string_(death_test_style); #if GTEST_HAS_DEATH_TEST namespace internal { // Returns a Boolean value indicating whether the caller is currently // executing in the context of the death test child process. Tools such as // Valgrind heap checkers may need this to modify their behavior in death // tests. IMPORTANT: This is an internal utility. Using it may break the // implementation of death tests. User code MUST NOT use it. GTEST_API_ bool InDeathTestChild(); } // namespace internal // The following macros are useful for writing death tests. // Here's what happens when an ASSERT_DEATH* or EXPECT_DEATH* is // executed: // // 1. It generates a warning if there is more than one active // thread. This is because it's safe to fork() or clone() only // when there is a single thread. // // 2. The parent process clone()s a sub-process and runs the death // test in it; the sub-process exits with code 0 at the end of the // death test, if it hasn't exited already. // // 3. The parent process waits for the sub-process to terminate. // // 4. The parent process checks the exit code and error message of // the sub-process. // // Examples: // // ASSERT_DEATH(server.SendMessage(56, "Hello"), "Invalid port number"); // for (int i = 0; i < 5; i++) { // EXPECT_DEATH(server.ProcessRequest(i), // "Invalid request .* in ProcessRequest()") // << "Failed to die on request " << i; // } // // ASSERT_EXIT(server.ExitNow(), ::testing::ExitedWithCode(0), "Exiting"); // // bool KilledBySIGHUP(int exit_code) { // return WIFSIGNALED(exit_code) && WTERMSIG(exit_code) == SIGHUP; // } // // ASSERT_EXIT(client.HangUpServer(), KilledBySIGHUP, "Hanging up!"); // // On the regular expressions used in death tests: // // On POSIX-compliant systems (*nix), we use the library, // which uses the POSIX extended regex syntax. // // On other platforms (e.g. Windows), we only support a simple regex // syntax implemented as part of Google Test. This limited // implementation should be enough most of the time when writing // death tests; though it lacks many features you can find in PCRE // or POSIX extended regex syntax. For example, we don't support // union ("x|y"), grouping ("(xy)"), brackets ("[xy]"), and // repetition count ("x{5,7}"), among others. // // Below is the syntax that we do support. We chose it to be a // subset of both PCRE and POSIX extended regex, so it's easy to // learn wherever you come from. In the following: 'A' denotes a // literal character, period (.), or a single \\ escape sequence; // 'x' and 'y' denote regular expressions; 'm' and 'n' are for // natural numbers. // // c matches any literal character c // \\d matches any decimal digit // \\D matches any character that's not a decimal digit // \\f matches \f // \\n matches \n // \\r matches \r // \\s matches any ASCII whitespace, including \n // \\S matches any character that's not a whitespace // \\t matches \t // \\v matches \v // \\w matches any letter, _, or decimal digit // \\W matches any character that \\w doesn't match // \\c matches any literal character c, which must be a punctuation // . matches any single character except \n // A? matches 0 or 1 occurrences of A // A* matches 0 or many occurrences of A // A+ matches 1 or many occurrences of A // ^ matches the beginning of a string (not that of each line) // $ matches the end of a string (not that of each line) // xy matches x followed by y // // If you accidentally use PCRE or POSIX extended regex features // not implemented by us, you will get a run-time failure. In that // case, please try to rewrite your regular expression within the // above syntax. // // This implementation is *not* meant to be as highly tuned or robust // as a compiled regex library, but should perform well enough for a // death test, which already incurs significant overhead by launching // a child process. // // Known caveats: // // A "threadsafe" style death test obtains the path to the test // program from argv[0] and re-executes it in the sub-process. For // simplicity, the current implementation doesn't search the PATH // when launching the sub-process. This means that the user must // invoke the test program via a path that contains at least one // path separator (e.g. path/to/foo_test and // /absolute/path/to/bar_test are fine, but foo_test is not). This // is rarely a problem as people usually don't put the test binary // directory in PATH. // // TODO(wan@google.com): make thread-safe death tests search the PATH. // Asserts that a given statement causes the program to exit, with an // integer exit status that satisfies predicate, and emitting error output // that matches regex. # define ASSERT_EXIT(statement, predicate, regex) \ GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_FATAL_FAILURE_) // Like ASSERT_EXIT, but continues on to successive tests in the // test case, if any: # define EXPECT_EXIT(statement, predicate, regex) \ GTEST_DEATH_TEST_(statement, predicate, regex, GTEST_NONFATAL_FAILURE_) // Asserts that a given statement causes the program to exit, either by // explicitly exiting with a nonzero exit code or being killed by a // signal, and emitting error output that matches regex. # define ASSERT_DEATH(statement, regex) \ ASSERT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) // Like ASSERT_DEATH, but continues on to successive tests in the // test case, if any: # define EXPECT_DEATH(statement, regex) \ EXPECT_EXIT(statement, ::testing::internal::ExitedUnsuccessfully, regex) // Two predicate classes that can be used in {ASSERT,EXPECT}_EXIT*: // Tests that an exit code describes a normal exit with a given exit code. class GTEST_API_ ExitedWithCode { public: explicit ExitedWithCode(int exit_code); bool operator()(int exit_status) const; private: // No implementation - assignment is unsupported. void operator=(const ExitedWithCode& other); const int exit_code_; }; # if !GTEST_OS_WINDOWS // Tests that an exit code describes an exit due to termination by a // given signal. class GTEST_API_ KilledBySignal { public: explicit KilledBySignal(int signum); bool operator()(int exit_status) const; private: const int signum_; }; # endif // !GTEST_OS_WINDOWS // EXPECT_DEBUG_DEATH asserts that the given statements die in debug mode. // The death testing framework causes this to have interesting semantics, // since the sideeffects of the call are only visible in opt mode, and not // in debug mode. // // In practice, this can be used to test functions that utilize the // LOG(DFATAL) macro using the following style: // // int DieInDebugOr12(int* sideeffect) { // if (sideeffect) { // *sideeffect = 12; // } // LOG(DFATAL) << "death"; // return 12; // } // // TEST(TestCase, TestDieOr12WorksInDgbAndOpt) { // int sideeffect = 0; // // Only asserts in dbg. // EXPECT_DEBUG_DEATH(DieInDebugOr12(&sideeffect), "death"); // // #ifdef NDEBUG // // opt-mode has sideeffect visible. // EXPECT_EQ(12, sideeffect); // #else // // dbg-mode no visible sideeffect. // EXPECT_EQ(0, sideeffect); // #endif // } // // This will assert that DieInDebugReturn12InOpt() crashes in debug // mode, usually due to a DCHECK or LOG(DFATAL), but returns the // appropriate fallback value (12 in this case) in opt mode. If you // need to test that a function has appropriate side-effects in opt // mode, include assertions against the side-effects. A general // pattern for this is: // // EXPECT_DEBUG_DEATH({ // // Side-effects here will have an effect after this statement in // // opt mode, but none in debug mode. // EXPECT_EQ(12, DieInDebugOr12(&sideeffect)); // }, "death"); // # ifdef NDEBUG # define EXPECT_DEBUG_DEATH(statement, regex) \ GTEST_EXECUTE_STATEMENT_(statement, regex) # define ASSERT_DEBUG_DEATH(statement, regex) \ GTEST_EXECUTE_STATEMENT_(statement, regex) # else # define EXPECT_DEBUG_DEATH(statement, regex) \ EXPECT_DEATH(statement, regex) # define ASSERT_DEBUG_DEATH(statement, regex) \ ASSERT_DEATH(statement, regex) # endif // NDEBUG for EXPECT_DEBUG_DEATH #endif // GTEST_HAS_DEATH_TEST // EXPECT_DEATH_IF_SUPPORTED(statement, regex) and // ASSERT_DEATH_IF_SUPPORTED(statement, regex) expand to real death tests if // death tests are supported; otherwise they just issue a warning. This is // useful when you are combining death test assertions with normal test // assertions in one test. #if GTEST_HAS_DEATH_TEST # define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ EXPECT_DEATH(statement, regex) # define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ ASSERT_DEATH(statement, regex) #else # define EXPECT_DEATH_IF_SUPPORTED(statement, regex) \ GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, ) # define ASSERT_DEATH_IF_SUPPORTED(statement, regex) \ GTEST_UNSUPPORTED_DEATH_TEST_(statement, regex, return) #endif } // namespace testing #endif // GTEST_INCLUDE_GTEST_GTEST_DEATH_TEST_H_ // This file was GENERATED by command: // pump.py gtest-param-test.h.pump // DO NOT EDIT BY HAND!!! // Copyright 2008, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Authors: vladl@google.com (Vlad Losev) // // Macros and functions for implementing parameterized tests // in Google C++ Testing Framework (Google Test) // // This file is generated by a SCRIPT. DO NOT EDIT BY HAND! // #ifndef GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ #define GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ // Value-parameterized tests allow you to test your code with different // parameters without writing multiple copies of the same test. // // Here is how you use value-parameterized tests: #if 0 // To write value-parameterized tests, first you should define a fixture // class. It is usually derived from testing::TestWithParam (see below for // another inheritance scheme that's sometimes useful in more complicated // class hierarchies), where the type of your parameter values. // TestWithParam is itself derived from testing::Test. T can be any // copyable type. If it's a raw pointer, you are responsible for managing the // lifespan of the pointed values. class FooTest : public ::testing::TestWithParam { // You can implement all the usual class fixture members here. }; // Then, use the TEST_P macro to define as many parameterized tests // for this fixture as you want. The _P suffix is for "parameterized" // or "pattern", whichever you prefer to think. TEST_P(FooTest, DoesBlah) { // Inside a test, access the test parameter with the GetParam() method // of the TestWithParam class: EXPECT_TRUE(foo.Blah(GetParam())); ... } TEST_P(FooTest, HasBlahBlah) { ... } // Finally, you can use INSTANTIATE_TEST_CASE_P to instantiate the test // case with any set of parameters you want. Google Test defines a number // of functions for generating test parameters. They return what we call // (surprise!) parameter generators. Here is a summary of them, which // are all in the testing namespace: // // // Range(begin, end [, step]) - Yields values {begin, begin+step, // begin+step+step, ...}. The values do not // include end. step defaults to 1. // Values(v1, v2, ..., vN) - Yields values {v1, v2, ..., vN}. // ValuesIn(container) - Yields values from a C-style array, an STL // ValuesIn(begin,end) container, or an iterator range [begin, end). // Bool() - Yields sequence {false, true}. // Combine(g1, g2, ..., gN) - Yields all combinations (the Cartesian product // for the math savvy) of the values generated // by the N generators. // // For more details, see comments at the definitions of these functions below // in this file. // // The following statement will instantiate tests from the FooTest test case // each with parameter values "meeny", "miny", and "moe". INSTANTIATE_TEST_CASE_P(InstantiationName, FooTest, Values("meeny", "miny", "moe")); // To distinguish different instances of the pattern, (yes, you // can instantiate it more then once) the first argument to the // INSTANTIATE_TEST_CASE_P macro is a prefix that will be added to the // actual test case name. Remember to pick unique prefixes for different // instantiations. The tests from the instantiation above will have // these names: // // * InstantiationName/FooTest.DoesBlah/0 for "meeny" // * InstantiationName/FooTest.DoesBlah/1 for "miny" // * InstantiationName/FooTest.DoesBlah/2 for "moe" // * InstantiationName/FooTest.HasBlahBlah/0 for "meeny" // * InstantiationName/FooTest.HasBlahBlah/1 for "miny" // * InstantiationName/FooTest.HasBlahBlah/2 for "moe" // // You can use these names in --gtest_filter. // // This statement will instantiate all tests from FooTest again, each // with parameter values "cat" and "dog": const char* pets[] = {"cat", "dog"}; INSTANTIATE_TEST_CASE_P(AnotherInstantiationName, FooTest, ValuesIn(pets)); // The tests from the instantiation above will have these names: // // * AnotherInstantiationName/FooTest.DoesBlah/0 for "cat" // * AnotherInstantiationName/FooTest.DoesBlah/1 for "dog" // * AnotherInstantiationName/FooTest.HasBlahBlah/0 for "cat" // * AnotherInstantiationName/FooTest.HasBlahBlah/1 for "dog" // // Please note that INSTANTIATE_TEST_CASE_P will instantiate all tests // in the given test case, whether their definitions come before or // AFTER the INSTANTIATE_TEST_CASE_P statement. // // Please also note that generator expressions (including parameters to the // generators) are evaluated in InitGoogleTest(), after main() has started. // This allows the user on one hand, to adjust generator parameters in order // to dynamically determine a set of tests to run and on the other hand, // give the user a chance to inspect the generated tests with Google Test // reflection API before RUN_ALL_TESTS() is executed. // // You can see samples/sample7_unittest.cc and samples/sample8_unittest.cc // for more examples. // // In the future, we plan to publish the API for defining new parameter // generators. But for now this interface remains part of the internal // implementation and is subject to change. // // // A parameterized test fixture must be derived from testing::Test and from // testing::WithParamInterface, where T is the type of the parameter // values. Inheriting from TestWithParam satisfies that requirement because // TestWithParam inherits from both Test and WithParamInterface. In more // complicated hierarchies, however, it is occasionally useful to inherit // separately from Test and WithParamInterface. For example: class BaseTest : public ::testing::Test { // You can inherit all the usual members for a non-parameterized test // fixture here. }; class DerivedTest : public BaseTest, public ::testing::WithParamInterface { // The usual test fixture members go here too. }; TEST_F(BaseTest, HasFoo) { // This is an ordinary non-parameterized test. } TEST_P(DerivedTest, DoesBlah) { // GetParam works just the same here as if you inherit from TestWithParam. EXPECT_TRUE(foo.Blah(GetParam())); } #endif // 0 #if !GTEST_OS_SYMBIAN # include #endif // scripts/fuse_gtest.py depends on gtest's own header being #included // *unconditionally*. Therefore these #includes cannot be moved // inside #if GTEST_HAS_PARAM_TEST. // Copyright 2008 Google Inc. // All Rights Reserved. // // 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 Google Inc. 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. // // Author: vladl@google.com (Vlad Losev) // Type and function utilities for implementing parameterized tests. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ #include #include #include // scripts/fuse_gtest.py depends on gtest's own header being #included // *unconditionally*. Therefore these #includes cannot be moved // inside #if GTEST_HAS_PARAM_TEST. // Copyright 2003 Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Authors: Dan Egnor (egnor@google.com) // // A "smart" pointer type with reference tracking. Every pointer to a // particular object is kept on a circular linked list. When the last pointer // to an object is destroyed or reassigned, the object is deleted. // // Used properly, this deletes the object when the last reference goes away. // There are several caveats: // - Like all reference counting schemes, cycles lead to leaks. // - Each smart pointer is actually two pointers (8 bytes instead of 4). // - Every time a pointer is assigned, the entire list of pointers to that // object is traversed. This class is therefore NOT SUITABLE when there // will often be more than two or three pointers to a particular object. // - References are only tracked as long as linked_ptr<> objects are copied. // If a linked_ptr<> is converted to a raw pointer and back, BAD THINGS // will happen (double deletion). // // A good use of this class is storing object references in STL containers. // You can safely put linked_ptr<> in a vector<>. // Other uses may not be as good. // // Note: If you use an incomplete type with linked_ptr<>, the class // *containing* linked_ptr<> must have a constructor and destructor (even // if they do nothing!). // // Bill Gibbons suggested we use something like this. // // Thread Safety: // Unlike other linked_ptr implementations, in this implementation // a linked_ptr object is thread-safe in the sense that: // - it's safe to copy linked_ptr objects concurrently, // - it's safe to copy *from* a linked_ptr and read its underlying // raw pointer (e.g. via get()) concurrently, and // - it's safe to write to two linked_ptrs that point to the same // shared object concurrently. // TODO(wan@google.com): rename this to safe_linked_ptr to avoid // confusion with normal linked_ptr. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ #include #include namespace testing { namespace internal { // Protects copying of all linked_ptr objects. GTEST_API_ GTEST_DECLARE_STATIC_MUTEX_(g_linked_ptr_mutex); // This is used internally by all instances of linked_ptr<>. It needs to be // a non-template class because different types of linked_ptr<> can refer to // the same object (linked_ptr(obj) vs linked_ptr(obj)). // So, it needs to be possible for different types of linked_ptr to participate // in the same circular linked list, so we need a single class type here. // // DO NOT USE THIS CLASS DIRECTLY YOURSELF. Use linked_ptr. class linked_ptr_internal { public: // Create a new circle that includes only this instance. void join_new() { next_ = this; } // Many linked_ptr operations may change p.link_ for some linked_ptr // variable p in the same circle as this object. Therefore we need // to prevent two such operations from occurring concurrently. // // Note that different types of linked_ptr objects can coexist in a // circle (e.g. linked_ptr, linked_ptr, and // linked_ptr). Therefore we must use a single mutex to // protect all linked_ptr objects. This can create serious // contention in production code, but is acceptable in a testing // framework. // Join an existing circle. void join(linked_ptr_internal const* ptr) GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) { MutexLock lock(&g_linked_ptr_mutex); linked_ptr_internal const* p = ptr; while (p->next_ != ptr) p = p->next_; p->next_ = this; next_ = ptr; } // Leave whatever circle we're part of. Returns true if we were the // last member of the circle. Once this is done, you can join() another. bool depart() GTEST_LOCK_EXCLUDED_(g_linked_ptr_mutex) { MutexLock lock(&g_linked_ptr_mutex); if (next_ == this) return true; linked_ptr_internal const* p = next_; while (p->next_ != this) p = p->next_; p->next_ = next_; return false; } private: mutable linked_ptr_internal const* next_; }; template class linked_ptr { public: typedef T element_type; // Take over ownership of a raw pointer. This should happen as soon as // possible after the object is created. explicit linked_ptr(T* ptr = NULL) { capture(ptr); } ~linked_ptr() { depart(); } // Copy an existing linked_ptr<>, adding ourselves to the list of references. template linked_ptr(linked_ptr const& ptr) { copy(&ptr); } linked_ptr(linked_ptr const& ptr) { // NOLINT assert(&ptr != this); copy(&ptr); } // Assignment releases the old value and acquires the new. template linked_ptr& operator=(linked_ptr const& ptr) { depart(); copy(&ptr); return *this; } linked_ptr& operator=(linked_ptr const& ptr) { if (&ptr != this) { depart(); copy(&ptr); } return *this; } // Smart pointer members. void reset(T* ptr = NULL) { depart(); capture(ptr); } T* get() const { return value_; } T* operator->() const { return value_; } T& operator*() const { return *value_; } bool operator==(T* p) const { return value_ == p; } bool operator!=(T* p) const { return value_ != p; } template bool operator==(linked_ptr const& ptr) const { return value_ == ptr.get(); } template bool operator!=(linked_ptr const& ptr) const { return value_ != ptr.get(); } private: template friend class linked_ptr; T* value_; linked_ptr_internal link_; void depart() { if (link_.depart()) delete value_; } void capture(T* ptr) { value_ = ptr; link_.join_new(); } template void copy(linked_ptr const* ptr) { value_ = ptr->get(); if (value_) link_.join(&ptr->link_); else link_.join_new(); } }; template inline bool operator==(T* ptr, const linked_ptr& x) { return ptr == x.get(); } template inline bool operator!=(T* ptr, const linked_ptr& x) { return ptr != x.get(); } // A function to convert T* into linked_ptr // Doing e.g. make_linked_ptr(new FooBarBaz(arg)) is a shorter notation // for linked_ptr >(new FooBarBaz(arg)) template linked_ptr make_linked_ptr(T* ptr) { return linked_ptr(ptr); } } // namespace internal } // namespace testing #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_LINKED_PTR_H_ // Copyright 2007, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // Google Test - The Google C++ Testing Framework // // This file implements a universal value printer that can print a // value of any type T: // // void ::testing::internal::UniversalPrinter::Print(value, ostream_ptr); // // A user can teach this function how to print a class type T by // defining either operator<<() or PrintTo() in the namespace that // defines T. More specifically, the FIRST defined function in the // following list will be used (assuming T is defined in namespace // foo): // // 1. foo::PrintTo(const T&, ostream*) // 2. operator<<(ostream&, const T&) defined in either foo or the // global namespace. // // If none of the above is defined, it will print the debug string of // the value if it is a protocol buffer, or print the raw bytes in the // value otherwise. // // To aid debugging: when T is a reference type, the address of the // value is also printed; when T is a (const) char pointer, both the // pointer value and the NUL-terminated string it points to are // printed. // // We also provide some convenient wrappers: // // // Prints a value to a string. For a (const or not) char // // pointer, the NUL-terminated string (but not the pointer) is // // printed. // std::string ::testing::PrintToString(const T& value); // // // Prints a value tersely: for a reference type, the referenced // // value (but not the address) is printed; for a (const or not) char // // pointer, the NUL-terminated string (but not the pointer) is // // printed. // void ::testing::internal::UniversalTersePrint(const T& value, ostream*); // // // Prints value using the type inferred by the compiler. The difference // // from UniversalTersePrint() is that this function prints both the // // pointer and the NUL-terminated string for a (const or not) char pointer. // void ::testing::internal::UniversalPrint(const T& value, ostream*); // // // Prints the fields of a tuple tersely to a string vector, one // // element for each field. Tuple support must be enabled in // // gtest-port.h. // std::vector UniversalTersePrintTupleFieldsToStrings( // const Tuple& value); // // Known limitation: // // The print primitives print the elements of an STL-style container // using the compiler-inferred type of *iter where iter is a // const_iterator of the container. When const_iterator is an input // iterator but not a forward iterator, this inferred type may not // match value_type, and the print output may be incorrect. In // practice, this is rarely a problem as for most containers // const_iterator is a forward iterator. We'll fix this if there's an // actual need for it. Note that this fix cannot rely on value_type // being defined as many user-defined container types don't have // value_type. #ifndef GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ #define GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ #include // NOLINT #include #include #include #include namespace testing { // Definitions in the 'internal' and 'internal2' name spaces are // subject to change without notice. DO NOT USE THEM IN USER CODE! namespace internal2 { // Prints the given number of bytes in the given object to the given // ostream. GTEST_API_ void PrintBytesInObjectTo(const unsigned char* obj_bytes, size_t count, ::std::ostream* os); // For selecting which printer to use when a given type has neither << // nor PrintTo(). enum TypeKind { kProtobuf, // a protobuf type kConvertibleToInteger, // a type implicitly convertible to BiggestInt // (e.g. a named or unnamed enum type) kOtherType // anything else }; // TypeWithoutFormatter::PrintValue(value, os) is called // by the universal printer to print a value of type T when neither // operator<< nor PrintTo() is defined for T, where kTypeKind is the // "kind" of T as defined by enum TypeKind. template class TypeWithoutFormatter { public: // This default version is called when kTypeKind is kOtherType. static void PrintValue(const T& value, ::std::ostream* os) { PrintBytesInObjectTo(reinterpret_cast(&value), sizeof(value), os); } }; // We print a protobuf using its ShortDebugString() when the string // doesn't exceed this many characters; otherwise we print it using // DebugString() for better readability. const size_t kProtobufOneLinerMaxLength = 50; template class TypeWithoutFormatter { public: static void PrintValue(const T& value, ::std::ostream* os) { const ::testing::internal::string short_str = value.ShortDebugString(); const ::testing::internal::string pretty_str = short_str.length() <= kProtobufOneLinerMaxLength ? short_str : ("\n" + value.DebugString()); *os << ("<" + pretty_str + ">"); } }; template class TypeWithoutFormatter { public: // Since T has no << operator or PrintTo() but can be implicitly // converted to BiggestInt, we print it as a BiggestInt. // // Most likely T is an enum type (either named or unnamed), in which // case printing it as an integer is the desired behavior. In case // T is not an enum, printing it as an integer is the best we can do // given that it has no user-defined printer. static void PrintValue(const T& value, ::std::ostream* os) { const internal::BiggestInt kBigInt = value; *os << kBigInt; } }; // Prints the given value to the given ostream. If the value is a // protocol message, its debug string is printed; if it's an enum or // of a type implicitly convertible to BiggestInt, it's printed as an // integer; otherwise the bytes in the value are printed. This is // what UniversalPrinter::Print() does when it knows nothing about // type T and T has neither << operator nor PrintTo(). // // A user can override this behavior for a class type Foo by defining // a << operator in the namespace where Foo is defined. // // We put this operator in namespace 'internal2' instead of 'internal' // to simplify the implementation, as much code in 'internal' needs to // use << in STL, which would conflict with our own << were it defined // in 'internal'. // // Note that this operator<< takes a generic std::basic_ostream type instead of the more restricted std::ostream. If // we define it to take an std::ostream instead, we'll get an // "ambiguous overloads" compiler error when trying to print a type // Foo that supports streaming to std::basic_ostream, as the compiler cannot tell whether // operator<<(std::ostream&, const T&) or // operator<<(std::basic_stream, const Foo&) is more // specific. template ::std::basic_ostream& operator<<( ::std::basic_ostream& os, const T& x) { TypeWithoutFormatter::value ? kProtobuf : internal::ImplicitlyConvertible::value ? kConvertibleToInteger : kOtherType)>::PrintValue(x, &os); return os; } } // namespace internal2 } // namespace testing // This namespace MUST NOT BE NESTED IN ::testing, or the name look-up // magic needed for implementing UniversalPrinter won't work. namespace testing_internal { // Used to print a value that is not an STL-style container when the // user doesn't define PrintTo() for it. template void DefaultPrintNonContainerTo(const T& value, ::std::ostream* os) { // With the following statement, during unqualified name lookup, // testing::internal2::operator<< appears as if it was declared in // the nearest enclosing namespace that contains both // ::testing_internal and ::testing::internal2, i.e. the global // namespace. For more details, refer to the C++ Standard section // 7.3.4-1 [namespace.udir]. This allows us to fall back onto // testing::internal2::operator<< in case T doesn't come with a << // operator. // // We cannot write 'using ::testing::internal2::operator<<;', which // gcc 3.3 fails to compile due to a compiler bug. using namespace ::testing::internal2; // NOLINT // Assuming T is defined in namespace foo, in the next statement, // the compiler will consider all of: // // 1. foo::operator<< (thanks to Koenig look-up), // 2. ::operator<< (as the current namespace is enclosed in ::), // 3. testing::internal2::operator<< (thanks to the using statement above). // // The operator<< whose type matches T best will be picked. // // We deliberately allow #2 to be a candidate, as sometimes it's // impossible to define #1 (e.g. when foo is ::std, defining // anything in it is undefined behavior unless you are a compiler // vendor.). *os << value; } } // namespace testing_internal namespace testing { namespace internal { // UniversalPrinter::Print(value, ostream_ptr) prints the given // value to the given ostream. The caller must ensure that // 'ostream_ptr' is not NULL, or the behavior is undefined. // // We define UniversalPrinter as a class template (as opposed to a // function template), as we need to partially specialize it for // reference types, which cannot be done with function templates. template class UniversalPrinter; template void UniversalPrint(const T& value, ::std::ostream* os); // Used to print an STL-style container when the user doesn't define // a PrintTo() for it. template void DefaultPrintTo(IsContainer /* dummy */, false_type /* is not a pointer */, const C& container, ::std::ostream* os) { const size_t kMaxCount = 32; // The maximum number of elements to print. *os << '{'; size_t count = 0; for (typename C::const_iterator it = container.begin(); it != container.end(); ++it, ++count) { if (count > 0) { *os << ','; if (count == kMaxCount) { // Enough has been printed. *os << " ..."; break; } } *os << ' '; // We cannot call PrintTo(*it, os) here as PrintTo() doesn't // handle *it being a native array. internal::UniversalPrint(*it, os); } if (count > 0) { *os << ' '; } *os << '}'; } // Used to print a pointer that is neither a char pointer nor a member // pointer, when the user doesn't define PrintTo() for it. (A member // variable pointer or member function pointer doesn't really point to // a location in the address space. Their representation is // implementation-defined. Therefore they will be printed as raw // bytes.) template void DefaultPrintTo(IsNotContainer /* dummy */, true_type /* is a pointer */, T* p, ::std::ostream* os) { if (p == NULL) { *os << "NULL"; } else { // C++ doesn't allow casting from a function pointer to any object // pointer. // // IsTrue() silences warnings: "Condition is always true", // "unreachable code". if (IsTrue(ImplicitlyConvertible::value)) { // T is not a function type. We just call << to print p, // relying on ADL to pick up user-defined << for their pointer // types, if any. *os << p; } else { // T is a function type, so '*os << p' doesn't do what we want // (it just prints p as bool). We want to print p as a const // void*. However, we cannot cast it to const void* directly, // even using reinterpret_cast, as earlier versions of gcc // (e.g. 3.4.5) cannot compile the cast when p is a function // pointer. Casting to UInt64 first solves the problem. *os << reinterpret_cast( reinterpret_cast(p)); } } } // Used to print a non-container, non-pointer value when the user // doesn't define PrintTo() for it. template void DefaultPrintTo(IsNotContainer /* dummy */, false_type /* is not a pointer */, const T& value, ::std::ostream* os) { ::testing_internal::DefaultPrintNonContainerTo(value, os); } // Prints the given value using the << operator if it has one; // otherwise prints the bytes in it. This is what // UniversalPrinter::Print() does when PrintTo() is not specialized // or overloaded for type T. // // A user can override this behavior for a class type Foo by defining // an overload of PrintTo() in the namespace where Foo is defined. We // give the user this option as sometimes defining a << operator for // Foo is not desirable (e.g. the coding style may prevent doing it, // or there is already a << operator but it doesn't do what the user // wants). template void PrintTo(const T& value, ::std::ostream* os) { // DefaultPrintTo() is overloaded. The type of its first two // arguments determine which version will be picked. If T is an // STL-style container, the version for container will be called; if // T is a pointer, the pointer version will be called; otherwise the // generic version will be called. // // Note that we check for container types here, prior to we check // for protocol message types in our operator<<. The rationale is: // // For protocol messages, we want to give people a chance to // override Google Mock's format by defining a PrintTo() or // operator<<. For STL containers, other formats can be // incompatible with Google Mock's format for the container // elements; therefore we check for container types here to ensure // that our format is used. // // The second argument of DefaultPrintTo() is needed to bypass a bug // in Symbian's C++ compiler that prevents it from picking the right // overload between: // // PrintTo(const T& x, ...); // PrintTo(T* x, ...); DefaultPrintTo(IsContainerTest(0), is_pointer(), value, os); } // The following list of PrintTo() overloads tells // UniversalPrinter::Print() how to print standard types (built-in // types, strings, plain arrays, and pointers). // Overloads for various char types. GTEST_API_ void PrintTo(unsigned char c, ::std::ostream* os); GTEST_API_ void PrintTo(signed char c, ::std::ostream* os); inline void PrintTo(char c, ::std::ostream* os) { // When printing a plain char, we always treat it as unsigned. This // way, the output won't be affected by whether the compiler thinks // char is signed or not. PrintTo(static_cast(c), os); } // Overloads for other simple built-in types. inline void PrintTo(bool x, ::std::ostream* os) { *os << (x ? "true" : "false"); } // Overload for wchar_t type. // Prints a wchar_t as a symbol if it is printable or as its internal // code otherwise and also as its decimal code (except for L'\0'). // The L'\0' char is printed as "L'\\0'". The decimal code is printed // as signed integer when wchar_t is implemented by the compiler // as a signed type and is printed as an unsigned integer when wchar_t // is implemented as an unsigned type. GTEST_API_ void PrintTo(wchar_t wc, ::std::ostream* os); // Overloads for C strings. GTEST_API_ void PrintTo(const char* s, ::std::ostream* os); inline void PrintTo(char* s, ::std::ostream* os) { PrintTo(ImplicitCast_(s), os); } // signed/unsigned char is often used for representing binary data, so // we print pointers to it as void* to be safe. inline void PrintTo(const signed char* s, ::std::ostream* os) { PrintTo(ImplicitCast_(s), os); } inline void PrintTo(signed char* s, ::std::ostream* os) { PrintTo(ImplicitCast_(s), os); } inline void PrintTo(const unsigned char* s, ::std::ostream* os) { PrintTo(ImplicitCast_(s), os); } inline void PrintTo(unsigned char* s, ::std::ostream* os) { PrintTo(ImplicitCast_(s), os); } // MSVC can be configured to define wchar_t as a typedef of unsigned // short. It defines _NATIVE_WCHAR_T_DEFINED when wchar_t is a native // type. When wchar_t is a typedef, defining an overload for const // wchar_t* would cause unsigned short* be printed as a wide string, // possibly causing invalid memory accesses. #if !defined(_MSC_VER) || defined(_NATIVE_WCHAR_T_DEFINED) // Overloads for wide C strings GTEST_API_ void PrintTo(const wchar_t* s, ::std::ostream* os); inline void PrintTo(wchar_t* s, ::std::ostream* os) { PrintTo(ImplicitCast_(s), os); } #endif // Overload for C arrays. Multi-dimensional arrays are printed // properly. // Prints the given number of elements in an array, without printing // the curly braces. template void PrintRawArrayTo(const T a[], size_t count, ::std::ostream* os) { UniversalPrint(a[0], os); for (size_t i = 1; i != count; i++) { *os << ", "; UniversalPrint(a[i], os); } } // Overloads for ::string and ::std::string. #if GTEST_HAS_GLOBAL_STRING GTEST_API_ void PrintStringTo(const ::string&s, ::std::ostream* os); inline void PrintTo(const ::string& s, ::std::ostream* os) { PrintStringTo(s, os); } #endif // GTEST_HAS_GLOBAL_STRING GTEST_API_ void PrintStringTo(const ::std::string&s, ::std::ostream* os); inline void PrintTo(const ::std::string& s, ::std::ostream* os) { PrintStringTo(s, os); } // Overloads for ::wstring and ::std::wstring. #if GTEST_HAS_GLOBAL_WSTRING GTEST_API_ void PrintWideStringTo(const ::wstring&s, ::std::ostream* os); inline void PrintTo(const ::wstring& s, ::std::ostream* os) { PrintWideStringTo(s, os); } #endif // GTEST_HAS_GLOBAL_WSTRING #if GTEST_HAS_STD_WSTRING GTEST_API_ void PrintWideStringTo(const ::std::wstring&s, ::std::ostream* os); inline void PrintTo(const ::std::wstring& s, ::std::ostream* os) { PrintWideStringTo(s, os); } #endif // GTEST_HAS_STD_WSTRING #if GTEST_HAS_TR1_TUPLE // Overload for ::std::tr1::tuple. Needed for printing function arguments, // which are packed as tuples. // Helper function for printing a tuple. T must be instantiated with // a tuple type. template void PrintTupleTo(const T& t, ::std::ostream* os); // Overloaded PrintTo() for tuples of various arities. We support // tuples of up-to 10 fields. The following implementation works // regardless of whether tr1::tuple is implemented using the // non-standard variadic template feature or not. inline void PrintTo(const ::std::tr1::tuple<>& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo(const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } template void PrintTo( const ::std::tr1::tuple& t, ::std::ostream* os) { PrintTupleTo(t, os); } #endif // GTEST_HAS_TR1_TUPLE // Overload for std::pair. template void PrintTo(const ::std::pair& value, ::std::ostream* os) { *os << '('; // We cannot use UniversalPrint(value.first, os) here, as T1 may be // a reference type. The same for printing value.second. UniversalPrinter::Print(value.first, os); *os << ", "; UniversalPrinter::Print(value.second, os); *os << ')'; } // Implements printing a non-reference type T by letting the compiler // pick the right overload of PrintTo() for T. template class UniversalPrinter { public: // MSVC warns about adding const to a function type, so we want to // disable the warning. #ifdef _MSC_VER # pragma warning(push) // Saves the current warning state. # pragma warning(disable:4180) // Temporarily disables warning 4180. #endif // _MSC_VER // Note: we deliberately don't call this PrintTo(), as that name // conflicts with ::testing::internal::PrintTo in the body of the // function. static void Print(const T& value, ::std::ostream* os) { // By default, ::testing::internal::PrintTo() is used for printing // the value. // // Thanks to Koenig look-up, if T is a class and has its own // PrintTo() function defined in its namespace, that function will // be visible here. Since it is more specific than the generic ones // in ::testing::internal, it will be picked by the compiler in the // following statement - exactly what we want. PrintTo(value, os); } #ifdef _MSC_VER # pragma warning(pop) // Restores the warning state. #endif // _MSC_VER }; // UniversalPrintArray(begin, len, os) prints an array of 'len' // elements, starting at address 'begin'. template void UniversalPrintArray(const T* begin, size_t len, ::std::ostream* os) { if (len == 0) { *os << "{}"; } else { *os << "{ "; const size_t kThreshold = 18; const size_t kChunkSize = 8; // If the array has more than kThreshold elements, we'll have to // omit some details by printing only the first and the last // kChunkSize elements. // TODO(wan@google.com): let the user control the threshold using a flag. if (len <= kThreshold) { PrintRawArrayTo(begin, len, os); } else { PrintRawArrayTo(begin, kChunkSize, os); *os << ", ..., "; PrintRawArrayTo(begin + len - kChunkSize, kChunkSize, os); } *os << " }"; } } // This overload prints a (const) char array compactly. GTEST_API_ void UniversalPrintArray( const char* begin, size_t len, ::std::ostream* os); // This overload prints a (const) wchar_t array compactly. GTEST_API_ void UniversalPrintArray( const wchar_t* begin, size_t len, ::std::ostream* os); // Implements printing an array type T[N]. template class UniversalPrinter { public: // Prints the given array, omitting some elements when there are too // many. static void Print(const T (&a)[N], ::std::ostream* os) { UniversalPrintArray(a, N, os); } }; // Implements printing a reference type T&. template class UniversalPrinter { public: // MSVC warns about adding const to a function type, so we want to // disable the warning. #ifdef _MSC_VER # pragma warning(push) // Saves the current warning state. # pragma warning(disable:4180) // Temporarily disables warning 4180. #endif // _MSC_VER static void Print(const T& value, ::std::ostream* os) { // Prints the address of the value. We use reinterpret_cast here // as static_cast doesn't compile when T is a function type. *os << "@" << reinterpret_cast(&value) << " "; // Then prints the value itself. UniversalPrint(value, os); } #ifdef _MSC_VER # pragma warning(pop) // Restores the warning state. #endif // _MSC_VER }; // Prints a value tersely: for a reference type, the referenced value // (but not the address) is printed; for a (const) char pointer, the // NUL-terminated string (but not the pointer) is printed. template class UniversalTersePrinter { public: static void Print(const T& value, ::std::ostream* os) { UniversalPrint(value, os); } }; template class UniversalTersePrinter { public: static void Print(const T& value, ::std::ostream* os) { UniversalPrint(value, os); } }; template class UniversalTersePrinter { public: static void Print(const T (&value)[N], ::std::ostream* os) { UniversalPrinter::Print(value, os); } }; template <> class UniversalTersePrinter { public: static void Print(const char* str, ::std::ostream* os) { if (str == NULL) { *os << "NULL"; } else { UniversalPrint(string(str), os); } } }; template <> class UniversalTersePrinter { public: static void Print(char* str, ::std::ostream* os) { UniversalTersePrinter::Print(str, os); } }; #if GTEST_HAS_STD_WSTRING template <> class UniversalTersePrinter { public: static void Print(const wchar_t* str, ::std::ostream* os) { if (str == NULL) { *os << "NULL"; } else { UniversalPrint(::std::wstring(str), os); } } }; #endif template <> class UniversalTersePrinter { public: static void Print(wchar_t* str, ::std::ostream* os) { UniversalTersePrinter::Print(str, os); } }; template void UniversalTersePrint(const T& value, ::std::ostream* os) { UniversalTersePrinter::Print(value, os); } // Prints a value using the type inferred by the compiler. The // difference between this and UniversalTersePrint() is that for a // (const) char pointer, this prints both the pointer and the // NUL-terminated string. template void UniversalPrint(const T& value, ::std::ostream* os) { // A workarond for the bug in VC++ 7.1 that prevents us from instantiating // UniversalPrinter with T directly. typedef T T1; UniversalPrinter::Print(value, os); } #if GTEST_HAS_TR1_TUPLE typedef ::std::vector Strings; // This helper template allows PrintTo() for tuples and // UniversalTersePrintTupleFieldsToStrings() to be defined by // induction on the number of tuple fields. The idea is that // TuplePrefixPrinter::PrintPrefixTo(t, os) prints the first N // fields in tuple t, and can be defined in terms of // TuplePrefixPrinter. // The inductive case. template struct TuplePrefixPrinter { // Prints the first N fields of a tuple. template static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { TuplePrefixPrinter::PrintPrefixTo(t, os); *os << ", "; UniversalPrinter::type> ::Print(::std::tr1::get(t), os); } // Tersely prints the first N fields of a tuple to a string vector, // one element for each field. template static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { TuplePrefixPrinter::TersePrintPrefixToStrings(t, strings); ::std::stringstream ss; UniversalTersePrint(::std::tr1::get(t), &ss); strings->push_back(ss.str()); } }; // Base cases. template <> struct TuplePrefixPrinter<0> { template static void PrintPrefixTo(const Tuple&, ::std::ostream*) {} template static void TersePrintPrefixToStrings(const Tuple&, Strings*) {} }; // We have to specialize the entire TuplePrefixPrinter<> class // template here, even though the definition of // TersePrintPrefixToStrings() is the same as the generic version, as // Embarcadero (formerly CodeGear, formerly Borland) C++ doesn't // support specializing a method template of a class template. template <> struct TuplePrefixPrinter<1> { template static void PrintPrefixTo(const Tuple& t, ::std::ostream* os) { UniversalPrinter::type>:: Print(::std::tr1::get<0>(t), os); } template static void TersePrintPrefixToStrings(const Tuple& t, Strings* strings) { ::std::stringstream ss; UniversalTersePrint(::std::tr1::get<0>(t), &ss); strings->push_back(ss.str()); } }; // Helper function for printing a tuple. T must be instantiated with // a tuple type. template void PrintTupleTo(const T& t, ::std::ostream* os) { *os << "("; TuplePrefixPrinter< ::std::tr1::tuple_size::value>:: PrintPrefixTo(t, os); *os << ")"; } // Prints the fields of a tuple tersely to a string vector, one // element for each field. See the comment before // UniversalTersePrint() for how we define "tersely". template Strings UniversalTersePrintTupleFieldsToStrings(const Tuple& value) { Strings result; TuplePrefixPrinter< ::std::tr1::tuple_size::value>:: TersePrintPrefixToStrings(value, &result); return result; } #endif // GTEST_HAS_TR1_TUPLE } // namespace internal template ::std::string PrintToString(const T& value) { ::std::stringstream ss; internal::UniversalTersePrinter::Print(value, &ss); return ss.str(); } } // namespace testing #endif // GTEST_INCLUDE_GTEST_GTEST_PRINTERS_H_ #if GTEST_HAS_PARAM_TEST namespace testing { namespace internal { // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Outputs a message explaining invalid registration of different // fixture class for the same test case. This may happen when // TEST_P macro is used to define two tests with the same name // but in different namespaces. GTEST_API_ void ReportInvalidTestCaseType(const char* test_case_name, const char* file, int line); template class ParamGeneratorInterface; template class ParamGenerator; // Interface for iterating over elements provided by an implementation // of ParamGeneratorInterface. template class ParamIteratorInterface { public: virtual ~ParamIteratorInterface() {} // A pointer to the base generator instance. // Used only for the purposes of iterator comparison // to make sure that two iterators belong to the same generator. virtual const ParamGeneratorInterface* BaseGenerator() const = 0; // Advances iterator to point to the next element // provided by the generator. The caller is responsible // for not calling Advance() on an iterator equal to // BaseGenerator()->End(). virtual void Advance() = 0; // Clones the iterator object. Used for implementing copy semantics // of ParamIterator. virtual ParamIteratorInterface* Clone() const = 0; // Dereferences the current iterator and provides (read-only) access // to the pointed value. It is the caller's responsibility not to call // Current() on an iterator equal to BaseGenerator()->End(). // Used for implementing ParamGenerator::operator*(). virtual const T* Current() const = 0; // Determines whether the given iterator and other point to the same // element in the sequence generated by the generator. // Used for implementing ParamGenerator::operator==(). virtual bool Equals(const ParamIteratorInterface& other) const = 0; }; // Class iterating over elements provided by an implementation of // ParamGeneratorInterface. It wraps ParamIteratorInterface // and implements the const forward iterator concept. template class ParamIterator { public: typedef T value_type; typedef const T& reference; typedef ptrdiff_t difference_type; // ParamIterator assumes ownership of the impl_ pointer. ParamIterator(const ParamIterator& other) : impl_(other.impl_->Clone()) {} ParamIterator& operator=(const ParamIterator& other) { if (this != &other) impl_.reset(other.impl_->Clone()); return *this; } const T& operator*() const { return *impl_->Current(); } const T* operator->() const { return impl_->Current(); } // Prefix version of operator++. ParamIterator& operator++() { impl_->Advance(); return *this; } // Postfix version of operator++. ParamIterator operator++(int /*unused*/) { ParamIteratorInterface* clone = impl_->Clone(); impl_->Advance(); return ParamIterator(clone); } bool operator==(const ParamIterator& other) const { return impl_.get() == other.impl_.get() || impl_->Equals(*other.impl_); } bool operator!=(const ParamIterator& other) const { return !(*this == other); } private: friend class ParamGenerator; explicit ParamIterator(ParamIteratorInterface* impl) : impl_(impl) {} scoped_ptr > impl_; }; // ParamGeneratorInterface is the binary interface to access generators // defined in other translation units. template class ParamGeneratorInterface { public: typedef T ParamType; virtual ~ParamGeneratorInterface() {} // Generator interface definition virtual ParamIteratorInterface* Begin() const = 0; virtual ParamIteratorInterface* End() const = 0; }; // Wraps ParamGeneratorInterface and provides general generator syntax // compatible with the STL Container concept. // This class implements copy initialization semantics and the contained // ParamGeneratorInterface instance is shared among all copies // of the original object. This is possible because that instance is immutable. template class ParamGenerator { public: typedef ParamIterator iterator; explicit ParamGenerator(ParamGeneratorInterface* impl) : impl_(impl) {} ParamGenerator(const ParamGenerator& other) : impl_(other.impl_) {} ParamGenerator& operator=(const ParamGenerator& other) { impl_ = other.impl_; return *this; } iterator begin() const { return iterator(impl_->Begin()); } iterator end() const { return iterator(impl_->End()); } private: linked_ptr > impl_; }; // Generates values from a range of two comparable values. Can be used to // generate sequences of user-defined types that implement operator+() and // operator<(). // This class is used in the Range() function. template class RangeGenerator : public ParamGeneratorInterface { public: RangeGenerator(T begin, T end, IncrementT step) : begin_(begin), end_(end), step_(step), end_index_(CalculateEndIndex(begin, end, step)) {} virtual ~RangeGenerator() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, begin_, 0, step_); } virtual ParamIteratorInterface* End() const { return new Iterator(this, end_, end_index_, step_); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, T value, int index, IncrementT step) : base_(base), value_(value), index_(index), step_(step) {} virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } virtual void Advance() { value_ = value_ + step_; index_++; } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const T* Current() const { return &value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const int other_index = CheckedDowncastToActualType(&other)->index_; return index_ == other_index; } private: Iterator(const Iterator& other) : ParamIteratorInterface(), base_(other.base_), value_(other.value_), index_(other.index_), step_(other.step_) {} // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; T value_; int index_; const IncrementT step_; }; // class RangeGenerator::Iterator static int CalculateEndIndex(const T& begin, const T& end, const IncrementT& step) { int end_index = 0; for (T i = begin; i < end; i = i + step) end_index++; return end_index; } // No implementation - assignment is unsupported. void operator=(const RangeGenerator& other); const T begin_; const T end_; const IncrementT step_; // The index for the end() iterator. All the elements in the generated // sequence are indexed (0-based) to aid iterator comparison. const int end_index_; }; // class RangeGenerator // Generates values from a pair of STL-style iterators. Used in the // ValuesIn() function. The elements are copied from the source range // since the source can be located on the stack, and the generator // is likely to persist beyond that stack frame. template class ValuesInIteratorRangeGenerator : public ParamGeneratorInterface { public: template ValuesInIteratorRangeGenerator(ForwardIterator begin, ForwardIterator end) : container_(begin, end) {} virtual ~ValuesInIteratorRangeGenerator() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, container_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, container_.end()); } private: typedef typename ::std::vector ContainerType; class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, typename ContainerType::const_iterator iterator) : base_(base), iterator_(iterator) {} virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } virtual void Advance() { ++iterator_; value_.reset(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } // We need to use cached value referenced by iterator_ because *iterator_ // can return a temporary object (and of type other then T), so just // having "return &*iterator_;" doesn't work. // value_ is updated here and not in Advance() because Advance() // can advance iterator_ beyond the end of the range, and we cannot // detect that fact. The client code, on the other hand, is // responsible for not calling Current() on an out-of-range iterator. virtual const T* Current() const { if (value_.get() == NULL) value_.reset(new T(*iterator_)); return value_.get(); } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; return iterator_ == CheckedDowncastToActualType(&other)->iterator_; } private: Iterator(const Iterator& other) // The explicit constructor call suppresses a false warning // emitted by gcc when supplied with the -Wextra option. : ParamIteratorInterface(), base_(other.base_), iterator_(other.iterator_) {} const ParamGeneratorInterface* const base_; typename ContainerType::const_iterator iterator_; // A cached value of *iterator_. We keep it here to allow access by // pointer in the wrapping iterator's operator->(). // value_ needs to be mutable to be accessed in Current(). // Use of scoped_ptr helps manage cached value's lifetime, // which is bound by the lifespan of the iterator itself. mutable scoped_ptr value_; }; // class ValuesInIteratorRangeGenerator::Iterator // No implementation - assignment is unsupported. void operator=(const ValuesInIteratorRangeGenerator& other); const ContainerType container_; }; // class ValuesInIteratorRangeGenerator // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Stores a parameter value and later creates tests parameterized with that // value. template class ParameterizedTestFactory : public TestFactoryBase { public: typedef typename TestClass::ParamType ParamType; explicit ParameterizedTestFactory(ParamType parameter) : parameter_(parameter) {} virtual Test* CreateTest() { TestClass::SetParam(¶meter_); return new TestClass(); } private: const ParamType parameter_; GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestFactory); }; // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // TestMetaFactoryBase is a base class for meta-factories that create // test factories for passing into MakeAndRegisterTestInfo function. template class TestMetaFactoryBase { public: virtual ~TestMetaFactoryBase() {} virtual TestFactoryBase* CreateTestFactory(ParamType parameter) = 0; }; // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // TestMetaFactory creates test factories for passing into // MakeAndRegisterTestInfo function. Since MakeAndRegisterTestInfo receives // ownership of test factory pointer, same factory object cannot be passed // into that method twice. But ParameterizedTestCaseInfo is going to call // it for each Test/Parameter value combination. Thus it needs meta factory // creator class. template class TestMetaFactory : public TestMetaFactoryBase { public: typedef typename TestCase::ParamType ParamType; TestMetaFactory() {} virtual TestFactoryBase* CreateTestFactory(ParamType parameter) { return new ParameterizedTestFactory(parameter); } private: GTEST_DISALLOW_COPY_AND_ASSIGN_(TestMetaFactory); }; // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // ParameterizedTestCaseInfoBase is a generic interface // to ParameterizedTestCaseInfo classes. ParameterizedTestCaseInfoBase // accumulates test information provided by TEST_P macro invocations // and generators provided by INSTANTIATE_TEST_CASE_P macro invocations // and uses that information to register all resulting test instances // in RegisterTests method. The ParameterizeTestCaseRegistry class holds // a collection of pointers to the ParameterizedTestCaseInfo objects // and calls RegisterTests() on each of them when asked. class ParameterizedTestCaseInfoBase { public: virtual ~ParameterizedTestCaseInfoBase() {} // Base part of test case name for display purposes. virtual const string& GetTestCaseName() const = 0; // Test case id to verify identity. virtual TypeId GetTestCaseTypeId() const = 0; // UnitTest class invokes this method to register tests in this // test case right before running them in RUN_ALL_TESTS macro. // This method should not be called more then once on any single // instance of a ParameterizedTestCaseInfoBase derived class. virtual void RegisterTests() = 0; protected: ParameterizedTestCaseInfoBase() {} private: GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfoBase); }; // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // ParameterizedTestCaseInfo accumulates tests obtained from TEST_P // macro invocations for a particular test case and generators // obtained from INSTANTIATE_TEST_CASE_P macro invocations for that // test case. It registers tests with all values generated by all // generators when asked. template class ParameterizedTestCaseInfo : public ParameterizedTestCaseInfoBase { public: // ParamType and GeneratorCreationFunc are private types but are required // for declarations of public methods AddTestPattern() and // AddTestCaseInstantiation(). typedef typename TestCase::ParamType ParamType; // A function that returns an instance of appropriate generator type. typedef ParamGenerator(GeneratorCreationFunc)(); explicit ParameterizedTestCaseInfo(const char* name) : test_case_name_(name) {} // Test case base name for display purposes. virtual const string& GetTestCaseName() const { return test_case_name_; } // Test case id to verify identity. virtual TypeId GetTestCaseTypeId() const { return GetTypeId(); } // TEST_P macro uses AddTestPattern() to record information // about a single test in a LocalTestInfo structure. // test_case_name is the base name of the test case (without invocation // prefix). test_base_name is the name of an individual test without // parameter index. For the test SequenceA/FooTest.DoBar/1 FooTest is // test case base name and DoBar is test base name. void AddTestPattern(const char* test_case_name, const char* test_base_name, TestMetaFactoryBase* meta_factory) { tests_.push_back(linked_ptr(new TestInfo(test_case_name, test_base_name, meta_factory))); } // INSTANTIATE_TEST_CASE_P macro uses AddGenerator() to record information // about a generator. int AddTestCaseInstantiation(const string& instantiation_name, GeneratorCreationFunc* func, const char* /* file */, int /* line */) { instantiations_.push_back(::std::make_pair(instantiation_name, func)); return 0; // Return value used only to run this method in namespace scope. } // UnitTest class invokes this method to register tests in this test case // test cases right before running tests in RUN_ALL_TESTS macro. // This method should not be called more then once on any single // instance of a ParameterizedTestCaseInfoBase derived class. // UnitTest has a guard to prevent from calling this method more then once. virtual void RegisterTests() { for (typename TestInfoContainer::iterator test_it = tests_.begin(); test_it != tests_.end(); ++test_it) { linked_ptr test_info = *test_it; for (typename InstantiationContainer::iterator gen_it = instantiations_.begin(); gen_it != instantiations_.end(); ++gen_it) { const string& instantiation_name = gen_it->first; ParamGenerator generator((*gen_it->second)()); string test_case_name; if ( !instantiation_name.empty() ) test_case_name = instantiation_name + "/"; test_case_name += test_info->test_case_base_name; int i = 0; for (typename ParamGenerator::iterator param_it = generator.begin(); param_it != generator.end(); ++param_it, ++i) { Message test_name_stream; test_name_stream << test_info->test_base_name << "/" << i; MakeAndRegisterTestInfo( test_case_name.c_str(), test_name_stream.GetString().c_str(), NULL, // No type parameter. PrintToString(*param_it).c_str(), GetTestCaseTypeId(), TestCase::SetUpTestCase, TestCase::TearDownTestCase, test_info->test_meta_factory->CreateTestFactory(*param_it)); } // for param_it } // for gen_it } // for test_it } // RegisterTests private: // LocalTestInfo structure keeps information about a single test registered // with TEST_P macro. struct TestInfo { TestInfo(const char* a_test_case_base_name, const char* a_test_base_name, TestMetaFactoryBase* a_test_meta_factory) : test_case_base_name(a_test_case_base_name), test_base_name(a_test_base_name), test_meta_factory(a_test_meta_factory) {} const string test_case_base_name; const string test_base_name; const scoped_ptr > test_meta_factory; }; typedef ::std::vector > TestInfoContainer; // Keeps pairs of // received from INSTANTIATE_TEST_CASE_P macros. typedef ::std::vector > InstantiationContainer; const string test_case_name_; TestInfoContainer tests_; InstantiationContainer instantiations_; GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseInfo); }; // class ParameterizedTestCaseInfo // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // ParameterizedTestCaseRegistry contains a map of ParameterizedTestCaseInfoBase // classes accessed by test case names. TEST_P and INSTANTIATE_TEST_CASE_P // macros use it to locate their corresponding ParameterizedTestCaseInfo // descriptors. class ParameterizedTestCaseRegistry { public: ParameterizedTestCaseRegistry() {} ~ParameterizedTestCaseRegistry() { for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); it != test_case_infos_.end(); ++it) { delete *it; } } // Looks up or creates and returns a structure containing information about // tests and instantiations of a particular test case. template ParameterizedTestCaseInfo* GetTestCasePatternHolder( const char* test_case_name, const char* file, int line) { ParameterizedTestCaseInfo* typed_test_info = NULL; for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); it != test_case_infos_.end(); ++it) { if ((*it)->GetTestCaseName() == test_case_name) { if ((*it)->GetTestCaseTypeId() != GetTypeId()) { // Complain about incorrect usage of Google Test facilities // and terminate the program since we cannot guaranty correct // test case setup and tear-down in this case. ReportInvalidTestCaseType(test_case_name, file, line); posix::Abort(); } else { // At this point we are sure that the object we found is of the same // type we are looking for, so we downcast it to that type // without further checks. typed_test_info = CheckedDowncastToActualType< ParameterizedTestCaseInfo >(*it); } break; } } if (typed_test_info == NULL) { typed_test_info = new ParameterizedTestCaseInfo(test_case_name); test_case_infos_.push_back(typed_test_info); } return typed_test_info; } void RegisterTests() { for (TestCaseInfoContainer::iterator it = test_case_infos_.begin(); it != test_case_infos_.end(); ++it) { (*it)->RegisterTests(); } } private: typedef ::std::vector TestCaseInfoContainer; TestCaseInfoContainer test_case_infos_; GTEST_DISALLOW_COPY_AND_ASSIGN_(ParameterizedTestCaseRegistry); }; } // namespace internal } // namespace testing #endif // GTEST_HAS_PARAM_TEST #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_H_ // This file was GENERATED by command: // pump.py gtest-param-util-generated.h.pump // DO NOT EDIT BY HAND!!! // Copyright 2008 Google Inc. // All Rights Reserved. // // 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 Google Inc. 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. // // Author: vladl@google.com (Vlad Losev) // Type and function utilities for implementing parameterized tests. // This file is generated by a SCRIPT. DO NOT EDIT BY HAND! // // Currently Google Test supports at most 50 arguments in Values, // and at most 10 arguments in Combine. Please contact // googletestframework@googlegroups.com if you need more. // Please note that the number of arguments to Combine is limited // by the maximum arity of the implementation of tr1::tuple which is // currently set at 10. #ifndef GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ #define GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ // scripts/fuse_gtest.py depends on gtest's own header being #included // *unconditionally*. Therefore these #includes cannot be moved // inside #if GTEST_HAS_PARAM_TEST. #if GTEST_HAS_PARAM_TEST namespace testing { // Forward declarations of ValuesIn(), which is implemented in // include/gtest/gtest-param-test.h. template internal::ParamGenerator< typename ::testing::internal::IteratorTraits::value_type> ValuesIn(ForwardIterator begin, ForwardIterator end); template internal::ParamGenerator ValuesIn(const T (&array)[N]); template internal::ParamGenerator ValuesIn( const Container& container); namespace internal { // Used in the Values() function to provide polymorphic capabilities. template class ValueArray1 { public: explicit ValueArray1(T1 v1) : v1_(v1) {} template operator ParamGenerator() const { return ValuesIn(&v1_, &v1_ + 1); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray1& other); const T1 v1_; }; template class ValueArray2 { public: ValueArray2(T1 v1, T2 v2) : v1_(v1), v2_(v2) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray2& other); const T1 v1_; const T2 v2_; }; template class ValueArray3 { public: ValueArray3(T1 v1, T2 v2, T3 v3) : v1_(v1), v2_(v2), v3_(v3) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray3& other); const T1 v1_; const T2 v2_; const T3 v3_; }; template class ValueArray4 { public: ValueArray4(T1 v1, T2 v2, T3 v3, T4 v4) : v1_(v1), v2_(v2), v3_(v3), v4_(v4) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray4& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; }; template class ValueArray5 { public: ValueArray5(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray5& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; }; template class ValueArray6 { public: ValueArray6(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray6& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; }; template class ValueArray7 { public: ValueArray7(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray7& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; }; template class ValueArray8 { public: ValueArray8(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray8& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; }; template class ValueArray9 { public: ValueArray9(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray9& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; }; template class ValueArray10 { public: ValueArray10(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray10& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; }; template class ValueArray11 { public: ValueArray11(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray11& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; }; template class ValueArray12 { public: ValueArray12(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray12& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; }; template class ValueArray13 { public: ValueArray13(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray13& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; }; template class ValueArray14 { public: ValueArray14(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray14& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; }; template class ValueArray15 { public: ValueArray15(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray15& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; }; template class ValueArray16 { public: ValueArray16(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray16& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; }; template class ValueArray17 { public: ValueArray17(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray17& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; }; template class ValueArray18 { public: ValueArray18(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray18& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; }; template class ValueArray19 { public: ValueArray19(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray19& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; }; template class ValueArray20 { public: ValueArray20(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray20& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; }; template class ValueArray21 { public: ValueArray21(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray21& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; }; template class ValueArray22 { public: ValueArray22(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray22& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; }; template class ValueArray23 { public: ValueArray23(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray23& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; }; template class ValueArray24 { public: ValueArray24(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray24& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; }; template class ValueArray25 { public: ValueArray25(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray25& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; }; template class ValueArray26 { public: ValueArray26(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray26& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; }; template class ValueArray27 { public: ValueArray27(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray27& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; }; template class ValueArray28 { public: ValueArray28(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray28& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; }; template class ValueArray29 { public: ValueArray29(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray29& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; }; template class ValueArray30 { public: ValueArray30(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray30& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; }; template class ValueArray31 { public: ValueArray31(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray31& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; }; template class ValueArray32 { public: ValueArray32(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray32& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; }; template class ValueArray33 { public: ValueArray33(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray33& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; }; template class ValueArray34 { public: ValueArray34(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray34& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; }; template class ValueArray35 { public: ValueArray35(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray35& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; }; template class ValueArray36 { public: ValueArray36(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray36& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; }; template class ValueArray37 { public: ValueArray37(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray37& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; }; template class ValueArray38 { public: ValueArray38(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray38& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; }; template class ValueArray39 { public: ValueArray39(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray39& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; }; template class ValueArray40 { public: ValueArray40(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray40& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; }; template class ValueArray41 { public: ValueArray41(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray41& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; }; template class ValueArray42 { public: ValueArray42(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray42& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; }; template class ValueArray43 { public: ValueArray43(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_), static_cast(v43_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray43& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; const T43 v43_; }; template class ValueArray44 { public: ValueArray44(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_), static_cast(v43_), static_cast(v44_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray44& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; const T43 v43_; const T44 v44_; }; template class ValueArray45 { public: ValueArray45(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_), static_cast(v43_), static_cast(v44_), static_cast(v45_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray45& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; const T43 v43_; const T44 v44_; const T45 v45_; }; template class ValueArray46 { public: ValueArray46(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_), static_cast(v43_), static_cast(v44_), static_cast(v45_), static_cast(v46_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray46& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; const T43 v43_; const T44 v44_; const T45 v45_; const T46 v46_; }; template class ValueArray47 { public: ValueArray47(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46), v47_(v47) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_), static_cast(v43_), static_cast(v44_), static_cast(v45_), static_cast(v46_), static_cast(v47_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray47& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; const T43 v43_; const T44 v44_; const T45 v45_; const T46 v46_; const T47 v47_; }; template class ValueArray48 { public: ValueArray48(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46), v47_(v47), v48_(v48) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_), static_cast(v43_), static_cast(v44_), static_cast(v45_), static_cast(v46_), static_cast(v47_), static_cast(v48_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray48& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; const T43 v43_; const T44 v44_; const T45 v45_; const T46 v46_; const T47 v47_; const T48 v48_; }; template class ValueArray49 { public: ValueArray49(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_), static_cast(v43_), static_cast(v44_), static_cast(v45_), static_cast(v46_), static_cast(v47_), static_cast(v48_), static_cast(v49_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray49& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; const T43 v43_; const T44 v44_; const T45 v45_; const T46 v46_; const T47 v47_; const T48 v48_; const T49 v49_; }; template class ValueArray50 { public: ValueArray50(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) : v1_(v1), v2_(v2), v3_(v3), v4_(v4), v5_(v5), v6_(v6), v7_(v7), v8_(v8), v9_(v9), v10_(v10), v11_(v11), v12_(v12), v13_(v13), v14_(v14), v15_(v15), v16_(v16), v17_(v17), v18_(v18), v19_(v19), v20_(v20), v21_(v21), v22_(v22), v23_(v23), v24_(v24), v25_(v25), v26_(v26), v27_(v27), v28_(v28), v29_(v29), v30_(v30), v31_(v31), v32_(v32), v33_(v33), v34_(v34), v35_(v35), v36_(v36), v37_(v37), v38_(v38), v39_(v39), v40_(v40), v41_(v41), v42_(v42), v43_(v43), v44_(v44), v45_(v45), v46_(v46), v47_(v47), v48_(v48), v49_(v49), v50_(v50) {} template operator ParamGenerator() const { const T array[] = {static_cast(v1_), static_cast(v2_), static_cast(v3_), static_cast(v4_), static_cast(v5_), static_cast(v6_), static_cast(v7_), static_cast(v8_), static_cast(v9_), static_cast(v10_), static_cast(v11_), static_cast(v12_), static_cast(v13_), static_cast(v14_), static_cast(v15_), static_cast(v16_), static_cast(v17_), static_cast(v18_), static_cast(v19_), static_cast(v20_), static_cast(v21_), static_cast(v22_), static_cast(v23_), static_cast(v24_), static_cast(v25_), static_cast(v26_), static_cast(v27_), static_cast(v28_), static_cast(v29_), static_cast(v30_), static_cast(v31_), static_cast(v32_), static_cast(v33_), static_cast(v34_), static_cast(v35_), static_cast(v36_), static_cast(v37_), static_cast(v38_), static_cast(v39_), static_cast(v40_), static_cast(v41_), static_cast(v42_), static_cast(v43_), static_cast(v44_), static_cast(v45_), static_cast(v46_), static_cast(v47_), static_cast(v48_), static_cast(v49_), static_cast(v50_)}; return ValuesIn(array); } private: // No implementation - assignment is unsupported. void operator=(const ValueArray50& other); const T1 v1_; const T2 v2_; const T3 v3_; const T4 v4_; const T5 v5_; const T6 v6_; const T7 v7_; const T8 v8_; const T9 v9_; const T10 v10_; const T11 v11_; const T12 v12_; const T13 v13_; const T14 v14_; const T15 v15_; const T16 v16_; const T17 v17_; const T18 v18_; const T19 v19_; const T20 v20_; const T21 v21_; const T22 v22_; const T23 v23_; const T24 v24_; const T25 v25_; const T26 v26_; const T27 v27_; const T28 v28_; const T29 v29_; const T30 v30_; const T31 v31_; const T32 v32_; const T33 v33_; const T34 v34_; const T35 v35_; const T36 v36_; const T37 v37_; const T38 v38_; const T39 v39_; const T40 v40_; const T41 v41_; const T42 v42_; const T43 v43_; const T44 v44_; const T45 v45_; const T46 v46_; const T47 v47_; const T48 v48_; const T49 v49_; const T50 v50_; }; # if GTEST_HAS_COMBINE // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Generates values from the Cartesian product of values produced // by the argument generators. // template class CartesianProductGenerator2 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator2(const ParamGenerator& g1, const ParamGenerator& g2) : g1_(g1), g2_(g2) {} virtual ~CartesianProductGenerator2() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current2_; if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; ParamType current_value_; }; // class CartesianProductGenerator2::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator2& other); const ParamGenerator g1_; const ParamGenerator g2_; }; // class CartesianProductGenerator2 template class CartesianProductGenerator3 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator3(const ParamGenerator& g1, const ParamGenerator& g2, const ParamGenerator& g3) : g1_(g1), g2_(g2), g3_(g3) {} virtual ~CartesianProductGenerator3() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, g3_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2, const ParamGenerator& g3, const typename ParamGenerator::iterator& current3) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2), begin3_(g3.begin()), end3_(g3.end()), current3_(current3) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current3_; if (current3_ == end3_) { current3_ = begin3_; ++current2_; } if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_ && current3_ == typed_other->current3_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_), begin3_(other.begin3_), end3_(other.end3_), current3_(other.current3_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_, *current3_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_ || current3_ == end3_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; const typename ParamGenerator::iterator begin3_; const typename ParamGenerator::iterator end3_; typename ParamGenerator::iterator current3_; ParamType current_value_; }; // class CartesianProductGenerator3::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator3& other); const ParamGenerator g1_; const ParamGenerator g2_; const ParamGenerator g3_; }; // class CartesianProductGenerator3 template class CartesianProductGenerator4 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator4(const ParamGenerator& g1, const ParamGenerator& g2, const ParamGenerator& g3, const ParamGenerator& g4) : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {} virtual ~CartesianProductGenerator4() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, g3_.begin(), g4_, g4_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), g4_, g4_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2, const ParamGenerator& g3, const typename ParamGenerator::iterator& current3, const ParamGenerator& g4, const typename ParamGenerator::iterator& current4) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2), begin3_(g3.begin()), end3_(g3.end()), current3_(current3), begin4_(g4.begin()), end4_(g4.end()), current4_(current4) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current4_; if (current4_ == end4_) { current4_ = begin4_; ++current3_; } if (current3_ == end3_) { current3_ = begin3_; ++current2_; } if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_ && current3_ == typed_other->current3_ && current4_ == typed_other->current4_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_), begin3_(other.begin3_), end3_(other.end3_), current3_(other.current3_), begin4_(other.begin4_), end4_(other.end4_), current4_(other.current4_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_, *current3_, *current4_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_ || current3_ == end3_ || current4_ == end4_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; const typename ParamGenerator::iterator begin3_; const typename ParamGenerator::iterator end3_; typename ParamGenerator::iterator current3_; const typename ParamGenerator::iterator begin4_; const typename ParamGenerator::iterator end4_; typename ParamGenerator::iterator current4_; ParamType current_value_; }; // class CartesianProductGenerator4::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator4& other); const ParamGenerator g1_; const ParamGenerator g2_; const ParamGenerator g3_; const ParamGenerator g4_; }; // class CartesianProductGenerator4 template class CartesianProductGenerator5 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator5(const ParamGenerator& g1, const ParamGenerator& g2, const ParamGenerator& g3, const ParamGenerator& g4, const ParamGenerator& g5) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {} virtual ~CartesianProductGenerator5() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), g4_, g4_.end(), g5_, g5_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2, const ParamGenerator& g3, const typename ParamGenerator::iterator& current3, const ParamGenerator& g4, const typename ParamGenerator::iterator& current4, const ParamGenerator& g5, const typename ParamGenerator::iterator& current5) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2), begin3_(g3.begin()), end3_(g3.end()), current3_(current3), begin4_(g4.begin()), end4_(g4.end()), current4_(current4), begin5_(g5.begin()), end5_(g5.end()), current5_(current5) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current5_; if (current5_ == end5_) { current5_ = begin5_; ++current4_; } if (current4_ == end4_) { current4_ = begin4_; ++current3_; } if (current3_ == end3_) { current3_ = begin3_; ++current2_; } if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_ && current3_ == typed_other->current3_ && current4_ == typed_other->current4_ && current5_ == typed_other->current5_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_), begin3_(other.begin3_), end3_(other.end3_), current3_(other.current3_), begin4_(other.begin4_), end4_(other.end4_), current4_(other.current4_), begin5_(other.begin5_), end5_(other.end5_), current5_(other.current5_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_, *current3_, *current4_, *current5_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_ || current3_ == end3_ || current4_ == end4_ || current5_ == end5_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; const typename ParamGenerator::iterator begin3_; const typename ParamGenerator::iterator end3_; typename ParamGenerator::iterator current3_; const typename ParamGenerator::iterator begin4_; const typename ParamGenerator::iterator end4_; typename ParamGenerator::iterator current4_; const typename ParamGenerator::iterator begin5_; const typename ParamGenerator::iterator end5_; typename ParamGenerator::iterator current5_; ParamType current_value_; }; // class CartesianProductGenerator5::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator5& other); const ParamGenerator g1_; const ParamGenerator g2_; const ParamGenerator g3_; const ParamGenerator g4_; const ParamGenerator g5_; }; // class CartesianProductGenerator5 template class CartesianProductGenerator6 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator6(const ParamGenerator& g1, const ParamGenerator& g2, const ParamGenerator& g3, const ParamGenerator& g4, const ParamGenerator& g5, const ParamGenerator& g6) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {} virtual ~CartesianProductGenerator6() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2, const ParamGenerator& g3, const typename ParamGenerator::iterator& current3, const ParamGenerator& g4, const typename ParamGenerator::iterator& current4, const ParamGenerator& g5, const typename ParamGenerator::iterator& current5, const ParamGenerator& g6, const typename ParamGenerator::iterator& current6) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2), begin3_(g3.begin()), end3_(g3.end()), current3_(current3), begin4_(g4.begin()), end4_(g4.end()), current4_(current4), begin5_(g5.begin()), end5_(g5.end()), current5_(current5), begin6_(g6.begin()), end6_(g6.end()), current6_(current6) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current6_; if (current6_ == end6_) { current6_ = begin6_; ++current5_; } if (current5_ == end5_) { current5_ = begin5_; ++current4_; } if (current4_ == end4_) { current4_ = begin4_; ++current3_; } if (current3_ == end3_) { current3_ = begin3_; ++current2_; } if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_ && current3_ == typed_other->current3_ && current4_ == typed_other->current4_ && current5_ == typed_other->current5_ && current6_ == typed_other->current6_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_), begin3_(other.begin3_), end3_(other.end3_), current3_(other.current3_), begin4_(other.begin4_), end4_(other.end4_), current4_(other.current4_), begin5_(other.begin5_), end5_(other.end5_), current5_(other.current5_), begin6_(other.begin6_), end6_(other.end6_), current6_(other.current6_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_, *current3_, *current4_, *current5_, *current6_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_ || current3_ == end3_ || current4_ == end4_ || current5_ == end5_ || current6_ == end6_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; const typename ParamGenerator::iterator begin3_; const typename ParamGenerator::iterator end3_; typename ParamGenerator::iterator current3_; const typename ParamGenerator::iterator begin4_; const typename ParamGenerator::iterator end4_; typename ParamGenerator::iterator current4_; const typename ParamGenerator::iterator begin5_; const typename ParamGenerator::iterator end5_; typename ParamGenerator::iterator current5_; const typename ParamGenerator::iterator begin6_; const typename ParamGenerator::iterator end6_; typename ParamGenerator::iterator current6_; ParamType current_value_; }; // class CartesianProductGenerator6::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator6& other); const ParamGenerator g1_; const ParamGenerator g2_; const ParamGenerator g3_; const ParamGenerator g4_; const ParamGenerator g5_; const ParamGenerator g6_; }; // class CartesianProductGenerator6 template class CartesianProductGenerator7 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator7(const ParamGenerator& g1, const ParamGenerator& g2, const ParamGenerator& g3, const ParamGenerator& g4, const ParamGenerator& g5, const ParamGenerator& g6, const ParamGenerator& g7) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {} virtual ~CartesianProductGenerator7() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, g7_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2, const ParamGenerator& g3, const typename ParamGenerator::iterator& current3, const ParamGenerator& g4, const typename ParamGenerator::iterator& current4, const ParamGenerator& g5, const typename ParamGenerator::iterator& current5, const ParamGenerator& g6, const typename ParamGenerator::iterator& current6, const ParamGenerator& g7, const typename ParamGenerator::iterator& current7) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2), begin3_(g3.begin()), end3_(g3.end()), current3_(current3), begin4_(g4.begin()), end4_(g4.end()), current4_(current4), begin5_(g5.begin()), end5_(g5.end()), current5_(current5), begin6_(g6.begin()), end6_(g6.end()), current6_(current6), begin7_(g7.begin()), end7_(g7.end()), current7_(current7) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current7_; if (current7_ == end7_) { current7_ = begin7_; ++current6_; } if (current6_ == end6_) { current6_ = begin6_; ++current5_; } if (current5_ == end5_) { current5_ = begin5_; ++current4_; } if (current4_ == end4_) { current4_ = begin4_; ++current3_; } if (current3_ == end3_) { current3_ = begin3_; ++current2_; } if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_ && current3_ == typed_other->current3_ && current4_ == typed_other->current4_ && current5_ == typed_other->current5_ && current6_ == typed_other->current6_ && current7_ == typed_other->current7_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_), begin3_(other.begin3_), end3_(other.end3_), current3_(other.current3_), begin4_(other.begin4_), end4_(other.end4_), current4_(other.current4_), begin5_(other.begin5_), end5_(other.end5_), current5_(other.current5_), begin6_(other.begin6_), end6_(other.end6_), current6_(other.current6_), begin7_(other.begin7_), end7_(other.end7_), current7_(other.current7_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_, *current3_, *current4_, *current5_, *current6_, *current7_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_ || current3_ == end3_ || current4_ == end4_ || current5_ == end5_ || current6_ == end6_ || current7_ == end7_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; const typename ParamGenerator::iterator begin3_; const typename ParamGenerator::iterator end3_; typename ParamGenerator::iterator current3_; const typename ParamGenerator::iterator begin4_; const typename ParamGenerator::iterator end4_; typename ParamGenerator::iterator current4_; const typename ParamGenerator::iterator begin5_; const typename ParamGenerator::iterator end5_; typename ParamGenerator::iterator current5_; const typename ParamGenerator::iterator begin6_; const typename ParamGenerator::iterator end6_; typename ParamGenerator::iterator current6_; const typename ParamGenerator::iterator begin7_; const typename ParamGenerator::iterator end7_; typename ParamGenerator::iterator current7_; ParamType current_value_; }; // class CartesianProductGenerator7::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator7& other); const ParamGenerator g1_; const ParamGenerator g2_; const ParamGenerator g3_; const ParamGenerator g4_; const ParamGenerator g5_; const ParamGenerator g6_; const ParamGenerator g7_; }; // class CartesianProductGenerator7 template class CartesianProductGenerator8 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator8(const ParamGenerator& g1, const ParamGenerator& g2, const ParamGenerator& g3, const ParamGenerator& g4, const ParamGenerator& g5, const ParamGenerator& g6, const ParamGenerator& g7, const ParamGenerator& g8) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8) {} virtual ~CartesianProductGenerator8() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, g7_.begin(), g8_, g8_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, g8_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2, const ParamGenerator& g3, const typename ParamGenerator::iterator& current3, const ParamGenerator& g4, const typename ParamGenerator::iterator& current4, const ParamGenerator& g5, const typename ParamGenerator::iterator& current5, const ParamGenerator& g6, const typename ParamGenerator::iterator& current6, const ParamGenerator& g7, const typename ParamGenerator::iterator& current7, const ParamGenerator& g8, const typename ParamGenerator::iterator& current8) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2), begin3_(g3.begin()), end3_(g3.end()), current3_(current3), begin4_(g4.begin()), end4_(g4.end()), current4_(current4), begin5_(g5.begin()), end5_(g5.end()), current5_(current5), begin6_(g6.begin()), end6_(g6.end()), current6_(current6), begin7_(g7.begin()), end7_(g7.end()), current7_(current7), begin8_(g8.begin()), end8_(g8.end()), current8_(current8) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current8_; if (current8_ == end8_) { current8_ = begin8_; ++current7_; } if (current7_ == end7_) { current7_ = begin7_; ++current6_; } if (current6_ == end6_) { current6_ = begin6_; ++current5_; } if (current5_ == end5_) { current5_ = begin5_; ++current4_; } if (current4_ == end4_) { current4_ = begin4_; ++current3_; } if (current3_ == end3_) { current3_ = begin3_; ++current2_; } if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_ && current3_ == typed_other->current3_ && current4_ == typed_other->current4_ && current5_ == typed_other->current5_ && current6_ == typed_other->current6_ && current7_ == typed_other->current7_ && current8_ == typed_other->current8_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_), begin3_(other.begin3_), end3_(other.end3_), current3_(other.current3_), begin4_(other.begin4_), end4_(other.end4_), current4_(other.current4_), begin5_(other.begin5_), end5_(other.end5_), current5_(other.current5_), begin6_(other.begin6_), end6_(other.end6_), current6_(other.current6_), begin7_(other.begin7_), end7_(other.end7_), current7_(other.current7_), begin8_(other.begin8_), end8_(other.end8_), current8_(other.current8_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_, *current3_, *current4_, *current5_, *current6_, *current7_, *current8_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_ || current3_ == end3_ || current4_ == end4_ || current5_ == end5_ || current6_ == end6_ || current7_ == end7_ || current8_ == end8_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; const typename ParamGenerator::iterator begin3_; const typename ParamGenerator::iterator end3_; typename ParamGenerator::iterator current3_; const typename ParamGenerator::iterator begin4_; const typename ParamGenerator::iterator end4_; typename ParamGenerator::iterator current4_; const typename ParamGenerator::iterator begin5_; const typename ParamGenerator::iterator end5_; typename ParamGenerator::iterator current5_; const typename ParamGenerator::iterator begin6_; const typename ParamGenerator::iterator end6_; typename ParamGenerator::iterator current6_; const typename ParamGenerator::iterator begin7_; const typename ParamGenerator::iterator end7_; typename ParamGenerator::iterator current7_; const typename ParamGenerator::iterator begin8_; const typename ParamGenerator::iterator end8_; typename ParamGenerator::iterator current8_; ParamType current_value_; }; // class CartesianProductGenerator8::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator8& other); const ParamGenerator g1_; const ParamGenerator g2_; const ParamGenerator g3_; const ParamGenerator g4_; const ParamGenerator g5_; const ParamGenerator g6_; const ParamGenerator g7_; const ParamGenerator g8_; }; // class CartesianProductGenerator8 template class CartesianProductGenerator9 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator9(const ParamGenerator& g1, const ParamGenerator& g2, const ParamGenerator& g3, const ParamGenerator& g4, const ParamGenerator& g5, const ParamGenerator& g6, const ParamGenerator& g7, const ParamGenerator& g8, const ParamGenerator& g9) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), g9_(g9) {} virtual ~CartesianProductGenerator9() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, g8_.end(), g9_, g9_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2, const ParamGenerator& g3, const typename ParamGenerator::iterator& current3, const ParamGenerator& g4, const typename ParamGenerator::iterator& current4, const ParamGenerator& g5, const typename ParamGenerator::iterator& current5, const ParamGenerator& g6, const typename ParamGenerator::iterator& current6, const ParamGenerator& g7, const typename ParamGenerator::iterator& current7, const ParamGenerator& g8, const typename ParamGenerator::iterator& current8, const ParamGenerator& g9, const typename ParamGenerator::iterator& current9) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2), begin3_(g3.begin()), end3_(g3.end()), current3_(current3), begin4_(g4.begin()), end4_(g4.end()), current4_(current4), begin5_(g5.begin()), end5_(g5.end()), current5_(current5), begin6_(g6.begin()), end6_(g6.end()), current6_(current6), begin7_(g7.begin()), end7_(g7.end()), current7_(current7), begin8_(g8.begin()), end8_(g8.end()), current8_(current8), begin9_(g9.begin()), end9_(g9.end()), current9_(current9) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current9_; if (current9_ == end9_) { current9_ = begin9_; ++current8_; } if (current8_ == end8_) { current8_ = begin8_; ++current7_; } if (current7_ == end7_) { current7_ = begin7_; ++current6_; } if (current6_ == end6_) { current6_ = begin6_; ++current5_; } if (current5_ == end5_) { current5_ = begin5_; ++current4_; } if (current4_ == end4_) { current4_ = begin4_; ++current3_; } if (current3_ == end3_) { current3_ = begin3_; ++current2_; } if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_ && current3_ == typed_other->current3_ && current4_ == typed_other->current4_ && current5_ == typed_other->current5_ && current6_ == typed_other->current6_ && current7_ == typed_other->current7_ && current8_ == typed_other->current8_ && current9_ == typed_other->current9_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_), begin3_(other.begin3_), end3_(other.end3_), current3_(other.current3_), begin4_(other.begin4_), end4_(other.end4_), current4_(other.current4_), begin5_(other.begin5_), end5_(other.end5_), current5_(other.current5_), begin6_(other.begin6_), end6_(other.end6_), current6_(other.current6_), begin7_(other.begin7_), end7_(other.end7_), current7_(other.current7_), begin8_(other.begin8_), end8_(other.end8_), current8_(other.current8_), begin9_(other.begin9_), end9_(other.end9_), current9_(other.current9_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_, *current3_, *current4_, *current5_, *current6_, *current7_, *current8_, *current9_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_ || current3_ == end3_ || current4_ == end4_ || current5_ == end5_ || current6_ == end6_ || current7_ == end7_ || current8_ == end8_ || current9_ == end9_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; const typename ParamGenerator::iterator begin3_; const typename ParamGenerator::iterator end3_; typename ParamGenerator::iterator current3_; const typename ParamGenerator::iterator begin4_; const typename ParamGenerator::iterator end4_; typename ParamGenerator::iterator current4_; const typename ParamGenerator::iterator begin5_; const typename ParamGenerator::iterator end5_; typename ParamGenerator::iterator current5_; const typename ParamGenerator::iterator begin6_; const typename ParamGenerator::iterator end6_; typename ParamGenerator::iterator current6_; const typename ParamGenerator::iterator begin7_; const typename ParamGenerator::iterator end7_; typename ParamGenerator::iterator current7_; const typename ParamGenerator::iterator begin8_; const typename ParamGenerator::iterator end8_; typename ParamGenerator::iterator current8_; const typename ParamGenerator::iterator begin9_; const typename ParamGenerator::iterator end9_; typename ParamGenerator::iterator current9_; ParamType current_value_; }; // class CartesianProductGenerator9::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator9& other); const ParamGenerator g1_; const ParamGenerator g2_; const ParamGenerator g3_; const ParamGenerator g4_; const ParamGenerator g5_; const ParamGenerator g6_; const ParamGenerator g7_; const ParamGenerator g8_; const ParamGenerator g9_; }; // class CartesianProductGenerator9 template class CartesianProductGenerator10 : public ParamGeneratorInterface< ::std::tr1::tuple > { public: typedef ::std::tr1::tuple ParamType; CartesianProductGenerator10(const ParamGenerator& g1, const ParamGenerator& g2, const ParamGenerator& g3, const ParamGenerator& g4, const ParamGenerator& g5, const ParamGenerator& g6, const ParamGenerator& g7, const ParamGenerator& g8, const ParamGenerator& g9, const ParamGenerator& g10) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), g9_(g9), g10_(g10) {} virtual ~CartesianProductGenerator10() {} virtual ParamIteratorInterface* Begin() const { return new Iterator(this, g1_, g1_.begin(), g2_, g2_.begin(), g3_, g3_.begin(), g4_, g4_.begin(), g5_, g5_.begin(), g6_, g6_.begin(), g7_, g7_.begin(), g8_, g8_.begin(), g9_, g9_.begin(), g10_, g10_.begin()); } virtual ParamIteratorInterface* End() const { return new Iterator(this, g1_, g1_.end(), g2_, g2_.end(), g3_, g3_.end(), g4_, g4_.end(), g5_, g5_.end(), g6_, g6_.end(), g7_, g7_.end(), g8_, g8_.end(), g9_, g9_.end(), g10_, g10_.end()); } private: class Iterator : public ParamIteratorInterface { public: Iterator(const ParamGeneratorInterface* base, const ParamGenerator& g1, const typename ParamGenerator::iterator& current1, const ParamGenerator& g2, const typename ParamGenerator::iterator& current2, const ParamGenerator& g3, const typename ParamGenerator::iterator& current3, const ParamGenerator& g4, const typename ParamGenerator::iterator& current4, const ParamGenerator& g5, const typename ParamGenerator::iterator& current5, const ParamGenerator& g6, const typename ParamGenerator::iterator& current6, const ParamGenerator& g7, const typename ParamGenerator::iterator& current7, const ParamGenerator& g8, const typename ParamGenerator::iterator& current8, const ParamGenerator& g9, const typename ParamGenerator::iterator& current9, const ParamGenerator& g10, const typename ParamGenerator::iterator& current10) : base_(base), begin1_(g1.begin()), end1_(g1.end()), current1_(current1), begin2_(g2.begin()), end2_(g2.end()), current2_(current2), begin3_(g3.begin()), end3_(g3.end()), current3_(current3), begin4_(g4.begin()), end4_(g4.end()), current4_(current4), begin5_(g5.begin()), end5_(g5.end()), current5_(current5), begin6_(g6.begin()), end6_(g6.end()), current6_(current6), begin7_(g7.begin()), end7_(g7.end()), current7_(current7), begin8_(g8.begin()), end8_(g8.end()), current8_(current8), begin9_(g9.begin()), end9_(g9.end()), current9_(current9), begin10_(g10.begin()), end10_(g10.end()), current10_(current10) { ComputeCurrentValue(); } virtual ~Iterator() {} virtual const ParamGeneratorInterface* BaseGenerator() const { return base_; } // Advance should not be called on beyond-of-range iterators // so no component iterators must be beyond end of range, either. virtual void Advance() { assert(!AtEnd()); ++current10_; if (current10_ == end10_) { current10_ = begin10_; ++current9_; } if (current9_ == end9_) { current9_ = begin9_; ++current8_; } if (current8_ == end8_) { current8_ = begin8_; ++current7_; } if (current7_ == end7_) { current7_ = begin7_; ++current6_; } if (current6_ == end6_) { current6_ = begin6_; ++current5_; } if (current5_ == end5_) { current5_ = begin5_; ++current4_; } if (current4_ == end4_) { current4_ = begin4_; ++current3_; } if (current3_ == end3_) { current3_ = begin3_; ++current2_; } if (current2_ == end2_) { current2_ = begin2_; ++current1_; } ComputeCurrentValue(); } virtual ParamIteratorInterface* Clone() const { return new Iterator(*this); } virtual const ParamType* Current() const { return ¤t_value_; } virtual bool Equals(const ParamIteratorInterface& other) const { // Having the same base generator guarantees that the other // iterator is of the same type and we can downcast. GTEST_CHECK_(BaseGenerator() == other.BaseGenerator()) << "The program attempted to compare iterators " << "from different generators." << std::endl; const Iterator* typed_other = CheckedDowncastToActualType(&other); // We must report iterators equal if they both point beyond their // respective ranges. That can happen in a variety of fashions, // so we have to consult AtEnd(). return (AtEnd() && typed_other->AtEnd()) || ( current1_ == typed_other->current1_ && current2_ == typed_other->current2_ && current3_ == typed_other->current3_ && current4_ == typed_other->current4_ && current5_ == typed_other->current5_ && current6_ == typed_other->current6_ && current7_ == typed_other->current7_ && current8_ == typed_other->current8_ && current9_ == typed_other->current9_ && current10_ == typed_other->current10_); } private: Iterator(const Iterator& other) : base_(other.base_), begin1_(other.begin1_), end1_(other.end1_), current1_(other.current1_), begin2_(other.begin2_), end2_(other.end2_), current2_(other.current2_), begin3_(other.begin3_), end3_(other.end3_), current3_(other.current3_), begin4_(other.begin4_), end4_(other.end4_), current4_(other.current4_), begin5_(other.begin5_), end5_(other.end5_), current5_(other.current5_), begin6_(other.begin6_), end6_(other.end6_), current6_(other.current6_), begin7_(other.begin7_), end7_(other.end7_), current7_(other.current7_), begin8_(other.begin8_), end8_(other.end8_), current8_(other.current8_), begin9_(other.begin9_), end9_(other.end9_), current9_(other.current9_), begin10_(other.begin10_), end10_(other.end10_), current10_(other.current10_) { ComputeCurrentValue(); } void ComputeCurrentValue() { if (!AtEnd()) current_value_ = ParamType(*current1_, *current2_, *current3_, *current4_, *current5_, *current6_, *current7_, *current8_, *current9_, *current10_); } bool AtEnd() const { // We must report iterator past the end of the range when either of the // component iterators has reached the end of its range. return current1_ == end1_ || current2_ == end2_ || current3_ == end3_ || current4_ == end4_ || current5_ == end5_ || current6_ == end6_ || current7_ == end7_ || current8_ == end8_ || current9_ == end9_ || current10_ == end10_; } // No implementation - assignment is unsupported. void operator=(const Iterator& other); const ParamGeneratorInterface* const base_; // begin[i]_ and end[i]_ define the i-th range that Iterator traverses. // current[i]_ is the actual traversing iterator. const typename ParamGenerator::iterator begin1_; const typename ParamGenerator::iterator end1_; typename ParamGenerator::iterator current1_; const typename ParamGenerator::iterator begin2_; const typename ParamGenerator::iterator end2_; typename ParamGenerator::iterator current2_; const typename ParamGenerator::iterator begin3_; const typename ParamGenerator::iterator end3_; typename ParamGenerator::iterator current3_; const typename ParamGenerator::iterator begin4_; const typename ParamGenerator::iterator end4_; typename ParamGenerator::iterator current4_; const typename ParamGenerator::iterator begin5_; const typename ParamGenerator::iterator end5_; typename ParamGenerator::iterator current5_; const typename ParamGenerator::iterator begin6_; const typename ParamGenerator::iterator end6_; typename ParamGenerator::iterator current6_; const typename ParamGenerator::iterator begin7_; const typename ParamGenerator::iterator end7_; typename ParamGenerator::iterator current7_; const typename ParamGenerator::iterator begin8_; const typename ParamGenerator::iterator end8_; typename ParamGenerator::iterator current8_; const typename ParamGenerator::iterator begin9_; const typename ParamGenerator::iterator end9_; typename ParamGenerator::iterator current9_; const typename ParamGenerator::iterator begin10_; const typename ParamGenerator::iterator end10_; typename ParamGenerator::iterator current10_; ParamType current_value_; }; // class CartesianProductGenerator10::Iterator // No implementation - assignment is unsupported. void operator=(const CartesianProductGenerator10& other); const ParamGenerator g1_; const ParamGenerator g2_; const ParamGenerator g3_; const ParamGenerator g4_; const ParamGenerator g5_; const ParamGenerator g6_; const ParamGenerator g7_; const ParamGenerator g8_; const ParamGenerator g9_; const ParamGenerator g10_; }; // class CartesianProductGenerator10 // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Helper classes providing Combine() with polymorphic features. They allow // casting CartesianProductGeneratorN to ParamGenerator if T is // convertible to U. // template class CartesianProductHolder2 { public: CartesianProductHolder2(const Generator1& g1, const Generator2& g2) : g1_(g1), g2_(g2) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator2( static_cast >(g1_), static_cast >(g2_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder2& other); const Generator1 g1_; const Generator2 g2_; }; // class CartesianProductHolder2 template class CartesianProductHolder3 { public: CartesianProductHolder3(const Generator1& g1, const Generator2& g2, const Generator3& g3) : g1_(g1), g2_(g2), g3_(g3) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator3( static_cast >(g1_), static_cast >(g2_), static_cast >(g3_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder3& other); const Generator1 g1_; const Generator2 g2_; const Generator3 g3_; }; // class CartesianProductHolder3 template class CartesianProductHolder4 { public: CartesianProductHolder4(const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4) : g1_(g1), g2_(g2), g3_(g3), g4_(g4) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator4( static_cast >(g1_), static_cast >(g2_), static_cast >(g3_), static_cast >(g4_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder4& other); const Generator1 g1_; const Generator2 g2_; const Generator3 g3_; const Generator4 g4_; }; // class CartesianProductHolder4 template class CartesianProductHolder5 { public: CartesianProductHolder5(const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator5( static_cast >(g1_), static_cast >(g2_), static_cast >(g3_), static_cast >(g4_), static_cast >(g5_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder5& other); const Generator1 g1_; const Generator2 g2_; const Generator3 g3_; const Generator4 g4_; const Generator5 g5_; }; // class CartesianProductHolder5 template class CartesianProductHolder6 { public: CartesianProductHolder6(const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator6( static_cast >(g1_), static_cast >(g2_), static_cast >(g3_), static_cast >(g4_), static_cast >(g5_), static_cast >(g6_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder6& other); const Generator1 g1_; const Generator2 g2_; const Generator3 g3_; const Generator4 g4_; const Generator5 g5_; const Generator6 g6_; }; // class CartesianProductHolder6 template class CartesianProductHolder7 { public: CartesianProductHolder7(const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6, const Generator7& g7) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator7( static_cast >(g1_), static_cast >(g2_), static_cast >(g3_), static_cast >(g4_), static_cast >(g5_), static_cast >(g6_), static_cast >(g7_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder7& other); const Generator1 g1_; const Generator2 g2_; const Generator3 g3_; const Generator4 g4_; const Generator5 g5_; const Generator6 g6_; const Generator7 g7_; }; // class CartesianProductHolder7 template class CartesianProductHolder8 { public: CartesianProductHolder8(const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6, const Generator7& g7, const Generator8& g8) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator8( static_cast >(g1_), static_cast >(g2_), static_cast >(g3_), static_cast >(g4_), static_cast >(g5_), static_cast >(g6_), static_cast >(g7_), static_cast >(g8_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder8& other); const Generator1 g1_; const Generator2 g2_; const Generator3 g3_; const Generator4 g4_; const Generator5 g5_; const Generator6 g6_; const Generator7 g7_; const Generator8 g8_; }; // class CartesianProductHolder8 template class CartesianProductHolder9 { public: CartesianProductHolder9(const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6, const Generator7& g7, const Generator8& g8, const Generator9& g9) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), g9_(g9) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator9( static_cast >(g1_), static_cast >(g2_), static_cast >(g3_), static_cast >(g4_), static_cast >(g5_), static_cast >(g6_), static_cast >(g7_), static_cast >(g8_), static_cast >(g9_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder9& other); const Generator1 g1_; const Generator2 g2_; const Generator3 g3_; const Generator4 g4_; const Generator5 g5_; const Generator6 g6_; const Generator7 g7_; const Generator8 g8_; const Generator9 g9_; }; // class CartesianProductHolder9 template class CartesianProductHolder10 { public: CartesianProductHolder10(const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6, const Generator7& g7, const Generator8& g8, const Generator9& g9, const Generator10& g10) : g1_(g1), g2_(g2), g3_(g3), g4_(g4), g5_(g5), g6_(g6), g7_(g7), g8_(g8), g9_(g9), g10_(g10) {} template operator ParamGenerator< ::std::tr1::tuple >() const { return ParamGenerator< ::std::tr1::tuple >( new CartesianProductGenerator10( static_cast >(g1_), static_cast >(g2_), static_cast >(g3_), static_cast >(g4_), static_cast >(g5_), static_cast >(g6_), static_cast >(g7_), static_cast >(g8_), static_cast >(g9_), static_cast >(g10_))); } private: // No implementation - assignment is unsupported. void operator=(const CartesianProductHolder10& other); const Generator1 g1_; const Generator2 g2_; const Generator3 g3_; const Generator4 g4_; const Generator5 g5_; const Generator6 g6_; const Generator7 g7_; const Generator8 g8_; const Generator9 g9_; const Generator10 g10_; }; // class CartesianProductHolder10 # endif // GTEST_HAS_COMBINE } // namespace internal } // namespace testing #endif // GTEST_HAS_PARAM_TEST #endif // GTEST_INCLUDE_GTEST_INTERNAL_GTEST_PARAM_UTIL_GENERATED_H_ #if GTEST_HAS_PARAM_TEST namespace testing { // Functions producing parameter generators. // // Google Test uses these generators to produce parameters for value- // parameterized tests. When a parameterized test case is instantiated // with a particular generator, Google Test creates and runs tests // for each element in the sequence produced by the generator. // // In the following sample, tests from test case FooTest are instantiated // each three times with parameter values 3, 5, and 8: // // class FooTest : public TestWithParam { ... }; // // TEST_P(FooTest, TestThis) { // } // TEST_P(FooTest, TestThat) { // } // INSTANTIATE_TEST_CASE_P(TestSequence, FooTest, Values(3, 5, 8)); // // Range() returns generators providing sequences of values in a range. // // Synopsis: // Range(start, end) // - returns a generator producing a sequence of values {start, start+1, // start+2, ..., }. // Range(start, end, step) // - returns a generator producing a sequence of values {start, start+step, // start+step+step, ..., }. // Notes: // * The generated sequences never include end. For example, Range(1, 5) // returns a generator producing a sequence {1, 2, 3, 4}. Range(1, 9, 2) // returns a generator producing {1, 3, 5, 7}. // * start and end must have the same type. That type may be any integral or // floating-point type or a user defined type satisfying these conditions: // * It must be assignable (have operator=() defined). // * It must have operator+() (operator+(int-compatible type) for // two-operand version). // * It must have operator<() defined. // Elements in the resulting sequences will also have that type. // * Condition start < end must be satisfied in order for resulting sequences // to contain any elements. // template internal::ParamGenerator Range(T start, T end, IncrementT step) { return internal::ParamGenerator( new internal::RangeGenerator(start, end, step)); } template internal::ParamGenerator Range(T start, T end) { return Range(start, end, 1); } // ValuesIn() function allows generation of tests with parameters coming from // a container. // // Synopsis: // ValuesIn(const T (&array)[N]) // - returns a generator producing sequences with elements from // a C-style array. // ValuesIn(const Container& container) // - returns a generator producing sequences with elements from // an STL-style container. // ValuesIn(Iterator begin, Iterator end) // - returns a generator producing sequences with elements from // a range [begin, end) defined by a pair of STL-style iterators. These // iterators can also be plain C pointers. // // Please note that ValuesIn copies the values from the containers // passed in and keeps them to generate tests in RUN_ALL_TESTS(). // // Examples: // // This instantiates tests from test case StringTest // each with C-string values of "foo", "bar", and "baz": // // const char* strings[] = {"foo", "bar", "baz"}; // INSTANTIATE_TEST_CASE_P(StringSequence, SrtingTest, ValuesIn(strings)); // // This instantiates tests from test case StlStringTest // each with STL strings with values "a" and "b": // // ::std::vector< ::std::string> GetParameterStrings() { // ::std::vector< ::std::string> v; // v.push_back("a"); // v.push_back("b"); // return v; // } // // INSTANTIATE_TEST_CASE_P(CharSequence, // StlStringTest, // ValuesIn(GetParameterStrings())); // // // This will also instantiate tests from CharTest // each with parameter values 'a' and 'b': // // ::std::list GetParameterChars() { // ::std::list list; // list.push_back('a'); // list.push_back('b'); // return list; // } // ::std::list l = GetParameterChars(); // INSTANTIATE_TEST_CASE_P(CharSequence2, // CharTest, // ValuesIn(l.begin(), l.end())); // template internal::ParamGenerator< typename ::testing::internal::IteratorTraits::value_type> ValuesIn(ForwardIterator begin, ForwardIterator end) { typedef typename ::testing::internal::IteratorTraits ::value_type ParamType; return internal::ParamGenerator( new internal::ValuesInIteratorRangeGenerator(begin, end)); } template internal::ParamGenerator ValuesIn(const T (&array)[N]) { return ValuesIn(array, array + N); } template internal::ParamGenerator ValuesIn( const Container& container) { return ValuesIn(container.begin(), container.end()); } // Values() allows generating tests from explicitly specified list of // parameters. // // Synopsis: // Values(T v1, T v2, ..., T vN) // - returns a generator producing sequences with elements v1, v2, ..., vN. // // For example, this instantiates tests from test case BarTest each // with values "one", "two", and "three": // // INSTANTIATE_TEST_CASE_P(NumSequence, BarTest, Values("one", "two", "three")); // // This instantiates tests from test case BazTest each with values 1, 2, 3.5. // The exact type of values will depend on the type of parameter in BazTest. // // INSTANTIATE_TEST_CASE_P(FloatingNumbers, BazTest, Values(1, 2, 3.5)); // // Currently, Values() supports from 1 to 50 parameters. // template internal::ValueArray1 Values(T1 v1) { return internal::ValueArray1(v1); } template internal::ValueArray2 Values(T1 v1, T2 v2) { return internal::ValueArray2(v1, v2); } template internal::ValueArray3 Values(T1 v1, T2 v2, T3 v3) { return internal::ValueArray3(v1, v2, v3); } template internal::ValueArray4 Values(T1 v1, T2 v2, T3 v3, T4 v4) { return internal::ValueArray4(v1, v2, v3, v4); } template internal::ValueArray5 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5) { return internal::ValueArray5(v1, v2, v3, v4, v5); } template internal::ValueArray6 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6) { return internal::ValueArray6(v1, v2, v3, v4, v5, v6); } template internal::ValueArray7 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7) { return internal::ValueArray7(v1, v2, v3, v4, v5, v6, v7); } template internal::ValueArray8 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8) { return internal::ValueArray8(v1, v2, v3, v4, v5, v6, v7, v8); } template internal::ValueArray9 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9) { return internal::ValueArray9(v1, v2, v3, v4, v5, v6, v7, v8, v9); } template internal::ValueArray10 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10) { return internal::ValueArray10(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10); } template internal::ValueArray11 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11) { return internal::ValueArray11(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11); } template internal::ValueArray12 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12) { return internal::ValueArray12(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12); } template internal::ValueArray13 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13) { return internal::ValueArray13(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13); } template internal::ValueArray14 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14) { return internal::ValueArray14(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14); } template internal::ValueArray15 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15) { return internal::ValueArray15(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15); } template internal::ValueArray16 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16) { return internal::ValueArray16(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16); } template internal::ValueArray17 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17) { return internal::ValueArray17(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17); } template internal::ValueArray18 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18) { return internal::ValueArray18(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18); } template internal::ValueArray19 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19) { return internal::ValueArray19(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19); } template internal::ValueArray20 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20) { return internal::ValueArray20(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20); } template internal::ValueArray21 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21) { return internal::ValueArray21(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21); } template internal::ValueArray22 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22) { return internal::ValueArray22(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22); } template internal::ValueArray23 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23) { return internal::ValueArray23(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23); } template internal::ValueArray24 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24) { return internal::ValueArray24(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24); } template internal::ValueArray25 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25) { return internal::ValueArray25(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25); } template internal::ValueArray26 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26) { return internal::ValueArray26(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26); } template internal::ValueArray27 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27) { return internal::ValueArray27(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27); } template internal::ValueArray28 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28) { return internal::ValueArray28(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28); } template internal::ValueArray29 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29) { return internal::ValueArray29(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29); } template internal::ValueArray30 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30) { return internal::ValueArray30(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30); } template internal::ValueArray31 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31) { return internal::ValueArray31(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31); } template internal::ValueArray32 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32) { return internal::ValueArray32(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32); } template internal::ValueArray33 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33) { return internal::ValueArray33(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33); } template internal::ValueArray34 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34) { return internal::ValueArray34(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34); } template internal::ValueArray35 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35) { return internal::ValueArray35(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35); } template internal::ValueArray36 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36) { return internal::ValueArray36(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36); } template internal::ValueArray37 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37) { return internal::ValueArray37(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37); } template internal::ValueArray38 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38) { return internal::ValueArray38(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38); } template internal::ValueArray39 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39) { return internal::ValueArray39(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39); } template internal::ValueArray40 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40) { return internal::ValueArray40(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40); } template internal::ValueArray41 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41) { return internal::ValueArray41(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41); } template internal::ValueArray42 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42) { return internal::ValueArray42(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42); } template internal::ValueArray43 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43) { return internal::ValueArray43(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43); } template internal::ValueArray44 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44) { return internal::ValueArray44(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44); } template internal::ValueArray45 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45) { return internal::ValueArray45(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45); } template internal::ValueArray46 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46) { return internal::ValueArray46(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46); } template internal::ValueArray47 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47) { return internal::ValueArray47(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47); } template internal::ValueArray48 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48) { return internal::ValueArray48(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48); } template internal::ValueArray49 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49) { return internal::ValueArray49(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49); } template internal::ValueArray50 Values(T1 v1, T2 v2, T3 v3, T4 v4, T5 v5, T6 v6, T7 v7, T8 v8, T9 v9, T10 v10, T11 v11, T12 v12, T13 v13, T14 v14, T15 v15, T16 v16, T17 v17, T18 v18, T19 v19, T20 v20, T21 v21, T22 v22, T23 v23, T24 v24, T25 v25, T26 v26, T27 v27, T28 v28, T29 v29, T30 v30, T31 v31, T32 v32, T33 v33, T34 v34, T35 v35, T36 v36, T37 v37, T38 v38, T39 v39, T40 v40, T41 v41, T42 v42, T43 v43, T44 v44, T45 v45, T46 v46, T47 v47, T48 v48, T49 v49, T50 v50) { return internal::ValueArray50(v1, v2, v3, v4, v5, v6, v7, v8, v9, v10, v11, v12, v13, v14, v15, v16, v17, v18, v19, v20, v21, v22, v23, v24, v25, v26, v27, v28, v29, v30, v31, v32, v33, v34, v35, v36, v37, v38, v39, v40, v41, v42, v43, v44, v45, v46, v47, v48, v49, v50); } // Bool() allows generating tests with parameters in a set of (false, true). // // Synopsis: // Bool() // - returns a generator producing sequences with elements {false, true}. // // It is useful when testing code that depends on Boolean flags. Combinations // of multiple flags can be tested when several Bool()'s are combined using // Combine() function. // // In the following example all tests in the test case FlagDependentTest // will be instantiated twice with parameters false and true. // // class FlagDependentTest : public testing::TestWithParam { // virtual void SetUp() { // external_flag = GetParam(); // } // } // INSTANTIATE_TEST_CASE_P(BoolSequence, FlagDependentTest, Bool()); // inline internal::ParamGenerator Bool() { return Values(false, true); } # if GTEST_HAS_COMBINE // Combine() allows the user to combine two or more sequences to produce // values of a Cartesian product of those sequences' elements. // // Synopsis: // Combine(gen1, gen2, ..., genN) // - returns a generator producing sequences with elements coming from // the Cartesian product of elements from the sequences generated by // gen1, gen2, ..., genN. The sequence elements will have a type of // tuple where T1, T2, ..., TN are the types // of elements from sequences produces by gen1, gen2, ..., genN. // // Combine can have up to 10 arguments. This number is currently limited // by the maximum number of elements in the tuple implementation used by Google // Test. // // Example: // // This will instantiate tests in test case AnimalTest each one with // the parameter values tuple("cat", BLACK), tuple("cat", WHITE), // tuple("dog", BLACK), and tuple("dog", WHITE): // // enum Color { BLACK, GRAY, WHITE }; // class AnimalTest // : public testing::TestWithParam > {...}; // // TEST_P(AnimalTest, AnimalLooksNice) {...} // // INSTANTIATE_TEST_CASE_P(AnimalVariations, AnimalTest, // Combine(Values("cat", "dog"), // Values(BLACK, WHITE))); // // This will instantiate tests in FlagDependentTest with all variations of two // Boolean flags: // // class FlagDependentTest // : public testing::TestWithParam > { // virtual void SetUp() { // // Assigns external_flag_1 and external_flag_2 values from the tuple. // tie(external_flag_1, external_flag_2) = GetParam(); // } // }; // // TEST_P(FlagDependentTest, TestFeature1) { // // Test your code using external_flag_1 and external_flag_2 here. // } // INSTANTIATE_TEST_CASE_P(TwoBoolSequence, FlagDependentTest, // Combine(Bool(), Bool())); // template internal::CartesianProductHolder2 Combine( const Generator1& g1, const Generator2& g2) { return internal::CartesianProductHolder2( g1, g2); } template internal::CartesianProductHolder3 Combine( const Generator1& g1, const Generator2& g2, const Generator3& g3) { return internal::CartesianProductHolder3( g1, g2, g3); } template internal::CartesianProductHolder4 Combine( const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4) { return internal::CartesianProductHolder4( g1, g2, g3, g4); } template internal::CartesianProductHolder5 Combine( const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5) { return internal::CartesianProductHolder5( g1, g2, g3, g4, g5); } template internal::CartesianProductHolder6 Combine( const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6) { return internal::CartesianProductHolder6( g1, g2, g3, g4, g5, g6); } template internal::CartesianProductHolder7 Combine( const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6, const Generator7& g7) { return internal::CartesianProductHolder7( g1, g2, g3, g4, g5, g6, g7); } template internal::CartesianProductHolder8 Combine( const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6, const Generator7& g7, const Generator8& g8) { return internal::CartesianProductHolder8( g1, g2, g3, g4, g5, g6, g7, g8); } template internal::CartesianProductHolder9 Combine( const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6, const Generator7& g7, const Generator8& g8, const Generator9& g9) { return internal::CartesianProductHolder9( g1, g2, g3, g4, g5, g6, g7, g8, g9); } template internal::CartesianProductHolder10 Combine( const Generator1& g1, const Generator2& g2, const Generator3& g3, const Generator4& g4, const Generator5& g5, const Generator6& g6, const Generator7& g7, const Generator8& g8, const Generator9& g9, const Generator10& g10) { return internal::CartesianProductHolder10( g1, g2, g3, g4, g5, g6, g7, g8, g9, g10); } # endif // GTEST_HAS_COMBINE # define TEST_P(test_case_name, test_name) \ class GTEST_TEST_CLASS_NAME_(test_case_name, test_name) \ : public test_case_name { \ public: \ GTEST_TEST_CLASS_NAME_(test_case_name, test_name)() {} \ virtual void TestBody(); \ private: \ static int AddToRegistry() { \ ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ GetTestCasePatternHolder(\ #test_case_name, __FILE__, __LINE__)->AddTestPattern(\ #test_case_name, \ #test_name, \ new ::testing::internal::TestMetaFactory< \ GTEST_TEST_CLASS_NAME_(test_case_name, test_name)>()); \ return 0; \ } \ static int gtest_registering_dummy_; \ GTEST_DISALLOW_COPY_AND_ASSIGN_(\ GTEST_TEST_CLASS_NAME_(test_case_name, test_name)); \ }; \ int GTEST_TEST_CLASS_NAME_(test_case_name, \ test_name)::gtest_registering_dummy_ = \ GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::AddToRegistry(); \ void GTEST_TEST_CLASS_NAME_(test_case_name, test_name)::TestBody() # define INSTANTIATE_TEST_CASE_P(prefix, test_case_name, generator) \ ::testing::internal::ParamGenerator \ gtest_##prefix##test_case_name##_EvalGenerator_() { return generator; } \ int gtest_##prefix##test_case_name##_dummy_ = \ ::testing::UnitTest::GetInstance()->parameterized_test_registry(). \ GetTestCasePatternHolder(\ #test_case_name, __FILE__, __LINE__)->AddTestCaseInstantiation(\ #prefix, \ >est_##prefix##test_case_name##_EvalGenerator_, \ __FILE__, __LINE__) } // namespace testing #endif // GTEST_HAS_PARAM_TEST #endif // GTEST_INCLUDE_GTEST_GTEST_PARAM_TEST_H_ // Copyright 2006, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) // // Google C++ Testing Framework definitions useful in production code. #ifndef GTEST_INCLUDE_GTEST_GTEST_PROD_H_ #define GTEST_INCLUDE_GTEST_GTEST_PROD_H_ // When you need to test the private or protected members of a class, // use the FRIEND_TEST macro to declare your tests as friends of the // class. For example: // // class MyClass { // private: // void MyMethod(); // FRIEND_TEST(MyClassTest, MyMethod); // }; // // class MyClassTest : public testing::Test { // // ... // }; // // TEST_F(MyClassTest, MyMethod) { // // Can call MyClass::MyMethod() here. // } #define FRIEND_TEST(test_case_name, test_name)\ friend class test_case_name##_##test_name##_Test #endif // GTEST_INCLUDE_GTEST_GTEST_PROD_H_ // Copyright 2008, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // // Author: mheule@google.com (Markus Heule) // #ifndef GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ #define GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ #include #include namespace testing { // A copyable object representing the result of a test part (i.e. an // assertion or an explicit FAIL(), ADD_FAILURE(), or SUCCESS()). // // Don't inherit from TestPartResult as its destructor is not virtual. class GTEST_API_ TestPartResult { public: // The possible outcomes of a test part (i.e. an assertion or an // explicit SUCCEED(), FAIL(), or ADD_FAILURE()). enum Type { kSuccess, // Succeeded. kNonFatalFailure, // Failed but the test can continue. kFatalFailure // Failed and the test should be terminated. }; // C'tor. TestPartResult does NOT have a default constructor. // Always use this constructor (with parameters) to create a // TestPartResult object. TestPartResult(Type a_type, const char* a_file_name, int a_line_number, const char* a_message) : type_(a_type), file_name_(a_file_name == NULL ? "" : a_file_name), line_number_(a_line_number), summary_(ExtractSummary(a_message)), message_(a_message) { } // Gets the outcome of the test part. Type type() const { return type_; } // Gets the name of the source file where the test part took place, or // NULL if it's unknown. const char* file_name() const { return file_name_.empty() ? NULL : file_name_.c_str(); } // Gets the line in the source file where the test part took place, // or -1 if it's unknown. int line_number() const { return line_number_; } // Gets the summary of the failure message. const char* summary() const { return summary_.c_str(); } // Gets the message associated with the test part. const char* message() const { return message_.c_str(); } // Returns true iff the test part passed. bool passed() const { return type_ == kSuccess; } // Returns true iff the test part failed. bool failed() const { return type_ != kSuccess; } // Returns true iff the test part non-fatally failed. bool nonfatally_failed() const { return type_ == kNonFatalFailure; } // Returns true iff the test part fatally failed. bool fatally_failed() const { return type_ == kFatalFailure; } private: Type type_; // Gets the summary of the failure message by omitting the stack // trace in it. static std::string ExtractSummary(const char* message); // The name of the source file where the test part took place, or // "" if the source file is unknown. std::string file_name_; // The line in the source file where the test part took place, or -1 // if the line number is unknown. int line_number_; std::string summary_; // The test failure summary. std::string message_; // The test failure message. }; // Prints a TestPartResult object. std::ostream& operator<<(std::ostream& os, const TestPartResult& result); // An array of TestPartResult objects. // // Don't inherit from TestPartResultArray as its destructor is not // virtual. class GTEST_API_ TestPartResultArray { public: TestPartResultArray() {} // Appends the given TestPartResult to the array. void Append(const TestPartResult& result); // Returns the TestPartResult at the given index (0-based). const TestPartResult& GetTestPartResult(int index) const; // Returns the number of TestPartResult objects in the array. int size() const; private: std::vector array_; GTEST_DISALLOW_COPY_AND_ASSIGN_(TestPartResultArray); }; // This interface knows how to report a test part result. class TestPartResultReporterInterface { public: virtual ~TestPartResultReporterInterface() {} virtual void ReportTestPartResult(const TestPartResult& result) = 0; }; namespace internal { // This helper class is used by {ASSERT|EXPECT}_NO_FATAL_FAILURE to check if a // statement generates new fatal failures. To do so it registers itself as the // current test part result reporter. Besides checking if fatal failures were // reported, it only delegates the reporting to the former result reporter. // The original result reporter is restored in the destructor. // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. class GTEST_API_ HasNewFatalFailureHelper : public TestPartResultReporterInterface { public: HasNewFatalFailureHelper(); virtual ~HasNewFatalFailureHelper(); virtual void ReportTestPartResult(const TestPartResult& result); bool has_new_fatal_failure() const { return has_new_fatal_failure_; } private: bool has_new_fatal_failure_; TestPartResultReporterInterface* original_reporter_; GTEST_DISALLOW_COPY_AND_ASSIGN_(HasNewFatalFailureHelper); }; } // namespace internal } // namespace testing #endif // GTEST_INCLUDE_GTEST_GTEST_TEST_PART_H_ // Copyright 2008 Google Inc. // All Rights Reserved. // // 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 Google Inc. 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. // // Author: wan@google.com (Zhanyong Wan) #ifndef GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ #define GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ // This header implements typed tests and type-parameterized tests. // Typed (aka type-driven) tests repeat the same test for types in a // list. You must know which types you want to test with when writing // typed tests. Here's how you do it: #if 0 // First, define a fixture class template. It should be parameterized // by a type. Remember to derive it from testing::Test. template class FooTest : public testing::Test { public: ... typedef std::list List; static T shared_; T value_; }; // Next, associate a list of types with the test case, which will be // repeated for each type in the list. The typedef is necessary for // the macro to parse correctly. typedef testing::Types MyTypes; TYPED_TEST_CASE(FooTest, MyTypes); // If the type list contains only one type, you can write that type // directly without Types<...>: // TYPED_TEST_CASE(FooTest, int); // Then, use TYPED_TEST() instead of TEST_F() to define as many typed // tests for this test case as you want. TYPED_TEST(FooTest, DoesBlah) { // Inside a test, refer to TypeParam to get the type parameter. // Since we are inside a derived class template, C++ requires use to // visit the members of FooTest via 'this'. TypeParam n = this->value_; // To visit static members of the fixture, add the TestFixture:: // prefix. n += TestFixture::shared_; // To refer to typedefs in the fixture, add the "typename // TestFixture::" prefix. typename TestFixture::List values; values.push_back(n); ... } TYPED_TEST(FooTest, HasPropertyA) { ... } #endif // 0 // Type-parameterized tests are abstract test patterns parameterized // by a type. Compared with typed tests, type-parameterized tests // allow you to define the test pattern without knowing what the type // parameters are. The defined pattern can be instantiated with // different types any number of times, in any number of translation // units. // // If you are designing an interface or concept, you can define a // suite of type-parameterized tests to verify properties that any // valid implementation of the interface/concept should have. Then, // each implementation can easily instantiate the test suite to verify // that it conforms to the requirements, without having to write // similar tests repeatedly. Here's an example: #if 0 // First, define a fixture class template. It should be parameterized // by a type. Remember to derive it from testing::Test. template class FooTest : public testing::Test { ... }; // Next, declare that you will define a type-parameterized test case // (the _P suffix is for "parameterized" or "pattern", whichever you // prefer): TYPED_TEST_CASE_P(FooTest); // Then, use TYPED_TEST_P() to define as many type-parameterized tests // for this type-parameterized test case as you want. TYPED_TEST_P(FooTest, DoesBlah) { // Inside a test, refer to TypeParam to get the type parameter. TypeParam n = 0; ... } TYPED_TEST_P(FooTest, HasPropertyA) { ... } // Now the tricky part: you need to register all test patterns before // you can instantiate them. The first argument of the macro is the // test case name; the rest are the names of the tests in this test // case. REGISTER_TYPED_TEST_CASE_P(FooTest, DoesBlah, HasPropertyA); // Finally, you are free to instantiate the pattern with the types you // want. If you put the above code in a header file, you can #include // it in multiple C++ source files and instantiate it multiple times. // // To distinguish different instances of the pattern, the first // argument to the INSTANTIATE_* macro is a prefix that will be added // to the actual test case name. Remember to pick unique prefixes for // different instances. typedef testing::Types MyTypes; INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, MyTypes); // If the type list contains only one type, you can write that type // directly without Types<...>: // INSTANTIATE_TYPED_TEST_CASE_P(My, FooTest, int); #endif // 0 // Implements typed tests. #if GTEST_HAS_TYPED_TEST // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Expands to the name of the typedef for the type parameters of the // given test case. # define GTEST_TYPE_PARAMS_(TestCaseName) gtest_type_params_##TestCaseName##_ // The 'Types' template argument below must have spaces around it // since some compilers may choke on '>>' when passing a template // instance (e.g. Types) # define TYPED_TEST_CASE(CaseName, Types) \ typedef ::testing::internal::TypeList< Types >::type \ GTEST_TYPE_PARAMS_(CaseName) # define TYPED_TEST(CaseName, TestName) \ template \ class GTEST_TEST_CLASS_NAME_(CaseName, TestName) \ : public CaseName { \ private: \ typedef CaseName TestFixture; \ typedef gtest_TypeParam_ TypeParam; \ virtual void TestBody(); \ }; \ bool gtest_##CaseName##_##TestName##_registered_ GTEST_ATTRIBUTE_UNUSED_ = \ ::testing::internal::TypeParameterizedTest< \ CaseName, \ ::testing::internal::TemplateSel< \ GTEST_TEST_CLASS_NAME_(CaseName, TestName)>, \ GTEST_TYPE_PARAMS_(CaseName)>::Register(\ "", #CaseName, #TestName, 0); \ template \ void GTEST_TEST_CLASS_NAME_(CaseName, TestName)::TestBody() #endif // GTEST_HAS_TYPED_TEST // Implements type-parameterized tests. #if GTEST_HAS_TYPED_TEST_P // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Expands to the namespace name that the type-parameterized tests for // the given type-parameterized test case are defined in. The exact // name of the namespace is subject to change without notice. # define GTEST_CASE_NAMESPACE_(TestCaseName) \ gtest_case_##TestCaseName##_ // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // // Expands to the name of the variable used to remember the names of // the defined tests in the given test case. # define GTEST_TYPED_TEST_CASE_P_STATE_(TestCaseName) \ gtest_typed_test_case_p_state_##TestCaseName##_ // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE DIRECTLY. // // Expands to the name of the variable used to remember the names of // the registered tests in the given test case. # define GTEST_REGISTERED_TEST_NAMES_(TestCaseName) \ gtest_registered_test_names_##TestCaseName##_ // The variables defined in the type-parameterized test macros are // static as typically these macros are used in a .h file that can be // #included in multiple translation units linked together. # define TYPED_TEST_CASE_P(CaseName) \ static ::testing::internal::TypedTestCasePState \ GTEST_TYPED_TEST_CASE_P_STATE_(CaseName) # define TYPED_TEST_P(CaseName, TestName) \ namespace GTEST_CASE_NAMESPACE_(CaseName) { \ template \ class TestName : public CaseName { \ private: \ typedef CaseName TestFixture; \ typedef gtest_TypeParam_ TypeParam; \ virtual void TestBody(); \ }; \ static bool gtest_##TestName##_defined_ GTEST_ATTRIBUTE_UNUSED_ = \ GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).AddTestName(\ __FILE__, __LINE__, #CaseName, #TestName); \ } \ template \ void GTEST_CASE_NAMESPACE_(CaseName)::TestName::TestBody() # define REGISTER_TYPED_TEST_CASE_P(CaseName, ...) \ namespace GTEST_CASE_NAMESPACE_(CaseName) { \ typedef ::testing::internal::Templates<__VA_ARGS__>::type gtest_AllTests_; \ } \ static const char* const GTEST_REGISTERED_TEST_NAMES_(CaseName) = \ GTEST_TYPED_TEST_CASE_P_STATE_(CaseName).VerifyRegisteredTestNames(\ __FILE__, __LINE__, #__VA_ARGS__) // The 'Types' template argument below must have spaces around it // since some compilers may choke on '>>' when passing a template // instance (e.g. Types) # define INSTANTIATE_TYPED_TEST_CASE_P(Prefix, CaseName, Types) \ bool gtest_##Prefix##_##CaseName GTEST_ATTRIBUTE_UNUSED_ = \ ::testing::internal::TypeParameterizedTestCase::type>::Register(\ #Prefix, #CaseName, GTEST_REGISTERED_TEST_NAMES_(CaseName)) #endif // GTEST_HAS_TYPED_TEST_P #endif // GTEST_INCLUDE_GTEST_GTEST_TYPED_TEST_H_ // Depending on the platform, different string classes are available. // On Linux, in addition to ::std::string, Google also makes use of // class ::string, which has the same interface as ::std::string, but // has a different implementation. // // The user can define GTEST_HAS_GLOBAL_STRING to 1 to indicate that // ::string is available AND is a distinct type to ::std::string, or // define it to 0 to indicate otherwise. // // If the user's ::std::string and ::string are the same class due to // aliasing, he should define GTEST_HAS_GLOBAL_STRING to 0. // // If the user doesn't define GTEST_HAS_GLOBAL_STRING, it is defined // heuristically. namespace testing { // Declares the flags. // This flag temporary enables the disabled tests. GTEST_DECLARE_bool_(also_run_disabled_tests); // This flag brings the debugger on an assertion failure. GTEST_DECLARE_bool_(break_on_failure); // This flag controls whether Google Test catches all test-thrown exceptions // and logs them as failures. GTEST_DECLARE_bool_(catch_exceptions); // This flag enables using colors in terminal output. Available values are // "yes" to enable colors, "no" (disable colors), or "auto" (the default) // to let Google Test decide. GTEST_DECLARE_string_(color); // This flag sets up the filter to select by name using a glob pattern // the tests to run. If the filter is not given all tests are executed. GTEST_DECLARE_string_(filter); // This flag causes the Google Test to list tests. None of the tests listed // are actually run if the flag is provided. GTEST_DECLARE_bool_(list_tests); // This flag controls whether Google Test emits a detailed XML report to a file // in addition to its normal textual output. GTEST_DECLARE_string_(output); // This flags control whether Google Test prints the elapsed time for each // test. GTEST_DECLARE_bool_(print_time); // This flag specifies the random number seed. GTEST_DECLARE_int32_(random_seed); // This flag sets how many times the tests are repeated. The default value // is 1. If the value is -1 the tests are repeating forever. GTEST_DECLARE_int32_(repeat); // This flag controls whether Google Test includes Google Test internal // stack frames in failure stack traces. GTEST_DECLARE_bool_(show_internal_stack_frames); // When this flag is specified, tests' order is randomized on every iteration. GTEST_DECLARE_bool_(shuffle); // This flag specifies the maximum number of stack frames to be // printed in a failure message. GTEST_DECLARE_int32_(stack_trace_depth); // When this flag is specified, a failed assertion will throw an // exception if exceptions are enabled, or exit the program with a // non-zero code otherwise. GTEST_DECLARE_bool_(throw_on_failure); // When this flag is set with a "host:port" string, on supported // platforms test results are streamed to the specified port on // the specified host machine. GTEST_DECLARE_string_(stream_result_to); // The upper limit for valid stack trace depths. const int kMaxStackTraceDepth = 100; namespace internal { class AssertHelper; class DefaultGlobalTestPartResultReporter; class ExecDeathTest; class NoExecDeathTest; class FinalSuccessChecker; class GTestFlagSaver; class StreamingListenerTest; class TestResultAccessor; class TestEventListenersAccessor; class TestEventRepeater; class UnitTestRecordPropertyTestHelper; class WindowsDeathTest; class UnitTestImpl* GetUnitTestImpl(); void ReportFailureInUnknownLocation(TestPartResult::Type result_type, const std::string& message); } // namespace internal // The friend relationship of some of these classes is cyclic. // If we don't forward declare them the compiler might confuse the classes // in friendship clauses with same named classes on the scope. class Test; class TestCase; class TestInfo; class UnitTest; // A class for indicating whether an assertion was successful. When // the assertion wasn't successful, the AssertionResult object // remembers a non-empty message that describes how it failed. // // To create an instance of this class, use one of the factory functions // (AssertionSuccess() and AssertionFailure()). // // This class is useful for two purposes: // 1. Defining predicate functions to be used with Boolean test assertions // EXPECT_TRUE/EXPECT_FALSE and their ASSERT_ counterparts // 2. Defining predicate-format functions to be // used with predicate assertions (ASSERT_PRED_FORMAT*, etc). // // For example, if you define IsEven predicate: // // testing::AssertionResult IsEven(int n) { // if ((n % 2) == 0) // return testing::AssertionSuccess(); // else // return testing::AssertionFailure() << n << " is odd"; // } // // Then the failed expectation EXPECT_TRUE(IsEven(Fib(5))) // will print the message // // Value of: IsEven(Fib(5)) // Actual: false (5 is odd) // Expected: true // // instead of a more opaque // // Value of: IsEven(Fib(5)) // Actual: false // Expected: true // // in case IsEven is a simple Boolean predicate. // // If you expect your predicate to be reused and want to support informative // messages in EXPECT_FALSE and ASSERT_FALSE (negative assertions show up // about half as often as positive ones in our tests), supply messages for // both success and failure cases: // // testing::AssertionResult IsEven(int n) { // if ((n % 2) == 0) // return testing::AssertionSuccess() << n << " is even"; // else // return testing::AssertionFailure() << n << " is odd"; // } // // Then a statement EXPECT_FALSE(IsEven(Fib(6))) will print // // Value of: IsEven(Fib(6)) // Actual: true (8 is even) // Expected: false // // NB: Predicates that support negative Boolean assertions have reduced // performance in positive ones so be careful not to use them in tests // that have lots (tens of thousands) of positive Boolean assertions. // // To use this class with EXPECT_PRED_FORMAT assertions such as: // // // Verifies that Foo() returns an even number. // EXPECT_PRED_FORMAT1(IsEven, Foo()); // // you need to define: // // testing::AssertionResult IsEven(const char* expr, int n) { // if ((n % 2) == 0) // return testing::AssertionSuccess(); // else // return testing::AssertionFailure() // << "Expected: " << expr << " is even\n Actual: it's " << n; // } // // If Foo() returns 5, you will see the following message: // // Expected: Foo() is even // Actual: it's 5 // class GTEST_API_ AssertionResult { public: // Copy constructor. // Used in EXPECT_TRUE/FALSE(assertion_result). AssertionResult(const AssertionResult& other); // Used in the EXPECT_TRUE/FALSE(bool_expression). explicit AssertionResult(bool success) : success_(success) {} // Returns true iff the assertion succeeded. operator bool() const { return success_; } // NOLINT // Returns the assertion's negation. Used with EXPECT/ASSERT_FALSE. AssertionResult operator!() const; // Returns the text streamed into this AssertionResult. Test assertions // use it when they fail (i.e., the predicate's outcome doesn't match the // assertion's expectation). When nothing has been streamed into the // object, returns an empty string. const char* message() const { return message_.get() != NULL ? message_->c_str() : ""; } // TODO(vladl@google.com): Remove this after making sure no clients use it. // Deprecated; please use message() instead. const char* failure_message() const { return message(); } // Streams a custom failure message into this object. template AssertionResult& operator<<(const T& value) { AppendMessage(Message() << value); return *this; } // Allows streaming basic output manipulators such as endl or flush into // this object. AssertionResult& operator<<( ::std::ostream& (*basic_manipulator)(::std::ostream& stream)) { AppendMessage(Message() << basic_manipulator); return *this; } private: // Appends the contents of message to message_. void AppendMessage(const Message& a_message) { if (message_.get() == NULL) message_.reset(new ::std::string); message_->append(a_message.GetString().c_str()); } // Stores result of the assertion predicate. bool success_; // Stores the message describing the condition in case the expectation // construct is not satisfied with the predicate's outcome. // Referenced via a pointer to avoid taking too much stack frame space // with test assertions. internal::scoped_ptr< ::std::string> message_; GTEST_DISALLOW_ASSIGN_(AssertionResult); }; // Makes a successful assertion result. GTEST_API_ AssertionResult AssertionSuccess(); // Makes a failed assertion result. GTEST_API_ AssertionResult AssertionFailure(); // Makes a failed assertion result with the given failure message. // Deprecated; use AssertionFailure() << msg. GTEST_API_ AssertionResult AssertionFailure(const Message& msg); // The abstract class that all tests inherit from. // // In Google Test, a unit test program contains one or many TestCases, and // each TestCase contains one or many Tests. // // When you define a test using the TEST macro, you don't need to // explicitly derive from Test - the TEST macro automatically does // this for you. // // The only time you derive from Test is when defining a test fixture // to be used a TEST_F. For example: // // class FooTest : public testing::Test { // protected: // virtual void SetUp() { ... } // virtual void TearDown() { ... } // ... // }; // // TEST_F(FooTest, Bar) { ... } // TEST_F(FooTest, Baz) { ... } // // Test is not copyable. class GTEST_API_ Test { public: friend class TestInfo; // Defines types for pointers to functions that set up and tear down // a test case. typedef internal::SetUpTestCaseFunc SetUpTestCaseFunc; typedef internal::TearDownTestCaseFunc TearDownTestCaseFunc; // The d'tor is virtual as we intend to inherit from Test. virtual ~Test(); // Sets up the stuff shared by all tests in this test case. // // Google Test will call Foo::SetUpTestCase() before running the first // test in test case Foo. Hence a sub-class can define its own // SetUpTestCase() method to shadow the one defined in the super // class. static void SetUpTestCase() {} // Tears down the stuff shared by all tests in this test case. // // Google Test will call Foo::TearDownTestCase() after running the last // test in test case Foo. Hence a sub-class can define its own // TearDownTestCase() method to shadow the one defined in the super // class. static void TearDownTestCase() {} // Returns true iff the current test has a fatal failure. static bool HasFatalFailure(); // Returns true iff the current test has a non-fatal failure. static bool HasNonfatalFailure(); // Returns true iff the current test has a (either fatal or // non-fatal) failure. static bool HasFailure() { return HasFatalFailure() || HasNonfatalFailure(); } // Logs a property for the current test, test case, or for the entire // invocation of the test program when used outside of the context of a // test case. Only the last value for a given key is remembered. These // are public static so they can be called from utility functions that are // not members of the test fixture. Calls to RecordProperty made during // lifespan of the test (from the moment its constructor starts to the // moment its destructor finishes) will be output in XML as attributes of // the element. Properties recorded from fixture's // SetUpTestCase or TearDownTestCase are logged as attributes of the // corresponding element. Calls to RecordProperty made in the // global context (before or after invocation of RUN_ALL_TESTS and from // SetUp/TearDown method of Environment objects registered with Google // Test) will be output as attributes of the element. static void RecordProperty(const std::string& key, const std::string& value); static void RecordProperty(const std::string& key, int value); protected: // Creates a Test object. Test(); // Sets up the test fixture. virtual void SetUp(); // Tears down the test fixture. virtual void TearDown(); private: // Returns true iff the current test has the same fixture class as // the first test in the current test case. static bool HasSameFixtureClass(); // Runs the test after the test fixture has been set up. // // A sub-class must implement this to define the test logic. // // DO NOT OVERRIDE THIS FUNCTION DIRECTLY IN A USER PROGRAM. // Instead, use the TEST or TEST_F macro. virtual void TestBody() = 0; // Sets up, executes, and tears down the test. void Run(); // Deletes self. We deliberately pick an unusual name for this // internal method to avoid clashing with names used in user TESTs. void DeleteSelf_() { delete this; } // Uses a GTestFlagSaver to save and restore all Google Test flags. const internal::GTestFlagSaver* const gtest_flag_saver_; // Often a user mis-spells SetUp() as Setup() and spends a long time // wondering why it is never called by Google Test. The declaration of // the following method is solely for catching such an error at // compile time: // // - The return type is deliberately chosen to be not void, so it // will be a conflict if a user declares void Setup() in his test // fixture. // // - This method is private, so it will be another compiler error // if a user calls it from his test fixture. // // DO NOT OVERRIDE THIS FUNCTION. // // If you see an error about overriding the following function or // about it being private, you have mis-spelled SetUp() as Setup(). struct Setup_should_be_spelled_SetUp {}; virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } // We disallow copying Tests. GTEST_DISALLOW_COPY_AND_ASSIGN_(Test); }; typedef internal::TimeInMillis TimeInMillis; // A copyable object representing a user specified test property which can be // output as a key/value string pair. // // Don't inherit from TestProperty as its destructor is not virtual. class TestProperty { public: // C'tor. TestProperty does NOT have a default constructor. // Always use this constructor (with parameters) to create a // TestProperty object. TestProperty(const std::string& a_key, const std::string& a_value) : key_(a_key), value_(a_value) { } // Gets the user supplied key. const char* key() const { return key_.c_str(); } // Gets the user supplied value. const char* value() const { return value_.c_str(); } // Sets a new value, overriding the one supplied in the constructor. void SetValue(const std::string& new_value) { value_ = new_value; } private: // The key supplied by the user. std::string key_; // The value supplied by the user. std::string value_; }; // The result of a single Test. This includes a list of // TestPartResults, a list of TestProperties, a count of how many // death tests there are in the Test, and how much time it took to run // the Test. // // TestResult is not copyable. class GTEST_API_ TestResult { public: // Creates an empty TestResult. TestResult(); // D'tor. Do not inherit from TestResult. ~TestResult(); // Gets the number of all test parts. This is the sum of the number // of successful test parts and the number of failed test parts. int total_part_count() const; // Returns the number of the test properties. int test_property_count() const; // Returns true iff the test passed (i.e. no test part failed). bool Passed() const { return !Failed(); } // Returns true iff the test failed. bool Failed() const; // Returns true iff the test fatally failed. bool HasFatalFailure() const; // Returns true iff the test has a non-fatal failure. bool HasNonfatalFailure() const; // Returns the elapsed time, in milliseconds. TimeInMillis elapsed_time() const { return elapsed_time_; } // Returns the i-th test part result among all the results. i can range // from 0 to test_property_count() - 1. If i is not in that range, aborts // the program. const TestPartResult& GetTestPartResult(int i) const; // Returns the i-th test property. i can range from 0 to // test_property_count() - 1. If i is not in that range, aborts the // program. const TestProperty& GetTestProperty(int i) const; private: friend class TestInfo; friend class TestCase; friend class UnitTest; friend class internal::DefaultGlobalTestPartResultReporter; friend class internal::ExecDeathTest; friend class internal::TestResultAccessor; friend class internal::UnitTestImpl; friend class internal::WindowsDeathTest; // Gets the vector of TestPartResults. const std::vector& test_part_results() const { return test_part_results_; } // Gets the vector of TestProperties. const std::vector& test_properties() const { return test_properties_; } // Sets the elapsed time. void set_elapsed_time(TimeInMillis elapsed) { elapsed_time_ = elapsed; } // Adds a test property to the list. The property is validated and may add // a non-fatal failure if invalid (e.g., if it conflicts with reserved // key names). If a property is already recorded for the same key, the // value will be updated, rather than storing multiple values for the same // key. xml_element specifies the element for which the property is being // recorded and is used for validation. void RecordProperty(const std::string& xml_element, const TestProperty& test_property); // Adds a failure if the key is a reserved attribute of Google Test // testcase tags. Returns true if the property is valid. // TODO(russr): Validate attribute names are legal and human readable. static bool ValidateTestProperty(const std::string& xml_element, const TestProperty& test_property); // Adds a test part result to the list. void AddTestPartResult(const TestPartResult& test_part_result); // Returns the death test count. int death_test_count() const { return death_test_count_; } // Increments the death test count, returning the new count. int increment_death_test_count() { return ++death_test_count_; } // Clears the test part results. void ClearTestPartResults(); // Clears the object. void Clear(); // Protects mutable state of the property vector and of owned // properties, whose values may be updated. internal::Mutex test_properites_mutex_; // The vector of TestPartResults std::vector test_part_results_; // The vector of TestProperties std::vector test_properties_; // Running count of death tests. int death_test_count_; // The elapsed time, in milliseconds. TimeInMillis elapsed_time_; // We disallow copying TestResult. GTEST_DISALLOW_COPY_AND_ASSIGN_(TestResult); }; // class TestResult // A TestInfo object stores the following information about a test: // // Test case name // Test name // Whether the test should be run // A function pointer that creates the test object when invoked // Test result // // The constructor of TestInfo registers itself with the UnitTest // singleton such that the RUN_ALL_TESTS() macro knows which tests to // run. class GTEST_API_ TestInfo { public: // Destructs a TestInfo object. This function is not virtual, so // don't inherit from TestInfo. ~TestInfo(); // Returns the test case name. const char* test_case_name() const { return test_case_name_.c_str(); } // Returns the test name. const char* name() const { return name_.c_str(); } // Returns the name of the parameter type, or NULL if this is not a typed // or a type-parameterized test. const char* type_param() const { if (type_param_.get() != NULL) return type_param_->c_str(); return NULL; } // Returns the text representation of the value parameter, or NULL if this // is not a value-parameterized test. const char* value_param() const { if (value_param_.get() != NULL) return value_param_->c_str(); return NULL; } // Returns true if this test should run, that is if the test is not // disabled (or it is disabled but the also_run_disabled_tests flag has // been specified) and its full name matches the user-specified filter. // // Google Test allows the user to filter the tests by their full names. // The full name of a test Bar in test case Foo is defined as // "Foo.Bar". Only the tests that match the filter will run. // // A filter is a colon-separated list of glob (not regex) patterns, // optionally followed by a '-' and a colon-separated list of // negative patterns (tests to exclude). A test is run if it // matches one of the positive patterns and does not match any of // the negative patterns. // // For example, *A*:Foo.* is a filter that matches any string that // contains the character 'A' or starts with "Foo.". bool should_run() const { return should_run_; } // Returns true iff this test will appear in the XML report. bool is_reportable() const { // For now, the XML report includes all tests matching the filter. // In the future, we may trim tests that are excluded because of // sharding. return matches_filter_; } // Returns the result of the test. const TestResult* result() const { return &result_; } private: #if GTEST_HAS_DEATH_TEST friend class internal::DefaultDeathTestFactory; #endif // GTEST_HAS_DEATH_TEST friend class Test; friend class TestCase; friend class internal::UnitTestImpl; friend class internal::StreamingListenerTest; friend TestInfo* internal::MakeAndRegisterTestInfo( const char* test_case_name, const char* name, const char* type_param, const char* value_param, internal::TypeId fixture_class_id, Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc, internal::TestFactoryBase* factory); // Constructs a TestInfo object. The newly constructed instance assumes // ownership of the factory object. TestInfo(const std::string& test_case_name, const std::string& name, const char* a_type_param, // NULL if not a type-parameterized test const char* a_value_param, // NULL if not a value-parameterized test internal::TypeId fixture_class_id, internal::TestFactoryBase* factory); // Increments the number of death tests encountered in this test so // far. int increment_death_test_count() { return result_.increment_death_test_count(); } // Creates the test object, runs it, records its result, and then // deletes it. void Run(); static void ClearTestResult(TestInfo* test_info) { test_info->result_.Clear(); } // These fields are immutable properties of the test. const std::string test_case_name_; // Test case name const std::string name_; // Test name // Name of the parameter type, or NULL if this is not a typed or a // type-parameterized test. const internal::scoped_ptr type_param_; // Text representation of the value parameter, or NULL if this is not a // value-parameterized test. const internal::scoped_ptr value_param_; const internal::TypeId fixture_class_id_; // ID of the test fixture class bool should_run_; // True iff this test should run bool is_disabled_; // True iff this test is disabled bool matches_filter_; // True if this test matches the // user-specified filter. internal::TestFactoryBase* const factory_; // The factory that creates // the test object // This field is mutable and needs to be reset before running the // test for the second time. TestResult result_; GTEST_DISALLOW_COPY_AND_ASSIGN_(TestInfo); }; // A test case, which consists of a vector of TestInfos. // // TestCase is not copyable. class GTEST_API_ TestCase { public: // Creates a TestCase with the given name. // // TestCase does NOT have a default constructor. Always use this // constructor to create a TestCase object. // // Arguments: // // name: name of the test case // a_type_param: the name of the test's type parameter, or NULL if // this is not a type-parameterized test. // set_up_tc: pointer to the function that sets up the test case // tear_down_tc: pointer to the function that tears down the test case TestCase(const char* name, const char* a_type_param, Test::SetUpTestCaseFunc set_up_tc, Test::TearDownTestCaseFunc tear_down_tc); // Destructor of TestCase. virtual ~TestCase(); // Gets the name of the TestCase. const char* name() const { return name_.c_str(); } // Returns the name of the parameter type, or NULL if this is not a // type-parameterized test case. const char* type_param() const { if (type_param_.get() != NULL) return type_param_->c_str(); return NULL; } // Returns true if any test in this test case should run. bool should_run() const { return should_run_; } // Gets the number of successful tests in this test case. int successful_test_count() const; // Gets the number of failed tests in this test case. int failed_test_count() const; // Gets the number of disabled tests that will be reported in the XML report. int reportable_disabled_test_count() const; // Gets the number of disabled tests in this test case. int disabled_test_count() const; // Gets the number of tests to be printed in the XML report. int reportable_test_count() const; // Get the number of tests in this test case that should run. int test_to_run_count() const; // Gets the number of all tests in this test case. int total_test_count() const; // Returns true iff the test case passed. bool Passed() const { return !Failed(); } // Returns true iff the test case failed. bool Failed() const { return failed_test_count() > 0; } // Returns the elapsed time, in milliseconds. TimeInMillis elapsed_time() const { return elapsed_time_; } // Returns the i-th test among all the tests. i can range from 0 to // total_test_count() - 1. If i is not in that range, returns NULL. const TestInfo* GetTestInfo(int i) const; // Returns the TestResult that holds test properties recorded during // execution of SetUpTestCase and TearDownTestCase. const TestResult& ad_hoc_test_result() const { return ad_hoc_test_result_; } private: friend class Test; friend class internal::UnitTestImpl; // Gets the (mutable) vector of TestInfos in this TestCase. std::vector& test_info_list() { return test_info_list_; } // Gets the (immutable) vector of TestInfos in this TestCase. const std::vector& test_info_list() const { return test_info_list_; } // Returns the i-th test among all the tests. i can range from 0 to // total_test_count() - 1. If i is not in that range, returns NULL. TestInfo* GetMutableTestInfo(int i); // Sets the should_run member. void set_should_run(bool should) { should_run_ = should; } // Adds a TestInfo to this test case. Will delete the TestInfo upon // destruction of the TestCase object. void AddTestInfo(TestInfo * test_info); // Clears the results of all tests in this test case. void ClearResult(); // Clears the results of all tests in the given test case. static void ClearTestCaseResult(TestCase* test_case) { test_case->ClearResult(); } // Runs every test in this TestCase. void Run(); // Runs SetUpTestCase() for this TestCase. This wrapper is needed // for catching exceptions thrown from SetUpTestCase(). void RunSetUpTestCase() { (*set_up_tc_)(); } // Runs TearDownTestCase() for this TestCase. This wrapper is // needed for catching exceptions thrown from TearDownTestCase(). void RunTearDownTestCase() { (*tear_down_tc_)(); } // Returns true iff test passed. static bool TestPassed(const TestInfo* test_info) { return test_info->should_run() && test_info->result()->Passed(); } // Returns true iff test failed. static bool TestFailed(const TestInfo* test_info) { return test_info->should_run() && test_info->result()->Failed(); } // Returns true iff the test is disabled and will be reported in the XML // report. static bool TestReportableDisabled(const TestInfo* test_info) { return test_info->is_reportable() && test_info->is_disabled_; } // Returns true iff test is disabled. static bool TestDisabled(const TestInfo* test_info) { return test_info->is_disabled_; } // Returns true iff this test will appear in the XML report. static bool TestReportable(const TestInfo* test_info) { return test_info->is_reportable(); } // Returns true if the given test should run. static bool ShouldRunTest(const TestInfo* test_info) { return test_info->should_run(); } // Shuffles the tests in this test case. void ShuffleTests(internal::Random* random); // Restores the test order to before the first shuffle. void UnshuffleTests(); // Name of the test case. std::string name_; // Name of the parameter type, or NULL if this is not a typed or a // type-parameterized test. const internal::scoped_ptr type_param_; // The vector of TestInfos in their original order. It owns the // elements in the vector. std::vector test_info_list_; // Provides a level of indirection for the test list to allow easy // shuffling and restoring the test order. The i-th element in this // vector is the index of the i-th test in the shuffled test list. std::vector test_indices_; // Pointer to the function that sets up the test case. Test::SetUpTestCaseFunc set_up_tc_; // Pointer to the function that tears down the test case. Test::TearDownTestCaseFunc tear_down_tc_; // True iff any test in this test case should run. bool should_run_; // Elapsed time, in milliseconds. TimeInMillis elapsed_time_; // Holds test properties recorded during execution of SetUpTestCase and // TearDownTestCase. TestResult ad_hoc_test_result_; // We disallow copying TestCases. GTEST_DISALLOW_COPY_AND_ASSIGN_(TestCase); }; // An Environment object is capable of setting up and tearing down an // environment. The user should subclass this to define his own // environment(s). // // An Environment object does the set-up and tear-down in virtual // methods SetUp() and TearDown() instead of the constructor and the // destructor, as: // // 1. You cannot safely throw from a destructor. This is a problem // as in some cases Google Test is used where exceptions are enabled, and // we may want to implement ASSERT_* using exceptions where they are // available. // 2. You cannot use ASSERT_* directly in a constructor or // destructor. class Environment { public: // The d'tor is virtual as we need to subclass Environment. virtual ~Environment() {} // Override this to define how to set up the environment. virtual void SetUp() {} // Override this to define how to tear down the environment. virtual void TearDown() {} private: // If you see an error about overriding the following function or // about it being private, you have mis-spelled SetUp() as Setup(). struct Setup_should_be_spelled_SetUp {}; virtual Setup_should_be_spelled_SetUp* Setup() { return NULL; } }; // The interface for tracing execution of tests. The methods are organized in // the order the corresponding events are fired. class TestEventListener { public: virtual ~TestEventListener() {} // Fired before any test activity starts. virtual void OnTestProgramStart(const UnitTest& unit_test) = 0; // Fired before each iteration of tests starts. There may be more than // one iteration if GTEST_FLAG(repeat) is set. iteration is the iteration // index, starting from 0. virtual void OnTestIterationStart(const UnitTest& unit_test, int iteration) = 0; // Fired before environment set-up for each iteration of tests starts. virtual void OnEnvironmentsSetUpStart(const UnitTest& unit_test) = 0; // Fired after environment set-up for each iteration of tests ends. virtual void OnEnvironmentsSetUpEnd(const UnitTest& unit_test) = 0; // Fired before the test case starts. virtual void OnTestCaseStart(const TestCase& test_case) = 0; // Fired before the test starts. virtual void OnTestStart(const TestInfo& test_info) = 0; // Fired after a failed assertion or a SUCCEED() invocation. virtual void OnTestPartResult(const TestPartResult& test_part_result) = 0; // Fired after the test ends. virtual void OnTestEnd(const TestInfo& test_info) = 0; // Fired after the test case ends. virtual void OnTestCaseEnd(const TestCase& test_case) = 0; // Fired before environment tear-down for each iteration of tests starts. virtual void OnEnvironmentsTearDownStart(const UnitTest& unit_test) = 0; // Fired after environment tear-down for each iteration of tests ends. virtual void OnEnvironmentsTearDownEnd(const UnitTest& unit_test) = 0; // Fired after each iteration of tests finishes. virtual void OnTestIterationEnd(const UnitTest& unit_test, int iteration) = 0; // Fired after all test activities have ended. virtual void OnTestProgramEnd(const UnitTest& unit_test) = 0; }; // The convenience class for users who need to override just one or two // methods and are not concerned that a possible change to a signature of // the methods they override will not be caught during the build. For // comments about each method please see the definition of TestEventListener // above. class EmptyTestEventListener : public TestEventListener { public: virtual void OnTestProgramStart(const UnitTest& /*unit_test*/) {} virtual void OnTestIterationStart(const UnitTest& /*unit_test*/, int /*iteration*/) {} virtual void OnEnvironmentsSetUpStart(const UnitTest& /*unit_test*/) {} virtual void OnEnvironmentsSetUpEnd(const UnitTest& /*unit_test*/) {} virtual void OnTestCaseStart(const TestCase& /*test_case*/) {} virtual void OnTestStart(const TestInfo& /*test_info*/) {} virtual void OnTestPartResult(const TestPartResult& /*test_part_result*/) {} virtual void OnTestEnd(const TestInfo& /*test_info*/) {} virtual void OnTestCaseEnd(const TestCase& /*test_case*/) {} virtual void OnEnvironmentsTearDownStart(const UnitTest& /*unit_test*/) {} virtual void OnEnvironmentsTearDownEnd(const UnitTest& /*unit_test*/) {} virtual void OnTestIterationEnd(const UnitTest& /*unit_test*/, int /*iteration*/) {} virtual void OnTestProgramEnd(const UnitTest& /*unit_test*/) {} }; // TestEventListeners lets users add listeners to track events in Google Test. class GTEST_API_ TestEventListeners { public: TestEventListeners(); ~TestEventListeners(); // Appends an event listener to the end of the list. Google Test assumes // the ownership of the listener (i.e. it will delete the listener when // the test program finishes). void Append(TestEventListener* listener); // Removes the given event listener from the list and returns it. It then // becomes the caller's responsibility to delete the listener. Returns // NULL if the listener is not found in the list. TestEventListener* Release(TestEventListener* listener); // Returns the standard listener responsible for the default console // output. Can be removed from the listeners list to shut down default // console output. Note that removing this object from the listener list // with Release transfers its ownership to the caller and makes this // function return NULL the next time. TestEventListener* default_result_printer() const { return default_result_printer_; } // Returns the standard listener responsible for the default XML output // controlled by the --gtest_output=xml flag. Can be removed from the // listeners list by users who want to shut down the default XML output // controlled by this flag and substitute it with custom one. Note that // removing this object from the listener list with Release transfers its // ownership to the caller and makes this function return NULL the next // time. TestEventListener* default_xml_generator() const { return default_xml_generator_; } private: friend class TestCase; friend class TestInfo; friend class internal::DefaultGlobalTestPartResultReporter; friend class internal::NoExecDeathTest; friend class internal::TestEventListenersAccessor; friend class internal::UnitTestImpl; // Returns repeater that broadcasts the TestEventListener events to all // subscribers. TestEventListener* repeater(); // Sets the default_result_printer attribute to the provided listener. // The listener is also added to the listener list and previous // default_result_printer is removed from it and deleted. The listener can // also be NULL in which case it will not be added to the list. Does // nothing if the previous and the current listener objects are the same. void SetDefaultResultPrinter(TestEventListener* listener); // Sets the default_xml_generator attribute to the provided listener. The // listener is also added to the listener list and previous // default_xml_generator is removed from it and deleted. The listener can // also be NULL in which case it will not be added to the list. Does // nothing if the previous and the current listener objects are the same. void SetDefaultXmlGenerator(TestEventListener* listener); // Controls whether events will be forwarded by the repeater to the // listeners in the list. bool EventForwardingEnabled() const; void SuppressEventForwarding(); // The actual list of listeners. internal::TestEventRepeater* repeater_; // Listener responsible for the standard result output. TestEventListener* default_result_printer_; // Listener responsible for the creation of the XML output file. TestEventListener* default_xml_generator_; // We disallow copying TestEventListeners. GTEST_DISALLOW_COPY_AND_ASSIGN_(TestEventListeners); }; // A UnitTest consists of a vector of TestCases. // // This is a singleton class. The only instance of UnitTest is // created when UnitTest::GetInstance() is first called. This // instance is never deleted. // // UnitTest is not copyable. // // This class is thread-safe as long as the methods are called // according to their specification. class GTEST_API_ UnitTest { public: // Gets the singleton UnitTest object. The first time this method // is called, a UnitTest object is constructed and returned. // Consecutive calls will return the same object. static UnitTest* GetInstance(); // Runs all tests in this UnitTest object and prints the result. // Returns 0 if successful, or 1 otherwise. // // This method can only be called from the main thread. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. int Run() GTEST_MUST_USE_RESULT_; // Returns the working directory when the first TEST() or TEST_F() // was executed. The UnitTest object owns the string. const char* original_working_dir() const; // Returns the TestCase object for the test that's currently running, // or NULL if no test is running. const TestCase* current_test_case() const GTEST_LOCK_EXCLUDED_(mutex_); // Returns the TestInfo object for the test that's currently running, // or NULL if no test is running. const TestInfo* current_test_info() const GTEST_LOCK_EXCLUDED_(mutex_); // Returns the random seed used at the start of the current test run. int random_seed() const; #if GTEST_HAS_PARAM_TEST // Returns the ParameterizedTestCaseRegistry object used to keep track of // value-parameterized tests and instantiate and register them. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. internal::ParameterizedTestCaseRegistry& parameterized_test_registry() GTEST_LOCK_EXCLUDED_(mutex_); #endif // GTEST_HAS_PARAM_TEST // Gets the number of successful test cases. int successful_test_case_count() const; // Gets the number of failed test cases. int failed_test_case_count() const; // Gets the number of all test cases. int total_test_case_count() const; // Gets the number of all test cases that contain at least one test // that should run. int test_case_to_run_count() const; // Gets the number of successful tests. int successful_test_count() const; // Gets the number of failed tests. int failed_test_count() const; // Gets the number of disabled tests that will be reported in the XML report. int reportable_disabled_test_count() const; // Gets the number of disabled tests. int disabled_test_count() const; // Gets the number of tests to be printed in the XML report. int reportable_test_count() const; // Gets the number of all tests. int total_test_count() const; // Gets the number of tests that should run. int test_to_run_count() const; // Gets the time of the test program start, in ms from the start of the // UNIX epoch. TimeInMillis start_timestamp() const; // Gets the elapsed time, in milliseconds. TimeInMillis elapsed_time() const; // Returns true iff the unit test passed (i.e. all test cases passed). bool Passed() const; // Returns true iff the unit test failed (i.e. some test case failed // or something outside of all tests failed). bool Failed() const; // Gets the i-th test case among all the test cases. i can range from 0 to // total_test_case_count() - 1. If i is not in that range, returns NULL. const TestCase* GetTestCase(int i) const; // Returns the TestResult containing information on test failures and // properties logged outside of individual test cases. const TestResult& ad_hoc_test_result() const; // Returns the list of event listeners that can be used to track events // inside Google Test. TestEventListeners& listeners(); private: // Registers and returns a global test environment. When a test // program is run, all global test environments will be set-up in // the order they were registered. After all tests in the program // have finished, all global test environments will be torn-down in // the *reverse* order they were registered. // // The UnitTest object takes ownership of the given environment. // // This method can only be called from the main thread. Environment* AddEnvironment(Environment* env); // Adds a TestPartResult to the current TestResult object. All // Google Test assertion macros (e.g. ASSERT_TRUE, EXPECT_EQ, etc) // eventually call this to report their results. The user code // should use the assertion macros instead of calling this directly. void AddTestPartResult(TestPartResult::Type result_type, const char* file_name, int line_number, const std::string& message, const std::string& os_stack_trace) GTEST_LOCK_EXCLUDED_(mutex_); // Adds a TestProperty to the current TestResult object when invoked from // inside a test, to current TestCase's ad_hoc_test_result_ when invoked // from SetUpTestCase or TearDownTestCase, or to the global property set // when invoked elsewhere. If the result already contains a property with // the same key, the value will be updated. void RecordProperty(const std::string& key, const std::string& value); // Gets the i-th test case among all the test cases. i can range from 0 to // total_test_case_count() - 1. If i is not in that range, returns NULL. TestCase* GetMutableTestCase(int i); // Accessors for the implementation object. internal::UnitTestImpl* impl() { return impl_; } const internal::UnitTestImpl* impl() const { return impl_; } // These classes and funcions are friends as they need to access private // members of UnitTest. friend class Test; friend class internal::AssertHelper; friend class internal::ScopedTrace; friend class internal::StreamingListenerTest; friend class internal::UnitTestRecordPropertyTestHelper; friend Environment* AddGlobalTestEnvironment(Environment* env); friend internal::UnitTestImpl* internal::GetUnitTestImpl(); friend void internal::ReportFailureInUnknownLocation( TestPartResult::Type result_type, const std::string& message); // Creates an empty UnitTest. UnitTest(); // D'tor virtual ~UnitTest(); // Pushes a trace defined by SCOPED_TRACE() on to the per-thread // Google Test trace stack. void PushGTestTrace(const internal::TraceInfo& trace) GTEST_LOCK_EXCLUDED_(mutex_); // Pops a trace from the per-thread Google Test trace stack. void PopGTestTrace() GTEST_LOCK_EXCLUDED_(mutex_); // Protects mutable state in *impl_. This is mutable as some const // methods need to lock it too. mutable internal::Mutex mutex_; // Opaque implementation object. This field is never changed once // the object is constructed. We don't mark it as const here, as // doing so will cause a warning in the constructor of UnitTest. // Mutable state in *impl_ is protected by mutex_. internal::UnitTestImpl* impl_; // We disallow copying UnitTest. GTEST_DISALLOW_COPY_AND_ASSIGN_(UnitTest); }; // A convenient wrapper for adding an environment for the test // program. // // You should call this before RUN_ALL_TESTS() is called, probably in // main(). If you use gtest_main, you need to call this before main() // starts for it to take effect. For example, you can define a global // variable like this: // // testing::Environment* const foo_env = // testing::AddGlobalTestEnvironment(new FooEnvironment); // // However, we strongly recommend you to write your own main() and // call AddGlobalTestEnvironment() there, as relying on initialization // of global variables makes the code harder to read and may cause // problems when you register multiple environments from different // translation units and the environments have dependencies among them // (remember that the compiler doesn't guarantee the order in which // global variables from different translation units are initialized). inline Environment* AddGlobalTestEnvironment(Environment* env) { return UnitTest::GetInstance()->AddEnvironment(env); } // Initializes Google Test. This must be called before calling // RUN_ALL_TESTS(). In particular, it parses a command line for the // flags that Google Test recognizes. Whenever a Google Test flag is // seen, it is removed from argv, and *argc is decremented. // // No value is returned. Instead, the Google Test flag variables are // updated. // // Calling the function for the second time has no user-visible effect. GTEST_API_ void InitGoogleTest(int* argc, char** argv); // This overloaded version can be used in Windows programs compiled in // UNICODE mode. GTEST_API_ void InitGoogleTest(int* argc, wchar_t** argv); namespace internal { // FormatForComparison::Format(value) formats a // value of type ToPrint that is an operand of a comparison assertion // (e.g. ASSERT_EQ). OtherOperand is the type of the other operand in // the comparison, and is used to help determine the best way to // format the value. In particular, when the value is a C string // (char pointer) and the other operand is an STL string object, we // want to format the C string as a string, since we know it is // compared by value with the string object. If the value is a char // pointer but the other operand is not an STL string object, we don't // know whether the pointer is supposed to point to a NUL-terminated // string, and thus want to print it as a pointer to be safe. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // The default case. template class FormatForComparison { public: static ::std::string Format(const ToPrint& value) { return ::testing::PrintToString(value); } }; // Array. template class FormatForComparison { public: static ::std::string Format(const ToPrint* value) { return FormatForComparison::Format(value); } }; // By default, print C string as pointers to be safe, as we don't know // whether they actually point to a NUL-terminated string. #define GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(CharType) \ template \ class FormatForComparison { \ public: \ static ::std::string Format(CharType* value) { \ return ::testing::PrintToString(static_cast(value)); \ } \ } GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(char); GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const char); GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(wchar_t); GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_(const wchar_t); #undef GTEST_IMPL_FORMAT_C_STRING_AS_POINTER_ // If a C string is compared with an STL string object, we know it's meant // to point to a NUL-terminated string, and thus can print it as a string. #define GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(CharType, OtherStringType) \ template <> \ class FormatForComparison { \ public: \ static ::std::string Format(CharType* value) { \ return ::testing::PrintToString(value); \ } \ } GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::std::string); GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::std::string); #if GTEST_HAS_GLOBAL_STRING GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(char, ::string); GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const char, ::string); #endif #if GTEST_HAS_GLOBAL_WSTRING GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::wstring); GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::wstring); #endif #if GTEST_HAS_STD_WSTRING GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(wchar_t, ::std::wstring); GTEST_IMPL_FORMAT_C_STRING_AS_STRING_(const wchar_t, ::std::wstring); #endif #undef GTEST_IMPL_FORMAT_C_STRING_AS_STRING_ // Formats a comparison assertion (e.g. ASSERT_EQ, EXPECT_LT, and etc) // operand to be used in a failure message. The type (but not value) // of the other operand may affect the format. This allows us to // print a char* as a raw pointer when it is compared against another // char* or void*, and print it as a C string when it is compared // against an std::string object, for example. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. template std::string FormatForComparisonFailureMessage( const T1& value, const T2& /* other_operand */) { return FormatForComparison::Format(value); } // The helper function for {ASSERT|EXPECT}_EQ. template AssertionResult CmpHelperEQ(const char* expected_expression, const char* actual_expression, const T1& expected, const T2& actual) { #ifdef _MSC_VER # pragma warning(push) // Saves the current warning state. # pragma warning(disable:4389) // Temporarily disables warning on // signed/unsigned mismatch. #endif if (expected == actual) { return AssertionSuccess(); } #ifdef _MSC_VER # pragma warning(pop) // Restores the warning state. #endif return EqFailure(expected_expression, actual_expression, FormatForComparisonFailureMessage(expected, actual), FormatForComparisonFailureMessage(actual, expected), false); } // With this overloaded version, we allow anonymous enums to be used // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous enums // can be implicitly cast to BiggestInt. GTEST_API_ AssertionResult CmpHelperEQ(const char* expected_expression, const char* actual_expression, BiggestInt expected, BiggestInt actual); // The helper class for {ASSERT|EXPECT}_EQ. The template argument // lhs_is_null_literal is true iff the first argument to ASSERT_EQ() // is a null pointer literal. The following default implementation is // for lhs_is_null_literal being false. template class EqHelper { public: // This templatized version is for the general case. template static AssertionResult Compare(const char* expected_expression, const char* actual_expression, const T1& expected, const T2& actual) { return CmpHelperEQ(expected_expression, actual_expression, expected, actual); } // With this overloaded version, we allow anonymous enums to be used // in {ASSERT|EXPECT}_EQ when compiled with gcc 4, as anonymous // enums can be implicitly cast to BiggestInt. // // Even though its body looks the same as the above version, we // cannot merge the two, as it will make anonymous enums unhappy. static AssertionResult Compare(const char* expected_expression, const char* actual_expression, BiggestInt expected, BiggestInt actual) { return CmpHelperEQ(expected_expression, actual_expression, expected, actual); } }; // This specialization is used when the first argument to ASSERT_EQ() // is a null pointer literal, like NULL, false, or 0. template <> class EqHelper { public: // We define two overloaded versions of Compare(). The first // version will be picked when the second argument to ASSERT_EQ() is // NOT a pointer, e.g. ASSERT_EQ(0, AnIntFunction()) or // EXPECT_EQ(false, a_bool). template static AssertionResult Compare( const char* expected_expression, const char* actual_expression, const T1& expected, const T2& actual, // The following line prevents this overload from being considered if T2 // is not a pointer type. We need this because ASSERT_EQ(NULL, my_ptr) // expands to Compare("", "", NULL, my_ptr), which requires a conversion // to match the Secret* in the other overload, which would otherwise make // this template match better. typename EnableIf::value>::type* = 0) { return CmpHelperEQ(expected_expression, actual_expression, expected, actual); } // This version will be picked when the second argument to ASSERT_EQ() is a // pointer, e.g. ASSERT_EQ(NULL, a_pointer). template static AssertionResult Compare( const char* expected_expression, const char* actual_expression, // We used to have a second template parameter instead of Secret*. That // template parameter would deduce to 'long', making this a better match // than the first overload even without the first overload's EnableIf. // Unfortunately, gcc with -Wconversion-null warns when "passing NULL to // non-pointer argument" (even a deduced integral argument), so the old // implementation caused warnings in user code. Secret* /* expected (NULL) */, T* actual) { // We already know that 'expected' is a null pointer. return CmpHelperEQ(expected_expression, actual_expression, static_cast(NULL), actual); } }; // A macro for implementing the helper functions needed to implement // ASSERT_?? and EXPECT_??. It is here just to avoid copy-and-paste // of similar code. // // For each templatized helper function, we also define an overloaded // version for BiggestInt in order to reduce code bloat and allow // anonymous enums to be used with {ASSERT|EXPECT}_?? when compiled // with gcc 4. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. #define GTEST_IMPL_CMP_HELPER_(op_name, op)\ template \ AssertionResult CmpHelper##op_name(const char* expr1, const char* expr2, \ const T1& val1, const T2& val2) {\ if (val1 op val2) {\ return AssertionSuccess();\ } else {\ return AssertionFailure() \ << "Expected: (" << expr1 << ") " #op " (" << expr2\ << "), actual: " << FormatForComparisonFailureMessage(val1, val2)\ << " vs " << FormatForComparisonFailureMessage(val2, val1);\ }\ }\ GTEST_API_ AssertionResult CmpHelper##op_name(\ const char* expr1, const char* expr2, BiggestInt val1, BiggestInt val2) // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. // Implements the helper function for {ASSERT|EXPECT}_NE GTEST_IMPL_CMP_HELPER_(NE, !=); // Implements the helper function for {ASSERT|EXPECT}_LE GTEST_IMPL_CMP_HELPER_(LE, <=); // Implements the helper function for {ASSERT|EXPECT}_LT GTEST_IMPL_CMP_HELPER_(LT, <); // Implements the helper function for {ASSERT|EXPECT}_GE GTEST_IMPL_CMP_HELPER_(GE, >=); // Implements the helper function for {ASSERT|EXPECT}_GT GTEST_IMPL_CMP_HELPER_(GT, >); #undef GTEST_IMPL_CMP_HELPER_ // The helper function for {ASSERT|EXPECT}_STREQ. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression, const char* actual_expression, const char* expected, const char* actual); // The helper function for {ASSERT|EXPECT}_STRCASEEQ. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTRCASEEQ(const char* expected_expression, const char* actual_expression, const char* expected, const char* actual); // The helper function for {ASSERT|EXPECT}_STRNE. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, const char* s2_expression, const char* s1, const char* s2); // The helper function for {ASSERT|EXPECT}_STRCASENE. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTRCASENE(const char* s1_expression, const char* s2_expression, const char* s1, const char* s2); // Helper function for *_STREQ on wide strings. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTREQ(const char* expected_expression, const char* actual_expression, const wchar_t* expected, const wchar_t* actual); // Helper function for *_STRNE on wide strings. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult CmpHelperSTRNE(const char* s1_expression, const char* s2_expression, const wchar_t* s1, const wchar_t* s2); } // namespace internal // IsSubstring() and IsNotSubstring() are intended to be used as the // first argument to {EXPECT,ASSERT}_PRED_FORMAT2(), not by // themselves. They check whether needle is a substring of haystack // (NULL is considered a substring of itself only), and return an // appropriate error message when they fail. // // The {needle,haystack}_expr arguments are the stringified // expressions that generated the two real arguments. GTEST_API_ AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const char* needle, const char* haystack); GTEST_API_ AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack); GTEST_API_ AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const char* needle, const char* haystack); GTEST_API_ AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const wchar_t* needle, const wchar_t* haystack); GTEST_API_ AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack); GTEST_API_ AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const ::std::string& needle, const ::std::string& haystack); #if GTEST_HAS_STD_WSTRING GTEST_API_ AssertionResult IsSubstring( const char* needle_expr, const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack); GTEST_API_ AssertionResult IsNotSubstring( const char* needle_expr, const char* haystack_expr, const ::std::wstring& needle, const ::std::wstring& haystack); #endif // GTEST_HAS_STD_WSTRING namespace internal { // Helper template function for comparing floating-points. // // Template parameter: // // RawType: the raw floating-point type (either float or double) // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. template AssertionResult CmpHelperFloatingPointEQ(const char* expected_expression, const char* actual_expression, RawType expected, RawType actual) { const FloatingPoint lhs(expected), rhs(actual); if (lhs.AlmostEquals(rhs)) { return AssertionSuccess(); } ::std::stringstream expected_ss; expected_ss << std::setprecision(std::numeric_limits::digits10 + 2) << expected; ::std::stringstream actual_ss; actual_ss << std::setprecision(std::numeric_limits::digits10 + 2) << actual; return EqFailure(expected_expression, actual_expression, StringStreamToString(&expected_ss), StringStreamToString(&actual_ss), false); } // Helper function for implementing ASSERT_NEAR. // // INTERNAL IMPLEMENTATION - DO NOT USE IN A USER PROGRAM. GTEST_API_ AssertionResult DoubleNearPredFormat(const char* expr1, const char* expr2, const char* abs_error_expr, double val1, double val2, double abs_error); // INTERNAL IMPLEMENTATION - DO NOT USE IN USER CODE. // A class that enables one to stream messages to assertion macros class GTEST_API_ AssertHelper { public: // Constructor. AssertHelper(TestPartResult::Type type, const char* file, int line, const char* message); ~AssertHelper(); // Message assignment is a semantic trick to enable assertion // streaming; see the GTEST_MESSAGE_ macro below. void operator=(const Message& message) const; private: // We put our data in a struct so that the size of the AssertHelper class can // be as small as possible. This is important because gcc is incapable of // re-using stack space even for temporary variables, so every EXPECT_EQ // reserves stack space for another AssertHelper. struct AssertHelperData { AssertHelperData(TestPartResult::Type t, const char* srcfile, int line_num, const char* msg) : type(t), file(srcfile), line(line_num), message(msg) { } TestPartResult::Type const type; const char* const file; int const line; std::string const message; private: GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelperData); }; AssertHelperData* const data_; GTEST_DISALLOW_COPY_AND_ASSIGN_(AssertHelper); }; } // namespace internal #if GTEST_HAS_PARAM_TEST // The pure interface class that all value-parameterized tests inherit from. // A value-parameterized class must inherit from both ::testing::Test and // ::testing::WithParamInterface. In most cases that just means inheriting // from ::testing::TestWithParam, but more complicated test hierarchies // may need to inherit from Test and WithParamInterface at different levels. // // This interface has support for accessing the test parameter value via // the GetParam() method. // // Use it with one of the parameter generator defining functions, like Range(), // Values(), ValuesIn(), Bool(), and Combine(). // // class FooTest : public ::testing::TestWithParam { // protected: // FooTest() { // // Can use GetParam() here. // } // virtual ~FooTest() { // // Can use GetParam() here. // } // virtual void SetUp() { // // Can use GetParam() here. // } // virtual void TearDown { // // Can use GetParam() here. // } // }; // TEST_P(FooTest, DoesBar) { // // Can use GetParam() method here. // Foo foo; // ASSERT_TRUE(foo.DoesBar(GetParam())); // } // INSTANTIATE_TEST_CASE_P(OneToTenRange, FooTest, ::testing::Range(1, 10)); template class WithParamInterface { public: typedef T ParamType; virtual ~WithParamInterface() {} // The current parameter value. Is also available in the test fixture's // constructor. This member function is non-static, even though it only // references static data, to reduce the opportunity for incorrect uses // like writing 'WithParamInterface::GetParam()' for a test that // uses a fixture whose parameter type is int. const ParamType& GetParam() const { GTEST_CHECK_(parameter_ != NULL) << "GetParam() can only be called inside a value-parameterized test " << "-- did you intend to write TEST_P instead of TEST_F?"; return *parameter_; } private: // Sets parameter value. The caller is responsible for making sure the value // remains alive and unchanged throughout the current test. static void SetParam(const ParamType* parameter) { parameter_ = parameter; } // Static value used for accessing parameter during a test lifetime. static const ParamType* parameter_; // TestClass must be a subclass of WithParamInterface and Test. template friend class internal::ParameterizedTestFactory; }; template const T* WithParamInterface::parameter_ = NULL; // Most value-parameterized classes can ignore the existence of // WithParamInterface, and can just inherit from ::testing::TestWithParam. template class TestWithParam : public Test, public WithParamInterface { }; #endif // GTEST_HAS_PARAM_TEST // Macros for indicating success/failure in test code. // ADD_FAILURE unconditionally adds a failure to the current test. // SUCCEED generates a success - it doesn't automatically make the // current test successful, as a test is only successful when it has // no failure. // // EXPECT_* verifies that a certain condition is satisfied. If not, // it behaves like ADD_FAILURE. In particular: // // EXPECT_TRUE verifies that a Boolean condition is true. // EXPECT_FALSE verifies that a Boolean condition is false. // // FAIL and ASSERT_* are similar to ADD_FAILURE and EXPECT_*, except // that they will also abort the current function on failure. People // usually want the fail-fast behavior of FAIL and ASSERT_*, but those // writing data-driven tests often find themselves using ADD_FAILURE // and EXPECT_* more. // Generates a nonfatal failure with a generic message. #define ADD_FAILURE() GTEST_NONFATAL_FAILURE_("Failed") // Generates a nonfatal failure at the given source file location with // a generic message. #define ADD_FAILURE_AT(file, line) \ GTEST_MESSAGE_AT_(file, line, "Failed", \ ::testing::TestPartResult::kNonFatalFailure) // Generates a fatal failure with a generic message. #define GTEST_FAIL() GTEST_FATAL_FAILURE_("Failed") // Define this macro to 1 to omit the definition of FAIL(), which is a // generic name and clashes with some other libraries. #if !GTEST_DONT_DEFINE_FAIL # define FAIL() GTEST_FAIL() #endif // Generates a success with a generic message. #define GTEST_SUCCEED() GTEST_SUCCESS_("Succeeded") // Define this macro to 1 to omit the definition of SUCCEED(), which // is a generic name and clashes with some other libraries. #if !GTEST_DONT_DEFINE_SUCCEED # define SUCCEED() GTEST_SUCCEED() #endif // Macros for testing exceptions. // // * {ASSERT|EXPECT}_THROW(statement, expected_exception): // Tests that the statement throws the expected exception. // * {ASSERT|EXPECT}_NO_THROW(statement): // Tests that the statement doesn't throw any exception. // * {ASSERT|EXPECT}_ANY_THROW(statement): // Tests that the statement throws an exception. #define EXPECT_THROW(statement, expected_exception) \ GTEST_TEST_THROW_(statement, expected_exception, GTEST_NONFATAL_FAILURE_) #define EXPECT_NO_THROW(statement) \ GTEST_TEST_NO_THROW_(statement, GTEST_NONFATAL_FAILURE_) #define EXPECT_ANY_THROW(statement) \ GTEST_TEST_ANY_THROW_(statement, GTEST_NONFATAL_FAILURE_) #define ASSERT_THROW(statement, expected_exception) \ GTEST_TEST_THROW_(statement, expected_exception, GTEST_FATAL_FAILURE_) #define ASSERT_NO_THROW(statement) \ GTEST_TEST_NO_THROW_(statement, GTEST_FATAL_FAILURE_) #define ASSERT_ANY_THROW(statement) \ GTEST_TEST_ANY_THROW_(statement, GTEST_FATAL_FAILURE_) // Boolean assertions. Condition can be either a Boolean expression or an // AssertionResult. For more information on how to use AssertionResult with // these macros see comments on that class. #define EXPECT_TRUE(condition) \ GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ GTEST_NONFATAL_FAILURE_) #define EXPECT_FALSE(condition) \ GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ GTEST_NONFATAL_FAILURE_) #define ASSERT_TRUE(condition) \ GTEST_TEST_BOOLEAN_(condition, #condition, false, true, \ GTEST_FATAL_FAILURE_) #define ASSERT_FALSE(condition) \ GTEST_TEST_BOOLEAN_(!(condition), #condition, true, false, \ GTEST_FATAL_FAILURE_) // Includes the auto-generated header that implements a family of // generic predicate assertion macros. // Copyright 2006, Google Inc. // All rights reserved. // // 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 Google Inc. 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. // This file is AUTOMATICALLY GENERATED on 10/31/2011 by command // 'gen_gtest_pred_impl.py 5'. DO NOT EDIT BY HAND! // // Implements a family of generic predicate assertion macros. #ifndef GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ #define GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ // Makes sure this header is not included before gtest.h. #ifndef GTEST_INCLUDE_GTEST_GTEST_H_ # error Do not include gtest_pred_impl.h directly. Include gtest.h instead. #endif // GTEST_INCLUDE_GTEST_GTEST_H_ // This header implements a family of generic predicate assertion // macros: // // ASSERT_PRED_FORMAT1(pred_format, v1) // ASSERT_PRED_FORMAT2(pred_format, v1, v2) // ... // // where pred_format is a function or functor that takes n (in the // case of ASSERT_PRED_FORMATn) values and their source expression // text, and returns a testing::AssertionResult. See the definition // of ASSERT_EQ in gtest.h for an example. // // If you don't care about formatting, you can use the more // restrictive version: // // ASSERT_PRED1(pred, v1) // ASSERT_PRED2(pred, v1, v2) // ... // // where pred is an n-ary function or functor that returns bool, // and the values v1, v2, ..., must support the << operator for // streaming to std::ostream. // // We also define the EXPECT_* variations. // // For now we only support predicates whose arity is at most 5. // Please email googletestframework@googlegroups.com if you need // support for higher arities. // GTEST_ASSERT_ is the basic statement to which all of the assertions // in this file reduce. Don't use this in your code. #define GTEST_ASSERT_(expression, on_failure) \ GTEST_AMBIGUOUS_ELSE_BLOCKER_ \ if (const ::testing::AssertionResult gtest_ar = (expression)) \ ; \ else \ on_failure(gtest_ar.failure_message()) // Helper function for implementing {EXPECT|ASSERT}_PRED1. Don't use // this in your code. template AssertionResult AssertPred1Helper(const char* pred_text, const char* e1, Pred pred, const T1& v1) { if (pred(v1)) return AssertionSuccess(); return AssertionFailure() << pred_text << "(" << e1 << ") evaluates to false, where" << "\n" << e1 << " evaluates to " << v1; } // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT1. // Don't use this in your code. #define GTEST_PRED_FORMAT1_(pred_format, v1, on_failure)\ GTEST_ASSERT_(pred_format(#v1, v1), \ on_failure) // Internal macro for implementing {EXPECT|ASSERT}_PRED1. Don't use // this in your code. #define GTEST_PRED1_(pred, v1, on_failure)\ GTEST_ASSERT_(::testing::AssertPred1Helper(#pred, \ #v1, \ pred, \ v1), on_failure) // Unary predicate assertion macros. #define EXPECT_PRED_FORMAT1(pred_format, v1) \ GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_NONFATAL_FAILURE_) #define EXPECT_PRED1(pred, v1) \ GTEST_PRED1_(pred, v1, GTEST_NONFATAL_FAILURE_) #define ASSERT_PRED_FORMAT1(pred_format, v1) \ GTEST_PRED_FORMAT1_(pred_format, v1, GTEST_FATAL_FAILURE_) #define ASSERT_PRED1(pred, v1) \ GTEST_PRED1_(pred, v1, GTEST_FATAL_FAILURE_) // Helper function for implementing {EXPECT|ASSERT}_PRED2. Don't use // this in your code. template AssertionResult AssertPred2Helper(const char* pred_text, const char* e1, const char* e2, Pred pred, const T1& v1, const T2& v2) { if (pred(v1, v2)) return AssertionSuccess(); return AssertionFailure() << pred_text << "(" << e1 << ", " << e2 << ") evaluates to false, where" << "\n" << e1 << " evaluates to " << v1 << "\n" << e2 << " evaluates to " << v2; } // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT2. // Don't use this in your code. #define GTEST_PRED_FORMAT2_(pred_format, v1, v2, on_failure)\ GTEST_ASSERT_(pred_format(#v1, #v2, v1, v2), \ on_failure) // Internal macro for implementing {EXPECT|ASSERT}_PRED2. Don't use // this in your code. #define GTEST_PRED2_(pred, v1, v2, on_failure)\ GTEST_ASSERT_(::testing::AssertPred2Helper(#pred, \ #v1, \ #v2, \ pred, \ v1, \ v2), on_failure) // Binary predicate assertion macros. #define EXPECT_PRED_FORMAT2(pred_format, v1, v2) \ GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_NONFATAL_FAILURE_) #define EXPECT_PRED2(pred, v1, v2) \ GTEST_PRED2_(pred, v1, v2, GTEST_NONFATAL_FAILURE_) #define ASSERT_PRED_FORMAT2(pred_format, v1, v2) \ GTEST_PRED_FORMAT2_(pred_format, v1, v2, GTEST_FATAL_FAILURE_) #define ASSERT_PRED2(pred, v1, v2) \ GTEST_PRED2_(pred, v1, v2, GTEST_FATAL_FAILURE_) // Helper function for implementing {EXPECT|ASSERT}_PRED3. Don't use // this in your code. template AssertionResult AssertPred3Helper(const char* pred_text, const char* e1, const char* e2, const char* e3, Pred pred, const T1& v1, const T2& v2, const T3& v3) { if (pred(v1, v2, v3)) return AssertionSuccess(); return AssertionFailure() << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ") evaluates to false, where" << "\n" << e1 << " evaluates to " << v1 << "\n" << e2 << " evaluates to " << v2 << "\n" << e3 << " evaluates to " << v3; } // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT3. // Don't use this in your code. #define GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, on_failure)\ GTEST_ASSERT_(pred_format(#v1, #v2, #v3, v1, v2, v3), \ on_failure) // Internal macro for implementing {EXPECT|ASSERT}_PRED3. Don't use // this in your code. #define GTEST_PRED3_(pred, v1, v2, v3, on_failure)\ GTEST_ASSERT_(::testing::AssertPred3Helper(#pred, \ #v1, \ #v2, \ #v3, \ pred, \ v1, \ v2, \ v3), on_failure) // Ternary predicate assertion macros. #define EXPECT_PRED_FORMAT3(pred_format, v1, v2, v3) \ GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_NONFATAL_FAILURE_) #define EXPECT_PRED3(pred, v1, v2, v3) \ GTEST_PRED3_(pred, v1, v2, v3, GTEST_NONFATAL_FAILURE_) #define ASSERT_PRED_FORMAT3(pred_format, v1, v2, v3) \ GTEST_PRED_FORMAT3_(pred_format, v1, v2, v3, GTEST_FATAL_FAILURE_) #define ASSERT_PRED3(pred, v1, v2, v3) \ GTEST_PRED3_(pred, v1, v2, v3, GTEST_FATAL_FAILURE_) // Helper function for implementing {EXPECT|ASSERT}_PRED4. Don't use // this in your code. template AssertionResult AssertPred4Helper(const char* pred_text, const char* e1, const char* e2, const char* e3, const char* e4, Pred pred, const T1& v1, const T2& v2, const T3& v3, const T4& v4) { if (pred(v1, v2, v3, v4)) return AssertionSuccess(); return AssertionFailure() << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4 << ") evaluates to false, where" << "\n" << e1 << " evaluates to " << v1 << "\n" << e2 << " evaluates to " << v2 << "\n" << e3 << " evaluates to " << v3 << "\n" << e4 << " evaluates to " << v4; } // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT4. // Don't use this in your code. #define GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, on_failure)\ GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, v1, v2, v3, v4), \ on_failure) // Internal macro for implementing {EXPECT|ASSERT}_PRED4. Don't use // this in your code. #define GTEST_PRED4_(pred, v1, v2, v3, v4, on_failure)\ GTEST_ASSERT_(::testing::AssertPred4Helper(#pred, \ #v1, \ #v2, \ #v3, \ #v4, \ pred, \ v1, \ v2, \ v3, \ v4), on_failure) // 4-ary predicate assertion macros. #define EXPECT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) #define EXPECT_PRED4(pred, v1, v2, v3, v4) \ GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_NONFATAL_FAILURE_) #define ASSERT_PRED_FORMAT4(pred_format, v1, v2, v3, v4) \ GTEST_PRED_FORMAT4_(pred_format, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) #define ASSERT_PRED4(pred, v1, v2, v3, v4) \ GTEST_PRED4_(pred, v1, v2, v3, v4, GTEST_FATAL_FAILURE_) // Helper function for implementing {EXPECT|ASSERT}_PRED5. Don't use // this in your code. template AssertionResult AssertPred5Helper(const char* pred_text, const char* e1, const char* e2, const char* e3, const char* e4, const char* e5, Pred pred, const T1& v1, const T2& v2, const T3& v3, const T4& v4, const T5& v5) { if (pred(v1, v2, v3, v4, v5)) return AssertionSuccess(); return AssertionFailure() << pred_text << "(" << e1 << ", " << e2 << ", " << e3 << ", " << e4 << ", " << e5 << ") evaluates to false, where" << "\n" << e1 << " evaluates to " << v1 << "\n" << e2 << " evaluates to " << v2 << "\n" << e3 << " evaluates to " << v3 << "\n" << e4 << " evaluates to " << v4 << "\n" << e5 << " evaluates to " << v5; } // Internal macro for implementing {EXPECT|ASSERT}_PRED_FORMAT5. // Don't use this in your code. #define GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, on_failure)\ GTEST_ASSERT_(pred_format(#v1, #v2, #v3, #v4, #v5, v1, v2, v3, v4, v5), \ on_failure) // Internal macro for implementing {EXPECT|ASSERT}_PRED5. Don't use // this in your code. #define GTEST_PRED5_(pred, v1, v2, v3, v4, v5, on_failure)\ GTEST_ASSERT_(::testing::AssertPred5Helper(#pred, \ #v1, \ #v2, \ #v3, \ #v4, \ #v5, \ pred, \ v1, \ v2, \ v3, \ v4, \ v5), on_failure) // 5-ary predicate assertion macros. #define EXPECT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) #define EXPECT_PRED5(pred, v1, v2, v3, v4, v5) \ GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_NONFATAL_FAILURE_) #define ASSERT_PRED_FORMAT5(pred_format, v1, v2, v3, v4, v5) \ GTEST_PRED_FORMAT5_(pred_format, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) #define ASSERT_PRED5(pred, v1, v2, v3, v4, v5) \ GTEST_PRED5_(pred, v1, v2, v3, v4, v5, GTEST_FATAL_FAILURE_) #endif // GTEST_INCLUDE_GTEST_GTEST_PRED_IMPL_H_ // Macros for testing equalities and inequalities. // // * {ASSERT|EXPECT}_EQ(expected, actual): Tests that expected == actual // * {ASSERT|EXPECT}_NE(v1, v2): Tests that v1 != v2 // * {ASSERT|EXPECT}_LT(v1, v2): Tests that v1 < v2 // * {ASSERT|EXPECT}_LE(v1, v2): Tests that v1 <= v2 // * {ASSERT|EXPECT}_GT(v1, v2): Tests that v1 > v2 // * {ASSERT|EXPECT}_GE(v1, v2): Tests that v1 >= v2 // // When they are not, Google Test prints both the tested expressions and // their actual values. The values must be compatible built-in types, // or you will get a compiler error. By "compatible" we mean that the // values can be compared by the respective operator. // // Note: // // 1. It is possible to make a user-defined type work with // {ASSERT|EXPECT}_??(), but that requires overloading the // comparison operators and is thus discouraged by the Google C++ // Usage Guide. Therefore, you are advised to use the // {ASSERT|EXPECT}_TRUE() macro to assert that two objects are // equal. // // 2. The {ASSERT|EXPECT}_??() macros do pointer comparisons on // pointers (in particular, C strings). Therefore, if you use it // with two C strings, you are testing how their locations in memory // are related, not how their content is related. To compare two C // strings by content, use {ASSERT|EXPECT}_STR*(). // // 3. {ASSERT|EXPECT}_EQ(expected, actual) is preferred to // {ASSERT|EXPECT}_TRUE(expected == actual), as the former tells you // what the actual value is when it fails, and similarly for the // other comparisons. // // 4. Do not depend on the order in which {ASSERT|EXPECT}_??() // evaluate their arguments, which is undefined. // // 5. These macros evaluate their arguments exactly once. // // Examples: // // EXPECT_NE(5, Foo()); // EXPECT_EQ(NULL, a_pointer); // ASSERT_LT(i, array_size); // ASSERT_GT(records.size(), 0) << "There is no record left."; #define EXPECT_EQ(expected, actual) \ EXPECT_PRED_FORMAT2(::testing::internal:: \ EqHelper::Compare, \ expected, actual) #define EXPECT_NE(expected, actual) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperNE, expected, actual) #define EXPECT_LE(val1, val2) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) #define EXPECT_LT(val1, val2) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) #define EXPECT_GE(val1, val2) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) #define EXPECT_GT(val1, val2) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) #define GTEST_ASSERT_EQ(expected, actual) \ ASSERT_PRED_FORMAT2(::testing::internal:: \ EqHelper::Compare, \ expected, actual) #define GTEST_ASSERT_NE(val1, val2) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperNE, val1, val2) #define GTEST_ASSERT_LE(val1, val2) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLE, val1, val2) #define GTEST_ASSERT_LT(val1, val2) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperLT, val1, val2) #define GTEST_ASSERT_GE(val1, val2) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGE, val1, val2) #define GTEST_ASSERT_GT(val1, val2) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperGT, val1, val2) // Define macro GTEST_DONT_DEFINE_ASSERT_XY to 1 to omit the definition of // ASSERT_XY(), which clashes with some users' own code. #if !GTEST_DONT_DEFINE_ASSERT_EQ # define ASSERT_EQ(val1, val2) GTEST_ASSERT_EQ(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_NE # define ASSERT_NE(val1, val2) GTEST_ASSERT_NE(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_LE # define ASSERT_LE(val1, val2) GTEST_ASSERT_LE(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_LT # define ASSERT_LT(val1, val2) GTEST_ASSERT_LT(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_GE # define ASSERT_GE(val1, val2) GTEST_ASSERT_GE(val1, val2) #endif #if !GTEST_DONT_DEFINE_ASSERT_GT # define ASSERT_GT(val1, val2) GTEST_ASSERT_GT(val1, val2) #endif // C-string Comparisons. All tests treat NULL and any non-NULL string // as different. Two NULLs are equal. // // * {ASSERT|EXPECT}_STREQ(s1, s2): Tests that s1 == s2 // * {ASSERT|EXPECT}_STRNE(s1, s2): Tests that s1 != s2 // * {ASSERT|EXPECT}_STRCASEEQ(s1, s2): Tests that s1 == s2, ignoring case // * {ASSERT|EXPECT}_STRCASENE(s1, s2): Tests that s1 != s2, ignoring case // // For wide or narrow string objects, you can use the // {ASSERT|EXPECT}_??() macros. // // Don't depend on the order in which the arguments are evaluated, // which is undefined. // // These macros evaluate their arguments exactly once. #define EXPECT_STREQ(expected, actual) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual) #define EXPECT_STRNE(s1, s2) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) #define EXPECT_STRCASEEQ(expected, actual) \ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual) #define EXPECT_STRCASENE(s1, s2)\ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) #define ASSERT_STREQ(expected, actual) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTREQ, expected, actual) #define ASSERT_STRNE(s1, s2) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRNE, s1, s2) #define ASSERT_STRCASEEQ(expected, actual) \ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASEEQ, expected, actual) #define ASSERT_STRCASENE(s1, s2)\ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperSTRCASENE, s1, s2) // Macros for comparing floating-point numbers. // // * {ASSERT|EXPECT}_FLOAT_EQ(expected, actual): // Tests that two float values are almost equal. // * {ASSERT|EXPECT}_DOUBLE_EQ(expected, actual): // Tests that two double values are almost equal. // * {ASSERT|EXPECT}_NEAR(v1, v2, abs_error): // Tests that v1 and v2 are within the given distance to each other. // // Google Test uses ULP-based comparison to automatically pick a default // error bound that is appropriate for the operands. See the // FloatingPoint template class in gtest-internal.h if you are // interested in the implementation details. #define EXPECT_FLOAT_EQ(expected, actual)\ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ, \ expected, actual) #define EXPECT_DOUBLE_EQ(expected, actual)\ EXPECT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ, \ expected, actual) #define ASSERT_FLOAT_EQ(expected, actual)\ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ, \ expected, actual) #define ASSERT_DOUBLE_EQ(expected, actual)\ ASSERT_PRED_FORMAT2(::testing::internal::CmpHelperFloatingPointEQ, \ expected, actual) #define EXPECT_NEAR(val1, val2, abs_error)\ EXPECT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ val1, val2, abs_error) #define ASSERT_NEAR(val1, val2, abs_error)\ ASSERT_PRED_FORMAT3(::testing::internal::DoubleNearPredFormat, \ val1, val2, abs_error) // These predicate format functions work on floating-point values, and // can be used in {ASSERT|EXPECT}_PRED_FORMAT2*(), e.g. // // EXPECT_PRED_FORMAT2(testing::DoubleLE, Foo(), 5.0); // Asserts that val1 is less than, or almost equal to, val2. Fails // otherwise. In particular, it fails if either val1 or val2 is NaN. GTEST_API_ AssertionResult FloatLE(const char* expr1, const char* expr2, float val1, float val2); GTEST_API_ AssertionResult DoubleLE(const char* expr1, const char* expr2, double val1, double val2); #if GTEST_OS_WINDOWS // Macros that test for HRESULT failure and success, these are only useful // on Windows, and rely on Windows SDK macros and APIs to compile. // // * {ASSERT|EXPECT}_HRESULT_{SUCCEEDED|FAILED}(expr) // // When expr unexpectedly fails or succeeds, Google Test prints the // expected result and the actual result with both a human-readable // string representation of the error, if available, as well as the // hex result code. # define EXPECT_HRESULT_SUCCEEDED(expr) \ EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) # define ASSERT_HRESULT_SUCCEEDED(expr) \ ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTSuccess, (expr)) # define EXPECT_HRESULT_FAILED(expr) \ EXPECT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) # define ASSERT_HRESULT_FAILED(expr) \ ASSERT_PRED_FORMAT1(::testing::internal::IsHRESULTFailure, (expr)) #endif // GTEST_OS_WINDOWS // Macros that execute statement and check that it doesn't generate new fatal // failures in the current thread. // // * {ASSERT|EXPECT}_NO_FATAL_FAILURE(statement); // // Examples: // // EXPECT_NO_FATAL_FAILURE(Process()); // ASSERT_NO_FATAL_FAILURE(Process()) << "Process() failed"; // #define ASSERT_NO_FATAL_FAILURE(statement) \ GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_FATAL_FAILURE_) #define EXPECT_NO_FATAL_FAILURE(statement) \ GTEST_TEST_NO_FATAL_FAILURE_(statement, GTEST_NONFATAL_FAILURE_) // Causes a trace (including the source file path, the current line // number, and the given message) to be included in every test failure // message generated by code in the current scope. The effect is // undone when the control leaves the current scope. // // The message argument can be anything streamable to std::ostream. // // In the implementation, we include the current line number as part // of the dummy variable name, thus allowing multiple SCOPED_TRACE()s // to appear in the same block - as long as they are on different // lines. #define SCOPED_TRACE(message) \ ::testing::internal::ScopedTrace GTEST_CONCAT_TOKEN_(gtest_trace_, __LINE__)(\ __FILE__, __LINE__, ::testing::Message() << (message)) // Compile-time assertion for type equality. // StaticAssertTypeEq() compiles iff type1 and type2 are // the same type. The value it returns is not interesting. // // Instead of making StaticAssertTypeEq a class template, we make it a // function template that invokes a helper class template. This // prevents a user from misusing StaticAssertTypeEq by // defining objects of that type. // // CAVEAT: // // When used inside a method of a class template, // StaticAssertTypeEq() is effective ONLY IF the method is // instantiated. For example, given: // // template class Foo { // public: // void Bar() { testing::StaticAssertTypeEq(); } // }; // // the code: // // void Test1() { Foo foo; } // // will NOT generate a compiler error, as Foo::Bar() is never // actually instantiated. Instead, you need: // // void Test2() { Foo foo; foo.Bar(); } // // to cause a compiler error. template bool StaticAssertTypeEq() { (void)internal::StaticAssertTypeEqHelper(); return true; } // Defines a test. // // The first parameter is the name of the test case, and the second // parameter is the name of the test within the test case. // // The convention is to end the test case name with "Test". For // example, a test case for the Foo class can be named FooTest. // // The user should put his test code between braces after using this // macro. Example: // // TEST(FooTest, InitializesCorrectly) { // Foo foo; // EXPECT_TRUE(foo.StatusIsOK()); // } // Note that we call GetTestTypeId() instead of GetTypeId< // ::testing::Test>() here to get the type ID of testing::Test. This // is to work around a suspected linker bug when using Google Test as // a framework on Mac OS X. The bug causes GetTypeId< // ::testing::Test>() to return different values depending on whether // the call is from the Google Test framework itself or from user test // code. GetTestTypeId() is guaranteed to always return the same // value, as it always calls GetTypeId<>() from the Google Test // framework. #define GTEST_TEST(test_case_name, test_name)\ GTEST_TEST_(test_case_name, test_name, \ ::testing::Test, ::testing::internal::GetTestTypeId()) // Define this macro to 1 to omit the definition of TEST(), which // is a generic name and clashes with some other libraries. #if !GTEST_DONT_DEFINE_TEST # define TEST(test_case_name, test_name) GTEST_TEST(test_case_name, test_name) #endif // Defines a test that uses a test fixture. // // The first parameter is the name of the test fixture class, which // also doubles as the test case name. The second parameter is the // name of the test within the test case. // // A test fixture class must be declared earlier. The user should put // his test code between braces after using this macro. Example: // // class FooTest : public testing::Test { // protected: // virtual void SetUp() { b_.AddElement(3); } // // Foo a_; // Foo b_; // }; // // TEST_F(FooTest, InitializesCorrectly) { // EXPECT_TRUE(a_.StatusIsOK()); // } // // TEST_F(FooTest, ReturnsElementCountCorrectly) { // EXPECT_EQ(0, a_.size()); // EXPECT_EQ(1, b_.size()); // } #define TEST_F(test_fixture, test_name)\ GTEST_TEST_(test_fixture, test_name, test_fixture, \ ::testing::internal::GetTypeId()) } // namespace testing // Use this function in main() to run all tests. It returns 0 if all // tests are successful, or 1 otherwise. // // RUN_ALL_TESTS() should be invoked after the command line has been // parsed by InitGoogleTest(). // // This function was formerly a macro; thus, it is in the global // namespace and has an all-caps name. int RUN_ALL_TESTS() GTEST_MUST_USE_RESULT_; inline int RUN_ALL_TESTS() { return ::testing::UnitTest::GetInstance()->Run(); } #endif // GTEST_INCLUDE_GTEST_GTEST_H_ hyperscan-4.4.1/unit/CMakeLists.txt0000644000175000017500000000733613055426554020027 0ustar sleuthkidsleuthkidset(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_C_FLAGS}") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} ${EXTRA_CXX_FLAGS}") set(gtest_SOURCES gtest/gtest-all.cc gtest/gtest.h) if(NOT XCODE) include_directories(SYSTEM ${CMAKE_CURRENT_SOURCE_DIR}) else() set(CMAKE_CXX_FLAGS "-isystem ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CXX_FLAGS}") endif() include_directories(${PROJECT_SOURCE_DIR}) # remove some warnings # cmake's scope means these only apply here if (CXX_MISSING_DECLARATIONS) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-missing-declarations") endif() if(CXX_WEAK_VTABLES) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-weak-vtables") endif() if(CXX_WUNUSED_VARIABLE) set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-unused-variable") endif() if(CMAKE_COMPILER_IS_GNUCC) # spurious warnings? set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-array-bounds") endif() add_library(gtest STATIC ${gtest_SOURCES}) add_definitions(-DGTEST_HAS_PTHREAD=0 -DSRCDIR=${PROJECT_SOURCE_DIR}) if (NOT (RELEASE_BUILD OR FAT_RUNTIME)) set(unit_internal_SOURCES internal/bitfield.cpp internal/bitutils.cpp internal/charreach.cpp internal/compare.cpp internal/database.cpp internal/depth.cpp internal/fdr.cpp internal/fdr_flood.cpp internal/fdr_loadval.cpp internal/flat_set.cpp internal/flat_map.cpp internal/graph.cpp internal/lbr.cpp internal/limex_nfa.cpp internal/masked_move.cpp internal/multi_bit.cpp internal/multiaccel_matcher.cpp internal/multiaccel_shift.cpp internal/nfagraph_common.h internal/nfagraph_comp.cpp internal/nfagraph_equivalence.cpp internal/nfagraph_find_matches.cpp internal/nfagraph_literal_analysis.cpp internal/nfagraph_redundancy.cpp internal/nfagraph_repeat.cpp internal/nfagraph_util.cpp internal/nfagraph_width.cpp internal/noodle.cpp internal/pack_bits.cpp internal/parser.cpp internal/partial.cpp internal/pqueue.cpp internal/repeat.cpp internal/rose_build_merge.cpp internal/rose_mask.cpp internal/rose_mask_32.cpp internal/rvermicelli.cpp internal/simd_utils.cpp internal/shuffle.cpp internal/shufti.cpp internal/state_compress.cpp internal/truffle.cpp internal/unaligned.cpp internal/unicode_set.cpp internal/uniform_ops.cpp internal/utf8_validate.cpp internal/util_string.cpp internal/vermicelli.cpp internal/main.cpp ) add_executable(unit-internal ${unit_internal_SOURCES}) target_link_libraries(unit-internal hs gtest corpusomatic) endif(NOT (RELEASE_BUILD OR FAT_RUNTIME)) set(unit_hyperscan_SOURCES hyperscan/allocators.cpp hyperscan/arg_checks.cpp hyperscan/bad_patterns.cpp hyperscan/bad_patterns.txt hyperscan/behaviour.cpp hyperscan/expr_info.cpp hyperscan/extparam.cpp hyperscan/identical.cpp hyperscan/main.cpp hyperscan/multi.cpp hyperscan/order.cpp hyperscan/scratch_op.cpp hyperscan/scratch_in_use.cpp hyperscan/serialize.cpp hyperscan/single.cpp hyperscan/som.cpp hyperscan/stream_op.cpp hyperscan/test_util.cpp hyperscan/test_util.h ) add_executable(unit-hyperscan ${unit_hyperscan_SOURCES}) if (BUILD_STATIC_AND_SHARED OR BUILD_SHARED_LIBS) target_link_libraries(unit-hyperscan hs_shared gtest expressionutil) else() target_link_libraries(unit-hyperscan hs gtest expressionutil) endif() # # build target to run unit tests # if (NOT RELEASE_BUILD) add_custom_target( unit COMMAND bin/unit-internal COMMAND bin/unit-hyperscan WORKING_DIRECTORY ${CMAKE_BINARY_DIR} DEPENDS unit-internal unit-hyperscan ) else () add_custom_target( unit COMMAND bin/unit-hyperscan WORKING_DIRECTORY ${CMAKE_BINARY_DIR} DEPENDS unit-hyperscan ) endif() hyperscan-4.4.1/unit/hyperscan/0000755000175000017500000000000013055426554017252 5ustar sleuthkidsleuthkidhyperscan-4.4.1/unit/hyperscan/arg_checks.cpp0000644000175000017500000023252313055426554022056 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" static char garbage[] = "TEST(HyperscanArgChecks, DatabaseSizeNoDatabase) {" \ " size_t sz = hs_database_size(0);" \ " ASSERT_EQ(0, sz);"; static unsigned lastMatchId = 0; static unsigned long long lastMatchFrom = 0; static unsigned long long lastMatchTo = 0; static unsigned lastMatchFlags = 0; static void *lastMatchCtx = nullptr; // Single match callback: record all the details from a single match static int singleHandler(unsigned id, unsigned long long from, unsigned long long to, unsigned flags, void *ctx) { lastMatchId = id; lastMatchFrom = from; lastMatchTo = to; lastMatchFlags = flags; lastMatchCtx = ctx; return 0; } namespace /* anonymous */ { // Break the magic number of the given database. void breakDatabaseMagic(hs_database *db) { // database magic should be 0xdbdb at the start ASSERT_TRUE(memcmp("\xdb\xdb", db, 2) == 0); *(char *)db = 0xdc; } // Break the version number of the given database. void breakDatabaseVersion(hs_database *db) { // database version is the second u32 *((char *)db + 4) += 1; } // Break the platform data of the given database. void breakDatabasePlatform(hs_database *db) { // database platform is an aligned u64a 16 bytes in memset((char *)db + 16, 0xff, 8); } // Break the alignment of the bytecode for the given database. void breakDatabaseBytecode(hs_database *db) { // bytecode ptr is a u32, 36 bytes in unsigned int *bytecode = (unsigned int *)((char *)db + 36); ASSERT_NE(0U, *bytecode); ASSERT_EQ(0U, (size_t)((char *)db + *bytecode) % 16U); *bytecode += 3; } // Check that hs_valid_platform says we can run here TEST(HyperscanArgChecks, ValidPlatform) { hs_error_t error = hs_valid_platform(); ASSERT_EQ(HS_SUCCESS, error) << "hs_valid_platform should return zero"; } // Check that hs_version gives us a reasonable string back TEST(HyperscanArgChecks, Version) { const char *version = hs_version(); ASSERT_TRUE(version != nullptr); ASSERT_TRUE(version[0] >= '0' && version[0] <= '9') << "First byte should be a digit."; ASSERT_EQ('.', version[1]) << "Second byte should be a dot."; } // hs_compile: Compile a NULL pattern (block mode) TEST(HyperscanArgChecks, SingleCompileBlockNoPattern) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile(nullptr, 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile: Compile a NULL pattern (streaming mode) TEST(HyperscanArgChecks, SingleCompileStreamingNoPattern) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile(nullptr, 0, HS_MODE_STREAM, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile: Compile a pattern to a NULL database ptr (block mode) TEST(HyperscanArgChecks, SingleCompileBlockNoDatabase) { hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, nullptr, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile: Compile a pattern to a NULL database ptr (streaming mode) TEST(HyperscanArgChecks, SingleCompileStreamingNoDatabase) { hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, nullptr, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile: Compile a pattern with no mode set TEST(HyperscanArgChecks, SingleCompileNoMode) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, 0, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile: Compile a pattern with several modes set TEST(HyperscanArgChecks, SingleCompileSeveralModes1) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM | HS_MODE_NOSTREAM, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile: Compile a pattern with bogus flags TEST(HyperscanArgChecks, SingleCompileBogusFlags) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0xdeadbeef, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); EXPECT_STREQ("Unrecognised flag.", compile_err->message); hs_free_compile_error(compile_err); } // hs_compile: Compile a pattern with bogus mode flags set. TEST(HyperscanArgChecks, SingleCompileBogusMode1) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; unsigned mode = HS_MODE_STREAM | (1U << 30); hs_error_t err = hs_compile("foobar", 0, mode, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); ASSERT_TRUE(compile_err != nullptr); ASSERT_STREQ("Invalid parameter: unrecognised mode flags.", compile_err->message); hs_free_compile_error(compile_err); } TEST(HyperscanArgChecks, SingleCompileBadTune) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_platform_info_t plat; plat.cpu_features = 0; plat.tune = 42; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, &plat, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); EXPECT_STREQ("Invalid tuning value specified in the platform information.", compile_err->message); hs_free_compile_error(compile_err); } TEST(HyperscanArgChecks, SingleCompileBadFeatures) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_platform_info_t plat; plat.cpu_features = 42; plat.tune = 0; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, &plat, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); EXPECT_STREQ("Invalid cpu features specified in the platform information.", compile_err->message); hs_free_compile_error(compile_err); } // hs_compile: Check SOM flag validation. TEST(HyperscanArgChecks, SingleCompileSOMFlag) { // try using the flags without a SOM mode. hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", HS_FLAG_SOM_LEFTMOST, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_COMPILER_ERROR, err) << "should have failed with flag " << HS_FLAG_SOM_LEFTMOST; ASSERT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile: Check SOM mode validation. TEST(HyperscanArgChecks, SingleCompileSOMModes) { static const unsigned som_modes[] = { HS_MODE_SOM_HORIZON_LARGE, HS_MODE_SOM_HORIZON_MEDIUM, HS_MODE_SOM_HORIZON_SMALL }; const size_t num_modes = sizeof(som_modes)/sizeof(som_modes[0]); // compilation of a trivial case with a single mode set should be fine. for (size_t i = 0; i < num_modes; i++) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", HS_FLAG_SOM_LEFTMOST, HS_MODE_STREAM | som_modes[i], nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // you can only use one of the SOM modes at a time. for (size_t i = 0; i < num_modes; i++) { for (size_t j = i + 1; j < num_modes; j++) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; unsigned int mode = som_modes[i] | som_modes[j]; hs_error_t err = hs_compile("foobar", HS_FLAG_SOM_LEFTMOST, HS_MODE_STREAM | mode, nullptr, &db, &compile_err); ASSERT_EQ(HS_COMPILER_ERROR, err) << "should have failed with mode " << mode; ASSERT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } } } // hs_compile_multi: Compile a NULL pattern set (block mode) TEST(HyperscanArgChecks, MultiCompileBlockNoPattern) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile_multi(nullptr, nullptr, nullptr, 1, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile_multi: Compile a NULL pattern set (streaming mode) TEST(HyperscanArgChecks, MultiCompileStreamingNoPattern) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile_multi(nullptr, nullptr, nullptr, 1, HS_MODE_STREAM, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile_multi: Compile a set of zero patterns TEST(HyperscanArgChecks, MultiCompileZeroPatterns) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; const char *expr[] = {"foobar"}; hs_error_t err = hs_compile_multi(expr, nullptr, nullptr, 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile_multi: Compile a pattern to a NULL database ptr (block mode) TEST(HyperscanArgChecks, MultiCompileBlockNoDatabase) { hs_compile_error_t *compile_err = nullptr; const char *expr[] = {"foobar"}; hs_error_t err = hs_compile_multi(expr, nullptr, nullptr, 1, HS_MODE_NOSTREAM, nullptr, nullptr, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_compile_multi: Compile a pattern to a NULL database ptr (streaming mode) TEST(HyperscanArgChecks, MultiCompileStreamingNoDatabase) { hs_compile_error_t *compile_err = nullptr; const char *expr[] = {"foobar"}; hs_error_t err = hs_compile_multi(expr, nullptr, nullptr, 1, HS_MODE_STREAM, nullptr, nullptr, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_open_stream: Open a stream with a NULL database ptr TEST(HyperscanArgChecks, OpenStreamNoDatabase) { hs_stream_t *stream = nullptr; hs_error_t err = hs_open_stream(nullptr, 0, &stream); EXPECT_NE(HS_SUCCESS, err); EXPECT_TRUE(stream == nullptr); } // hs_open_stream: Open a stream with a NULL stream ptr TEST(HyperscanArgChecks, OpenStreamNoStreamId) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, nullptr); ASSERT_EQ(HS_INVALID, err); // teardown hs_free_database(db); } // hs_open_stream: Open a stream with a non-streaming database TEST(HyperscanArgChecks, OpenStreamWithBlockDatabase) { hs_stream_t *stream = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream); EXPECT_NE(HS_SUCCESS, err); EXPECT_TRUE(stream == nullptr); // teardown hs_free_database(db); } // hs_open_stream: Open a stream with a broken database bytecode TEST(HyperscanArgChecks, OpenStreamWithBrokenDatabaseBytecode) { hs_stream_t *stream = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); breakDatabaseBytecode(db); err = hs_open_stream(db, 0, &stream); EXPECT_NE(HS_SUCCESS, err); EXPECT_TRUE(stream == nullptr); // teardown hs_free_database(db); } // hs_scan_stream: Call with no stream ID TEST(HyperscanArgChecks, ScanStreamNoStreamID) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); err = hs_scan_stream(nullptr, "data", 4, 0, scratch, dummy_cb, nullptr); EXPECT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan_stream: Call with no data TEST(HyperscanArgChecks, ScanStreamNoData) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, nullptr, 4, 0, scratch, dummy_cb, nullptr); EXPECT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_close_stream(stream, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan_stream: Call with no scratch TEST(HyperscanArgChecks, ScanStreamNoScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, nullptr, 4, 0, scratch, dummy_cb, nullptr); EXPECT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_close_stream(stream, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_close_stream: Call with no stream TEST(HyperscanArgChecks, CloseStreamNoStream) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); err = hs_close_stream(nullptr, scratch, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_close_stream: Call with no scratch TEST(HyperscanArgChecks, CloseStreamNoScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_close_stream(stream, nullptr, dummy_cb, nullptr); EXPECT_NE(HS_SUCCESS, err); // We happen to know we can free the stream here, and we do it so that // this doesn't appear as a memory leak in valgrind free(stream); // teardown hs_free_database(db); } // hs_close_stream: Call with no scratch and no callback (allowed) TEST(HyperscanArgChecks, CloseStreamNoScratchNoCallback) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_close_stream(stream, nullptr, nullptr, nullptr); EXPECT_EQ(HS_SUCCESS, err); // teardown hs_free_database(db); } // hs_close_stream_nomatch: Call with no stream TEST(HyperscanArgChecks, CloseStreamNoMatchNoStream) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(nullptr, scratch, nullptr, nullptr); ASSERT_NE(HS_SUCCESS, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_set_stream_context: change context TEST(HyperscanArgChecks, ChangeStreamContext) { const char *str = "foobar"; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile(str, 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); // we'll start with the context pointer set to the scratch space ... hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, str, strlen(str), 0, scratch, singleHandler, (void *)scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(lastMatchTo, strlen(str)); ASSERT_EQ(lastMatchCtx, scratch); // ... and then change it to the stream ptr itself. err = hs_scan_stream(stream, str, strlen(str), 0, scratch, singleHandler, (void *)stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(lastMatchTo, 2*strlen(str)); ASSERT_EQ(lastMatchCtx, stream); err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); // teardown hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } // hs_reset_stream: Call with no stream id TEST(HyperscanArgChecks, ResetStreamNoId) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_reset_stream(nullptr, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_reset_stream: Call with no scratch TEST(HyperscanArgChecks, ResetStreamNoScratch) { hs_stream_t *stream = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_reset_stream(stream, 0, nullptr, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_close_stream(stream, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_copy_stream: Call with no from_id TEST(HyperscanArgChecks, CopyStreamNoFromId) { hs_stream_t *to; hs_error_t err = hs_copy_stream(&to, nullptr); ASSERT_EQ(HS_INVALID, err); } // hs_copy_stream: Call with no to_id TEST(HyperscanArgChecks, CopyStreamNoToId) { hs_stream_t *stream = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_copy_stream(nullptr, stream); ASSERT_EQ(HS_INVALID, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_close_stream(stream, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ResetAndCopyStreamNoToId) { hs_stream_t *stream = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_reset_and_copy_stream(nullptr, stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_INVALID, err); err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ResetAndCopyStreamNoFromId) { hs_stream_t *stream = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_reset_and_copy_stream(stream, nullptr, scratch, nullptr, nullptr); ASSERT_EQ(HS_INVALID, err); err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ResetAndCopyStreamSameToId) { hs_stream_t *stream = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_reset_and_copy_stream(stream, stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_INVALID, err); err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_reset_and_copy_stream: You're allowed to reset and copy a stream with no // scratch and no callback. TEST(HyperscanArgChecks, ResetAndCopyStreamNoCallbackOrScratch) { hs_stream_t *stream = nullptr; hs_stream_t *stream_to = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream_to); ASSERT_EQ(HS_SUCCESS, err); err = hs_reset_and_copy_stream(stream_to, stream, nullptr, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream_to, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_reset_and_copy_stream: If you specify a callback, you must provide // scratch. TEST(HyperscanArgChecks, ResetAndCopyStreamNoScratch) { hs_stream_t *stream = nullptr; hs_stream_t *stream_to = nullptr; hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream_to); ASSERT_EQ(HS_SUCCESS, err); err = hs_reset_and_copy_stream(stream_to, stream, nullptr, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); err = hs_close_stream(stream_to, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ResetAndCopyStreamDiffDb) { hs_stream_t *stream = nullptr; hs_stream_t *stream_to = nullptr; hs_database_t *db = nullptr; hs_database_t *db2 = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); err = hs_compile("barfoo", 0, HS_MODE_STREAM, nullptr, &db2, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_alloc_scratch(db2, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); err = hs_open_stream(db2, 0, &stream_to); ASSERT_EQ(HS_SUCCESS, err); err = hs_reset_and_copy_stream(stream_to, stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_INVALID, err); err = hs_close_stream(stream_to, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); hs_free_database(db2); } // hs_scan: Call with no database TEST(HyperscanArgChecks, ScanBlockNoDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); err = hs_scan(nullptr, "data", 4, 0, scratch, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan: Call with a database with broken magic TEST(HyperscanArgChecks, ScanBlockBrokenDatabaseMagic) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); // break the database here, after scratch alloc breakDatabaseMagic(db); err = hs_scan(db, "data", 4, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); free(db); } // hs_scan: Call with a database with broken version TEST(HyperscanArgChecks, ScanBlockBrokenDatabaseVersion) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); // break the database here, after scratch alloc breakDatabaseVersion(db); err = hs_scan(db, "data", 4, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_DB_VERSION_ERROR, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan: Call with a database with broken bytecode offset TEST(HyperscanArgChecks, ScanBlockBrokenDatabaseBytecode) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); // break the database here, after scratch alloc breakDatabaseBytecode(db); err = hs_scan(db, "data", 4, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan: Call with a database built for streaming mode TEST(HyperscanArgChecks, ScanBlockStreamingDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); err = hs_scan(db, "data", 4, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_DB_MODE_ERROR, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ScanBlockVectoredDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); err = hs_scan(db, "data", 4, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_DB_MODE_ERROR, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan: Call with no data TEST(HyperscanArgChecks, ScanBlockNoData) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); err = hs_scan(db, nullptr, 4, 0, scratch, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan: Call with no scratch TEST(HyperscanArgChecks, ScanBlockNoScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); err = hs_scan(db, "data", 4, 0, nullptr, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown hs_free_database(db); } // hs_scan: Call with no event handler TEST(HyperscanArgChecks, ScanBlockNoHandler) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); err = hs_scan(db, "data", 4, 0, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan_vector: Call with no database TEST(HyperscanArgChecks, ScanVectorNoDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); const char *data[] = {"data", "data"}; unsigned int len[] = {4, 4}; err = hs_scan_vector(nullptr, data, len, 2, 0, scratch, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan_vector: Call with a database with broken magic TEST(HyperscanArgChecks, ScanVectorBrokenDatabaseMagic) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); // break the database here, after scratch alloc breakDatabaseMagic(db); const char *data[] = {"data", "data"}; unsigned int len[] = {4, 4}; err = hs_scan_vector(db, data, len, 2, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); free(db); } // hs_scan_vector: Call with a database with broken version TEST(HyperscanArgChecks, ScanVectorBrokenDatabaseVersion) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); // break the database here, after scratch alloc breakDatabaseVersion(db); const char *data[] = {"data", "data"}; unsigned int len[] = {4, 4}; err = hs_scan_vector(db, data, len, 2, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_DB_VERSION_ERROR, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan_vector: Call with a database with broken bytecode offset TEST(HyperscanArgChecks, ScanVectorBrokenDatabaseBytecode) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); // break the database here, after scratch alloc breakDatabaseBytecode(db); const char *data[] = {"data", "data"}; unsigned int len[] = {4, 4}; err = hs_scan_vector(db, data, len, 2, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan_vector: Call with a database built for streaming mode TEST(HyperscanArgChecks, ScanVectorStreamingDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); const char *data[] = {"data", "data"}; unsigned int len[] = {4, 4}; err = hs_scan_vector(db, data, len, 2, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_DB_MODE_ERROR, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ScanVectorBlockDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_BLOCK, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); const char *data[] = {"data", "data"}; unsigned int len[] = {4, 4}; err = hs_scan_vector(db, data, len, 2, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_DB_MODE_ERROR, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan_vector: Call with null data TEST(HyperscanArgChecks, ScanVectorNoDataArray) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); unsigned int len[] = {4, 4}; err = hs_scan_vector(db, nullptr, len, 2, 0, scratch, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ScanVectorNoDataBlock) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); const char *data[] = {"data", nullptr}; unsigned int len[] = {4, 4}; err = hs_scan_vector(db, data, len, 2, 0, scratch, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ScanVectorNoLenArray) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); const char *data[] = {"data", "data"}; err = hs_scan_vector(db, data, nullptr, 2, 0, scratch, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_scan_vector: Call with no scratch TEST(HyperscanArgChecks, ScanVectorNoScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); const char *data[] = {"data", "data"}; unsigned int len[] = {4, 4}; err = hs_scan_vector(db, data, len, 2, 0, nullptr, dummy_cb, nullptr); ASSERT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown hs_free_database(db); } // hs_scan_vector: Call with no event handler TEST(HyperscanArgChecks, ScanVectorNoHandler) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); const char *data[] = {"data", "data"}; unsigned int len[] = {4, 4}; err = hs_scan_vector(db, data, len, 2, 0, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // hs_alloc_scratch: Call with no database TEST(HyperscanArgChecks, AllocScratchNoDatabase) { hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(nullptr, &scratch); EXPECT_NE(HS_SUCCESS, err); EXPECT_TRUE(scratch == nullptr); } // hs_alloc_scratch: Call with NULL ptr-to-scratch TEST(HyperscanArgChecks, AllocScratchNullScratchPtr) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); err = hs_alloc_scratch(db, nullptr); ASSERT_EQ(HS_INVALID, err); // teardown hs_free_database(db); } // hs_alloc_scratch: Call with bogus scratch TEST(HyperscanArgChecks, AllocScratchBogusScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *blah = (hs_scratch_t *)malloc(100); memset(blah, 0xf0, 100); err = hs_alloc_scratch(db, &blah); ASSERT_EQ(HS_INVALID, err); // teardown free(blah); hs_free_database(db); } // hs_alloc_scratch: Call with broken database magic TEST(HyperscanArgChecks, AllocScratchBadDatabaseMagic) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); breakDatabaseMagic(db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_INVALID, err); // teardown free(db); } // hs_alloc_scratch: Call with broken database version TEST(HyperscanArgChecks, AllocScratchBadDatabaseVersion) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); breakDatabaseVersion(db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_DB_VERSION_ERROR, err); // teardown hs_free_database(db); } // hs_alloc_scratch: Call with broken database platform TEST(HyperscanArgChecks, AllocScratchBadDatabasePlatform) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); breakDatabasePlatform(db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_DB_PLATFORM_ERROR, err); // teardown hs_free_database(db); } // hs_alloc_scratch: Call with broken database bytecode alignment TEST(HyperscanArgChecks, AllocScratchBadDatabaseBytecode) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); breakDatabaseBytecode(db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_INVALID, err); // teardown hs_free_database(db); } // hs_alloc_scratch: Call with broken database CRC TEST(HyperscanArgChecks, AllocScratchBadDatabaseCRC) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t len = 0; err = hs_database_size(db, &len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0U, len); // ensure that we're able to alloc scratch for the unbroken db. hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); // for want of a better case, corrupt the "middle byte" of the database. char *mid = (char *)db + len/2; *mid += 17; scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_INVALID, err); // teardown hs_free_database(db); } // hs_clone_scratch: Call with no source scratch TEST(HyperscanArgChecks, CloneScratchNoSource) { hs_scratch_t *scratch = nullptr, *scratch2 = nullptr; hs_error_t err = hs_clone_scratch(scratch, &scratch2); EXPECT_NE(HS_SUCCESS, err); EXPECT_TRUE(scratch2 == nullptr); } // hs_serialize_database: Call with no database TEST(HyperscanArgChecks, SerializeNoDatabase) { char *bytes = nullptr; size_t length = 0; hs_error_t err = hs_serialize_database(nullptr, &bytes, &length); EXPECT_NE(HS_SUCCESS, err); EXPECT_TRUE(bytes == nullptr); } // hs_serialize_database: Call with no bytes ptr TEST(HyperscanArgChecks, SerializeNoBuffer) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t length = 0; err = hs_serialize_database(db, nullptr, &length); EXPECT_NE(HS_SUCCESS, err); EXPECT_EQ(0U, length); // teardown hs_free_database(db); } // hs_serialize_database: Call with no bytes ptr TEST(HyperscanArgChecks, SerializeNoLength) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); char *buf = nullptr; err = hs_serialize_database(db, &buf, nullptr); EXPECT_NE(HS_SUCCESS, err); EXPECT_TRUE(buf == nullptr); // teardown hs_free_database(db); } // hs_stream_size: Call with no database TEST(HyperscanArgChecks, StreamSizeNoDatabase) { size_t sz; hs_error_t err = hs_stream_size(nullptr, &sz); ASSERT_EQ(HS_INVALID, err); } // hs_stream_size: Call with invalid database TEST(HyperscanArgChecks, StreamSizeBogusDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t len; err = hs_database_size(db, &len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_LT(0U, len); memset(db, 0xf0, len); size_t sz; err = hs_stream_size(db, &sz); ASSERT_EQ(HS_INVALID, err); free(db); } // hs_stream_size: Call with a block-mode database TEST(HyperscanArgChecks, StreamSizeBlockDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t sz; err = hs_stream_size(db, &sz); ASSERT_EQ(HS_DB_MODE_ERROR, err); hs_free_database(db); } TEST(HyperscanArgChecks, StreamSizeVectoredDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t sz; err = hs_stream_size(db, &sz); ASSERT_EQ(HS_DB_MODE_ERROR, err); hs_free_database(db); } TEST(HyperscanArgChecks, OpenStreamBlockDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_stream_t *id; err = hs_open_stream(db, 0, &id); ASSERT_EQ(HS_DB_MODE_ERROR, err); hs_free_database(db); } TEST(HyperscanArgChecks, OpenStreamVectoredDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_stream_t *id; err = hs_open_stream(db, 0, &id); ASSERT_EQ(HS_DB_MODE_ERROR, err); hs_free_database(db); } // hs_stream_size: Call with a real database TEST(HyperscanArgChecks, StreamSizeRealDatabase) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t sz; err = hs_stream_size(db, &sz); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0U, sz) << "Stream-mode database should have non-zero stream size"; hs_free_database(db); } TEST(HyperscanArgChecks, StreamSizeNoSize) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); err = hs_stream_size(db, nullptr); ASSERT_EQ(HS_INVALID, err); hs_free_database(db); } // hs_database_size: Call with no database TEST(HyperscanArgChecks, DatabaseSizeNoDatabase) { size_t sz; hs_error_t err = hs_database_size(nullptr, &sz); ASSERT_EQ(HS_INVALID, err); } TEST(HyperscanArgChecks, DatabaseSizeNoSize) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); err = hs_database_size(db, nullptr); ASSERT_EQ(HS_INVALID, err); hs_free_database(db); } TEST(HyperscanArgChecks, DatabaseSizeBadDb) { hs_database_t *db = (hs_database_t *)garbage; size_t sz; hs_error_t err = hs_database_size(db, &sz); ASSERT_EQ(HS_INVALID, err); } TEST(HyperscanArgChecks, DatabaseInfoBadDb) { hs_database_t *db = (hs_database_t *)garbage; char *info = garbage; hs_error_t err = hs_database_info(db, &info); ASSERT_EQ(HS_INVALID, err); ASSERT_TRUE(nullptr == info); } TEST(HyperscanArgChecks, DatabaseInfoNullDb) { char *info = garbage; hs_error_t err = hs_database_info(nullptr, &info); ASSERT_EQ(HS_INVALID, err); ASSERT_TRUE(nullptr == info); } TEST(HyperscanArgChecks, DatabaseInfoNullInfo) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_NOSTREAM, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); err = hs_database_info(db, nullptr); ASSERT_EQ(HS_INVALID, err); hs_free_database(db); } TEST(HyperscanArgChecks, SerializedDatabaseSizeBadLen) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_NOSTREAM, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); hs_free_database(db); size_t ser_len; err = hs_serialized_database_size(bytes, 16, &ser_len); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, SerializedDatabaseSizeNoSize) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_NOSTREAM, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); hs_free_database(db); err = hs_serialized_database_size(bytes, bytes_len, nullptr); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, SerializedDatabaseSizeNoBytes) { size_t sz; hs_error_t err = hs_serialized_database_size(nullptr, 1024, &sz); ASSERT_EQ(HS_INVALID, err); } TEST(HyperscanArgChecks, SerializedDatabaseInfoBadLen) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_NOSTREAM, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); hs_free_database(db); char *info = garbage; err = hs_serialized_database_info(bytes, 16, &info); ASSERT_EQ(HS_INVALID, err); ASSERT_TRUE(nullptr == info); free(bytes); } TEST(HyperscanArgChecks, SerializedDatabaseInfoNoInfo) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_NOSTREAM, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); hs_free_database(db); err = hs_serialized_database_info(bytes, bytes_len, nullptr); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, SerializedDatabaseInfoNoBytes) { char *info = garbage; hs_error_t err = hs_serialized_database_info(nullptr, 1024, &info); ASSERT_EQ(HS_INVALID, err); ASSERT_TRUE(nullptr == info); } TEST(HyperscanArgChecks, DeserializeDatabaseNoBytes) { hs_database_t *db = nullptr; hs_error_t err = hs_deserialize_database(nullptr, 2048, &db); ASSERT_EQ(HS_INVALID, err); } TEST(HyperscanArgChecks, DeserializeDatabaseAtNoBytes) { hs_database_t *db = nullptr; hs_error_t err = hs_deserialize_database_at(nullptr, 2048, db); ASSERT_EQ(HS_INVALID, err); } static void makeSerializedDatabase(char **bytes, size_t *length) { hs_database_t *db = buildDB("(foo.*bar){3,}", 0, 0, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_error_t err = hs_serialize_database(db, bytes, length); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, DeserializeDatabaseNoDb) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); hs_error_t err = hs_deserialize_database(bytes, length, nullptr); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, DeserializeDatabaseBadLen) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); hs_database_t *db = nullptr; hs_error_t err = hs_deserialize_database(bytes, length - 1, &db); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, DeserializeDatabaseBadLen2) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); hs_database_t *db = nullptr; hs_error_t err = hs_deserialize_database(bytes, length + 1, &db); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, DeserializeDatabaseBadBytes) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); memset(bytes, 0xff, length); // scribble hs_database_t *db = nullptr; hs_error_t err = hs_deserialize_database(bytes, length, &db); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, DeserializeDatabaseBadBytes2) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); memset(bytes, 0, length); // scribble hs_database_t *db = nullptr; hs_error_t err = hs_deserialize_database(bytes, length, &db); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, DeserializeDatabaseAtNoDb) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); hs_error_t err = hs_deserialize_database_at(bytes, length, nullptr); ASSERT_EQ(HS_INVALID, err); free(bytes); } TEST(HyperscanArgChecks, DeserializeDatabaseAtBadLen) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); size_t db_length = 0; hs_error_t err = hs_serialized_database_size(bytes, length, &db_length); ASSERT_EQ(HS_SUCCESS, err); hs_database_t *db = (hs_database_t *)malloc(db_length); err = hs_deserialize_database_at(bytes, length - 1, db); ASSERT_EQ(HS_INVALID, err); free(bytes); free(db); } TEST(HyperscanArgChecks, DeserializeDatabaseAtBadLen2) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); size_t db_length = 0; hs_error_t err = hs_serialized_database_size(bytes, length, &db_length); ASSERT_EQ(HS_SUCCESS, err); hs_database_t *db = (hs_database_t *)malloc(db_length); err = hs_deserialize_database_at(bytes, length + 1, db); ASSERT_EQ(HS_INVALID, err); free(bytes); free(db); } TEST(HyperscanArgChecks, DeserializeDatabaseAtBadBytes) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); size_t db_length = 0; hs_error_t err = hs_serialized_database_size(bytes, length, &db_length); ASSERT_EQ(HS_SUCCESS, err); hs_database_t *db = (hs_database_t *)malloc(db_length); memset(bytes, 0xff, length); // scribble err = hs_deserialize_database_at(bytes, length, db); ASSERT_EQ(HS_INVALID, err); free(bytes); free(db); } TEST(HyperscanArgChecks, DeserializeDatabaseAtBadBytes2) { char *bytes = nullptr; size_t length = 0; makeSerializedDatabase(&bytes, &length); size_t db_length = 0; hs_error_t err = hs_serialized_database_size(bytes, length, &db_length); ASSERT_EQ(HS_SUCCESS, err); hs_database_t *db = (hs_database_t *)malloc(db_length); memset(bytes, 0, length); // scribble err = hs_deserialize_database_at(bytes, length, db); ASSERT_EQ(HS_INVALID, err); free(bytes); free(db); } TEST(HyperscanArgChecks, ScratchSizeNoSize) { hs_error_t err; // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; err = hs_compile("foo.*bar$", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); err = hs_scratch_size(scratch, nullptr); ASSERT_EQ(HS_INVALID, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, ScratchSizeNoScratch) { size_t size; hs_error_t err = hs_scratch_size(nullptr, &size); ASSERT_EQ(HS_INVALID, err); } TEST(HyperscanArgChecks, ScratchSizeBadScratch) { hs_scratch_t *scratch = (hs_scratch_t *)garbage; size_t size; hs_error_t err = hs_scratch_size(scratch, &size); ASSERT_EQ(HS_INVALID, err); } // hs_clone_scratch: bad scratch arg TEST(HyperscanArgChecks, CloneBadScratch) { // Try cloning the scratch void *local_garbage = malloc(sizeof(garbage)); memcpy(local_garbage, garbage, sizeof(garbage)); hs_scratch_t *cloned = nullptr; hs_scratch_t *scratch = (hs_scratch_t *)local_garbage; hs_error_t err = hs_clone_scratch(scratch, &cloned); free(local_garbage); ASSERT_EQ(HS_INVALID, err); } // hs_scan: bad scratch arg TEST(HyperscanArgChecks, ScanBadScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); void *local_garbage = malloc(sizeof(garbage)); memcpy(local_garbage, garbage, sizeof(garbage)); hs_scratch_t *scratch = (hs_scratch_t *)local_garbage; err = hs_scan(db, "data", 4, 0, scratch, dummy_cb, nullptr); free(local_garbage); ASSERT_EQ(HS_INVALID, err); // teardown hs_free_database(db); } // hs_scan_stream: bad scratch arg TEST(HyperscanArgChecks, ScanStreamBadScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); void *local_garbage = malloc(sizeof(garbage)); memcpy(local_garbage, garbage, sizeof(garbage)); hs_scratch_t *scratch = (hs_scratch_t *)local_garbage; hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, "data", 4, 0, scratch, nullptr, nullptr); EXPECT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_close_stream(stream, scratch, dummy_cb, nullptr); EXPECT_EQ(HS_INVALID, err); scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); hs_close_stream(stream, scratch, nullptr, nullptr); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); free(local_garbage); } // hs_reset_stream: bad scratch arg TEST(HyperscanArgChecks, ResetStreamBadScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); void *local_garbage = malloc(sizeof(garbage)); memcpy(local_garbage, garbage, sizeof(garbage)); hs_scratch_t *scratch = (hs_scratch_t *)local_garbage; hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_reset_stream(stream, 0, scratch, dummy_cb, nullptr); EXPECT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown err = hs_close_stream(stream, scratch, dummy_cb, nullptr); EXPECT_EQ(HS_INVALID, err); scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); hs_close_stream(stream, scratch, nullptr, nullptr); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); free(local_garbage); } // hs_scan_stream: bad scratch arg TEST(HyperscanArgChecks, ScanVectorBadScratch) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); void *local_garbage = malloc(sizeof(garbage)); memcpy(local_garbage, garbage, sizeof(garbage)); hs_scratch_t *scratch = (hs_scratch_t *)local_garbage; const char *data[] = { "data" }; unsigned int len[] = { 4 }; err = hs_scan_vector(db, data, len, 1, 0, scratch, dummy_cb, nullptr); EXPECT_NE(HS_SUCCESS, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown hs_free_database(db); free(local_garbage); } // hs_scan: bad (freed) scratch arg // disabled as, unsurprisingly, valgrind complains #ifdef TEST_FREED_MEM TEST(HyperscanArgChecks, ScanFreedScratch) { hs_database_t *db = 0; hs_compile_error_t *compile_err = 0; hs_error_t err = hs_compile("foobar", 0, HS_MODE_NOSTREAM, NULL, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != NULL); hs_scratch_t *scratch = 0; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != NULL); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan(db, "data", 4, 0, scratch, dummy_cb, 0); ASSERT_EQ(HS_INVALID, err); EXPECT_NE(HS_SCAN_TERMINATED, err); // teardown hs_free_database(db); } #endif // TEST_FREED_MEM // hs_expression_info: Compile a NULL pattern TEST(HyperscanArgChecks, ExprInfoNullExpression) { hs_expr_info_t *info = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_expression_info(nullptr, 0, &info, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(info == nullptr); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_expression_info: NULL info block ptr TEST(HyperscanArgChecks, ExprInfoNullInfoPtr) { hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_expression_info("foobar", 0, nullptr, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_expression_info: No compiler error block TEST(HyperscanArgChecks, ExprInfoNullErrPtr) { hs_expr_info_t *info = nullptr; hs_error_t err = hs_expression_info("foobar", 0, &info, nullptr); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(info == nullptr); } // hs_expression_ext_info: Compile a NULL pattern TEST(HyperscanArgChecks, ExprExtInfoNullExpression) { hs_expr_info_t *info = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_expression_ext_info(nullptr, 0, nullptr, &info, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(info == nullptr); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_expression_ext_info: NULL info block ptr TEST(HyperscanArgChecks, ExprExtInfoNullInfoPtr) { hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_expression_ext_info("foobar", 0, nullptr, nullptr, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); hs_free_compile_error(compile_err); } // hs_expression_ext_info: No compiler error block TEST(HyperscanArgChecks, ExprExtInfoNullErrPtr) { hs_expr_info_t *info = nullptr; hs_error_t err = hs_expression_ext_info("foobar", 0, nullptr, &info, nullptr); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(info == nullptr); } TEST(HyperscanArgChecks, hs_free_database_null) { hs_error_t err = hs_free_database(nullptr); ASSERT_EQ(HS_SUCCESS, err); } TEST(HyperscanArgChecks, hs_free_database_garbage) { hs_error_t err = hs_free_database((hs_database_t *)garbage); ASSERT_EQ(HS_INVALID, err); } TEST(HyperscanArgChecks, hs_free_scratch_null) { hs_error_t err = hs_free_scratch(nullptr); ASSERT_EQ(HS_SUCCESS, err); } TEST(HyperscanArgChecks, hs_free_scratch_garbage) { hs_error_t err = hs_free_scratch((hs_scratch_t *)garbage); ASSERT_EQ(HS_INVALID, err); } TEST(HyperscanArgChecks, hs_free_compile_error_null) { hs_error_t err = hs_free_compile_error(nullptr); ASSERT_EQ(HS_SUCCESS, err); } TEST(HyperscanArgChecks, multicompile_mix_highlander_1) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; const char *expr[] = {"aoo[A-K]", "bar[L-Z]"}; unsigned flags[] = {HS_FLAG_SINGLEMATCH, 0}; unsigned ids[] = {30, 30}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_COMPILER_ERROR, err); hs_free_compile_error(compile_err); } TEST(HyperscanArgChecks, multicompile_mix_highlander_2) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; const char *expr[] = {"aoo[A-K]", "bar[L-Z]"}; unsigned flags[] = {0, HS_FLAG_SINGLEMATCH}; unsigned ids[] = {30, 30}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_COMPILER_ERROR, err); hs_free_compile_error(compile_err); } TEST(HyperscanArgChecks, multicompile_nomix_highlander_1) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; const char *expr[] = {"aoo[A-K]", "bar[L-Z]"}; unsigned flags[] = {HS_FLAG_SINGLEMATCH, HS_FLAG_SINGLEMATCH}; unsigned ids[] = {30, 30}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, multicompile_nomix_highlander_2) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; const char *expr[] = {"aoo[A-K]", "bar[L-Z]"}; unsigned flags[] = {0, 0}; unsigned ids[] = {30, 30}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanArgChecks, hs_populate_platform_null) { hs_error_t err = hs_populate_platform(nullptr); ASSERT_EQ(HS_INVALID, err); } class BadModeTest : public testing::TestWithParam {}; // hs_compile: Compile a pattern with bogus mode flags set. TEST_P(BadModeTest, FailCompile) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; unsigned mode = GetParam(); SCOPED_TRACE(mode); hs_error_t err = hs_compile("foo", 0, mode, nullptr, &db, &compile_err); ASSERT_EQ(HS_COMPILER_ERROR, err); ASSERT_TRUE(compile_err != nullptr); ASSERT_TRUE(compile_err->message != nullptr); hs_free_compile_error(compile_err); } static const unsigned badModeValues[] = { // Multiple modes at once. HS_MODE_BLOCK | HS_MODE_STREAM | HS_MODE_VECTORED, HS_MODE_BLOCK | HS_MODE_STREAM, HS_MODE_BLOCK | HS_MODE_VECTORED, HS_MODE_STREAM | HS_MODE_VECTORED, // SOM horizon modes are only accepted in streaming mode. HS_MODE_BLOCK | HS_MODE_SOM_HORIZON_LARGE, HS_MODE_BLOCK | HS_MODE_SOM_HORIZON_MEDIUM, HS_MODE_BLOCK | HS_MODE_SOM_HORIZON_SMALL, HS_MODE_VECTORED | HS_MODE_SOM_HORIZON_LARGE, HS_MODE_VECTORED | HS_MODE_SOM_HORIZON_MEDIUM, HS_MODE_VECTORED | HS_MODE_SOM_HORIZON_SMALL, // Can't specify more than one SOM horizon. HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE | HS_MODE_SOM_HORIZON_MEDIUM | HS_MODE_SOM_HORIZON_SMALL, HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE | HS_MODE_SOM_HORIZON_SMALL, HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE | HS_MODE_SOM_HORIZON_MEDIUM, HS_MODE_STREAM | HS_MODE_SOM_HORIZON_MEDIUM | HS_MODE_SOM_HORIZON_SMALL, }; INSTANTIATE_TEST_CASE_P(HyperscanArgChecks, BadModeTest, testing::ValuesIn(badModeValues)); } // namespace hyperscan-4.4.1/unit/hyperscan/behaviour.cpp0000644000175000017500000014623713055426554021757 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ #include "config.h" #include #include #include #include #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" using namespace std; using namespace testing; namespace /* anonymous */ { // Dummy callback: does nothing, returns 0 (keep matching) int dummyHandler(unsigned, unsigned long long, unsigned long long, unsigned, void *) { // empty return 0; } unsigned lastMatchId = 0; unsigned long long lastMatchFrom = 0; unsigned long long lastMatchTo = 0; unsigned lastMatchFlags = 0; void *lastMatchCtx = nullptr; // Single match Callback: record all the details from a single match int singleHandler(unsigned id, unsigned long long from, unsigned long long to, unsigned flags, void *ctx) { lastMatchId = id; lastMatchFrom = from; lastMatchTo = to; lastMatchFlags = flags; lastMatchCtx = ctx; return 0; } unsigned matchCount = 0; // Counter callback: just counts the number of calls int countHandler(unsigned, unsigned long long, unsigned long long, unsigned, void *) { matchCount++; return 0; } // Stop handler: take one match and tell Hyperscan to not deliver any more. int stopHandler(unsigned, unsigned long long, unsigned long long, unsigned, void *) { matchCount++; return 1; } // Can we scan 5GB of data (pushing past the uint32_t limit) TEST(HyperscanTestBehaviour, ScanSeveralGigabytesNoMatch) { hs_error_t err; const size_t datalen = 1024 * 1024; size_t megabytes = 5 * 1024; vector data(datalen, 'X'); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; err = hs_compile("hatstand.*teakettle.*badgerbrush", HS_FLAG_DOTALL, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); // streaming mode scan of our megabyte of data 5K times hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); while (megabytes-- > 0) { err = hs_scan_stream(stream, data.data(), data.size(), 0, scratch, dummyHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); } err = hs_close_stream(stream, scratch, dummyHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } struct HugeScanMatchingData { const char *pattern; unsigned int flags; const char *preBlock; // scan before 5GB of X's const char *postBlock; // scan after 5GB of X's, single match at end }; class HyperscanScanGigabytesMatch : public TestWithParam { }; // Can we scan 5GB of data (pushing past the uint32_t limit) and get a real match TEST_P(HyperscanScanGigabytesMatch, StreamingMatch) { const HugeScanMatchingData ¶ms = GetParam(); SCOPED_TRACE(params.pattern); hs_error_t err; const size_t datalen = 1024*1024; vector data(datalen, 'X'); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; err = hs_compile(params.pattern, params.flags, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); // gb is the number of gigabytes to scan between pre-block and post-block // run over 1,2,4,8 gb for (unsigned long long gb = 1; gb <= 8; gb *= 2) { SCOPED_TRACE(gb); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); // scan our pre-block lastMatchTo = 0; err = hs_scan_stream(stream, params.preBlock, strlen(params.preBlock), 0, scratch, singleHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0ULL, lastMatchTo); // streaming mode scan of our megabyte of data gb*1024 times unsigned long remaining = gb * 1024; while (remaining-- > 0) { err = hs_scan_stream(stream, data.data(), data.size(), 0, scratch, singleHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0ULL, lastMatchTo); } // scan post-block and close stream err = hs_scan_stream(stream, params.postBlock, strlen(params.postBlock), 0, scratch, singleHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, singleHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); // make sure we got our match unsigned long long totalLen = strlen(params.preBlock) + gb * 1024 * datalen + strlen(params.postBlock); ASSERT_EQ(totalLen, lastMatchTo); } // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // Helper function to actually perform scans for BlockMatch test below void allocAndScanBlock(const HugeScanMatchingData ¶ms, const hs_database_t *db, hs_scratch_t *scratch, unsigned int len) { SCOPED_TRACE(len); char *data = (char *)calloc(len, 1); if (data == nullptr) { printf("Can't allocate %u bytes, skipping test\n", len); return; } // write pre-block at the start and post-block at the end memcpy(data, params.preBlock, strlen(params.preBlock)); memcpy(data+len - strlen(params.postBlock), params.postBlock, strlen(params.postBlock)); lastMatchTo = 0; hs_error_t err; err = hs_scan(db, data, len, 0, scratch, singleHandler, nullptr); free(data); ASSERT_EQ(HS_SUCCESS, err); // make sure we got our match ASSERT_EQ(len, lastMatchTo); } // Define to run even more huge block tests //#define BIG_BLOCKS // Can we scan gigabytes of data in a block and get a real match TEST_P(HyperscanScanGigabytesMatch, BlockMatch) { const HugeScanMatchingData ¶ms = GetParam(); SCOPED_TRACE(params.pattern); hs_error_t err; // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; err = hs_compile(params.pattern, params.flags, HS_MODE_BLOCK, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); // try various data sizes (in kilobytes) size_t blockSizes[] = { // kilobytes 1, 4, 8, 16, 32, 64, 128, 256, 512, // megabytes 1*1024, #ifdef BIG_BLOCKS 4*1024, 32*1024, 128*1024, 512*1024, // gigabytes 1024*1024, #ifdef ARCH_X86_64 // big cases for big beefy machines 2048*1024, 3072*1024 #endif // ARCH_X86_64 #endif // BIG_BLOCKS }; for (const auto size : blockSizes) { size_t bytes = size * 1024; // The block API only accepts blocks up to UINT_MAX in size. ASSERT_GE(UINT_MAX, bytes); ASSERT_GE(UINT_MAX, bytes + strlen(params.postBlock)); // First test: block size exactly. allocAndScanBlock(params, db, scratch, bytes); // Second test: block size plus four bytes, to make our post-block // straddle the block size boundary. allocAndScanBlock(params, db, scratch, bytes + 4); // Third test: block size plus the length of post-block. allocAndScanBlock(params, db, scratch, bytes + strlen(params.postBlock)); } // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } static const HugeScanMatchingData gigTests[] = { { "foobar", 0, "flibble", "foobar" }, { "longliteralislongerthanlong", 0, "precursor", "longliteralislongerthanlong" }, { "foobar\\z", 0, "flibble", "foobar" }, { "hatstand.*teakettle.*badgerbrush", HS_FLAG_DOTALL, "hatstand teakettle", "_badgerbrush" }, { "hatstand.*teakettle.*badgerbrush\\z", HS_FLAG_DOTALL, "hatstand teakettle", "_badgerbrush" }, { "a.*(([0123][56789]){3,6}|flibble|xyz{1,2}y)", 0, "a", "051629" }, { "^a.*(([0123][56789]){3,6}|flibble|xyz{1,2}y)", 0, "a", "051629" }, { "(badger.*){3,}mushroom.*mushroom", HS_FLAG_DOTALL, "badger badger badger", "mushroom! mushroom" }, { "(badger.*){3,}mushroom.*mushroom$", HS_FLAG_DOTALL, "badger badger badger", "mushroom! mushroom" }, { "foo[^X]{16}", HS_FLAG_SINGLEMATCH, "preblock", "foo0123456789abcdef" }, { "foobar.*bazbaz[^X]{16}", HS_FLAG_DOTALL|HS_FLAG_SINGLEMATCH, "foobar", "bazbaz0123456789abcdef" }, { "t?((w.(u|t|.)){6,10}|[dqnt]|e|va)", 0, "~~~~", "tva" }, { "HTTP.*foobar.*blah", HS_FLAG_DOTALL, "bing", "HTTP foobar blah" }, }; INSTANTIATE_TEST_CASE_P(HyperscanTestBehaviour, HyperscanScanGigabytesMatch, ValuesIn(gigTests)); // Do we actually only get a single match back from HS_FLAG_SINGLEMATCH? TEST(HyperscanTestBehaviour, StreamingThereCanBeOnlyOne) { hs_error_t err; const std::string data1("hackhackHACKhackHACkhAcK"); const std::string data2("KHACKhackHACKhaCkhAcKhaaaaaaaaaaaaaaaaaaaackk"); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; err = hs_compile(".ck", HS_FLAG_CASELESS | HS_FLAG_SINGLEMATCH, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); matchCount = 0; err = hs_scan_stream(stream, data1.c_str(), data1.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // only one match err = hs_scan_stream(stream, data2.c_str(), data2.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // just the one from the first call above err = hs_close_stream(stream, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // Do we actually only get a single match back from HS_FLAG_SINGLEMATCH? TEST(HyperscanTestBehaviour, BlockThereCanBeOnlyOne) { hs_error_t err; const std::string data1("hackhackHACKhackHACkhAcKzofunvuynlslijlnikshvb ar yhtkubq45ytvb iuyh " "ackeruniou viytdfjhg nvldkrjgnal"); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; err = hs_compile(".ck", HS_FLAG_CASELESS | HS_FLAG_SINGLEMATCH, HS_MODE_BLOCK, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, data1.c_str(), data1.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // only one match // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } class HyperscanLiteralLengthTest : public TestWithParam { protected: virtual void SetUp() { literal_len = GetParam(); } size_t literal_len; }; TEST_P(HyperscanLiteralLengthTest, FloatingBlock) { SCOPED_TRACE(literal_len); const string pattern(literal_len, 'a'); const string data(literal_len + 4, 'a'); SCOPED_TRACE(pattern); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err; err = hs_compile(pattern.c_str(), 0, HS_MODE_BLOCK, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(5U, matchCount); // five matches // Should see no match from five bytes in matchCount = 0; err = hs_scan(db, data.c_str() + 5, data.size() - 5, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // no matches // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST_P(HyperscanLiteralLengthTest, AnchoredBlock) { SCOPED_TRACE(literal_len); const string pattern = "^" + string(literal_len, 'a'); const string data(literal_len + 4, 'a'); SCOPED_TRACE(pattern); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err; err = hs_compile(pattern.c_str(), 0, HS_MODE_BLOCK, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // one match // Should see no match from five bytes in matchCount = 0; err = hs_scan(db, data.c_str() + 5, data.size() - 5, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // no matches // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } INSTANTIATE_TEST_CASE_P(HyperscanLiteralLength, HyperscanLiteralLengthTest, Values(1, 2, 3, 4, 8, 16, 17, 32, 100, 200, 400, 1000, 4096, 8192, 15000, 15999)); struct CallbackStopData { const char *pattern; unsigned int flags; const char *corpus; }; class CallbackReturnStop : public TestWithParam { }; TEST_P(CallbackReturnStop, Block) { const CallbackStopData ¶ms = GetParam(); SCOPED_TRACE(params.pattern); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err; err = hs_compile(params.pattern, params.flags, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, params.corpus, strlen(params.corpus), 0, scratch, stopHandler, nullptr); ASSERT_EQ(1U, matchCount) << "One match exactly should be recorded."; ASSERT_EQ(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST_P(CallbackReturnStop, Streaming) { const CallbackStopData ¶ms = GetParam(); SCOPED_TRACE(params.pattern); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err; err = hs_compile(params.pattern, params.flags, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); matchCount = 0; err = hs_scan_stream(stream, params.corpus, strlen(params.corpus), 0, scratch, stopHandler, nullptr); ASSERT_EQ(1U, matchCount) << "One match exactly should be recorded."; ASSERT_EQ(HS_SCAN_TERMINATED, err); err = hs_close_stream(stream, scratch, stopHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST_P(CallbackReturnStop, Vectored) { const CallbackStopData ¶ms = GetParam(); SCOPED_TRACE(params.pattern); // build a database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err; err = hs_compile(params.pattern, params.flags, HS_MODE_VECTORED, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; const char *data[] = { params.corpus }; unsigned int len[] = { (unsigned int)strlen(params.corpus) }; err = hs_scan_vector(db, data, len, 1, 0, scratch, stopHandler, nullptr); ASSERT_EQ(1U, matchCount) << "One match exactly should be recorded."; ASSERT_EQ(HS_SCAN_TERMINATED, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } static const CallbackStopData callbackStopTests[] = { { "foobar", 0, "xxxfoobarxxxfoobarxxxfoobar" }, { "a", 0, "xxxaaaaaaaaaaaaaaaaaaa" }, { "a", HS_FLAG_CASELESS, "xxxAaAaAaAa" }, { ".", 0, "acbdef" }, { ".", HS_FLAG_DOTALL, "abcdef" }, { "foo.*bar.*foo", HS_FLAG_DOTALL, "foobarfoobarfoobarfoobarfoo" }, { "(badger.*){3,}", HS_FLAG_DOTALL, "badger badger badger badger badger badger badger badger" }, { "foobar.*", 0, "foobarxxx" }, { "[012]{3,7}.*abba", 0, "0120120120abbaabba" }, }; INSTANTIATE_TEST_CASE_P(HyperscanTestBehaviour, CallbackReturnStop, ValuesIn(callbackStopTests)); // Serialization, then deserialization: A simple case, with just a single // trivial pattern. TEST(HyperscanTestBehaviour, SerializedDogfood1) { // build database hs_database_t *db = buildDB("puppy treats!", 0, 0, HS_MODE_BLOCK); ASSERT_TRUE(db != nullptr); hs_error_t err; size_t origSize; err = hs_database_size(db, &origSize); ASSERT_EQ(HS_SUCCESS, err); // serialise to buffer char *bytes = nullptr; size_t length = 0; err = hs_serialize_database(db, &bytes, &length); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(bytes != nullptr); ASSERT_LT(0U, length); // free original database hs_free_database(db); db = nullptr; // deserialize hs_database_t *db2 = nullptr; err = hs_deserialize_database(bytes, length, &db2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db2 != nullptr); free(bytes); // tests size_t newSize; err = hs_database_size(db2, &newSize); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(newSize, origSize) << "Database lengths should match."; // check that we can get a match out of it lastMatchTo = 0; const char *data = "delicious puppy treats!"; unsigned int len = strlen(data); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db2, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan(db2, data, len, 0, scratch, singleHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(len, lastMatchTo); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db2); } // A more complicated case, with several patterns TEST(HyperscanTestBehaviour, SerializedDogfood2) { // build database hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err; static const vector expressions { "puppy treats!", "foobar", "foo.*bar.*foo", "(badger.*){3,}", "[012]{3,7}.*abba" }; static const vector flags { 0, 0, HS_FLAG_DOTALL, HS_FLAG_DOTALL, 0 }; static const vector ids { 1000, 1001, 1002, 1003, 1004 }; size_t num = expressions.size(); ASSERT_EQ(num, flags.size()); ASSERT_EQ(num, ids.size()); err = hs_compile_multi(expressions.data(), flags.data(), ids.data(), num, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); size_t origSize; err = hs_database_size(db, &origSize); ASSERT_EQ(HS_SUCCESS, err); // serialise to buffer char *bytes = nullptr; size_t length = 0; err = hs_serialize_database(db, &bytes, &length); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(bytes != nullptr); ASSERT_LT(0U, length); // free original database hs_free_database(db); db = nullptr; // deserialize hs_database_t *db2 = nullptr; err = hs_deserialize_database(bytes, length, &db2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db2 != nullptr); free(bytes); // tests size_t newSize; err = hs_database_size(db2, &newSize); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(newSize, origSize) << "Database lengths should match."; // check that we can get a match out of it lastMatchTo = 0; lastMatchId = 0; const char *data = "delicious puppy treats!"; unsigned int len = strlen(data); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db2, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan(db2, data, len, 0, scratch, singleHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(len, lastMatchTo); ASSERT_EQ(ids[0], lastMatchId); // check another pattern const char *data2 = "badger badger badger"; unsigned int len2 = strlen(data2); err = hs_scan(db2, data2, len2, 0, scratch, singleHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(len2, lastMatchTo); ASSERT_EQ(ids[3], lastMatchId); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db2); } // Serialization, then deserialization into a preallocated memory region. A // simple case, with just a single trivial pattern. TEST(HyperscanTestBehaviour, SerializedDogfood3) { // build database hs_database_t *db = buildDB("puppy treats!", 0, 0, HS_MODE_BLOCK); ASSERT_TRUE(db != nullptr); hs_error_t err; size_t origSize; err = hs_database_size(db, &origSize); ASSERT_EQ(HS_SUCCESS, err); // serialise to buffer char *bytes = nullptr; size_t length = 0; err = hs_serialize_database(db, &bytes, &length); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(bytes != nullptr); ASSERT_LT(0U, length); // free original database hs_free_database(db); db = nullptr; // find out how much space we need size_t slength; err = hs_serialized_database_size(bytes, length, &slength); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(slength, origSize) << "Database lengths should match."; // fail tests: try to deserialize into an incorrectly aligned region. char *mem = (char *)malloc(slength + 16); ASSERT_TRUE(mem != nullptr); ASSERT_EQ(0U, (ptrdiff_t)mem % 8); // add one for epic fail err = hs_deserialize_database_at(bytes, length, (hs_database_t *)(mem + 1)); ASSERT_EQ(HS_BAD_ALIGN, err); // add four, which should give us 4-byte alignment which isn't good enough. err = hs_deserialize_database_at(bytes, length, (hs_database_t *)(mem + 4)); ASSERT_EQ(HS_BAD_ALIGN, err); // deserialize for real err = hs_deserialize_database_at(bytes, length, (hs_database_t *)mem); ASSERT_EQ(HS_SUCCESS, err); free(bytes); const hs_database_t *db2 = (const hs_database_t *)mem; // tests size_t newSize; err = hs_database_size(db2, &newSize); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(newSize, origSize) << "Database lengths should match."; // check that we can get a match out of it lastMatchTo = 0; const char *data = "delicious puppy treats!"; unsigned int len = strlen(data); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db2, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan(db2, data, len, 0, scratch, singleHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(len, lastMatchTo); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); free(mem); } // Test that we do get a pending match on stream close. TEST(HyperscanTestBehaviour, CloseStreamMatch) { hs_error_t err; // build a database hs_database_t *db = buildDB("foo.*bar$", 0, 0, HS_MODE_STREAM); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); matchCount = 0; const string data("foo bar"); err = hs_scan_stream(stream, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // hasn't matched until stream end err = hs_close_stream(stream, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // our match was returned // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } /* Test that if we scan without a callback during main phase that we are still * tracking stuff internally */ TEST(HyperscanTestBehaviour, NoMainCB) { hs_error_t err; // build a database hs_database_t *db = buildDB("foo|foo.*bar$", 0, 0, HS_MODE_STREAM); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); matchCount = 0; const string data("foo bar"); err = hs_scan_stream(stream, data.c_str(), data.size(), 0, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // hasn't matched until stream end err = hs_close_stream(stream, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // our match was returned // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // Test that we don't get a match that's pending on stream close when we use // hs_close_stream with no event handler. TEST(HyperscanTestBehaviour, CloseStreamNoMatch) { hs_error_t err; // build a database hs_database_t *db = buildDB("foo.*bar$", 0, 0, HS_MODE_STREAM); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); matchCount = 0; const string data("foo bar"); err = hs_scan_stream(stream, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // hasn't matched until stream end err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // no match was returned // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // Test that we can close a stream correctly after we've terminated matching. TEST(HyperscanTestBehaviour, CloseStreamAfterTermination) { hs_error_t err; // build a database hs_database_t *db = buildDB("foo.*(bar|baz\\z)", 0, 0, HS_MODE_STREAM); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); matchCount = 0; const string data("foo bar baz"); err = hs_scan_stream(stream, data.c_str(), data.size(), 0, scratch, stopHandler, nullptr); ASSERT_EQ(HS_SCAN_TERMINATED, err); EXPECT_EQ(1U, matchCount); // after "bar" err = hs_close_stream(stream, scratch, stopHandler, nullptr); EXPECT_EQ(1U, matchCount); // no match for baz ASSERT_EQ(HS_SUCCESS, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, Vectored1) { hs_error_t err; // build a database hs_database_t *db = buildDB("^foo.*bar", HS_FLAG_DOTALL, 0, HS_MODE_VECTORED); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); const char *data[] = { "foo", " ", "bar" }; unsigned int len[] = { 3, 3, 3}; matchCount = 0; err = hs_scan_vector(db, data, len, 3, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, Vectored2) { hs_error_t err; // build a database hs_database_t *db = buildDB("^foo.*bar", HS_FLAG_DOTALL, 0, HS_MODE_VECTORED); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); const char *data[] = { "", "foo", " ", "bar" }; unsigned int len[] = { 0, 3, 3, 3}; matchCount = 0; err = hs_scan_vector(db, data, len, 4, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, Vectored3) { hs_error_t err; // build a database hs_database_t *db = buildDB("^foo.*bar", HS_FLAG_DOTALL, 0, HS_MODE_VECTORED); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); const char *data[] = { "foo", " ", "", "bar" }; unsigned int len[] = { 3, 3, 0, 3}; matchCount = 0; err = hs_scan_vector(db, data, len, 4, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, Vectored4) { hs_error_t err; // build a database hs_database_t *db = buildDB("^foo.*bar", HS_FLAG_DOTALL, 0, HS_MODE_VECTORED); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); const char *data[] = { "foo", " ", "bar", "" }; unsigned int len[] = { 3, 3, 3, 0}; matchCount = 0; err = hs_scan_vector(db, data, len, 4, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, Vectored5) { hs_error_t err; // build a database hs_database_t *db = buildDB("^foo.*bar", HS_FLAG_DOTALL, 0, HS_MODE_VECTORED); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); const char *data[] = { "", "foo", " ", "bar" }; unsigned int len[] = { 0, 3, 3, 3}; matchCount = 0; err = hs_scan_vector(db, data, len, 0, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, Vectored6) { hs_error_t err; // build a database hs_database_t *db = buildDB("^", HS_FLAG_DOTALL | HS_FLAG_ALLOWEMPTY, 0, HS_MODE_VECTORED); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); const char *data[] = { "", "foo", " ", "bar" }; unsigned int len[] = { 0, 3, 3, 3}; matchCount = 0; err = hs_scan_vector(db, data, len, 0, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, Vectored7) { hs_error_t err; // build a database hs_database_t *db = buildDB("$", HS_FLAG_DOTALL | HS_FLAG_ALLOWEMPTY, 0, HS_MODE_VECTORED); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); const char *data[] = { "", "foo", " ", "bar" }; unsigned int len[] = { 0, 3, 3, 3}; matchCount = 0; err = hs_scan_vector(db, data, len, 0, 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, MultiStream1) { hs_error_t err; // build a database hs_database_t *db = buildDB("foo.*bar.*\\b", 0, 0, HS_MODE_STREAM); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); hs_stream_t *stream2 = nullptr; err = hs_open_stream(db, 0, &stream2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream2 != nullptr); matchCount = 0; const string data("foo bara"); err = hs_scan_stream(stream, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // hasn't matched until stream end const string data2("foo bar "); err = hs_scan_stream(stream2, data2.c_str(), data2.size(), 0, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); err = hs_close_stream(stream, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); err = hs_close_stream(stream2, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(HyperscanTestBehaviour, MultiStream2) { hs_error_t err; // build a database hs_database_t *db = buildDB("foo.*bar.*\\b", 0, 0, HS_MODE_STREAM); ASSERT_TRUE(db != nullptr); // alloc some scratch hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); hs_stream_t *stream2 = nullptr; err = hs_open_stream(db, 0, &stream2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream2 != nullptr); matchCount = 0; const string data2("foo bar "); err = hs_scan_stream(stream2, data2.c_str(), data2.size(), 0, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); const string data("foo bara"); err = hs_scan_stream(stream, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); // hasn't matched until stream end err = hs_close_stream(stream2, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, matchCount); err = hs_close_stream(stream, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1U, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(regression, UE_1005) { hs_error_t err; vector patterns; patterns.push_back(pattern("match[^Z]*", HS_FLAG_DOTALL|HS_FLAG_SINGLEMATCH, 1)); patterns.push_back(pattern("[^X]+\\z", HS_FLAG_DOTALL|HS_FLAG_SINGLEMATCH, 2)); patterns.push_back(pattern("[^Y]+\\z", HS_FLAG_DOTALL|HS_FLAG_SINGLEMATCH, 3)); hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; const char dataA[] = "match"; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, dataA, strlen(dataA), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(3U, c.matches.size()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(5, 1)) != c.matches.end()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(5, 2)) != c.matches.end()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(5, 3)) != c.matches.end()); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(regression, UE_2425) { const char regex[] = "(b|[cd](\\B|a){14}|[ba]cd.[^ece]b.[da]cbe|d[cad]cb.[da](cd|[abedc])|\\ba.edbac){18}"; unsigned flags = HS_FLAG_DOTALL | HS_FLAG_CASELESS | HS_FLAG_SINGLEMATCH | HS_FLAG_UTF8 | HS_FLAG_PREFILTER; vector patterns; patterns.push_back(pattern(regex, flags, 1)); // This bug was an assertion failure at Puff construction time (Puff // generated by prefilter reductions.) hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_free_database(db); } TEST(regression, UE_2485) { const char regex[] = "(?:(.EeEa|((a{2}BD[bc]Bd[eae]|[DCd]|c|ebCa|d)){7,21})(E{5,}A{4,}[Cc].cc{3,6}|eCec|e+CaBEd|[Bb])){10}DB(a|[AAda])..A?DE?E"; unsigned flags = HS_FLAG_DOTALL | HS_FLAG_CASELESS | HS_FLAG_UTF8 | HS_FLAG_PREFILTER; vector patterns; patterns.push_back(pattern(regex, flags, 1)); // This bug was an assertion failure at compile time due to // removeRedundancy rendering a graph unimplementable after a merge, for // the prefiltered pattern. hs_database_t *db = buildDB(patterns, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_free_database(db); } TEST(regression, UE_2452) { const char regex[] = "/ab.b[bca]{2,}ca((?:c|(abc(?sxmi-xm)){10,14}|c|b|[abcb])){4,23}acbcbb*ba((?:(a|.{4,}|.|[acba])){3,16}a)+"; unsigned flags = HS_FLAG_MULTILINE | HS_FLAG_CASELESS | HS_FLAG_UTF8 | HS_FLAG_UCP | HS_FLAG_PREFILTER; vector patterns; patterns.push_back(pattern(regex, flags, 1)); // This bug was an interaction between bounded repeat analysis, // prefiltering and edge redundancy. hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_free_database(db); } TEST(regression, UE_2595) { const char regex[] = "(?:(?:acAa|c[EAA]aEb|((?:CC[bdd].cE((?x-msix)BE){32}(?:\\B)){16,19}CdD.E(E|E|B)){3,6}|E(a|d|.)(?:(?xs-isxm)|b|.|C))){17,}"; unsigned flags = HS_FLAG_MULTILINE | HS_FLAG_CASELESS | HS_FLAG_SINGLEMATCH | HS_FLAG_PREFILTER; vector patterns; patterns.push_back(pattern(regex, flags, 1)); // This pattern has some very large depth values and isn't compilable by // PCRE at all. hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_free_database(db); } TEST(regression, UE_2762) { const vector patterns = { pattern("\\Aa\\z", HS_FLAG_MULTILINE, 1), pattern("^a", HS_FLAG_MULTILINE, 2), pattern("a|^a", HS_FLAG_MULTILINE | HS_FLAG_SOM_LEFTMOST, 3)}; hs_database_t *db = buildDB(patterns, HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; const char dataA[] = "a"; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, stream); err = hs_scan_stream(stream, dataA, strlen(dataA), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(3U, c.matches.size()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(1, 1)) != c.matches.end()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(1, 2)) != c.matches.end()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(1, 3)) != c.matches.end()); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(regression, UE_2763) { const vector patterns = { pattern("aaa.a+$", HS_FLAG_CASELESS, 1), pattern("aaa.a", HS_FLAG_CASELESS | HS_FLAG_SINGLEMATCH | HS_FLAG_UTF8, 2)}; hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; const char dataA[] = "aAasaA"; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, stream); err = hs_scan_stream(stream, dataA, strlen(dataA), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(6, 1)) != c.matches.end()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(5, 2)) != c.matches.end()); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(regression, UE_2798) { const vector patterns = { pattern("([ab]b|aab+)$", HS_FLAG_DOTALL, 1), pattern("ab+", HS_FLAG_SOM_LEFTMOST, 2), pattern("a(b.)?ba+b", 0, 3)}; hs_database_t *db = buildDB(patterns, HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; const char dataA[] = "ab_baab\n"; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, stream); err = hs_scan_stream(stream, dataA, strlen(dataA), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(4U, c.matches.size()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(7, 1)) != c.matches.end()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(2, 2)) != c.matches.end()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(7, 2)) != c.matches.end()); ASSERT_TRUE(find(c.matches.begin(), c.matches.end(), MatchRecord(7, 3)) != c.matches.end()); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(PcreSpace, NewPcre) { const char regex[] = "\\s"; const string data = "\x09\x0a\x0b\x0c\x0d\x20"; /* aka "\t\n\v\f\r " */ unsigned flags = 0; vector patterns; patterns.push_back(pattern(regex, flags, 1)); hs_error_t err; hs_database_t *db = buildDB(patterns, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(data.size(), matchCount); // all are spaces // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(PcreSpace, NewPcreClass) { const char regex[] = "[\\s]"; const string data = "\x09\x0a\x0b\x0c\x0d\x20"; /* aka "\t\n\v\f\r " */ unsigned flags = 0; vector patterns; patterns.push_back(pattern(regex, flags, 1)); hs_error_t err; hs_database_t *db = buildDB(patterns, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(data.size(), matchCount); // all are spaces // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(PcreSpace, NewPcreNeg) { const char regex[] = "\\S"; const string data = "\x09\x0a\x0b\x0c\x0d\x20"; /* aka "\t\n\v\f\r " */ unsigned flags = 0; vector patterns; patterns.push_back(pattern(regex, flags, 1)); hs_error_t err; hs_database_t *db = buildDB(patterns, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0, matchCount); // no matches, all are spaces // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(PcreSpace, NewPcreClassNeg) { const char regex[] = "[\\S]"; const string data = "\x09\x0a\x0b\x0c\x0d\x20"; /* aka "\t\n\v\f\r " */ unsigned flags = 0; vector patterns; patterns.push_back(pattern(regex, flags, 1)); hs_error_t err; hs_database_t *db = buildDB(patterns, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0, matchCount); // no matches, all are spaces // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(Parser, NewlineTerminatedComment) { // Extended mode comments and whitespace should be stripped. const vector patterns = { pattern("(?x)foo # initial comment \n bar # second comment \n baz", 0, 1)}; const string data = "foobarbaz"; hs_database_t *db = buildDB(patterns, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); matchCount = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, countHandler, nullptr); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(1, matchCount); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } } // namespace hyperscan-4.4.1/unit/hyperscan/order.cpp0000644000175000017500000003144713055426554021102 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include #include #include #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" using namespace std; using namespace testing; namespace /* anonymous */ { bool matchesOrdered(const vector &matches) { unsigned long lastMatch = 0; for (vector::const_iterator it = matches.begin(); it != matches.end(); ++it) { if (lastMatch > it->to) { return false; } lastMatch = it->to; } return true; } unsigned countMatchesById(const vector &matches, int id) { unsigned count = 0; for (vector::const_iterator it = matches.begin(); it != matches.end(); ++it) { if (id == it->id) { count++; } } return count; } TEST(order, ordering1) { vector patterns; patterns.push_back(pattern("aa", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); patterns.push_back(pattern("^.{0,4}aa", HS_FLAG_DOTALL, 5)); const char *data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; hs_database_t *db = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); CallBackContext c; err = hs_scan(db, data, strlen(data), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(31U, countMatchesById(c.matches, 1)); EXPECT_EQ(30U, countMatchesById(c.matches, 2)); EXPECT_EQ(29U, countMatchesById(c.matches, 3)); EXPECT_EQ(5U, countMatchesById(c.matches, 4)); EXPECT_EQ(5U, countMatchesById(c.matches, 5)); ASSERT_TRUE(matchesOrdered(c.matches)); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(order, ordering2) { vector patterns; patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); patterns.push_back(pattern("^.{0,4}aa", HS_FLAG_DOTALL, 5)); const char *data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; hs_database_t *db = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); CallBackContext c; err = hs_scan(db, data, strlen(data), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, countMatchesById(c.matches, 1)); EXPECT_EQ(30U, countMatchesById(c.matches, 2)); EXPECT_EQ(29U, countMatchesById(c.matches, 3)); EXPECT_EQ(5U, countMatchesById(c.matches, 4)); EXPECT_EQ(5U, countMatchesById(c.matches, 5)); ASSERT_TRUE(matchesOrdered(c.matches)); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(order, ordering3) { vector patterns; patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); const char *data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; hs_database_t *db = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); CallBackContext c; err = hs_scan(db, data, strlen(data), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(0U, countMatchesById(c.matches, 1)); EXPECT_EQ(30U, countMatchesById(c.matches, 2)); EXPECT_EQ(29U, countMatchesById(c.matches, 3)); EXPECT_EQ(5U, countMatchesById(c.matches, 4)); EXPECT_EQ(0U, countMatchesById(c.matches, 5)); ASSERT_TRUE(matchesOrdered(c.matches)); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(order, ordering4) { vector patterns; patterns.push_back(pattern("aa", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); const char *data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; hs_database_t *db = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); CallBackContext c; err = hs_scan(db, data, strlen(data), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(31U, countMatchesById(c.matches, 1)); EXPECT_EQ(30U, countMatchesById(c.matches, 2)); EXPECT_EQ(29U, countMatchesById(c.matches, 3)); EXPECT_EQ(0U, countMatchesById(c.matches, 4)); EXPECT_EQ(0U, countMatchesById(c.matches, 5)); ASSERT_TRUE(matchesOrdered(c.matches)); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(order, ordering5) { vector patterns; patterns.push_back(pattern("aa", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); patterns.push_back(pattern("^.{0,4}aa", HS_FLAG_DOTALL, 5)); const char *data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; for (size_t jump = 1; jump <= 8; jump++) { err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); for (unsigned i = 0; i < strlen(data); i += jump) { err = hs_scan_stream(stream, data + i, min(jump, strlen(data) - i), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); } EXPECT_EQ(31U, countMatchesById(c.matches, 1)); EXPECT_EQ(30U, countMatchesById(c.matches, 2)); EXPECT_EQ(29U, countMatchesById(c.matches, 3)); EXPECT_EQ(5U, countMatchesById(c.matches, 4)); EXPECT_EQ(5U, countMatchesById(c.matches, 5)); ASSERT_TRUE(matchesOrdered(c.matches)); c.matches.clear(); hs_close_stream(stream, scratch, record_cb, (void *)&c); } err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(order, ordering6) { vector patterns; patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); patterns.push_back(pattern("^.{0,4}aa", HS_FLAG_DOTALL, 5)); const char *data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; for (size_t jump = 1; jump <= 8; jump++) { err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); for (unsigned i = 0; i < strlen(data); i += jump) { err = hs_scan_stream(stream, data + i, min(jump, strlen(data) - i), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); } EXPECT_EQ(0U, countMatchesById(c.matches, 1)); EXPECT_EQ(30U, countMatchesById(c.matches, 2)); EXPECT_EQ(29U, countMatchesById(c.matches, 3)); EXPECT_EQ(5U, countMatchesById(c.matches, 4)); EXPECT_EQ(5U, countMatchesById(c.matches, 5)); ASSERT_TRUE(matchesOrdered(c.matches)); c.matches.clear(); hs_close_stream(stream, scratch, record_cb, (void *)&c); } err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(order, ordering7) { vector patterns; patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); const char *data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; for (size_t jump = 1; jump <= 8; jump++) { err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); for (unsigned i = 0; i < strlen(data); i += jump) { err = hs_scan_stream(stream, data + i, min(jump, strlen(data) - i), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); } EXPECT_EQ(0U, countMatchesById(c.matches, 1)); EXPECT_EQ(30U, countMatchesById(c.matches, 2)); EXPECT_EQ(29U, countMatchesById(c.matches, 3)); EXPECT_EQ(5U, countMatchesById(c.matches, 4)); EXPECT_EQ(0U, countMatchesById(c.matches, 5)); ASSERT_TRUE(matchesOrdered(c.matches)); c.matches.clear(); hs_close_stream(stream, scratch, record_cb, (void *)&c); } err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(order, ordering8) { vector patterns; patterns.push_back(pattern("aa", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); const char *data = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"; hs_database_t *db = buildDB(patterns, HS_MODE_STREAM); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; for (size_t jump = 1; jump <= 8; jump++) { err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); for (unsigned i = 0; i < strlen(data); i += jump) { err = hs_scan_stream(stream, data + i, min(jump, strlen(data) - i), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); } EXPECT_EQ(31U, countMatchesById(c.matches, 1)); EXPECT_EQ(30U, countMatchesById(c.matches, 2)); EXPECT_EQ(29U, countMatchesById(c.matches, 3)); EXPECT_EQ(0U, countMatchesById(c.matches, 4)); EXPECT_EQ(0U, countMatchesById(c.matches, 5)); ASSERT_TRUE(matchesOrdered(c.matches)); c.matches.clear(); hs_close_stream(stream, scratch, record_cb, (void *)&c); } err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } } hyperscan-4.4.1/unit/hyperscan/stream_op.cpp0000644000175000017500000006120413055426554021752 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" using namespace std; namespace /* anonymous */ { int record_cb2(unsigned id, unsigned long long, unsigned long long to, unsigned, void *ctxt) { CallBackContext *c = (CallBackContext *)ctxt; c->matches.push_back(MatchRecord(to + 1000, id)); return (int)c->halt; } static const char data1[] = "barfoobar"; TEST(StreamUtil, reset1) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; CallBackContext c, c2; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); // Note: we do not need matches from this reset operation, so we do not // need to supply a callback or scratch space. err = hs_reset_stream(stream, 0, nullptr, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb2, (void *)&c2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); ASSERT_EQ(1U, c2.matches.size()); ASSERT_EQ(MatchRecord(1009, 0), c2.matches[0]); hs_close_stream(stream, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, reset2) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; CallBackContext c, c2; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); c.halt = 1; err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); // Note: we do not need matches from this reset operation, so we do not // need to supply a callback or scratch space. err = hs_reset_stream(stream, 0, nullptr, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); ASSERT_EQ(1U, c2.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c2.matches[0]); hs_close_stream(stream, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, reset_matches) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar$", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, data1, strlen(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); err = hs_reset_stream(stream, 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); hs_close_stream(stream, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, reset_close) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); // break matching string over two stream writes const char part1[] = "---f"; err = hs_scan_stream(stream, part1, strlen(part1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); const char part2[] = "oo--"; err = hs_scan_stream(stream, part2, strlen(part2), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(6, 0), c.matches[0]); err = hs_reset_stream(stream, 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); // still only one match ASSERT_EQ(1U, c.matches.size()); err = hs_close_stream(stream, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, copy1) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); err = hs_copy_stream(&stream2, stream); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_EQ(MatchRecord(13, 0), c.matches[0]); ASSERT_EQ(MatchRecord(19, 0), c.matches[1]); c.matches.clear(); err = hs_scan_stream(stream2, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_EQ(MatchRecord(13, 0), c.matches[0]); ASSERT_EQ(MatchRecord(19, 0), c.matches[1]); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, copy2) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); c.halt = 1; err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); err = hs_copy_stream(&stream2, stream); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(0U, c.matches.size()); err = hs_scan_stream(stream2, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(0U, c.matches.size()); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, copy_reset1) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; CallBackContext c, c2; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_open_stream(db, 0, &stream2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream2 != nullptr); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); err = hs_reset_and_copy_stream(stream, stream2, nullptr, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb2, (void *)&c2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); ASSERT_EQ(1U, c2.matches.size()); ASSERT_EQ(MatchRecord(1009, 0), c2.matches[0]); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, copy_reset2) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; CallBackContext c, c2; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_open_stream(db, 0, &stream2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream2 != nullptr); c.halt = 1; err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); err = hs_reset_and_copy_stream(stream, stream2, nullptr, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); ASSERT_EQ(1U, c2.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c2.matches[0]); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, copy_reset3) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_open_stream(db, 0, &stream2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); err = hs_reset_and_copy_stream(stream2, stream, nullptr, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_EQ(MatchRecord(13, 0), c.matches[0]); ASSERT_EQ(MatchRecord(19, 0), c.matches[1]); c.matches.clear(); err = hs_scan_stream(stream2, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_EQ(MatchRecord(13, 0), c.matches[0]); ASSERT_EQ(MatchRecord(19, 0), c.matches[1]); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, copy_reset4) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_open_stream(db, 0, &stream2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream2 != nullptr); c.halt = 1; err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); err = hs_reset_and_copy_stream(stream2, stream, nullptr, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(0U, c.matches.size()); err = hs_scan_stream(stream2, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(0U, c.matches.size()); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, copy_reset5) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_open_stream(db, 0, &stream2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); c.matches.clear(); err = hs_scan_stream(stream2, "foo", 3, 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); err = hs_reset_and_copy_stream(stream2, stream, nullptr, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_EQ(MatchRecord(13, 0), c.matches[0]); ASSERT_EQ(MatchRecord(19, 0), c.matches[1]); c.matches.clear(); err = hs_scan_stream(stream2, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_EQ(MatchRecord(13, 0), c.matches[0]); ASSERT_EQ(MatchRecord(19, 0), c.matches[1]); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(StreamUtil, copy_reset_matches) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar$", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_open_stream(db, 0, &stream2); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream2 != nullptr); err = hs_scan_stream(stream, data1, strlen(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); err = hs_reset_and_copy_stream(stream, stream2, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } static size_t last_alloc; static void *wrap_m(size_t s) { last_alloc = s; return malloc(s); } TEST(StreamUtil, size) { hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch("foo.*bar", 0, 0, HS_MODE_STREAM, &scratch); hs_stream_t *stream = nullptr; CallBackContext c, c2; hs_set_allocator(wrap_m, nullptr); last_alloc = 0; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); size_t stream_size; err = hs_stream_size(db, &stream_size); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(last_alloc, stream_size); hs_set_allocator(nullptr, nullptr); hs_close_stream(stream, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } int alloc_called = 0; int alloc2_called = 0; int alloc3_called = 0; void *bad_alloc(size_t) { return nullptr; } void *my_alloc(size_t s) { ++alloc_called; return malloc(s); } void my_free(void *p) { free(p); --alloc_called; } void *my_alloc2(size_t s) { ++alloc2_called; return malloc(s); } void my_free2(void *p) { free(p); --alloc2_called; } void *my_alloc3(size_t s) { ++alloc3_called; return malloc(s); } void my_free3(void *p) { free(p); --alloc3_called; } TEST(StreamUtil, Alloc) { hs_compile_error_t *compile_err = nullptr; hs_database_t *db; hs_set_stream_allocator(my_alloc, my_free); alloc_called = 0; hs_error_t err = hs_compile("foo.*bar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); ASSERT_NE(alloc_called, 0); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); hs_close_stream(stream, scratch, record_cb, (void *)&c); ASSERT_EQ(alloc_called, 0); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); hs_free_compile_error(compile_err); hs_set_allocator(nullptr, nullptr); } TEST(StreamUtil, MoreAlloc) { hs_compile_error_t *compile_err = nullptr; hs_database_t *db; hs_set_allocator(my_alloc, my_free); alloc_called = 0; hs_error_t err = hs_compile("foo.*bar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1, alloc_called); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(2, alloc_called); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); ASSERT_EQ(alloc_called, 3); err = hs_scan_stream(stream, data1, sizeof(data1), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(9, 0), c.matches[0]); hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(alloc_called, 2); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(alloc_called, 1); hs_free_database(db); ASSERT_EQ(alloc_called, 0); hs_free_compile_error(compile_err); hs_set_allocator(nullptr, nullptr); } TEST(StreamUtil, BadStreamAlloc) { hs_compile_error_t *compile_err = nullptr; hs_database_t *db; hs_set_stream_allocator(bad_alloc, free); alloc_called = 0; hs_error_t err = hs_compile("foo.*bar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; CallBackContext c; // should go boom err = hs_open_stream(db, 0, &stream); ASSERT_NE(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); hs_free_compile_error(compile_err); hs_set_stream_allocator(nullptr, nullptr); } TEST(StreamUtil, StreamAllocUsage) { hs_compile_error_t *compile_err = nullptr; hs_database_t *db; hs_set_allocator(my_alloc, my_free); hs_set_stream_allocator(my_alloc2, my_free2); hs_set_scratch_allocator(my_alloc3, my_free3); alloc_called = 0; alloc2_called = 0; alloc3_called = 0; hs_error_t err = hs_compile("foo.*bar", 0, HS_MODE_STREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_stream_t *stream = nullptr; hs_stream_t *stream2 = nullptr; hs_stream_t *stream3 = nullptr; CallBackContext c; ASSERT_EQ(1, alloc_called); ASSERT_EQ(0, alloc2_called); ASSERT_EQ(1, alloc3_called); err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1, alloc_called); ASSERT_EQ(1, alloc2_called); ASSERT_EQ(1, alloc3_called); err = hs_copy_stream(&stream2, stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1, alloc_called); ASSERT_EQ(2, alloc2_called); ASSERT_EQ(1, alloc3_called); err = hs_open_stream(db, 0, &stream3); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1, alloc_called); ASSERT_EQ(3, alloc2_called); ASSERT_EQ(1, alloc3_called); hs_close_stream(stream, scratch, nullptr, nullptr); hs_close_stream(stream2, scratch, nullptr, nullptr); hs_close_stream(stream3, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); hs_free_compile_error(compile_err); hs_set_allocator(nullptr, nullptr); ASSERT_EQ(0, alloc_called); ASSERT_EQ(0, alloc2_called); ASSERT_EQ(0, alloc3_called); } } hyperscan-4.4.1/unit/hyperscan/serialize.cpp0000644000175000017500000004115013055426554021746 0ustar sleuthkidsleuthkid/* * 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. */ /** * Unit tests for serialization functions. */ #include "config.h" #include #include #include #include "gtest/gtest.h" #include "hs.h" #include "hs_internal.h" #include "test_util.h" namespace { using namespace std; using namespace testing; static const unsigned validModes[] = { HS_MODE_STREAM, HS_MODE_NOSTREAM }; class Serializep : public TestWithParam { }; // Check that we can deserialize from a char array at any alignment and the info // is consistent TEST_P(Serializep, DeserializeFromAnyAlignment) { const unsigned mode = GetParam(); SCOPED_TRACE(mode); hs_error_t err; hs_database_t *db = buildDB("hatstand.*teakettle.*badgerbrush", HS_FLAG_CASELESS, 1000, mode); ASSERT_TRUE(db != nullptr) << "database build failed."; char *original_info = nullptr; err = hs_database_info(db, &original_info); ASSERT_EQ(HS_SUCCESS, err); const char *mode_string = nullptr; switch (mode) { case HS_MODE_STREAM: mode_string = "STREAM"; break; case HS_MODE_NOSTREAM: mode_string = "BLOCK"; } ASSERT_NE(nullptr, original_info) << "hs_serialized_database_info returned null."; ASSERT_STREQ("Version:", string(original_info).substr(0, 8).c_str()); ASSERT_TRUE(strstr(original_info, mode_string) != nullptr); char *bytes = nullptr; size_t length = 0; err = hs_serialize_database(db, &bytes, &length); ASSERT_EQ(HS_SUCCESS, err) << "serialize failed."; ASSERT_NE(nullptr, bytes); ASSERT_LT(0U, length); hs_free_database(db); db = nullptr; const size_t maxalign = 16; char *copy = new char[length + maxalign]; // Deserialize from char arrays at a range of alignments. for (size_t i = 0; i < maxalign; i++) { SCOPED_TRACE(i); memset(copy, 0, length + maxalign); char *mycopy = copy + i; memcpy(mycopy, bytes, length); // We should be able to call hs_serialized_database_info and get back a // reasonable string. char *info; err = hs_serialized_database_info(mycopy, length, &info); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, original_info); ASSERT_STREQ(original_info, info); free(info); // We should be able to deserialize as well. err = hs_deserialize_database(mycopy, length, &db); ASSERT_EQ(HS_SUCCESS, err) << "deserialize failed."; ASSERT_TRUE(db != nullptr); // And the info there should match. err = hs_database_info(db, &info); ASSERT_EQ(HS_SUCCESS, err); ASSERT_STREQ(original_info, info); free(info); hs_free_database(db); db = nullptr; } free(original_info); free(bytes); delete[] copy; } // Check that we can deserialize_at from a char array at any alignment and the // info is consistent TEST_P(Serializep, DeserializeAtFromAnyAlignment) { const unsigned mode = GetParam(); SCOPED_TRACE(mode); hs_error_t err; hs_database_t *db = buildDB("hatstand.*teakettle.*badgerbrush", HS_FLAG_CASELESS, 1000, mode); ASSERT_TRUE(db != nullptr) << "database build failed."; char *original_info; err = hs_database_info(db, &original_info); ASSERT_EQ(HS_SUCCESS, err); const char *mode_string = nullptr; switch (mode) { case HS_MODE_STREAM: mode_string = "STREAM"; break; case HS_MODE_NOSTREAM: mode_string = "BLOCK"; } ASSERT_NE(nullptr, original_info) << "hs_serialized_database_info returned null."; ASSERT_STREQ("Version:", string(original_info).substr(0, 8).c_str()); ASSERT_TRUE(strstr(original_info, mode_string) != nullptr); char *bytes = nullptr; size_t length = 0; err = hs_serialize_database(db, &bytes, &length); ASSERT_EQ(HS_SUCCESS, err) << "serialize failed."; ASSERT_NE(nullptr, bytes); ASSERT_LT(0U, length); hs_free_database(db); db = nullptr; size_t slength; err = hs_serialized_database_size(bytes, length, &slength); ASSERT_EQ(HS_SUCCESS, err); const size_t maxalign = 16; char *copy = new char[length + maxalign]; char *mem = new char[slength]; db = (hs_database_t *)mem; // Deserialize from char arrays at a range of alignments. for (size_t i = 0; i < maxalign; i++) { SCOPED_TRACE(i); memset(copy, 0, length + maxalign); char *mycopy = copy + i; memcpy(mycopy, bytes, length); // We should be able to call hs_serialized_database_info and get back a // reasonable string. char *info; err = hs_serialized_database_info(mycopy, length, &info); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, original_info); ASSERT_STREQ(original_info, info); free(info); // Scrub target memory. memset(mem, 0xff, length); // We should be able to deserialize as well. err = hs_deserialize_database_at(mycopy, length, db); ASSERT_EQ(HS_SUCCESS, err) << "deserialize failed."; ASSERT_TRUE(db != nullptr); // And the info there should match. err = hs_database_info(db, &info); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(info != nullptr); ASSERT_STREQ(original_info, info); free(info); } free(original_info); free(bytes); delete[] copy; delete[] mem; } INSTANTIATE_TEST_CASE_P(Serialize, Serializep, ValuesIn(validModes)); // Attempt to reproduce the scenario in UE-1946. TEST(Serialize, CrossCompileSom) { hs_platform_info plat; plat.cpu_features = 0; plat.tune = HS_TUNE_FAMILY_GENERIC; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; const unsigned mode = HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE; hs_database_t *db = buildDB(pattern, HS_FLAG_SOM_LEFTMOST, 1000, mode, &plat); ASSERT_TRUE(db != nullptr) << "database build failed."; size_t db_len; hs_error_t err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); hs_free_database(db); // Relocate to misaligned block. char *copy = (char *)malloc(bytes_len + 1); ASSERT_TRUE(copy != nullptr); memcpy(copy + 1, bytes, bytes_len); free(bytes); size_t ser_len; err = hs_serialized_database_size(copy + 1, bytes_len, &ser_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, ser_len); ASSERT_EQ(db_len, ser_len); free(copy); } static void *null_malloc(size_t) { return nullptr; } static void *misaligned_malloc(size_t s) { char *c = (char *)malloc(s + 1); return (void *)(c + 1); } static void misaligned_free(void *p) { char *c = (char *)p; free(c - 1); } // make sure that serializing/deserializing to null or an unaligned address fails TEST(Serialize, CompileNullMalloc) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; // mallocing null should fail compile hs_set_allocator(null_malloc, nullptr); hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_NE(HS_SUCCESS, err); ASSERT_TRUE(db == nullptr); ASSERT_TRUE(c_err != nullptr); hs_free_compile_error(c_err); hs_set_allocator(nullptr, nullptr); } TEST(Serialize, CompileErrorAllocator) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatsta^nd.*(badgerbrush|teakettle)"; // failing to compile should use the misc allocator allocated_count = 0; allocated_count_b = 0; hs_set_allocator(count_malloc_b, count_free_b); hs_set_misc_allocator(count_malloc, count_free); hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_NE(HS_SUCCESS, err); ASSERT_TRUE(db == nullptr); ASSERT_TRUE(c_err != nullptr); ASSERT_EQ(0, allocated_count_b); ASSERT_NE(0, allocated_count); hs_free_compile_error(c_err); hs_set_allocator(nullptr, nullptr); ASSERT_EQ(0, allocated_count); } TEST(Serialize, AllocatorsUsed) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; allocated_count = 0; allocated_count_b = 0; hs_set_allocator(count_malloc_b, count_free_b); hs_set_database_allocator(count_malloc, count_free); hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); ASSERT_TRUE(c_err == nullptr); ASSERT_EQ(0, allocated_count_b); ASSERT_NE(0, allocated_count); /* serialize should use the misc allocator */ char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); ASSERT_EQ(bytes_len, allocated_count_b); count_free_b(bytes); hs_free_database(db); hs_set_allocator(nullptr, nullptr); ASSERT_EQ(0, allocated_count); ASSERT_EQ(0, allocated_count_b); } TEST(Serialize, CompileUnalignedMalloc) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; // unaligned malloc should fail compile hs_set_allocator(misaligned_malloc, misaligned_free); hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_NE(HS_SUCCESS, err); ASSERT_TRUE(db == nullptr); ASSERT_TRUE(c_err != nullptr); hs_free_compile_error(c_err); hs_set_allocator(nullptr, nullptr); } TEST(Serialize, SerializeNullMalloc) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; // fail when serialize gets a null malloc hs_set_allocator(null_malloc, nullptr); err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_NE(HS_SUCCESS, err); hs_set_allocator(nullptr, nullptr); hs_free_database(db); } // make sure that serializing/deserializing to null or an unaligned address fails TEST(Serialize, SerializeUnalignedMalloc) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; // fail when serialize gets a misaligned malloc hs_set_allocator(misaligned_malloc, misaligned_free); err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_NE(HS_SUCCESS, err); hs_set_allocator(nullptr, nullptr); hs_free_database(db); } TEST(Serialize, DeserializeNullMalloc) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); hs_free_database(db); size_t ser_len; err = hs_serialized_database_size(bytes, bytes_len, &ser_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, ser_len); err = hs_deserialize_database_at(bytes, ser_len, nullptr); ASSERT_NE(HS_SUCCESS, err); free(bytes); } TEST(Serialize, DeserializeUnalignedMalloc) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); hs_free_database(db); size_t ser_len; err = hs_serialized_database_size(bytes, bytes_len, &ser_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, ser_len); // and now fail when deserialize addr is unaligned char *new_db = (char *)malloc(ser_len + 8); for (int i = 1; i < 8; i++) { err = hs_deserialize_database_at(bytes, ser_len, (hs_database_t *)(new_db + i)); ASSERT_NE(HS_SUCCESS, err); } free(new_db); free(bytes); } TEST(Serialize, DeserializeGarbage) { hs_database_t *db; hs_compile_error_t *c_err; static const char *pattern = "hatstand.*(badgerbrush|teakettle)"; hs_error_t err = hs_compile(pattern, 0, HS_MODE_BLOCK, nullptr, &db, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); // determine database size for subsequent hs_deserialize_database_at size_t db_len; err = hs_database_size(db, &db_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, db_len); // serialize char *bytes = nullptr; size_t bytes_len = 0; err = hs_serialize_database(db, &bytes, &bytes_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0, bytes_len); hs_free_database(db); // append '\0' byte to the serialized string to spoil it bytes = (char *)realloc(bytes, bytes_len + 1); ASSERT_NE(nullptr, bytes); bytes[bytes_len] = '\0'; // create set of invalid serializations struct Arg { char *start; size_t len; }; const Arg invalid_args[] = { {bytes + 1, bytes_len}, {bytes + 1, bytes_len - 1}, {bytes, bytes_len - 1}, {bytes, bytes_len + 1}, }; for (const Arg &arg : invalid_args) { hs_database_t *a_db; err = hs_deserialize_database(arg.start, arg.len, &a_db); ASSERT_NE(HS_SUCCESS, err); char *new_db = (char *)malloc(db_len); ASSERT_NE(nullptr, new_db); err = hs_deserialize_database_at(arg.start, arg.len, (hs_database_t *)(new_db)); ASSERT_NE(HS_SUCCESS, err); free(new_db); char *info; err = hs_serialized_database_info(arg.start, arg.len, &info); ASSERT_NE(HS_SUCCESS, err); size_t ser_len; err = hs_serialized_database_size(arg.start, arg.len, &ser_len); ASSERT_NE(HS_SUCCESS, err); } free(bytes); } } hyperscan-4.4.1/unit/hyperscan/test_util.h0000644000175000017500000001017613055426554021444 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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 TEST_UTIL_H #define TEST_UTIL_H #include #include #include #include #include "hs.h" #ifndef UNUSED #if defined(_WIN32) || defined(_WIN64) #define UNUSED #else #define UNUSED __attribute__ ((unused)) #endif #endif struct MatchRecord { MatchRecord(unsigned long long t, int i) : to(t), id(i) {} bool operator==(const MatchRecord &o) const { return to == o.to && id == o.id; } unsigned long long to; int id; }; std::ostream &operator<< (std::ostream &o, const MatchRecord &m); struct CallBackContext { CallBackContext() : halt(false) {} bool halt; std::vector matches; void clear() { halt = false; matches.clear(); } }; int record_cb(unsigned id, unsigned long long, unsigned long long to, unsigned, void *ctxt); // Dummy callback: does nothing, returns 0 (keep matching) static UNUSED int dummy_cb(unsigned, unsigned long long, unsigned long long, unsigned, void *) { // empty return 0; } struct pattern { std::string expression; unsigned int flags; unsigned int id; hs_expr_ext ext; pattern(const std::string &expression_in, unsigned int flags_in = 0, unsigned int id_in = 0) : expression(expression_in), flags(flags_in), id(id_in) { memset(&ext, 0, sizeof(ext)); } pattern(const std::string &expression_in, unsigned int flags_in, unsigned int id_in, const hs_expr_ext &ext_in) : expression(expression_in), flags(flags_in), id(id_in), ext(ext_in) { } }; hs_database_t *buildDB(const std::vector &patterns, unsigned int mode, hs_platform_info *plat = nullptr); hs_database_t *buildDB(const pattern &pat, unsigned int mode); hs_database_t *buildDB(const char *expression, unsigned int flags, unsigned int id, unsigned int mode, hs_platform_info *plat = nullptr); hs_database_t *buildDB(const char *filename, unsigned int mode, unsigned int extra_flags = 0); hs_database_t *buildDB(const char *filename, unsigned int mode, bool check_ordering); hs_database_t *buildDBAndScratch(const char *expression, unsigned int flags, unsigned int id, unsigned int mode, hs_scratch_t **scratch); extern size_t allocated_count; extern size_t allocated_count_b; void *count_malloc(size_t n); void *count_malloc_b(size_t n); void count_free(void *p); void count_free_b(void *p); #endif hyperscan-4.4.1/unit/hyperscan/test_util.cpp0000644000175000017500000001533613055426554022002 0ustar sleuthkidsleuthkid/* * 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. */ #include #include #include #include #include "hs.h" #include "test_util.h" #include "gtest/gtest.h" #include "util/expressions.h" #include "util/ExpressionParser.h" using namespace std; int record_cb(unsigned id, unsigned long long, unsigned long long to, unsigned, void *ctxt) { CallBackContext *c = (CallBackContext *)ctxt; c->matches.push_back(MatchRecord(to, id)); return (int)c->halt; } std::ostream &operator<< (std::ostream &o, const MatchRecord &m) { return o << "[" << m.to << ", " << m.id << "]"; } hs_database_t *buildDB(const vector &patterns, unsigned int mode, hs_platform_info *plat) { vector expressions; vector flags; vector ids; vector ext; for (vector::const_iterator it = patterns.begin(); it != patterns.end(); ++it) { expressions.push_back(it->expression.c_str()); flags.push_back(it->flags); ids.push_back(it->id); ext.push_back(&it->ext); } hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err; err = hs_compile_ext_multi(&expressions[0], &flags[0], &ids[0], &ext[0], patterns.size(), mode, plat, &db, &compile_err); if (err != HS_SUCCESS) { return nullptr; } return db; } hs_database_t *buildDB(const pattern &expr, unsigned int mode) { return buildDB(vector(1, expr), mode); } hs_database_t *buildDB(const char *expression, unsigned int flags, unsigned int id, unsigned int mode, hs_platform_info_t *plat) { vector patterns; patterns.push_back(pattern(expression, flags, id)); return buildDB(patterns, mode, plat); } hs_database_t *buildDB(const char *filename, unsigned int mode, unsigned int extra_flags) { vector patterns; ExpressionMap expressions; loadExpressionsFromFile(filename, expressions); for (ExpressionMap::iterator it = expressions.begin(); it != expressions.end(); ++it) { unsigned int flags = 0; string regex; hs_expr_ext ext; if (!readExpression(it->second, regex, &flags, &ext)) { return nullptr; } patterns.push_back(pattern(regex, flags | extra_flags, it->first, ext)); } return buildDB(patterns, mode); } static bool isOrdered(const string &expr, unsigned int flags) { // SOM doesn't produce ordered matches? if (flags & HS_FLAG_SOM_LEFTMOST) { return false; } hs_expr_info_t *info = nullptr; hs_compile_error_t *error = nullptr; hs_error_t err = hs_expression_info(expr.c_str(), flags, &info, &error); if (err != HS_SUCCESS) { // Expression will fail compilation and report error elsewhere. free(info); hs_free_compile_error(error); return false; } assert(info); // Any pattern that does not require offset adjustment should produce // matches in order. bool ordered = !info->unordered_matches; free(info); return ordered; } hs_database_t *buildDB(const char *filename, unsigned int mode, bool check_ordering) { vector patterns; ExpressionMap expressions; loadExpressionsFromFile(filename, expressions); for (ExpressionMap::iterator it = expressions.begin(); it != expressions.end(); ++it) { unsigned int flags = 0; string regex; hs_expr_ext ext; bool must_be_ordered; if (!readExpression(it->second, regex, &flags, &ext, &must_be_ordered)) { return nullptr; } if (check_ordering && must_be_ordered && !isOrdered(regex, flags)) { return nullptr; } patterns.emplace_back(regex, flags, it->first, ext); } return buildDB(patterns, mode); } hs_database_t *buildDBAndScratch(const char *expression, unsigned int flags, unsigned int id, unsigned int mode, hs_scratch_t **scratch) { hs_database_t *db = buildDB(expression, flags, id, mode); EXPECT_TRUE(db != nullptr); *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, scratch); EXPECT_EQ(HS_SUCCESS, err); EXPECT_TRUE(*scratch != nullptr); return db; } size_t allocated_count; size_t allocated_count_b; void *count_malloc(size_t n) { void *pp = malloc(n + 16); if (!pp) { return nullptr; } allocated_count += n; *(size_t *)pp = n; void *p = (char *)pp + 16; return p; } void count_free(void *p) { if (!p) { return; } void *pp = (char *)p - 16; size_t n = *(size_t *)pp; allocated_count -= n; free(pp); } void *count_malloc_b(size_t n) { void *pp = malloc(n + 32); if (!pp) { return nullptr; } allocated_count_b += n; *(size_t *)pp = n; void *p = (char *)pp + 32; return p; } void count_free_b(void *p) { if (!p) { return; } void *pp = (char *)p - 32; size_t n = *(size_t *)pp; allocated_count_b -= n; free(pp); } hyperscan-4.4.1/unit/hyperscan/allocators.cpp0000644000175000017500000001445513055426554022132 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" #include #include using std::string; static void *null_malloc(size_t) { return nullptr; } TEST(CustomAllocator, DatabaseInfoBadAlloc) { hs_database_t *db = buildDB("foobar", 0, 0, HS_MODE_BLOCK); ASSERT_TRUE(db != nullptr); hs_set_allocator(null_malloc, nullptr); char *info = nullptr; hs_error_t err = hs_database_info(db, &info); ASSERT_EQ(HS_NOMEM, err); hs_set_allocator(nullptr, nullptr); hs_free_database(db); } static void * two_aligned_malloc(size_t len) { void *mem = malloc(len + 2); if (!mem) { return nullptr; } return (char *)mem + 2; } static void two_aligned_free(void *mem) { if (!mem) { return; } // Allocated with two_aligned_malloc above. free((char *)mem - 2); } TEST(CustomAllocator, TwoAlignedCompile) { hs_set_database_allocator(two_aligned_malloc, two_aligned_free); hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; const hs_platform_info_t *platform = nullptr; hs_error_t err = hs_compile("foobar", 0, HS_MODE_BLOCK, platform, &db, &compile_err); ASSERT_EQ(HS_COMPILER_ERROR, err); ASSERT_EQ(nullptr, db); ASSERT_NE(nullptr, compile_err); hs_free_compile_error(compile_err); hs_set_database_allocator(nullptr, nullptr); } TEST(CustomAllocator, TwoAlignedCompileError) { hs_set_misc_allocator(two_aligned_malloc, two_aligned_free); hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; const hs_platform_info_t *platform = nullptr; hs_error_t err = hs_compile("\\1", 0, HS_MODE_BLOCK, platform, &db, &compile_err); ASSERT_EQ(HS_COMPILER_ERROR, err); ASSERT_EQ(nullptr, db); ASSERT_NE(nullptr, compile_err); EXPECT_STREQ("Allocator returned misaligned memory.", compile_err->message); hs_free_compile_error(compile_err); hs_set_database_allocator(nullptr, nullptr); } TEST(CustomAllocator, TwoAlignedDatabaseInfo) { hs_database_t *db = buildDB("foobar", 0, 0, HS_MODE_BLOCK); ASSERT_TRUE(db != nullptr); hs_set_misc_allocator(two_aligned_malloc, two_aligned_free); char *info = nullptr; hs_error_t err = hs_database_info(db, &info); ASSERT_EQ(HS_BAD_ALLOC, err); hs_set_misc_allocator(nullptr, nullptr); hs_free_database(db); } TEST(CustomAllocator, TwoAlignedSerialize) { hs_database_t *db = buildDB("foobar", 0, 0, HS_MODE_BLOCK); ASSERT_TRUE(db != nullptr); hs_set_misc_allocator(two_aligned_malloc, two_aligned_free); char *bytes = nullptr; size_t serialized_len = 0; hs_error_t err = hs_serialize_database(db, &bytes, &serialized_len); ASSERT_EQ(HS_BAD_ALLOC, err); hs_set_misc_allocator(nullptr, nullptr); hs_free_database(db); } TEST(CustomAllocator, TwoAlignedDeserialize) { hs_database_t *db = buildDB("foobar", 0, 0, HS_MODE_BLOCK); ASSERT_TRUE(db != nullptr); char *bytes = nullptr; size_t serialized_len = 0; hs_error_t err = hs_serialize_database(db, &bytes, &serialized_len); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, bytes); hs_free_database(db); db = nullptr; hs_set_database_allocator(two_aligned_malloc, two_aligned_free); err = hs_deserialize_database(bytes, serialized_len, &db); ASSERT_EQ(HS_BAD_ALLOC, err); ASSERT_EQ(nullptr, db); hs_set_database_allocator(nullptr, nullptr); free(bytes); } TEST(CustomAllocator, TwoAlignedAllocScratch) { hs_database_t *db = buildDB("foobar", 0, 0, HS_MODE_BLOCK); ASSERT_TRUE(db != nullptr); hs_set_scratch_allocator(two_aligned_malloc, two_aligned_free); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_BAD_ALLOC, err); hs_set_scratch_allocator(nullptr, nullptr); hs_free_database(db); } TEST(CustomAllocator, NullMallocExpressionInfo) { hs_set_allocator(null_malloc, nullptr); string pattern = "foobar"; hs_expr_info_t *info = nullptr; hs_compile_error_t *c_err = nullptr; hs_error_t err = hs_expression_info(pattern.c_str(), 0, &info, &c_err); ASSERT_EQ(HS_COMPILER_ERROR, err); ASSERT_NE(nullptr, c_err); hs_free_compile_error(c_err); hs_set_allocator(nullptr, nullptr); } TEST(CustomAllocator, TwoAlignedExpressionInfo) { hs_set_misc_allocator(two_aligned_malloc, two_aligned_free); string pattern = "\\1"; hs_expr_info_t *info = nullptr; hs_compile_error_t *c_err = nullptr; hs_error_t err = hs_expression_info(pattern.c_str(), 0, &info, &c_err); ASSERT_EQ(HS_COMPILER_ERROR, err); ASSERT_NE(nullptr, c_err); EXPECT_STREQ("Allocator returned misaligned memory.", c_err->message); hs_free_compile_error(c_err); hs_set_allocator(nullptr, nullptr); } hyperscan-4.4.1/unit/hyperscan/expr_info.cpp0000644000175000017500000001433213055426554021752 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include #include #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" using namespace std; using namespace testing; namespace /* anonymous */ { struct expected_info { const char *pattern; hs_expr_ext ext; unsigned min; unsigned max; char unordered_matches; char matches_at_eod; char matches_only_at_eod; }; class ExprInfop : public TestWithParam { }; static void check_info(const expected_info &ei, const hs_expr_info_t *info) { EXPECT_EQ(ei.min, info->min_width); EXPECT_EQ(ei.max, info->max_width); EXPECT_EQ(ei.unordered_matches, info->unordered_matches); EXPECT_EQ(ei.matches_at_eod, info->matches_at_eod); EXPECT_EQ(ei.matches_only_at_eod, info->matches_only_at_eod); } // Check with hs_expression_info function. TEST_P(ExprInfop, check_no_ext) { const expected_info &ei = GetParam(); SCOPED_TRACE(ei.pattern); if (ei.ext.flags) { // This is an extparam test, skip it. return; } hs_expr_info_t *info = nullptr; hs_compile_error_t *c_err = nullptr; hs_error_t err = hs_expression_info(ei.pattern, 0, &info, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(info != nullptr); ASSERT_TRUE(c_err == nullptr); check_info(ei, info); free(info); } // Check with hs_expression_ext_info function. TEST_P(ExprInfop, check_ext) { const expected_info &ei = GetParam(); SCOPED_TRACE(ei.pattern); hs_expr_info_t *info = nullptr; hs_compile_error_t *c_err = nullptr; hs_error_t err = hs_expression_ext_info(ei.pattern, 0, &ei.ext, &info, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(info != nullptr); ASSERT_TRUE(c_err == nullptr); check_info(ei, info); free(info); } // Check with hs_expression_ext_info function and a nullptr ext param, for // cases where ext.flags == 0. Functionally identical to check_no_ext above. TEST_P(ExprInfop, check_ext_null) { const expected_info &ei = GetParam(); SCOPED_TRACE(ei.pattern); if (ei.ext.flags) { // This is an extparam test, skip it. return; } hs_expr_info_t *info = nullptr; hs_compile_error_t *c_err = nullptr; hs_error_t err = hs_expression_ext_info(ei.pattern, 0, nullptr, &info, &c_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(info != nullptr); ASSERT_TRUE(c_err == nullptr); check_info(ei, info); free(info); } static const hs_expr_ext NO_EXT_PARAM = { 0, 0, 0, 0 }; static const expected_info ei_test[] = { {"abc", NO_EXT_PARAM, 3, 3, 0, 0, 0}, {"abc.*def", NO_EXT_PARAM, 6, UINT_MAX, 0, 0, 0}, {"abc|defghi", NO_EXT_PARAM, 3, 6, 0, 0, 0}, {"abc(def)?", NO_EXT_PARAM, 3, 6, 0, 0, 0}, {"abc(def){0,3}", NO_EXT_PARAM, 3, 12, 0, 0, 0}, {"abc(def){1,4}", NO_EXT_PARAM, 6, 15, 0, 0, 0}, {"", NO_EXT_PARAM, 0, 0, 0, 0, 0}, {"^", NO_EXT_PARAM, 0, 0, 0, 0, 0}, {"^\\b", NO_EXT_PARAM, 0, 0, 1, 0, 0}, {"\\b$", NO_EXT_PARAM, 0, 0, 1, 1, 1}, {"(?m)\\b$", NO_EXT_PARAM, 0, 0, 1, 1, 0}, {"\\A", NO_EXT_PARAM, 0, 0, 0, 0, 0}, {"\\z", NO_EXT_PARAM, 0, 0, 0, 1, 1}, {"\\Z", NO_EXT_PARAM, 0, 0, 1, 1, 1}, {"$", NO_EXT_PARAM, 0, 0, 1, 1, 1}, {"(?m)$", NO_EXT_PARAM, 0, 0, 1, 1, 0}, {"^foo", NO_EXT_PARAM, 3, 3, 0, 0, 0}, {"^foo.*bar", NO_EXT_PARAM, 6, UINT_MAX, 0, 0, 0}, {"^foo.*bar?", NO_EXT_PARAM, 5, UINT_MAX, 0, 0, 0}, {"^foo.*bar$", NO_EXT_PARAM, 6, UINT_MAX, 1, 1, 1}, {"^foobar$", NO_EXT_PARAM, 6, 6, 1, 1, 1}, {"foobar$", NO_EXT_PARAM, 6, 6, 1, 1, 1}, {"^.*foo", NO_EXT_PARAM, 3, UINT_MAX, 0, 0, 0}, {"foo\\b", NO_EXT_PARAM, 3, 3, 1, 1, 0}, {"foo.{1,13}bar", NO_EXT_PARAM, 7, 19, 0, 0, 0}, {"foo.{10,}bar", NO_EXT_PARAM, 16, UINT_MAX, 0, 0, 0}, {"foo.{0,10}bar", NO_EXT_PARAM, 6, 16, 0, 0, 0}, {"foo.{,10}bar", NO_EXT_PARAM, 12, 12, 0, 0, 0}, {"foo.{10}bar", NO_EXT_PARAM, 16, 16, 0, 0, 0}, {"(^|\n)foo", NO_EXT_PARAM, 3, 4, 0, 0, 0}, {"(^\n|)foo", NO_EXT_PARAM, 3, 4, 0, 0, 0}, {"(?m)^foo", NO_EXT_PARAM, 3, 3, 0, 0, 0}, {"\\bfoo", NO_EXT_PARAM, 3, 3, 0, 0, 0}, {"^\\bfoo", NO_EXT_PARAM, 3, 3, 0, 0, 0}, {"(?m)^\\bfoo", NO_EXT_PARAM, 3, 3, 0, 0, 0}, {"\\Bfoo", NO_EXT_PARAM, 3, 3, 0, 0, 0}, {"(foo|bar\\z)", NO_EXT_PARAM, 3, 3, 0, 1, 0}, {"(foo|bar)\\z", NO_EXT_PARAM, 3, 3, 0, 1, 1}, // Some cases with extended parameters. {"^abc.*def", {HS_EXT_FLAG_MAX_OFFSET, 0, 10, 0}, 6, 10, 0, 0, 0}, {"abc.*def", {HS_EXT_FLAG_MAX_OFFSET, 0, 10, 0}, 6, 10, 0, 0, 0}, {"abc.*def", {HS_EXT_FLAG_MIN_LENGTH, 0, 0, 100}, 100, UINT_MAX, 0, 0, 0}, {"abc.*def", {HS_EXT_FLAG_MIN_LENGTH, 0, 0, 5}, 6, UINT_MAX, 0, 0, 0}, }; INSTANTIATE_TEST_CASE_P(ExprInfo, ExprInfop, ValuesIn(ei_test)); } hyperscan-4.4.1/unit/hyperscan/bad_patterns.cpp0000644000175000017500000002707313055426554022435 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "hs.h" #include #include #include #include "util/expressions.h" #include "util/ExpressionParser.h" using namespace std; using namespace testing; class HyperscanFailBadPattern : public TestWithParam> { protected: virtual void SetUp() { // compiles a database for this test instantiation bool isStreaming; tie(isStreaming, pattern) = GetParam(); err = hs_compile(pattern, 0, isStreaming ? HS_MODE_STREAM : HS_MODE_BLOCK, nullptr, &db, &compile_err); } virtual void TearDown() { hs_free_database(db); hs_free_compile_error(compile_err); } hs_error_t err; const char *pattern; hs_compile_error_t *compile_err; hs_database_t *db; }; static const char *badPatterns[] = { // vacuous patterns "", "a?", "a*", "(foo)?", "(foo)*(bar)*", "^arg|(foo)*(bar)*", "foo|bar|", "a*(b?)*c*", "a{0,3}", "[\\s\\S]*", "[^\\s\\S]*", // too big for our largest NFA "(ewh|m?uit|f|snmv.g.gx[yofl]|.[^g][hbd])((.h|((y|vypfw|dfg{4}|x+|o.|y{8,}))+|k{9}t|cgp...gsk+)){17,}", // illegal bounds "fooa{0}", "a{4,3}", "a{2,1}", // nothing to repeat "a++", "a+?+", "a??", "a?+", "?qa", "*abc", "+abc", // repeating boundaries is not allowed (UE-1007) "^?0", "^*0", "^+0", "^{1,3}0", "0$?", "0$*", "0$+", "0${1,3}", // zero width asserts ("lookarounds") "[a-z]+(?=;)", // positive lookahead ".((?!\\x00\\x00)..)*?foo", // negative lookahead "(?<=bullock|donkey)", // positive lookbehind "(?.{3,})bar", // possessive quantifiers "\\d++foo", "(abc|xyz){2,3}+", // back-reference inside a repeat (also too big, actually) "^..\x02.{10,522}([^\00])\1{16}", // char classes "[]", "[]foobar", "[`-\\80", "[A-\\K]", // bad named classes "[[:foo:]]", "[[:1234:]]", "[[:f\\oo:]]", "[[: :]]", "[[:...:]]", "[[:l\\ower:]]", "[[:abc\\:]]", "[abc[:x\\]pqr:]]", "[[:a\\dz:]]", // unhandled subroutines and backrefs "foo\\g''bar", "foo\\g'45'bar", "foo\\g'hatstand'bar", "foo\\g<>bar", "foo\\g<45>bar", "foo\\gbar", "((?i)rah)\\s+\\1", "(?(?i)rah)\\s+\\k", "(?'p1'(?i)rah)\\s+\\k{p1}", "(?P(?i)rah)\\s+(?P=p1)", "(?(?i)rah)\\s+\\g{p1}", // truly enormous and with complicated assert resolution (UE-1107) "((c(p|p)h{2,}bh.|p|((((cq|j|c|(\\b)|.[^nbgn]|(\\B)[qfh]a)){10,12}|ih|a|mnde[pa].|.g)){5,8})){21,29}", // conditional subpatterns "(?(?=[^a-z]*[a-z])\\d{2}-[a-z]{3}-\\d{2}|\\d{2}-\\d{2}-\\d{2)}", // unmatched parens "(foo", "foo)", "((foo)", "(foo))", // unterminated comment "/foo(?#comment/", // bogus \g backrefs "A\\g", "A(.*)\\ga", // malformed \g backrefs (see UE-950) "^(a)\\g", "^(a)\\g{3", "\\g{A", "[\\g6666666666]", "(^(a|b\\g<-1'c))", // oniguruma subroutine calls (UE-950 as well) "^(?a|b\\g'name'c)", "^(a|b\\g'1'c)", "^(a|b\\g'-1'c)", // backtracking control verbs "A((?:A|B(*ACCEPT)|C)D)", "(*FAIL)", "(*F)", "a+(*COMMIT)b", "(*PRUNE)", "a+(*SKIP)b", // other unsupported PCRE features "\\R", "foo\\Kbar", "\\Gfoo", "(?|(Sat)ur|(Sun))day", // duplicate subpatterns, see UE-958 "foobar\\", // trailing unescaped backslash "(?x)abc(#i)def" // unterminated extended-mode comment }; // Did we correctly fail the compile? TEST_P(HyperscanFailBadPattern, Compile) { ASSERT_NE(HS_SUCCESS, err) << "Compile should have failed for expr: " << pattern; EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); // We shouldn't fail with the following messagess EXPECT_STRNE("An invalid flag was specified.", compile_err->message); EXPECT_STRNE("Unable to allocate memory.", compile_err->message); EXPECT_STRNE("Internal error.", compile_err->message); EXPECT_STRNE("Match can be raised on EOD", compile_err->message); } INSTANTIATE_TEST_CASE_P(CompileBadPatterns, HyperscanFailBadPattern, Combine(Bool(), ValuesIn(badPatterns))); struct BadPatternParam { BadPatternParam(const string &expr_in, unsigned int flags_in, const hs_expr_ext &ext_in, const string &expected_error_in) : expr(expr_in), flags(flags_in), ext(ext_in), expected_error(expected_error_in) {} string expr; unsigned int flags; hs_expr_ext ext; string expected_error; // Wrap hs_compile_ext_multi for single patterns. hs_error_t compile(unsigned int mode, hs_database_t **db, hs_compile_error_t **compile_err) const { const char *regex = expr.c_str(); const hs_expr_ext *extp = &ext; return hs_compile_ext_multi(®ex, &flags, nullptr, &extp, 1, mode, nullptr, db, compile_err); } }; void PrintTo(const BadPatternParam &p, ::std::ostream *os) { *os << "expr: \"" << p.expr << "\", expected error: " << p.expected_error; } class BadPattern : public TestWithParam { }; TEST_P(BadPattern, Block) { const BadPatternParam &p = GetParam(); SCOPED_TRACE(p.expr); hs_compile_error_t *compile_err; hs_database_t *db; hs_error_t err = p.compile(HS_MODE_NOSTREAM, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); if (compile_err) { EXPECT_STREQ(p.expected_error.c_str(), compile_err->message); } hs_free_database(db); hs_free_compile_error(compile_err); } TEST_P(BadPattern, Stream) { const BadPatternParam &p = GetParam(); SCOPED_TRACE(p.expr); hs_compile_error_t *compile_err; hs_database_t *db; hs_error_t err = p.compile(HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); if (compile_err) { EXPECT_STREQ(p.expected_error.c_str(), compile_err->message); } hs_free_database(db); hs_free_compile_error(compile_err); } // happy fun preprocessor hoop jumping #define xstr(s) str(s) #define str(s) #s #define SRCDIR_PREFIX xstr(SRCDIR) static vector getBadPatterns() { string filename = "unit/hyperscan/bad_patterns.txt"; ifstream f; f.open(filename.c_str(), ifstream::in); if (!f.good()) { // try it with the src prefix f.open((string(SRCDIR_PREFIX) + "/" + filename).c_str(), ifstream::in); } vector rv; if (!f.good()) { string expr("couldn't find input file:" + filename); cerr << expr << endl; abort(); return rv; } string line; while (f.good()) { getline(f, line); if (line.empty()) { continue; } size_t hashIdx = line.find_first_of('#'); size_t colonIdx = line.find_first_of(':'); assert(hashIdx != string::npos); assert(colonIdx != string::npos); if (!hashIdx) { continue; } string error = line.substr(hashIdx + 1); string expr = line.substr(colonIdx + 1, hashIdx - colonIdx - 1); boost::trim(expr); unsigned int flags; string regex; hs_expr_ext ext; if (!readExpression(expr, regex, &flags, &ext)) { cerr << expr << " failed in readExpression" << endl; abort(); } rv.push_back(BadPatternParam(regex, flags, ext, error)); } f.close(); return rv; } INSTANTIATE_TEST_CASE_P(Hyperscan, BadPattern, ValuesIn(getBadPatterns())); TEST(ResourceLimits, longPattern) { #define LONG_PATTERN_LEN 16384 hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; char pattern[LONG_PATTERN_LEN]; memset(pattern, 'a', LONG_PATTERN_LEN); pattern[LONG_PATTERN_LEN - 1] = 0; hs_error_t err = hs_compile(pattern, HS_FLAG_DOTALL, HS_MODE_BLOCK, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); if (compile_err) { EXPECT_STREQ("Pattern length exceeds limit.", compile_err->message); } hs_free_database(db); hs_free_compile_error(compile_err); } TEST(ResourceLimits, longPatternInfo) { #define LONG_PATTERN_LEN 16384 hs_expr_info_t *info = nullptr; hs_compile_error_t *compile_err = nullptr; char pattern[LONG_PATTERN_LEN]; memset(pattern, 'a', LONG_PATTERN_LEN); pattern[LONG_PATTERN_LEN - 1] = 0; hs_error_t err = hs_expression_info(pattern, HS_FLAG_DOTALL, &info, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(compile_err != nullptr); if (compile_err) { EXPECT_STREQ("Pattern length exceeds limit.", compile_err->message); } free(info); hs_free_compile_error(compile_err); } TEST(ResourceLimits, longLiteral) { #define LONG_PATTERN_LEN 16384 hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; const char *pattern = "(abcd){4096}"; hs_error_t err = hs_compile(pattern, HS_FLAG_DOTALL, HS_MODE_BLOCK, nullptr, &db, &compile_err); EXPECT_EQ(HS_COMPILER_ERROR, err); EXPECT_TRUE(db == nullptr); EXPECT_TRUE(compile_err != nullptr); if (compile_err) { EXPECT_STREQ("Resource limit exceeded.", compile_err->message); } hs_free_database(db); hs_free_compile_error(compile_err); } hyperscan-4.4.1/unit/hyperscan/bad_patterns.txt0000644000175000017500000002104713055426554022465 0ustar sleuthkidsleuthkid1:/\c空/ #\c must be followed by an ASCII character at index 0. 2:/\c/ #\c must be followed by an ASCII character at index 0. 3:/[\c空]/ #\c must be followed by an ASCII character at index 1. 4:/[\c]/ #Unterminated character class starting at index 0. 5:/\c空/8 #\c must be followed by an ASCII character at index 0. 6:/<([^>+i)>.*?/sP #Unterminated character class starting at index 2. 6:/[foo/ #Unterminated character class starting at index 0. 7:/[\p{X}]/8 #Unknown property at index 4. 8:/[\p{^X}]/8 #Unknown property at index 5. 9:/[\p{L]/8 #Malformed property at index 0. 10:/[\p{^L]/8 #Malformed property at index 0. 11:/[\P{L]/8 #Malformed property at index 0. 12:/[\P{^L]/8 #Malformed property at index 0. 13:/\p/8 #Malformed property at index 0. 14:/\P/8 #Malformed property at index 0. 15:/\p{/8 #Malformed property at index 0. 16:/\P{/8 #Malformed property at index 0. 17:/\p{^/8 #Malformed property at index 0. 18:/\P{^/8 #Malformed property at index 0. 19:/[\p/8 #Malformed property at index 1. 20:/[\P/8 #Malformed property at index 1. 21:/[\p{/8 #Malformed property at index 0. 22:/[\P{/8 #Malformed property at index 0. 23:/[\p{^/8 #Malformed property at index 0. 24:/[\P{^/8 #Malformed property at index 0. 25:/\pl/8 #Unknown property at index 2. 26:/\p{any}/8 #Unknown property at index 3. 27:/\p{greek}/8 #Unknown property at index 3. 28:/\b/8W #\b unsupported in UCP mode at index 0. 29:/(*UCP)\b/8 #\b unsupported in UCP mode at index 6. 30:/\B/8W #\B unsupported in UCP mode at index 0. 31:/\B/W #\B unsupported in UCP mode at index 0. 32:/foo(?{print "Hello world\n";})bar/ #Embedded code is not supported at index 3. 33:/the (\S+)(?{ $color = $^N }) (\S+)(?{ $animal = $^N })/i #Embedded code is not supported at index 9. 35:/\X/8 #\X unsupported at index 0. 36:/\B+/ #Invalid repeat at index 2. 37:/\B?/ #Invalid repeat at index 2. 38:/\B*/ #Invalid repeat at index 2. 39:/\B{0,6}/ #Invalid repeat at index 2. 40:/\b+/ #Invalid repeat at index 2. 41:/\b?/ #Invalid repeat at index 2. 42:/\b*/ #Invalid repeat at index 2. 43:/\b{0,6}/ #Invalid repeat at index 2. 44:/[.ch.]/ #Unsupported POSIX collating element at index 0. 45:/[=ch=]/ #Unsupported POSIX collating element at index 0. 46:/[:digit:]/ #POSIX named classes are only supported inside a class at index 0. 47:/[[.ch.]]/ #Unsupported POSIX collating element at index 1. 48:/[[=ch=]]/ #Unsupported POSIX collating element at index 1. 49:/foo(?m)?bar/ #Invalid repeat at index 7. 50:/.(?)+/ #Invalid repeat at index 4. 51:/(abc)\2/P #Invalid back reference to expression 2. 52:/\x{100000000}/ #Value in \x{...} sequence is too large at index 0. 53:/^foo/{min_offset=5} #Expression is anchored and cannot satisfy min_offset=5 as it can only produce matches of length 3 bytes at most. 54:/foobar/{min_length=20} #Expression has min_length=20 but can only produce matches of length 6 bytes at most. 55:/foobar/{max_offset=3} #Expression has max_offset=3 but requires 6 bytes to match. 56:/mkdzo(x|u)(\b)kd/{max_offset=29} #Pattern can never match. 57:/[^\x00-\xff]/ #Pattern can never match. 58:/[^\x00-\xff]foo/ #Pattern can never match. 59:/^\Bfoo/ #Pattern can never match. 60:/^\B\Bfoo/ #Pattern can never match. 61:/can't_match\b\B/ #Pattern can never match. 62:/\b\Bcan't_match/ #Pattern can never match. 63:/^\b$/m #Pattern can never match. 64:/^\b\Z/m #Pattern can never match. 65:/^\b\z/m #Pattern can never match. 66:/\A\b$/m #Pattern can never match. 67:/\A\b\Z/m #Pattern can never match. 68:/\A\b\z/m #Pattern can never match. 69:/^[^\x00-\xff]foo/ #Pattern can never match. 70:/foo[^\x00-\xff]/ #Pattern can never match. 71:/foo[^\x00-\xff]$/ #Pattern can never match. 72:/\Bd\B/i{min_length=2,min_offset=4,max_offset=54} #Expression has min_length=2 but can only produce matches of length 1 bytes at most. 73:/(((.|aaa)aaaaaa.aaa){14,19}a((a|a{5,6}|aa){3,11}|aa.|a){2}){4}\Z/sm #Pattern is too large. 74:/(((.|aaa)aaaaaa.aaa){14,19}a((a|a{5,6}|aa){3,11}|aa.|a){2}){4}\Z/smL #Pattern is too large. 75:/\B/s8{min_length=1} #Expression has min_length=1 but can only produce matches of length 0 bytes at most. 76:/(f|d|(\b)|i|a\Z)/mHV8{min_length=2,min_offset=9,max_offset=14} #Expression has min_length=2 but can only produce matches of length 1 bytes at most. 77:/(f|e|d{19,}|h\Z|^j|\Aa)/smi{min_length=7,min_offset=8,max_offset=18} #Extended parameter constraints can not be satisfied for any match from this expression. 78:/(i{13,}|i\Z)/s{min_length=3,max_offset=5} #Extended parameter constraints can not be satisfied for any match from this expression. 79:/(?Pfoo).*(?Pbar)/ #Two named subpatterns use the name 'dupename' at index 19. 80:/_W{0,3}bazr_W{0,3}(ac[_a-z]{22}a)?e_W{0,3}bazr[_a-z](ac[a-z]{4}c{14}[a-z]{5})?e_W{0,3}bazr[_a-z](e|ac[_a-z]{4}c{16}([_a-z]|[a-p]W|[o-z]WW){3}([_a-z]|WWW))_W{0,3}bazr([_a-z]|[a-p]WW?|[o-z]WWW)a(foobar|c([a-z]W{0,3})bc([a-z]W{0,3})c{14}([_a-z]W{0,3}){6})((fooaa|[_a-z]W{0,3})bazr[_a-z]W{0,5}a(foobar|c([_a-z]|[a-z]W{1,3})bc([_a-z]|[o-z]W{1,5})c{14}([_a-f]|[A-Z0]W|~WW|;WWW){6})){40}(fooaa|_)bazr[_a-z]/sL #Pattern is too large. 81:/[..]/ #Unsupported POSIX collating element at index 0. 82:/[==]/ #Unsupported POSIX collating element at index 0. 83:/[.\].]/ #Unsupported POSIX collating element at index 0. 84:/[=\]=]/ #Unsupported POSIX collating element at index 0. 85:/A(?!)+Z/ #Invalid repeat at index 5. 86:/\X/ #\X unsupported at index 0. 88:/[A-\d]/ #Invalid range in character class at index 3. 89:/[A-[:digit:]]/ #Invalid range in character class at index 3. 90:/B[--[:digit:]--]+/ #Invalid range in character class at index 4. 91:/a\owibble/ #Value in \o{...} sequence is non-octal or missing braces at index 1. 92:/a\o{wibble/ #Value in \o{...} sequence is non-octal or missing braces at index 1. 93:/a\o{777}/ #Value in \o{...} sequence is too large at index 1. 94:/(*UTF16)foo/ #(*UTF16) not supported at index 2. 95:/(*BSR_UNICODE)abc/ #Unknown control verb at index 2. 96:/a+(*SKIP)b/ #Unknown control verb at index 4. 97:/foo(*/ #Invalid repeat at index 4. 98:/[:\]:]/ #POSIX named classes are only supported inside a class at index 0. 99:/[[:[:]/ #Invalid POSIX named class at index 1. 100:/abc(?(1)def|ghi)/P #Invalid conditional reference to expression 1. 101:/abc(?()def|ghi)/P #Invalid conditional reference to label 'blah'. 102:/(?(DEFINE)foo|bar)/P #DEFINE conditional group with more than one branch at index 17. 103:/(?<1name>group)/ #Group name cannot begin with a digit at index 0. 104:/abc((def)?(?(R)bar))+/P #Pattern recursion not supported at index 10. 105:/abc((def)?(?(R2)bar))+/P #Pattern recursion not supported at index 10. 106:/abc((def)(?(R&label)bar))+/P #Pattern recursion not supported at index 9. 107:/\o{4200000}/8 #Value in \o{...} sequence is too large at index 0. 108:/\o{19}/ #Value in \o{...} sequence is non-octal or missing braces at index 0. 109:/\o{/ #Value in \o{...} sequence is non-octal or missing braces at index 0. 110:/\o{1/ #Value in \o{...} sequence is non-octal or missing braces at index 0. 111:/\x{0x110000}/8 #Value in \x{...} sequence is non-hex or missing } at index 0. 112:/\cÀ/ #\c must be followed by an ASCII character at index 0. 113:/[\cÀ]/ #\c must be followed by an ASCII character at index 1. 114:/[\o{4200000}]/8 #Value in \o{...} sequence is too large at index 1. 115:/[\x{0x110000}]/8 #Value in \x{...} sequence is non-hex or missing } at index 1. 116:/[\o{70]/ #Value in \o{...} sequence is non-octal or missing braces at index 1. 117:/[\x{ff]/ #Value in \x{...} sequence is non-hex or missing } at index 1. 118:/foo/{min_offset=10,max_offset=9} #In hs_expr_ext, min_offset must be less than or equal to max_offset. 120:/foo/{min_length=10,max_offset=9} #In hs_expr_ext, min_length must be less than or equal to max_offset. 122:/ÀÀ/8 #Expression is not valid UTF-8. 123:/hello \6 world/P #Invalid back reference to expression 6. 124:/hello \6 world|dog/P #Invalid back reference to expression 6. 125:/[~-\V]/8 #Invalid range in character class at index 3. 126:/(*UTF8)ÀÀ/ #Expression is not valid UTF-8. 127:/^fo?ob{ro|nax_off\Qt=10omnax+8Wnah/ñññññññññññññññññññññññññññ0}l.{1,60}Car*k|npanomnax+8Wnah/8 #Expression is not valid UTF-8. 128:/(*UTF8)^fo?ob{ro|nax_off\Qt=10omnax+8Wnah/ñññññññññññññññññññññññññññ0}l.{1,60}Car*k|npanomnax+8Wnah/ #Expression is not valid UTF-8. 129:/bignum \1111111111111111111/ #Number is too big at index 7. 130:/foo|&{5555555,}/ #Bounded repeat is too large. 131:/[a[..]]/ #Unsupported POSIX collating element at index 2. 132:/[a[==]]/ #Unsupported POSIX collating element at index 2. 133:/[a[.\].]]/ #Unsupported POSIX collating element at index 2. 134:/[a[=\]=]]/ #Unsupported POSIX collating element at index 2. 135:/[^\D\d]/8W #Pattern can never match. hyperscan-4.4.1/unit/hyperscan/multi.cpp0000644000175000017500000002661213055426554021117 0ustar sleuthkidsleuthkid/* * 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. */ #include #include #include #include #include "gtest/gtest.h" #include "hs.h" #include "config.h" #include "test_util.h" using namespace std; TEST(MMAdaptor, norm_cont1) { // UE-901 hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; CallBackContext c; string data = "aooAaooAbarZ"; const char *expr[] = {"aoo[A-K]", "bar[L-Z]"}; unsigned flags[] = {0, 0}; unsigned ids[] = {30, 31}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); c.halt = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(3U, c.matches.size()); ASSERT_EQ(MatchRecord(4, 30), c.matches[0]); ASSERT_EQ(MatchRecord(8, 30), c.matches[1]); ASSERT_EQ(MatchRecord(12, 31), c.matches[2]); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } TEST(MMAdaptor, norm_cont2) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; CallBackContext c; string data = "aooAaooAbarZ "; const char *expr[] = {"aoo[A-K][^\n]{16}", "bar[L-Z][^\n]{16}"}; unsigned flags[] = {0, 0}; unsigned ids[] = {30, 31}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); c.halt = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(3U, c.matches.size()); ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(20, 30))); ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(24, 30))); ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(28, 31))); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } TEST(MMAdaptor, norm_halt1) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; CallBackContext c; string data = "aooAaooAbarZ"; const char *expr[] = {"aoo[A-K]", "bar[L-Z]"}; unsigned flags[] = {0, 0}; unsigned ids[] = {30, 31}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); c.halt = 1; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(4, 30), c.matches[0]); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } TEST(MMAdaptor, norm_halt2) { // UE-901 hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; CallBackContext c; string data = "aooAaooAbarZ "; const char *expr[] = {"aoo[A-K][^\n]{16}", "bar[L-Z][^\n]{16}"}; unsigned flags[] = {0, 0}; unsigned ids[] = {30, 31}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); c.halt = 1; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(20, 30), c.matches[0]); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } TEST(MMAdaptor, high_cont1) { // UE-901 hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; CallBackContext c; string data = "aooAaooAbarZ"; const char *expr[] = {"aoo[A-K]", "bar[L-Z]"}; unsigned flags[] = {HS_FLAG_SINGLEMATCH, 0}; unsigned ids[] = {30, 31}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); c.halt = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(4, 30))); ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(12, 31))); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } TEST(MMAdaptor, high_cont2) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; CallBackContext c; string data = "aooAaooAbarZ "; const char *expr[] = {"aoo[A-K][^\n]{16}", "bar[L-Z][^\n]{16}"}; unsigned flags[] = {HS_FLAG_SINGLEMATCH, 0}; unsigned ids[] = {30, 31}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); c.halt = 0; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(2U, c.matches.size()); ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(20, 30))); ASSERT_TRUE(c.matches.end() != find(c.matches.begin(), c.matches.end(), MatchRecord(28, 31))); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } TEST(MMAdaptor, high_halt1) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; CallBackContext c; string data = "aooAaooAbarZ"; const char *expr[] = {"aoo[A-K]", "bar[L-Z]"}; unsigned flags[] = {HS_FLAG_SINGLEMATCH, 0}; unsigned ids[] = {30, 31}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); c.halt = 1; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(4, 30), c.matches[0]); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } TEST(MMAdaptor, high_halt2) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; CallBackContext c; string data = "aooAaooAbarZbarZaooA "; const char *expr[] = {"aoo[A-K][^\n]{16}", "bar[L-Z][^\n]{16}"}; unsigned flags[] = {HS_FLAG_SINGLEMATCH, 0}; unsigned ids[] = {30, 31}; hs_error_t err = hs_compile_multi(expr, flags, ids, 2, HS_MODE_NOSTREAM, nullptr, &db, &compile_err); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); c.halt = 1; err = hs_scan(db, data.c_str(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SCAN_TERMINATED, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_TRUE(MatchRecord(20, 30) == c.matches[0] || MatchRecord(28, 31) == c.matches[0]); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } TEST(MPV, UE_2395) { vector patterns; patterns.push_back(pattern("^.{200}", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern(".{40,}", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aaa", HS_FLAG_DOTALL, 3)); hs_database_t *db = buildDB(patterns, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); array data; data.fill('a'); CallBackContext c; err = hs_scan(db, data.data(), data.size(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); unsigned seen = 39; for (vector::const_iterator it = c.matches.begin(); it != c.matches.end(); ++it) { if (it->id != 2) { if (it->id == 1) { ASSERT_EQ(200, it->to); } continue; } ASSERT_EQ(seen + 1, it->to); seen = it->to; } ASSERT_EQ(300, seen); hs_free_database(db); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } hyperscan-4.4.1/unit/hyperscan/scratch_op.cpp0000644000175000017500000002243713055426554022113 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include #include #include #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" using namespace std; using namespace testing; namespace /* anonymous */ { static size_t last_alloc_size; static void *log_malloc(size_t n) { last_alloc_size = n; return malloc(n); } static void *bad_alloc(size_t) { return nullptr; } TEST(scratch, testAlloc) { vector patterns; patterns.push_back(pattern("aa", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); patterns.push_back(pattern("^.{0,4}aa", HS_FLAG_DOTALL, 5)); hs_database_t *db = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db); hs_error_t err; err = hs_set_allocator(log_malloc, free); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); size_t curr_size; err = hs_scratch_size(scratch, &curr_size); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(last_alloc_size, curr_size); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); hs_set_allocator(nullptr, nullptr); } TEST(scratch, testScratchAlloc) { vector patterns; allocated_count = 0; allocated_count_b = 0; hs_error_t err = hs_set_allocator(count_malloc_b, count_free_b); ASSERT_EQ(HS_SUCCESS, err); err = hs_set_scratch_allocator(count_malloc, count_free); ASSERT_EQ(HS_SUCCESS, err); patterns.push_back(pattern("aa", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); patterns.push_back(pattern("^.{0,4}aa", HS_FLAG_DOTALL, 5)); hs_database_t *db = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db); ASSERT_EQ(0, allocated_count); ASSERT_NE(0, allocated_count_b); size_t old_b = allocated_count_b; hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); size_t curr_size; err = hs_scratch_size(scratch, &curr_size); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(allocated_count, curr_size); ASSERT_EQ(allocated_count_b, old_b); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); hs_set_allocator(nullptr, nullptr); ASSERT_EQ(0, allocated_count); ASSERT_EQ(0, allocated_count_b); } TEST(scratch, badAlloc) { vector patterns; patterns.push_back(pattern("aa", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); patterns.push_back(pattern("^.{0,4}aa", HS_FLAG_DOTALL, 5)); hs_database_t *db = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db); hs_error_t err; err = hs_set_scratch_allocator(bad_alloc, free); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_NE(HS_SUCCESS, err); ASSERT_TRUE(scratch == nullptr); hs_free_database(db); hs_set_scratch_allocator(nullptr, nullptr); } TEST(scratch, testScratchRealloc) { vector patterns; patterns.push_back(pattern("aa", HS_FLAG_DOTALL, 1)); patterns.push_back(pattern("aa.", HS_FLAG_DOTALL, 2)); patterns.push_back(pattern("aa..", HS_FLAG_DOTALL, 3)); patterns.push_back(pattern("^.{0,4}aa..", HS_FLAG_DOTALL, 4)); patterns.push_back(pattern("^.{0,4}aa", HS_FLAG_DOTALL, 5)); hs_database_t *db = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db); patterns.push_back(pattern("^.{0,4}aa{0,4}", HS_FLAG_DOTALL, 6)); patterns.push_back(pattern("^.{0,4}aa{0,4}a..", HS_FLAG_DOTALL, 7)); hs_database_t *db2 = buildDB(patterns, HS_MODE_NOSTREAM); ASSERT_NE(nullptr, db2); hs_error_t err; err = hs_set_scratch_allocator(log_malloc, free); ASSERT_EQ(HS_SUCCESS, err); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); size_t curr_size; err = hs_scratch_size(scratch, &curr_size); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(last_alloc_size, curr_size); err = hs_alloc_scratch(db2, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_scratch_size(scratch, &curr_size); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(last_alloc_size, curr_size); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); hs_free_database(db2); hs_set_scratch_allocator(nullptr, nullptr); } TEST(scratch, tooSmallForDatabase) { hs_database_t *db1 = buildDB("foobar", 0, 0, HS_MODE_BLOCK, nullptr); ASSERT_NE(nullptr, db1); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db1, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db1); hs_database_t *db2 = buildDB("(a.?b.?c.?d.?e.?f.?g)|(hatstand(..)+teakettle)", 0, 0, HS_MODE_BLOCK, nullptr); ASSERT_NE(nullptr, db2); // Try and scan some data using db2 and a scratch that has only been // allocated for db1. err = hs_scan(db2, "somedata", 8, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); // Alloc scratch correctly and try again. err = hs_alloc_scratch(db2, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan(db2, "somedata", 8, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db2); } TEST(scratch, tooSmallForDatabase2) { hs_database_t *db1 = buildDB("foobar", 0, 0, HS_MODE_STREAM, nullptr); ASSERT_NE(nullptr, db1); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db1, &scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db1); hs_database_t *db2 = buildDB("(a.?b.?c.?d.?e.?f.?g)|(hatstand(..)+teakettle)", 0, 0, HS_MODE_STREAM, nullptr); ASSERT_NE(nullptr, db2); // Try and scan some data using db2 and a scratch that has only been // allocated for db1. hs_stream_t *stream = nullptr; err = hs_open_stream(db2, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, "somedata", 8, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); // Alloc scratch correctly and try again. err = hs_alloc_scratch(db2, &scratch); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, "somedata", 8, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, nullptr, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db2); } TEST(scratch, damagedScratch) { hs_database_t *db = buildDB("foobar", 0, 0, HS_MODE_BLOCK, nullptr); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); size_t scratch_size = 0; err = hs_scratch_size(scratch, &scratch_size); ASSERT_EQ(HS_SUCCESS, err); ASSERT_LT(4, scratch_size); // Take a temp copy and then scribble over the first four bytes. char tmp[4]; memcpy(tmp, scratch, 4); memset(scratch, 0xff, 4); err = hs_scan(db, "somedata", 8, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_INVALID, err); // Restore first four bytes so we can free. memcpy(scratch, tmp, 4); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } } // namespace hyperscan-4.4.1/unit/hyperscan/identical.cpp0000644000175000017500000001466113055426554021722 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "test_util.h" #include "hs.h" namespace { struct PatternInfo { std::string expr; unsigned flags; std::string corpus; unsigned long long match; }; class IdenticalTest : public testing::TestWithParam {}; TEST_P(IdenticalTest, Block) { const PatternInfo &info = GetParam(); std::vector patterns; for (unsigned i = 0; i < 100; i++) { patterns.push_back(pattern(info.expr, info.flags, i)); } hs_database_t *db = buildDB(patterns, HS_MODE_BLOCK); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, scratch); CallBackContext cb; err = hs_scan(db, info.corpus.c_str(), info.corpus.size(), 0, scratch, record_cb, &cb); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); ASSERT_EQ(patterns.size(), cb.matches.size()); std::set ids; for (size_t i = 0; i < cb.matches.size(); i++) { ASSERT_EQ(info.match, cb.matches[i].to); ids.insert(cb.matches[i].id); } ASSERT_EQ(patterns.size(), ids.size()); ASSERT_EQ(0, *ids.begin()); ASSERT_EQ(patterns.size() - 1, *ids.rbegin()); } TEST_P(IdenticalTest, Stream) { const PatternInfo &info = GetParam(); std::vector patterns; for (unsigned i = 0; i < 100; i++) { patterns.push_back(pattern(info.expr, info.flags, i)); } hs_database_t *db = buildDB(patterns, HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, scratch); CallBackContext cb; hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, stream); err = hs_scan_stream(stream, info.corpus.c_str(), info.corpus.size(), 0, scratch, record_cb, &cb); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, record_cb, &cb); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); ASSERT_EQ(patterns.size(), cb.matches.size()); std::set ids; for (size_t i = 0; i < cb.matches.size(); i++) { ASSERT_EQ(info.match, cb.matches[i].to); ids.insert(cb.matches[i].id); } ASSERT_EQ(patterns.size(), ids.size()); ASSERT_EQ(0, *ids.begin()); ASSERT_EQ(patterns.size() - 1, *ids.rbegin()); } TEST_P(IdenticalTest, Vectored) { const PatternInfo &info = GetParam(); std::vector patterns; for (unsigned i = 0; i < 100; i++) { patterns.push_back(pattern(info.expr, info.flags, i)); } hs_database_t *db = buildDB(patterns, HS_MODE_VECTORED); ASSERT_NE(nullptr, db); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, scratch); CallBackContext cb; const char * const data[] = { info.corpus.c_str() }; const unsigned datalen[] = { (unsigned)info.corpus.size() }; err = hs_scan_vector(db, data, datalen, 1, 0, scratch, record_cb, &cb); ASSERT_EQ(HS_SUCCESS, err); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); ASSERT_EQ(patterns.size(), cb.matches.size()); std::set ids; for (size_t i = 0; i < cb.matches.size(); i++) { ASSERT_EQ(info.match, cb.matches[i].to); ids.insert(cb.matches[i].id); } ASSERT_EQ(patterns.size(), ids.size()); ASSERT_EQ(0, *ids.begin()); ASSERT_EQ(patterns.size() - 1, *ids.rbegin()); } static const PatternInfo patterns[] = { { "a", 0, "a", 1 }, { "a", HS_FLAG_SINGLEMATCH, "a", 1 }, { "handbasket", 0, "__handbasket__", 12 }, { "handbasket", HS_FLAG_SINGLEMATCH, "__handbasket__", 12 }, { "handbasket", HS_FLAG_SOM_LEFTMOST, "__handbasket__", 12 }, { "foo.*bar", 0, "a foolish embarrassment", 15 }, { "foo.*bar", HS_FLAG_SINGLEMATCH, "a foolish embarrassment", 15 }, { "foo.*bar", HS_FLAG_SOM_LEFTMOST, "a foolish embarrassment", 15 }, { "\\bword\\b(..)+\\d{3,7}", 0, " word 012", 15 }, { "\\bword\\b(..)+\\d{3,7}", HS_FLAG_SINGLEMATCH, " word 012", 15 }, { "\\bword\\b(..)+\\d{3,7}", HS_FLAG_SOM_LEFTMOST, " word 012", 15 }, { "eod\\z", 0, "eod", 3 }, { "eod\\z", HS_FLAG_SINGLEMATCH, "eod", 3 }, { "eod\\z", HS_FLAG_SOM_LEFTMOST, "eod", 3 }, }; INSTANTIATE_TEST_CASE_P(Identical, IdenticalTest, testing::ValuesIn(patterns)); // teach google-test how to print a param void PrintTo(const PatternInfo &p, ::std::ostream *os) { *os << p.expr << ":" << p.flags << ", " << p.corpus; } } // namespace hyperscan-4.4.1/unit/hyperscan/main.cpp0000644000175000017500000000335013055426554020703 0ustar sleuthkidsleuthkid/* * 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. */ #include "gtest/gtest.h" // Driver: run all the tests (defined in other source files in this directory) int main(int argc, char **argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } hyperscan-4.4.1/unit/hyperscan/single.cpp0000644000175000017500000005246313055426554021251 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" #include #include using namespace std; using namespace testing; namespace /* anonymous */ { class HyperscanSingleBase { public: virtual ~HyperscanSingleBase() {} // Simplest case: did we successfully produce a non-zero length database void compile() { SCOPED_TRACE("Compile"); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(db != nullptr); EXPECT_TRUE(compile_err == nullptr); size_t db_size; err = hs_database_size(db, &db_size); EXPECT_EQ(HS_SUCCESS, err); EXPECT_NE(0U, db_size); } // Can we query the database for various information? void queryDatabase() { SCOPED_TRACE("QueryDatabase"); // info about the database, should begin with "Version:" char *info; err = hs_database_info(db, &info); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(nullptr, info); ASSERT_STREQ("Version:", string(info).substr(0, 8).c_str()); free(info); // stream size, which is non-zero if streaming size_t stream_size; err = hs_stream_size(db, &stream_size); if (mode & HS_MODE_STREAM) { ASSERT_EQ(HS_SUCCESS, err); ASSERT_LT(0U, stream_size); ASSERT_GT(100000, stream_size); /* more than 100k of stream size * and we are probably returning * rubbish. */ } else { ASSERT_EQ(HS_DB_MODE_ERROR, err); } } protected: unsigned int mode; // HS_MODE_* mode flags hs_error_t err; hs_compile_error_t *compile_err; hs_database_t *db; }; class HyperscanTestRuntime : public HyperscanSingleBase, public TestWithParam< tuple> { protected: virtual void SetUp() { // compiles a database for this test instantiation const char *pattern; unsigned int flags; unsigned long long feature_mask; tie(pattern, flags, mode, feature_mask) = GetParam(); hs_platform_info_t plat; err = hs_populate_platform(&plat); ASSERT_EQ(HS_SUCCESS, err); plat.cpu_features &= feature_mask; err = hs_compile(pattern, flags, mode, &plat, &db, &compile_err); } virtual void TearDown() { hs_free_database(db); hs_free_compile_error(compile_err); } // does a simple scan with a dummy handler (ignores matches) virtual void simpleScan() { const size_t datalen = 2048; char data[datalen]; memset(data, 'X', datalen); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); if (mode & HS_MODE_STREAM) { // streaming mode scan hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); // just for fun, scan a zero-byte block. err = hs_scan_stream(stream, data, 0, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_scan_stream(stream, data, datalen, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); } else if (mode & HS_MODE_VECTORED) { const char * const vec_bufs[] = { data }; const unsigned int vec_lens[] = { datalen }; err = hs_scan_vector(db, vec_bufs, vec_lens, 1, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); } else { // block mode scan ASSERT_TRUE(mode & HS_MODE_BLOCK); err = hs_scan(db, data, datalen, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); } // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } virtual void zeroLengthScan() { const size_t datalen = 20; char data[datalen]; memset(data, 'X', datalen); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); if (mode & HS_MODE_STREAM) { // streaming mode scan hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, data, 0, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); err = hs_close_stream(stream, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); } else if (mode & HS_MODE_VECTORED) { const char * const vec_bufs[] = { data }; const unsigned int vec_lens[] = { 0 }; err = hs_scan_vector(db, vec_bufs, vec_lens, 1, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); } else { // block mode scan ASSERT_TRUE(mode & HS_MODE_BLOCK); err = hs_scan(db, data, 0, 0, scratch, dummy_cb, nullptr); ASSERT_EQ(HS_SUCCESS, err); } // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } // Can we allocate and clone scratch void allocateScratch() { SCOPED_TRACE("AllocateScratch"); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); // Try cloning the scratch hs_scratch_t *cloned = nullptr; err = hs_clone_scratch(scratch, &cloned); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(cloned != nullptr); err = hs_free_scratch(scratch); EXPECT_EQ(HS_SUCCESS, err); err = hs_free_scratch(cloned); EXPECT_EQ(HS_SUCCESS, err); } // Can we scan with the database (ignoring the matches, and using // streaming/block mode appropriately) void scanIgnoreMatches() { SCOPED_TRACE("ScanIgnoreMatches"); simpleScan(); } // Can we serialize and deserialize the database void serialiseAndDeserializeCombo() { SCOPED_TRACE("SerialiseAndDeserializeCombo"); char *bytes = nullptr; size_t len = 0; // serialise err = hs_serialize_database(db, &bytes, &len); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(bytes != nullptr); EXPECT_NE(0U, len); // destroy original database size_t origSize; err = hs_database_size(db, &origSize); ASSERT_EQ(HS_SUCCESS, err); memset(db, 0xff, origSize); free(db); /* hs_free_database not used as it is no longer a valid db */ // relocate to 16 different alignments, ensuring that we can // deserialize from any string char *buffer = new char[len + 16]; for (size_t i = 0; i < 16; i++) { size_t newSize; memset(buffer, 0, len + 16); // relocate char *copy = buffer + i; memcpy(copy, bytes, len); // deserialise hs_database_t *newdb; err = hs_deserialize_database(copy, len, &newdb); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(newdb != nullptr); err = hs_database_size(newdb, &newSize); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(origSize, newSize); // deserialiseAt // alloc a new place for this DB size_t buflen; err = hs_serialized_database_size(copy, len, &buflen); ASSERT_EQ(HS_SUCCESS, err); ASSERT_NE(0U, buflen); char *buf = new char[buflen]; memset(buf, 0, buflen); // deserialise to our buffer hs_database_t *newdbAt = (hs_database_t *)buf; err = hs_deserialize_database_at(copy, len, newdbAt); ASSERT_EQ(HS_SUCCESS, err); err = hs_database_size(newdb, &newSize); ASSERT_EQ(HS_SUCCESS, err); EXPECT_EQ(origSize, newSize); { SCOPED_TRACE("DeserializeAt"); // Replace test harness DB and run a simple scan as a test db = newdbAt; simpleScan(); delete[] buf; db = nullptr; } { SCOPED_TRACE("Deserialize"); // Replace test harness DB and run a simple scan as a test db = newdb; simpleScan(); hs_free_database(newdb); db = nullptr; } } delete[] buffer; free(bytes); } }; TEST_P(HyperscanTestRuntime, Combo) { compile(); queryDatabase(); allocateScratch(); zeroLengthScan(); scanIgnoreMatches(); serialiseAndDeserializeCombo(); } static const char *validPatterns[] = { "foobar", "abd.*def", "abc[123]def", "[pqr]", ".", "\\s", "hatstand.*(teakettle|badgerbrush)", "abc{1,3}", "abc", "^.{1,10}flibble", "(foobar)+", "(foo){2,5}", "((foo){2}){3}", "^.*test[a-f]{3}pattern.*$", "(([^u]|.){16}|x){1,2}", // from bug UE-500 // UE-1553: these should compile without eating all your RAM. "fooa?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?", "fooa?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?a?", // UE-1816 (makes libpcre hit its match limit) "((aaa|[aaa]aa|aa[^aaaa]a|a.aaa.|a)){27}", // UE-2370 (makes libpcre hit its match limit) "^.{0,40}((e{0,9}|b){16}a.A|[da]..ecbcbcc[^e]de{10,20}[Bb]{3}[dEe]*){2}", }; static const unsigned validFlags[] = { 0, HS_FLAG_CASELESS, HS_FLAG_DOTALL, HS_FLAG_MULTILINE, HS_FLAG_CASELESS | HS_FLAG_DOTALL | HS_FLAG_MULTILINE, HS_FLAG_SINGLEMATCH, }; static const unsigned validModes[] = { HS_MODE_BLOCK, HS_MODE_STREAM, HS_MODE_VECTORED, }; // Mode bits for switching off various architecture features static const unsigned long long featureMask[] = { ~0ULL, /* native */ ~HS_CPU_FEATURES_AVX2, /* no avx2 */ }; INSTANTIATE_TEST_CASE_P(Single, HyperscanTestRuntime, Combine(ValuesIn(validPatterns), ValuesIn(validFlags), ValuesIn(validModes), ValuesIn(featureMask))); struct TestPlatform { TestPlatform() : features(0ULL) {} TestPlatform(unsigned long long f) : features(f) {} unsigned long long features; }; class HyperscanTestCrossCompile : public HyperscanSingleBase, public TestWithParam< tuple> { protected: virtual void SetUp() { // compiles a database for this test instantiation const char *pattern; unsigned flags; TestPlatform tp; tie(pattern, flags, mode, tp) = GetParam(); hs_platform_info_t plat; plat.tune = HS_TUNE_FAMILY_GENERIC; plat.cpu_features = tp.features; err = hs_compile(pattern, flags, mode, &plat, &db, &compile_err); } virtual void TearDown() { hs_free_database(db); hs_free_compile_error(compile_err); } // Attempt to allocate a scratch region. This should succeed for the local // platform and return HS_DB_PLATFORM_ERROR for all the others. void attemptScratchAlloc() { SCOPED_TRACE("AttemptScratchAlloc"); hs_scratch_t *scratch = nullptr; err = hs_alloc_scratch(db, &scratch); // XXX: it'd be nice to be a bit less cavalier about this and actually // find out what the local platform is, then check explicitly that only // that platform produces HS_SUCCESS. if (err == HS_SUCCESS) { // host platform. err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } else { ASSERT_EQ(HS_DB_PLATFORM_ERROR, err); ASSERT_TRUE(!scratch); } } }; TEST_P(HyperscanTestCrossCompile, Build) { compile(); queryDatabase(); attemptScratchAlloc(); } static const TestPlatform validPlatforms[] = { TestPlatform(0), TestPlatform(HS_CPU_FEATURES_AVX2), }; INSTANTIATE_TEST_CASE_P(Single, HyperscanTestCrossCompile, Combine(ValuesIn(validPatterns), ValuesIn(validFlags), ValuesIn(validModes), ValuesIn(validPlatforms))); // Also instantiate some normal and cross-compile tests for SOM patterns. static const char *validSomPatterns[] = { "foobar", "abd.*def", "abc[123]def", "[pqr]", ".", "\\s", "hatstand.*(teakettle|badgerbrush)", "abc{1,3}", "abc", "^.{1,10}flibble", "(foobar)+", "(foo){2,5}", "((foo){2}){3}", "^.*test[a-f]{3}pattern.*$", }; static const unsigned validSomFlags[] = { HS_FLAG_SOM_LEFTMOST, }; static const unsigned validSomModes[] = { HS_MODE_BLOCK, HS_MODE_STREAM | HS_MODE_SOM_HORIZON_LARGE, HS_MODE_VECTORED, }; INSTANTIATE_TEST_CASE_P(SingleSom, HyperscanTestRuntime, Combine(ValuesIn(validSomPatterns), ValuesIn(validSomFlags), ValuesIn(validSomModes), ValuesIn(featureMask))); INSTANTIATE_TEST_CASE_P(SingleSom, HyperscanTestCrossCompile, Combine(ValuesIn(validSomPatterns), ValuesIn(validSomFlags), ValuesIn(validSomModes), ValuesIn(validPlatforms))); struct TerminateMatchData { TerminateMatchData(const char *pattern_, unsigned int flags_, const char *corpus_) : pattern(pattern_), flags(flags_), corpus(corpus_) {} const char *pattern; unsigned int flags; const char *corpus; }; class HyperscanTestMatchTerminate : public TestWithParam { // empty }; // Simple non-terminating callback: increments the int pointed to by the context // and tells the matcher to keep going. int countHandler(unsigned, unsigned long long, unsigned long long, unsigned, void *ctx) { int *count = (int *)ctx; (*count)++; return 0; // keep going } // Simple terminating callback: increments the int pointed to by the context // and tells the matcher to stop. int terminateHandler(unsigned, unsigned long long, unsigned long long, unsigned, void *ctx) { int *count = (int *)ctx; (*count)++; return 1; // stop matching } TEST_P(HyperscanTestMatchTerminate, MoreThanOne) { const TerminateMatchData &data = GetParam(); hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch(data.pattern, data.flags, 0, HS_MODE_BLOCK, &scratch); int count = 0; err = hs_scan(db, data.corpus, strlen(data.corpus), 0, scratch, countHandler, &count); ASSERT_EQ(HS_SUCCESS, err) << "hs_scan didn't return HS_SCAN_TERMINATED"; ASSERT_LT(1, count) << "Number of matches returned was not greater than 1."; err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST_P(HyperscanTestMatchTerminate, Block) { const TerminateMatchData &data = GetParam(); hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch(data.pattern, data.flags, 0, HS_MODE_BLOCK, &scratch); int count = 0; err = hs_scan(db, data.corpus, strlen(data.corpus), 0, scratch, terminateHandler, &count); ASSERT_EQ(HS_SCAN_TERMINATED, err) << "hs_scan didn't return HS_SCAN_TERMINATED"; ASSERT_EQ(1, count) << "Number of matches returned was not 1."; err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST_P(HyperscanTestMatchTerminate, StreamWhole) { const TerminateMatchData& data = GetParam(); hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch(data.pattern, data.flags, 0, HS_MODE_STREAM, &scratch); int count = 0; hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err) << "Stream open failed"; ASSERT_TRUE(stream != nullptr); err = hs_scan_stream(stream, data.corpus, strlen(data.corpus), 0, scratch, terminateHandler, &count); ASSERT_TRUE(err == HS_SUCCESS || err == HS_SCAN_TERMINATED); err = hs_close_stream(stream, scratch, terminateHandler, &count); ASSERT_EQ(1, count) << "Number of matches returned was not 1."; err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST_P(HyperscanTestMatchTerminate, StreamByteByByte) { const TerminateMatchData& data = GetParam(); hs_error_t err; hs_scratch_t *scratch = nullptr; hs_database_t *db = buildDBAndScratch(data.pattern, data.flags, 0, HS_MODE_STREAM, &scratch); int count = 0; hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err) << "Stream open failed"; ASSERT_TRUE(stream != nullptr); size_t len = strlen(data.corpus); for (size_t i = 0; i < len; i++) { err = hs_scan_stream(stream, data.corpus + i, 1, 0, scratch, terminateHandler, &count); ASSERT_TRUE(err == HS_SUCCESS || err == HS_SCAN_TERMINATED); } err = hs_close_stream(stream, scratch, terminateHandler, &count); ASSERT_EQ(1, count) << "Number of matches returned was not 1."; err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } // Each of these cases must match multiple times const TerminateMatchData terminateCases[] = { TerminateMatchData("foobar", 0, "foobarfoobarfoobar"), TerminateMatchData("a", 0, "a a a a a a a a a a a"), TerminateMatchData(".", 0, "zzzzzzzzzzzzaaaaaaaaaaaaa"), TerminateMatchData("...", 0, "zzzzzzzzzzzzaaaaaaaaaaaaa"), TerminateMatchData("[a-z]{3,7}", 0, "zzzzzzzzzzzzaaaaaaaaaaaaa"), TerminateMatchData("a", HS_FLAG_CASELESS, " xAaAa"), TerminateMatchData("xyzzy", HS_FLAG_CASELESS, "abcdef XYZZy xyzzy XyZzY"), TerminateMatchData("abc.*def", 0, "abc abc abc def def"), TerminateMatchData("abc.*def", HS_FLAG_DOTALL, "abc abc abc def def"), TerminateMatchData("(01234|abcde).*(foo|bar)", 0, "abcde xxxx bar foo abcde foo"), TerminateMatchData("(01234|abcde).*(foo|bar)", HS_FLAG_DOTALL, "abcde xxxx bar foo abcde foo"), TerminateMatchData("[0-9a-f]{4,10}.*(foobar|bazbaz)", 0, "0123456789abcdef bazbaz foobar"), TerminateMatchData("[0-9a-f]{4,10}.*(foobar|bazbaz)", HS_FLAG_DOTALL, "0123456789abcdef bazbaz foobar"), TerminateMatchData("^foobar[^z]{20,}", 0, "foobarxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"), TerminateMatchData("hatstand|teakettle|badgerbrush|mnemosyne", 0, "hatstand teakettle badgerbrush mnemosyne"), TerminateMatchData("a|b|c|d", 0, "a b c d a b c d a b c d"), TerminateMatchData("bat|cat|mat|rat|fat|sat|pat|hat|vat", HS_FLAG_CASELESS, "VAt hat pat sat fat rat mat caT BAT"), }; INSTANTIATE_TEST_CASE_P(Single, HyperscanTestMatchTerminate, ValuesIn(terminateCases)); } // namespace hyperscan-4.4.1/unit/hyperscan/som.cpp0000644000175000017500000001515613055426554020564 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include #include #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" using namespace std; using namespace testing; namespace { struct Match { Match(unsigned i, unsigned long long f, unsigned long long t) : id(i), from(f), to(t) {} unsigned int id; unsigned long long from; unsigned long long to; }; } static int vectorCallback(unsigned id, unsigned long long from, unsigned long long to, unsigned, void *ctx) { //printf("match id %u at (%llu,%llu)\n", id, from, to); vector *matches = (vector *)ctx; matches->push_back(Match(id, from, to)); return 0; } class SomTest : public TestWithParam { protected: virtual void SetUp() { som_mode = GetParam(); } unsigned long long getSomHorizon() const { switch (som_mode) { case HS_MODE_SOM_HORIZON_SMALL: return 1ULL << 16; case HS_MODE_SOM_HORIZON_MEDIUM: return 1ULL << 32; default: return ~(0ULL); } } unsigned int som_mode; }; TEST_P(SomTest, PastHorizon) { hs_database_t *db = buildDB("foo.*bar", HS_FLAG_SOM_LEFTMOST, 1000, HS_MODE_STREAM | som_mode); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); vector matches; hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); const string prefix(" foo"); const string suffix("bar"); const string filler(4096, 'X'); unsigned long long scanned_len = 0; err = hs_scan_stream(stream, prefix.c_str(), prefix.length(), 0, scratch, vectorCallback, &matches); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0, matches.size()); scanned_len += prefix.length(); const unsigned long long blocks = getSomHorizon() / filler.length(); for (unsigned long long i = 0; i < blocks; i += 1) { err = hs_scan_stream(stream, filler.c_str(), filler.length(), 0, scratch, vectorCallback, &matches); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0, matches.size()); scanned_len += filler.length(); } err = hs_scan_stream(stream, suffix.c_str(), suffix.length(), 0, scratch, vectorCallback, &matches); ASSERT_EQ(HS_SUCCESS, err); scanned_len += suffix.length(); // We receive one match with the correct 'to' offset, but a sentinel value // for 'from'. ASSERT_EQ(1, matches.size()); ASSERT_EQ(1000, matches[0].id); ASSERT_EQ(HS_OFFSET_PAST_HORIZON, matches[0].from); ASSERT_EQ(scanned_len, matches[0].to); err = hs_close_stream(stream, scratch, vectorCallback, &matches); ASSERT_EQ(HS_SUCCESS, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST_P(SomTest, NearHorizon) { hs_database_t *db = buildDB("foo.*bar", HS_FLAG_SOM_LEFTMOST, 1000, HS_MODE_STREAM | som_mode); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); EXPECT_TRUE(scratch != nullptr); vector matches; hs_stream_t *stream = nullptr; err = hs_open_stream(db, 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); const string prefix(" foo"); const string suffix("bar"); const string filler(4096, 'X'); unsigned long long scanned_len = 0; err = hs_scan_stream(stream, prefix.c_str(), prefix.length(), 0, scratch, vectorCallback, &matches); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0, matches.size()); scanned_len += prefix.length(); const unsigned long long blocks = getSomHorizon() / filler.length() - 1; for (unsigned long long i = 0; i < blocks; i += 1) { err = hs_scan_stream(stream, filler.c_str(), filler.length(), 0, scratch, vectorCallback, &matches); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0, matches.size()); scanned_len += filler.length(); } err = hs_scan_stream(stream, suffix.c_str(), suffix.length(), 0, scratch, vectorCallback, &matches); ASSERT_EQ(HS_SUCCESS, err); scanned_len += suffix.length(); // Both 'to' and 'from' should be accurate. ASSERT_EQ(1, matches.size()); ASSERT_EQ(1000, matches[0].id); ASSERT_EQ(1, matches[0].from); ASSERT_EQ(scanned_len, matches[0].to); err = hs_close_stream(stream, scratch, vectorCallback, &matches); ASSERT_EQ(HS_SUCCESS, err); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } INSTANTIATE_TEST_CASE_P(Som, SomTest, Values(HS_MODE_SOM_HORIZON_SMALL, HS_MODE_SOM_HORIZON_MEDIUM)); hyperscan-4.4.1/unit/hyperscan/scratch_in_use.cpp0000644000175000017500000002130513055426554022750 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "test_util.h" #include "hs.h" #include "gtest/gtest.h" #include using namespace std; struct RescanContext { RescanContext(const hs_database_t *db_in, hs_scratch_t *scratch_in) : db(db_in), scratch(scratch_in) {} const hs_database_t *db; hs_scratch_t *scratch; size_t matches = 0; }; struct HyperscanDatabaseDeleter { void operator()(hs_database_t *db) const { hs_error_t err = hs_free_database(db); EXPECT_EQ(HS_SUCCESS, err); } }; unique_ptr makeDatabase(const char *expression, unsigned int flags, unsigned int mode) { hs_database_t *db = nullptr; hs_compile_error_t *compile_err = nullptr; hs_error_t err = hs_compile(expression, flags, mode, nullptr, &db, &compile_err); EXPECT_EQ(HS_SUCCESS, err); return unique_ptr(db); } // Generic block mode test that uses the given scan callback. static void runBlockTest(match_event_handler cb_func) { auto db = makeDatabase("foo.*bar", 0, HS_MODE_BLOCK); ASSERT_NE(nullptr, db.get()); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db.get(), &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); RescanContext rc(db.get(), scratch); const string data = "___foo___bar_"; err = hs_scan(db.get(), data.c_str(), data.length(), 0, scratch, cb_func, &rc); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1, rc.matches); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } // Generic streaming mode test that uses the given scan callback. static void runStreamingTest(match_event_handler cb_func) { auto db = makeDatabase("foo.*bar", 0, HS_MODE_STREAM); ASSERT_NE(nullptr, db.get()); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db.get(), &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); hs_stream_t *stream = nullptr; err = hs_open_stream(db.get(), 0, &stream); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(stream != nullptr); RescanContext rc(db.get(), scratch); const string data = "___foo___bar_"; err = hs_scan_stream(stream, data.c_str(), data.length(), 0, scratch, cb_func, &rc); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1, rc.matches); // teardown hs_close_stream(stream, scratch, nullptr, nullptr); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } // Generic vectored mode test that uses the given scan callback. static void runVectoredTest(match_event_handler cb_func) { auto db = makeDatabase("foo.*bar", 0, HS_MODE_VECTORED); ASSERT_NE(nullptr, db.get()); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db.get(), &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); RescanContext rc(db.get(), scratch); const string data1 = "___foo_"; const string data2 = "bar_"; const char *vec[] = {data1.c_str(), data2.c_str()}; const unsigned int len[] = {unsigned(data1.length()), unsigned(data2.length())}; err = hs_scan_vector(db.get(), vec, len, 2, 0, scratch, cb_func, &rc); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1, rc.matches); // teardown err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); } static int rescan_block_cb(unsigned, unsigned long long, unsigned long long, unsigned, void *ctx) { RescanContext *rctx = (RescanContext *)ctx; rctx->matches++; const string data = "___foo___bar_"; hs_error_t err = hs_scan(rctx->db, data.c_str(), data.length(), 0, rctx->scratch, dummy_cb, nullptr); EXPECT_EQ(HS_SCRATCH_IN_USE, err); return 0; } // Attempt to use in-use scratch inside block mode callback. TEST(ScratchInUse, Block) { runBlockTest(rescan_block_cb); } static int rescan_stream_cb(unsigned, unsigned long long, unsigned long long, unsigned, void *ctx) { RescanContext *rctx = (RescanContext *)ctx; rctx->matches++; const string data = "___foo___bar_"; hs_stream_t *stream = nullptr; hs_error_t err = hs_open_stream(rctx->db, 0, &stream); EXPECT_EQ(HS_SUCCESS, err); EXPECT_TRUE(stream != nullptr); if (stream == nullptr) { return 1; } err = hs_scan_stream(stream, data.c_str(), data.length(), 0, rctx->scratch, dummy_cb, nullptr); EXPECT_EQ(HS_SCRATCH_IN_USE, err); hs_close_stream(stream, nullptr, nullptr, nullptr); return 0; } // Attempt to use in-use scratch inside streaming mode callback. TEST(ScratchInUse, Streaming) { runStreamingTest(rescan_stream_cb); } static int rescan_vector_cb(unsigned, unsigned long long, unsigned long long, unsigned, void *ctx) { RescanContext *rctx = (RescanContext *)ctx; rctx->matches++; const string data1 = "___foo_"; const string data2 = "bar_"; const char *vec[] = {data1.c_str(), data2.c_str()}; const unsigned int len[] = {unsigned(data1.length()), unsigned(data2.length())}; hs_error_t err = hs_scan_vector(rctx->db, vec, len, 2, 0, rctx->scratch, dummy_cb, nullptr); EXPECT_EQ(HS_SCRATCH_IN_USE, err); return 0; } // Attempt to use in-use scratch inside vectored mode callback. TEST(ScratchInUse, Vectored) { runVectoredTest(rescan_vector_cb); } static int rescan_realloc_cb(unsigned, unsigned long long, unsigned long long, unsigned, void *ctx) { RescanContext *rctx = (RescanContext *)ctx; rctx->matches++; auto db = makeDatabase("another db", 0, HS_MODE_BLOCK); hs_error_t err = hs_alloc_scratch(db.get(), &rctx->scratch); EXPECT_EQ(HS_SCRATCH_IN_USE, err); return 0; } // Attempt to use hs_alloc_scratch on in-use scratch inside callback (block // scan). TEST(ScratchInUse, ReallocScratchBlock) { runBlockTest(rescan_realloc_cb); } // Attempt to use hs_alloc_scratch on in-use scratch inside callback (streaming // scan). TEST(ScratchInUse, ReallocScratchStreaming) { runStreamingTest(rescan_realloc_cb); } // Attempt to use hs_alloc_scratch on in-use scratch inside callback (vectored // scan). TEST(ScratchInUse, ReallocScratchVector) { runVectoredTest(rescan_realloc_cb); } static int rescan_free_cb(unsigned, unsigned long long, unsigned long long, unsigned, void *ctx) { RescanContext *rctx = (RescanContext *)ctx; rctx->matches++; hs_error_t err = hs_free_scratch(rctx->scratch); EXPECT_EQ(HS_SCRATCH_IN_USE, err); return 0; } // Attempt to use hs_free_scratch on in-use scratch inside callback (block // scan). TEST(ScratchInUse, FreeScratchBlock) { runBlockTest(rescan_free_cb); } // Attempt to use hs_free_scratch on in-use scratch inside callback (streaming // scan). TEST(ScratchInUse, FreeScratchStreaming) { runStreamingTest(rescan_free_cb); } // Attempt to use hs_free_scratch on in-use scratch inside callback (vectored // scan). TEST(ScratchInUse, FreeScratchVector) { runVectoredTest(rescan_free_cb); } hyperscan-4.4.1/unit/hyperscan/extparam.cpp0000644000175000017500000001333113055426554021600 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include #include "gtest/gtest.h" #include "hs.h" #include "test_util.h" using namespace std; using namespace testing; TEST(ExtParam, LargeMinOffset) { hs_expr_ext ext; memset(&ext, 0, sizeof(ext)); ext.min_offset = 100000; ext.flags = HS_EXT_FLAG_MIN_OFFSET; pattern p("hatstand.*teakettle", 0, 0, ext); hs_database_t *db = buildDB(p, HS_MODE_NOSTREAM); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); CallBackContext c; // First, scan a matching corpus that's shorter than our min_offset and // ensure it doesn't match. string corpus = "hatstand" + string(80000, '_') + "teakettle"; err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); // Try exactly at the min_offset. corpus = "hatstand" + string(99983, '_') + "teakettle"; err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(100000, 0), c.matches[0]); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(ExtParam, LargeExactOffset) { hs_expr_ext ext; memset(&ext, 0, sizeof(ext)); ext.min_offset = 200000; ext.max_offset = 200000; ext.flags = HS_EXT_FLAG_MIN_OFFSET | HS_EXT_FLAG_MAX_OFFSET; pattern p("hatstand.*teakettle", 0, 0, ext); hs_database_t *db = buildDB(p, HS_MODE_NOSTREAM); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); CallBackContext c; // First, scan a matching corpus that's shorter than our min_offset and // ensure it doesn't match. string corpus = "hatstand" + string(199982, '_') + "teakettle"; err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); // Try the exact match. corpus = "hatstand" + string(199983, '_') + "teakettle"; err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(200000, 0), c.matches[0]); // Try one byte too far. c.clear(); corpus = "hatstand" + string(199984, '_') + "teakettle"; err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } TEST(ExtParam, LargeMinLength) { hs_expr_ext ext; memset(&ext, 0, sizeof(ext)); ext.min_length = 100000; ext.flags = HS_EXT_FLAG_MIN_LENGTH; pattern p("hatstand.*teakettle", 0, 0, ext); hs_database_t *db = buildDB(p, HS_MODE_NOSTREAM); ASSERT_TRUE(db != nullptr); hs_scratch_t *scratch = nullptr; hs_error_t err = hs_alloc_scratch(db, &scratch); ASSERT_EQ(HS_SUCCESS, err); ASSERT_TRUE(scratch != nullptr); CallBackContext c; // First, scan a matching corpus that contains a match that's a bit too // short. string corpus = string(10000, '_') + "hatstand" + string(80000, '_') + "teakettle"; err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(0U, c.matches.size()); // Now, a match of the right length. corpus = string(10000, '_') + "hatstand" + string(99983, '_') + "teakettle"; err = hs_scan(db, corpus.c_str(), corpus.length(), 0, scratch, record_cb, (void *)&c); ASSERT_EQ(HS_SUCCESS, err); ASSERT_EQ(1U, c.matches.size()); ASSERT_EQ(MatchRecord(110000, 0), c.matches[0]); err = hs_free_scratch(scratch); ASSERT_EQ(HS_SUCCESS, err); hs_free_database(db); } hyperscan-4.4.1/unit/internal/0000755000175000017500000000000013055426554017072 5ustar sleuthkidsleuthkidhyperscan-4.4.1/unit/internal/noodle.cpp0000644000175000017500000002106713055426554021064 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "ue2common.h" #include "hwlm/noodle_build.h" #include "hwlm/noodle_engine.h" #include "hwlm/hwlm.h" #include "hwlm/hwlm_literal.h" #include "util/alloc.h" #include "util/ue2string.h" #include #include #include "gtest/gtest.h" using std::unique_ptr; using std::vector; using namespace ue2; struct hlmMatchEntry { size_t from; size_t to; u32 id; hlmMatchEntry(size_t start, size_t end, u32 identifier) : from(start), to(end), id(identifier) {} }; typedef vector hlmMatchRecord; static hwlmcb_rv_t hlmSimpleCallback(size_t from, size_t to, u32 id, void *context) { hlmMatchRecord *mr = (hlmMatchRecord *)context; DEBUG_PRINTF("match @%zu = %u,%p\n", to, id, context); mr->push_back(hlmMatchEntry(from, to, id)); return HWLM_CONTINUE_MATCHING; } static void noodleMatch(const u8 *data, size_t data_len, const char *lit_str, size_t lit_len, char nocase, HWLMCallback cb, void *ctxt) { u32 id = 1000; hwlmLiteral lit(std::string(lit_str, lit_len), nocase, id); auto n = noodBuildTable(lit); ASSERT_TRUE(n != nullptr); hwlm_error_t rv; rv = noodExec(n.get(), data, data_len, 0, cb, ctxt); ASSERT_EQ(HWLM_SUCCESS, rv); } TEST(Noodle, nood1) { const size_t data_len = 1024; unsigned int i, j; hlmMatchRecord ctxt; u8 data[data_len]; memset(data, 'a', data_len); noodleMatch(data, data_len, "a", 1, 0, hlmSimpleCallback, &ctxt); ASSERT_EQ(1024U, ctxt.size()); for (i = 0; i < 1024; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i, ctxt[i].to); } ctxt.clear(); noodleMatch(data, data_len, "A", 1, 0, hlmSimpleCallback, &ctxt); ASSERT_EQ(0U, ctxt.size()); ctxt.clear(); noodleMatch(data, data_len, "A", 1, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1024U, ctxt.size()); for (i = 0; i < 1024; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i, ctxt[i].to); } for (j = 0; j < 16; j++) { ctxt.clear(); noodleMatch(data + j, data_len - j, "A", 1, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1024 - j, ctxt.size()); for (i = 0; i < 1024 - j; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i, ctxt[i].to); } ctxt.clear(); noodleMatch(data, data_len - j, "A", 1, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1024 - j, ctxt.size()); for (i = 0; i < 1024 - j; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i, ctxt[i].to); } } } TEST(Noodle, nood2) { const size_t data_len = 1024; unsigned int i, j; hlmMatchRecord ctxt; u8 data[data_len]; memset(data, 'a', data_len); noodleMatch(data, data_len, "aa", 2, 0, hlmSimpleCallback, &ctxt); ASSERT_EQ(1023U, ctxt.size()); for (i = 0; i < 1023; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 1, ctxt[i].to); } ctxt.clear(); noodleMatch(data, data_len, "aA", 2, 0, hlmSimpleCallback, &ctxt); ASSERT_EQ(0U, ctxt.size()); ctxt.clear(); noodleMatch(data, data_len, "AA", 2, 0, hlmSimpleCallback, &ctxt); ASSERT_EQ(0U, ctxt.size()); ctxt.clear(); noodleMatch(data, data_len, "aa", 2, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1023U, ctxt.size()); for (i = 0; i < 1023; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 1, ctxt[i].to); } ctxt.clear(); noodleMatch(data, data_len, "Aa", 2, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1023U, ctxt.size()); for (i = 0; i < 1023; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 1, ctxt[i].to); } ctxt.clear(); noodleMatch(data, data_len, "AA", 2, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1023U, ctxt.size()); for (i = 0; i < 1023; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 1, ctxt[i].to); } for (j = 0; j < 16; j++) { ctxt.clear(); noodleMatch(data + j, data_len - j, "Aa", 2, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1023 - j, ctxt.size()); for (i = 0; i < 1023 - j; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 1, ctxt[i].to); } ctxt.clear(); noodleMatch(data, data_len - j, "aA", 2, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1023 - j, ctxt.size()); for (i = 0; i < 1023 - j; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 1, ctxt[i].to); } } } TEST(Noodle, noodLong) { const size_t data_len = 1024; unsigned int i, j; hlmMatchRecord ctxt; u8 data[data_len]; memset(data, 'a', data_len); noodleMatch(data, data_len, "aaaa", 4, 0, hlmSimpleCallback, &ctxt); ASSERT_EQ(1021U, ctxt.size()); for (i = 0; i < 1021; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 3, ctxt[i].to); } ctxt.clear(); noodleMatch(data, data_len, "aaAA", 4, 0, hlmSimpleCallback, &ctxt); ASSERT_EQ(0U, ctxt.size()); ctxt.clear(); noodleMatch(data, data_len, "aaAA", 4, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1021U, ctxt.size()); for (i = 0; i < 1021; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 3, ctxt[i].to); } for (j = 0; j < 16; j++) { ctxt.clear(); noodleMatch(data + j, data_len - j, "AAaa", 4, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1021 - j, ctxt.size()); for (i = 0; i < 1021 - j; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 3, ctxt[i].to); } ctxt.clear(); noodleMatch(data + j, data_len - j, "aaaA", 4, 1, hlmSimpleCallback, &ctxt); ASSERT_EQ(1021 - j, ctxt.size()); for (i = 0; i < 1021 - j; i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 3, ctxt[i].to); } } } TEST(Noodle, noodCutoverSingle) { const size_t max_data_len = 128; hlmMatchRecord ctxt; u8 data[max_data_len + 15]; memset(data, 'a', max_data_len + 15); for (u32 align = 0; align < 16; align++) { for (u32 len = 0; len < max_data_len; len++) { ctxt.clear(); noodleMatch(data + align, len, "a", 1, 0, hlmSimpleCallback, &ctxt); EXPECT_EQ(len, ctxt.size()); for (u32 i = 0; i < ctxt.size(); i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i, ctxt[i].to); } } } } TEST(Noodle, noodCutoverDouble) { const size_t max_data_len = 128; hlmMatchRecord ctxt; u8 data[max_data_len + 15]; memset(data, 'a', max_data_len + 15); for (u32 align = 0; align < 16; align++) { for (u32 len = 0; len < max_data_len; len++) { ctxt.clear(); noodleMatch(data + align, len, "aa", 2, 0, hlmSimpleCallback, &ctxt); EXPECT_EQ(len ? len - 1 : 0U, ctxt.size()); for (u32 i = 0; i < ctxt.size(); i++) { ASSERT_EQ(i, ctxt[i].from); ASSERT_EQ(i + 1, ctxt[i].to); } } } } hyperscan-4.4.1/unit/internal/partial.cpp0000644000175000017500000001322213055426554021232 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "util/partial_store.h" #include "gtest/gtest.h" #include "ue2common.h" #include using namespace std; TEST(partial, u32_1) { u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u32(a + 8, 0xaa, 1); b[8] = 0xaa; ASSERT_EQ(0xaa, partial_load_u32(a + 8, 1)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u32_2) { u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u32(a + 8, 0xaabb, 2); b[8] = 0xbb; b[9] = 0xaa; ASSERT_EQ(0xaabb, partial_load_u32(a + 8, 2)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u32_3) { u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u32(a + 8, 0xaabbcc, 3); b[8] = 0xcc; b[9] = 0xbb; b[10] = 0xaa; ASSERT_EQ(0xaabbcc, partial_load_u32(a + 8, 3)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u32_4) { u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u32(a + 8, 0xaabbccdd, 4); b[8] = 0xdd; b[9] = 0xcc; b[10] = 0xbb; b[11] = 0xaa; ASSERT_EQ(0xaabbccdd, partial_load_u32(a + 8, 4)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u64a_1) { u64a val = 0xaa; u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u64a(a + 8, val, 1); b[8] = 0xaa; ASSERT_EQ(val, partial_load_u64a(a + 8, 1)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u64a_2) { u64a val = 0xaabb; u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u64a(a + 8, val, 2); b[8] = 0xbb; b[9] = 0xaa; ASSERT_EQ(val, partial_load_u64a(a + 8, 2)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u64a_3) { u64a val = 0xaabbcc; u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u64a(a + 8, val, 3); b[8] = 0xcc; b[9] = 0xbb; b[10] = 0xaa; ASSERT_EQ(val, partial_load_u64a(a + 8, 3)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u64a_4) { u64a val = 0xaabbccdd; u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u64a(a + 8, val, 4); b[8] = 0xdd; b[9] = 0xcc; b[10] = 0xbb; b[11] = 0xaa; ASSERT_EQ(val, partial_load_u64a(a + 8, 4)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u64a_5) { u64a val = 0xaabbccdd55ULL; u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u64a(a + 8, val, 5); b[8] = 0x55; b[9] = 0xdd; b[10] = 0xcc; b[11] = 0xbb; b[12] = 0xaa; ASSERT_EQ(val, partial_load_u64a(a + 8, 5)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u64a_6) { u64a val = 0xaabbccdd5566ULL; u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u64a(a + 8, val, 6); b[8] = 0x66; b[9] = 0x55; b[10] = 0xdd; b[11] = 0xcc; b[12] = 0xbb; b[13] = 0xaa; ASSERT_EQ(val, partial_load_u64a(a + 8, 6)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u64a_7) { u64a val = 0xaabbccdd556677ULL; u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u64a(a + 8, val, 7); b[8] = 0x77; b[9] = 0x66; b[10] = 0x55; b[11] = 0xdd; b[12] = 0xcc; b[13] = 0xbb; b[14] = 0xaa; ASSERT_EQ(val, partial_load_u64a(a + 8, 7)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } TEST(partial, u64a_8) { u64a val = 0xaabbccdd55667788ULL; u8 a[16]; memset(a, 0x1f, sizeof(a)); u8 b[16]; memcpy(b, a, sizeof(a)); partial_store_u64a(a + 8, val, 8); b[8] = 0x88; b[9] = 0x77; b[10] = 0x66; b[11] = 0x55; b[12] = 0xdd; b[13] = 0xcc; b[14] = 0xbb; b[15] = 0xaa; ASSERT_EQ(val, partial_load_u64a(a + 8, 8)); ASSERT_EQ(0, memcmp(a, b, sizeof(a))); } hyperscan-4.4.1/unit/internal/nfagraph_comp.cpp0000644000175000017500000000521513055426554022405 0ustar sleuthkidsleuthkid/* * 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. */ /** * Unit tests for checking the calc comp code in nfagraph/ng_calc_components.cpp */ #include "config.h" #include "gtest/gtest.h" #include "nfagraph_common.h" #include "grey.h" #include "hs.h" #include "compiler/compiler.h" #include "nfagraph/ng.h" #include "nfagraph/ng_builder.h" #include "nfagraph/ng_calc_components.h" #include "util/target_info.h" using namespace std; using namespace ue2; TEST(NFAGraph, CalcComp1) { auto graph = constructGraph("abc|def|ghi", 0); ASSERT_TRUE(graph != nullptr); deque> comps = calcComponents(*graph); ASSERT_EQ(3, comps.size()); } TEST(NFAGraph, CalcComp2) { auto graph = constructGraph("a|b|c|d|e|f|g|h|i", 0); ASSERT_TRUE(graph != nullptr); deque> comps = calcComponents(*graph); // We should be identifying this as a trivial case and not splitting it. ASSERT_EQ(1, comps.size()); } TEST(NFAGraph, RecalcComp1) { deque> comps; comps.push_back(constructGraph("abc|def|ghi", 0)); ASSERT_TRUE(comps.back() != nullptr); recalcComponents(comps); ASSERT_EQ(3, comps.size()); } hyperscan-4.4.1/unit/internal/shufti.cpp0000644000175000017500000010053613055426554021105 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include #include "gtest/gtest.h" #include "nfa/shufti.h" #include "nfa/shufticompile.h" #include "util/target_info.h" using namespace ue2; using std::set; using std::pair; using std::make_pair; TEST(Shufti, BuildMask1) { m128 lomask, himask; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lomask, (u8 *)&himask); ASSERT_NE(-1, ret); u8 *lo = (u8 *)&lomask; u8 *hi = (u8 *)&himask; for (int i = 0; i < 16; i++) { if (i == 'a' % 16) { ASSERT_EQ(1, lo[i]); } else { ASSERT_EQ(0, lo[i]); } if (i == 'a' >> 4) { ASSERT_EQ(1, hi[i]); } else { ASSERT_EQ(0, hi[i]); } } } TEST(Shufti, BuildMask2) { m128 lomask, himask; CharReach chars; chars.set('a'); chars.set('B'); int ret = shuftiBuildMasks(chars, (u8 *)&lomask, (u8 *)&himask); ASSERT_NE(-1, ret); u8 *lo = (u8 *)&lomask; u8 *hi = (u8 *)&himask; ASSERT_TRUE(lo['a' % 16] & hi['a' >> 4]); ASSERT_TRUE(lo['B' % 16] & hi['B' >> 4]); ASSERT_FALSE(lo['a' % 16] & hi['B' >> 4]); ASSERT_FALSE(lo['B' % 16] & hi['a' >> 4]); } TEST(Shufti, BuildMask4) { m128 lomask, himask; CharReach chars; chars.set('a'); chars.set('B'); chars.set('A'); chars.set('b'); int ret = shuftiBuildMasks(chars, (u8 *)&lomask, (u8 *)&himask); ASSERT_NE(-1, ret); u8 *lo = (u8 *)&lomask; u8 *hi = (u8 *)&himask; ASSERT_TRUE(lo['a' % 16] & hi['a' >> 4]); ASSERT_TRUE(lo['A' % 16] & hi['A' >> 4]); ASSERT_TRUE(lo['b' % 16] & hi['b' >> 4]); ASSERT_TRUE(lo['B' % 16] & hi['B' >> 4]); } TEST(Shufti, ExecNoMatch1) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 32; i++) { const u8 *rv = shuftiExec(lo, hi, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_LE(((size_t)t1 + strlen(t1)) & ~0xf, (size_t)rv); } } TEST(Shufti, ExecNoMatch2) { m128 lo, hi; CharReach chars; chars.set('a'); chars.set('B'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiExec(lo, hi, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_LE(((size_t)t1 + strlen(t1)) & ~0xf, (size_t)rv); } } TEST(Shufti, ExecNoMatch3) { m128 lo, hi; CharReach chars; chars.set('V'); /* V = 0x56, e = 0x65 */ int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiExec(lo, hi, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_LE(((size_t)t1 + strlen(t1)) & ~0xf, (size_t)rv); } } TEST(Shufti, ExecMatch1) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 32; i++) { const u8 *rv = shuftiExec(lo, hi, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 33, (size_t)rv); } } TEST(Shufti, ExecMatch2) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiExec(lo, hi, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(Shufti, ExecMatch3) { m128 lo, hi; CharReach chars; chars.set('a'); chars.set('B'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbBaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiExec(lo, hi, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(Shufti, ExecMatch4) { m128 lo, hi; CharReach chars; chars.set('a'); chars.set('C'); chars.set('A'); chars.set('c'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbAaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t2[] = "bbbbbbbbbbbbbbbbbCaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t3[] = "bbbbbbbbbbbbbbbbbcaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t4[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiExec(lo, hi, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = shuftiExec(lo, hi, (u8 *)t2 + i, (u8 *)t2 + strlen(t1)); ASSERT_EQ((size_t)t2 + 17, (size_t)rv); rv = shuftiExec(lo, hi, (u8 *)t3 + i, (u8 *)t3 + strlen(t3)); ASSERT_EQ((size_t)t3 + 17, (size_t)rv); rv = shuftiExec(lo, hi, (u8 *)t4 + i, (u8 *)t4 + strlen(t4)); ASSERT_EQ((size_t)t4 + 17, (size_t)rv); } } TEST(Shufti, ExecMatch5) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[48 - i] = 'a'; const u8 *rv = shuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); } } TEST(DoubleShufti, BuildMask1) { m128 lo1m, hi1m, lo2m, hi2m; flat_set> lits; lits.insert(make_pair('a', 'B')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m, (u8 *)&lo2m, (u8 *)&hi2m); ASSERT_TRUE(ret); u8 *lo1 = (u8 *)&lo1m; u8 *lo2 = (u8 *)&lo2m; u8 *hi1 = (u8 *)&hi1m; u8 *hi2 = (u8 *)&hi2m; for (int i = 0; i < 16; i++) { if (i == 'a' % 16) { ASSERT_EQ(254, lo1[i]); } else { ASSERT_EQ(255, lo1[i]); } if (i == 'a' >> 4) { ASSERT_EQ(254, hi1[i]); } else { ASSERT_EQ(255, hi1[i]); } if (i == 'B' % 16) { ASSERT_EQ(254, lo2[i]); } else { ASSERT_EQ(255, lo2[i]); } if (i == 'B' >> 4) { ASSERT_EQ(254, hi2[i]); } else { ASSERT_EQ(255, hi2[i]); } } } TEST(DoubleShufti, BuildMask2) { m128 lo1m, hi1m, lo2m, hi2m; flat_set> lits; lits.insert(make_pair('a','z')); lits.insert(make_pair('B','z')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m, (u8 *)&lo2m, (u8 *)&hi2m); ASSERT_TRUE(ret); u8 *lo1 = (u8 *)&lo1m; u8 *lo2 = (u8 *)&lo2m; u8 *hi1 = (u8 *)&hi1m; u8 *hi2 = (u8 *)&hi2m; ASSERT_NE(0xff, lo1['a' % 16] | hi1['a' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_NE(0xff, lo1['B' % 16] | hi1['B' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_EQ(0xff, lo1['a' % 16] | hi1['B' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_EQ(0xff, lo1['B' % 16] | hi1['a' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); } TEST(DoubleShufti, BuildMask4) { m128 lo1m, hi1m, lo2m, hi2m; flat_set> lits; lits.insert(make_pair('a','z')); lits.insert(make_pair('B','z')); lits.insert(make_pair('A','z')); lits.insert(make_pair('b','z')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m, (u8 *)&lo2m, (u8 *)&hi2m); ASSERT_TRUE(ret); u8 *lo1 = (u8 *)&lo1m; u8 *lo2 = (u8 *)&lo2m; u8 *hi1 = (u8 *)&hi1m; u8 *hi2 = (u8 *)&hi2m; ASSERT_NE(0xff, lo1['a' % 16] | hi1['a' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_NE(0xff, lo1['A' % 16] | hi1['A' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_NE(0xff, lo1['b' % 16] | hi1['b' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_NE(0xff, lo1['B' % 16] | hi1['B' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); } TEST(DoubleShufti, BuildMask5) { m128 lo1m, hi1m; m128 lo2m, hi2m; flat_set> lits; lits.insert(make_pair('a','z')); CharReach bytes; bytes.set('X'); bool ret = shuftiBuildDoubleMasks(bytes, lits, (u8 *)&lo1m, (u8 *)&hi1m, (u8 *)&lo2m, (u8 *)&hi2m); ASSERT_TRUE(ret); u8 *lo1 = (u8 *)&lo1m; u8 *lo2 = (u8 *)&lo2m; u8 *hi1 = (u8 *)&hi1m; u8 *hi2 = (u8 *)&hi2m; ASSERT_NE(0xff, lo1['a' % 16] | hi1['a' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_EQ(0xff, lo1['a' % 16] | hi1['a' >> 4] | lo2['X' % 16] | hi2['X' >> 4]); ASSERT_EQ(0xff, lo1['A' % 16] | hi1['A' >> 4] | lo2['X' % 16] | hi2['X' >> 4]); ASSERT_EQ(0xff, lo1['b' % 16] | hi1['b' >> 4] | lo2['X' % 16] | hi2['X' >> 4]); ASSERT_EQ(0xff, lo1['B' % 16] | hi1['B' >> 4] | lo2['X' % 16] | hi2['X' >> 4]); } TEST(DoubleShufti, BuildMask6) { m128 lo1m, hi1m, lo2m, hi2m; flat_set> lits; lits.insert(make_pair('a','z')); lits.insert(make_pair('B','z')); lits.insert(make_pair('A','z')); lits.insert(make_pair('b','z')); lits.insert(make_pair('a','y')); lits.insert(make_pair('B','y')); lits.insert(make_pair('A','y')); lits.insert(make_pair('b','y')); lits.insert(make_pair('a','x')); lits.insert(make_pair('B','x')); lits.insert(make_pair('A','x')); lits.insert(make_pair('b','x')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m, (u8 *)&lo2m, (u8 *)&hi2m); ASSERT_TRUE(ret); u8 *lo1 = (u8 *)&lo1m; u8 *lo2 = (u8 *)&lo2m; u8 *hi1 = (u8 *)&hi1m; u8 *hi2 = (u8 *)&hi2m; ASSERT_NE(0xff, lo1['a' % 16] | hi1['a' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_NE(0xff, lo1['A' % 16] | hi1['A' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_NE(0xff, lo1['b' % 16] | hi1['b' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_NE(0xff, lo1['B' % 16] | hi1['B' >> 4] | lo2['z' % 16] | hi2['z' >> 4]); ASSERT_NE(0xff, lo1['a' % 16] | hi1['a' >> 4] | lo2['y' % 16] | hi2['y' >> 4]); ASSERT_NE(0xff, lo1['A' % 16] | hi1['A' >> 4] | lo2['y' % 16] | hi2['y' >> 4]); ASSERT_NE(0xff, lo1['b' % 16] | hi1['b' >> 4] | lo2['y' % 16] | hi2['y' >> 4]); ASSERT_NE(0xff, lo1['B' % 16] | hi1['B' >> 4] | lo2['y' % 16] | hi2['y' >> 4]); ASSERT_NE(0xff, lo1['a' % 16] | hi1['a' >> 4] | lo2['x' % 16] | hi2['x' >> 4]); ASSERT_NE(0xff, lo1['A' % 16] | hi1['A' >> 4] | lo2['x' % 16] | hi2['x' >> 4]); ASSERT_NE(0xff, lo1['b' % 16] | hi1['b' >> 4] | lo2['x' % 16] | hi2['x' >> 4]); ASSERT_NE(0xff, lo1['B' % 16] | hi1['B' >> 4] | lo2['x' % 16] | hi2['x' >> 4]); } TEST(DoubleShufti, BuildMask7) { m128 lo1m, hi1m, lo2m, hi2m; flat_set> lits; lits.insert(make_pair('a','b')); lits.insert(make_pair('c','d')); lits.insert(make_pair('e','f')); lits.insert(make_pair('g','h')); lits.insert(make_pair('i','j')); lits.insert(make_pair('k','l')); lits.insert(make_pair('m','n')); lits.insert(make_pair('o','p')); lits.insert(make_pair('q','r')); lits.insert(make_pair('s','t')); lits.insert(make_pair('u','v')); lits.insert(make_pair('w','x')); bool rv = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1m, (u8 *)&hi1m, (u8 *)&lo2m, (u8 *)&hi2m); ASSERT_FALSE(rv); } TEST(DoubleShufti, ExecNoMatch1) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('a','b')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_LE(((size_t)t1 + strlen(t1)) & ~0xf, (size_t)rv); } } TEST(DoubleShufti, ExecNoMatch1b) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('b','a')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + i + 15, (size_t)rv); } } TEST(DoubleShufti, ExecNoMatch2) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('a','b')); lits.insert(make_pair('B','b')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_LE(((size_t)t1 + strlen(t1)) & ~0xf, (size_t)rv); } } TEST(DoubleShufti, ExecNoMatch2b) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('b','a')); lits.insert(make_pair('b','B')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + i + 15, (size_t)rv); } } TEST(DoubleShufti, ExecNoMatch3) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('V','e')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_LE(((size_t)t1 + strlen(t1)) & ~0xf, (size_t)rv); } } TEST(DoubleShufti, ExecNoMatch3b) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('e','V')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + i + 15, (size_t)rv); } } TEST(DoubleShufti, ExecMatchShort1) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('a','b')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(DoubleShufti, ExecMatch1) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('a','b')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(DoubleShufti, ExecMatch2) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('a','a')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(DoubleShufti, ExecMatch3) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('B','a')); lits.insert(make_pair('a','a')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbBaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(DoubleShufti, ExecMatch4) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('A','a')); lits.insert(make_pair('a','a')); lits.insert(make_pair('C','a')); lits.insert(make_pair('c','a')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbAaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t2[] = "bbbbbbbbbbbbbbbbbCaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t3[] = "bbbbbbbbbbbbbbbbbcaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t4[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t2 + i, (u8 *)t2 + strlen(t2)); ASSERT_EQ((size_t)t2 + 17, (size_t)rv); rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t3+ i, (u8 *)t3 + strlen(t3)); ASSERT_EQ((size_t)t3 + 17, (size_t)rv); rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t4 + i, (u8 *)t4 + strlen(t4)); ASSERT_EQ((size_t)t4 + 17, (size_t)rv); } } TEST(DoubleShufti, ExecMatch4b) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('a','A')); lits.insert(make_pair('a','a')); lits.insert(make_pair('a','C')); lits.insert(make_pair('a','c')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbaAaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t2[] = "bbbbbbbbbbbbbbbbbaCaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t3[] = "bbbbbbbbbbbbbbbbbacaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t4[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t2 + i, (u8 *)t2 + strlen(t2)); ASSERT_EQ((size_t)t2 + 17, (size_t)rv); rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t3+ i, (u8 *)t3 + strlen(t3)); ASSERT_EQ((size_t)t3 + 17, (size_t)rv); rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t4 + i, (u8 *)t4 + strlen(t4)); ASSERT_EQ((size_t)t4 + 17, (size_t)rv); } } TEST(DoubleShufti, ExecMatch5) { m128 lo1, hi1, lo2, hi2; flat_set> lits; lits.insert(make_pair('a','A')); bool ret = shuftiBuildDoubleMasks(CharReach(), lits, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[48 - i] = 'a'; t1[48 - i + 1] = 'A'; const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); } } TEST(DoubleShufti, ExecMatchMixed1) { m128 lo1, hi1, lo2, hi2; CharReach onebyte; flat_set> twobyte; // just one one-byte literal onebyte.set('a'); bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[48 - i] = 'a'; const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); } } TEST(DoubleShufti, ExecMatchMixed2) { m128 lo1, hi1, lo2, hi2; CharReach onebyte; flat_set> twobyte; // one of each onebyte.set('a'); twobyte.insert(make_pair('x', 'y')); bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; char t2[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[48 - i] = 'a'; const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); } for (size_t i = 0; i < 31; i++) { t2[48 - i] = 'x'; t2[48 - i + 1] = 'y'; const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t2, (u8 *)t2 + strlen(t1)); ASSERT_EQ((size_t)&t2[48 - i], (size_t)rv); } } TEST(DoubleShufti, ExecMatchMixed3) { m128 lo1, hi1, lo2, hi2; CharReach onebyte; flat_set> twobyte; // one of each onebyte.set('a'); twobyte.insert(make_pair('x', 'y')); bool ret = shuftiBuildDoubleMasks(onebyte, twobyte, (u8 *)&lo1, (u8 *)&hi1, (u8 *)&lo2, (u8 *)&hi2); ASSERT_TRUE(ret); const int len = 420; char t1[len + 1]; char t2[len + 2]; memset(t1, 'b', len); memset(t2, 'b', len); for (size_t i = 0; i < 400; i++) { t1[len - i] = 'a'; const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t1, (u8 *)t1 + len); ASSERT_EQ((size_t)&t1[len - i], (size_t)rv); } for (size_t i = 0; i < 400; i++) { t2[len - i] = 'x'; t2[len - i + 1] = 'y'; const u8 *rv = shuftiDoubleExec(lo1, hi1, lo2, hi2, (u8 *)t2, (u8 *)t2 + len); ASSERT_EQ((size_t)&t2[len - i], (size_t)rv); } } TEST(ReverseShufti, ExecNoMatch1) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_EQ((const u8 *)(t1 - 1), rv); } } TEST(ReverseShufti, ExecNoMatch2) { m128 lo, hi; CharReach chars; chars.set('a'); chars.set('B'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_EQ((const u8 *)(t1 - 1), rv); } } TEST(ReverseShufti, ExecNoMatch3) { m128 lo, hi; CharReach chars; chars.set('V'); /* V = 0x56, e = 0x65 */ int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_EQ((const u8 *)(t1 - 1), rv); } } TEST(ReverseShufti, ExecMatch1) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbabbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t1 + 17, rv); } } TEST(ReverseShufti, ExecMatch2) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbabbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t1 + 32, rv); } } TEST(ReverseShufti, ExecMatch3) { m128 lo, hi; CharReach chars; chars.set('a'); chars.set('B'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaBbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('B', (char)*rv); ASSERT_EQ((const u8 *)t1 + 32, rv); } // check that we match the 'a' bytes as well. ASSERT_EQ('B', t1[32]); t1[32] = 'b'; for (size_t i = 0; i < 16; i++) { const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t1 + 31, rv); } } TEST(ReverseShufti, ExecMatch4) { m128 lo, hi; CharReach chars; chars.set('a'); chars.set('C'); chars.set('A'); chars.set('c'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaAbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; char t2[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaCbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; char t3[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaacbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; char t4[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len - i); EXPECT_EQ('A', (char)*rv); ASSERT_EQ((const u8 *)t1 + 32, rv); rv = rshuftiExec(lo, hi, (u8 *)t2, (u8 *)t2 + len - i); EXPECT_EQ('C', (char)*rv); ASSERT_EQ((const u8 *)t2 + 32, rv); rv = rshuftiExec(lo, hi, (u8 *)t3, (u8 *)t3 + len - i); EXPECT_EQ('c', (char)*rv); ASSERT_EQ((const u8 *)t3 + 32, rv); rv = rshuftiExec(lo, hi, (u8 *)t4, (u8 *)t4 + len - i); EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t4 + 32, rv); } } TEST(ReverseShufti, ExecMatch5) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < len; i++) { t1[i] = 'a'; const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len); ASSERT_EQ((const u8 *)t1 + i, rv); } } TEST(ReverseShufti, ExecMatch6) { m128 lo, hi; CharReach chars; chars.set('a'); int ret = shuftiBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); ASSERT_NE(-1, ret); const size_t len = 256; char t1[len]; memset(t1, 'b', len); for (size_t i = 0; i < len; i++) { t1[i] = 'a'; const u8 *rv = rshuftiExec(lo, hi, (u8 *)t1, (u8 *)t1 + len); ASSERT_EQ((const u8 *)t1 + i, rv); } } hyperscan-4.4.1/unit/internal/simd_utils.cpp0000644000175000017500000006124713055426554021764 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/alloc.h" #include "util/make_unique.h" #include "util/simd_utils.h" using namespace std; using namespace ue2; namespace { // Switch one bit on in a bitmask. template Mask setbit(unsigned int bit) { union { Mask simd; char bytes[sizeof(Mask)]; } cf; memset(cf.bytes, 0, sizeof(Mask)); unsigned int byte_idx = bit / 8; cf.bytes[byte_idx] = 1U << (bit % 8); return cf.simd; } // Parameterized tests follow! // // Irritatingly we have to define a whole bunch of overrides here... because // templates. One Admiration Unit for anyone able to build a better way of // doing this. struct simd_zeroes { operator m128() { return zeroes128(); } operator m256() { return zeroes256(); } operator m384() { return zeroes384(); } operator m512() { return zeroes512(); } }; struct simd_ones { operator m128() { return ones128(); } operator m256() { return ones256(); } operator m384() { return ones384(); } operator m512() { return ones512(); } }; bool simd_diff(const m128 &a, const m128 &b) { return !!diff128(a, b); } bool simd_diff(const m256 &a, const m256 &b) { return !!diff256(a, b); } bool simd_diff(const m384 &a, const m384 &b) { return !!diff384(a, b); } bool simd_diff(const m512 &a, const m512 &b) { return !!diff512(a, b); } bool simd_isnonzero(const m128 &a) { return !!isnonzero128(a); } bool simd_isnonzero(const m256 &a) { return !!isnonzero256(a); } bool simd_isnonzero(const m384 &a) { return !!isnonzero384(a); } bool simd_isnonzero(const m512 &a) { return !!isnonzero512(a); } m128 simd_and(const m128 &a, const m128 &b) { return and128(a, b); } m256 simd_and(const m256 &a, const m256 &b) { return and256(a, b); } m384 simd_and(const m384 &a, const m384 &b) { return and384(a, b); } m512 simd_and(const m512 &a, const m512 &b) { return and512(a, b); } m128 simd_or(const m128 &a, const m128 &b) { return or128(a, b); } m256 simd_or(const m256 &a, const m256 &b) { return or256(a, b); } m384 simd_or(const m384 &a, const m384 &b) { return or384(a, b); } m512 simd_or(const m512 &a, const m512 &b) { return or512(a, b); } m128 simd_xor(const m128 &a, const m128 &b) { return xor128(a, b); } m256 simd_xor(const m256 &a, const m256 &b) { return xor256(a, b); } m384 simd_xor(const m384 &a, const m384 &b) { return xor384(a, b); } m512 simd_xor(const m512 &a, const m512 &b) { return xor512(a, b); } m128 simd_andnot(const m128 &a, const m128 &b) { return andnot128(a, b); } m256 simd_andnot(const m256 &a, const m256 &b) { return andnot256(a, b); } m384 simd_andnot(const m384 &a, const m384 &b) { return andnot384(a, b); } m512 simd_andnot(const m512 &a, const m512 &b) { return andnot512(a, b); } m128 simd_not(const m128 &a) { return not128(a); } m256 simd_not(const m256 &a) { return not256(a); } m384 simd_not(const m384 &a) { return not384(a); } m512 simd_not(const m512 &a) { return not512(a); } void simd_clearbit(m128 *a, unsigned int i) { return clearbit128(a, i); } void simd_clearbit(m256 *a, unsigned int i) { return clearbit256(a, i); } void simd_clearbit(m384 *a, unsigned int i) { return clearbit384(a, i); } void simd_clearbit(m512 *a, unsigned int i) { return clearbit512(a, i); } void simd_setbit(m128 *a, unsigned int i) { return setbit128(a, i); } void simd_setbit(m256 *a, unsigned int i) { return setbit256(a, i); } void simd_setbit(m384 *a, unsigned int i) { return setbit384(a, i); } void simd_setbit(m512 *a, unsigned int i) { return setbit512(a, i); } bool simd_testbit(const m128 &a, unsigned int i) { return testbit128(a, i); } bool simd_testbit(const m256 &a, unsigned int i) { return testbit256(a, i); } bool simd_testbit(const m384 &a, unsigned int i) { return testbit384(a, i); } bool simd_testbit(const m512 &a, unsigned int i) { return testbit512(a, i); } u32 simd_diffrich(const m128 &a, const m128 &b) { return diffrich128(a, b); } u32 simd_diffrich(const m256 &a, const m256 &b) { return diffrich256(a, b); } u32 simd_diffrich(const m384 &a, const m384 &b) { return diffrich384(a, b); } u32 simd_diffrich(const m512 &a, const m512 &b) { return diffrich512(a, b); } u32 simd_diffrich64(const m128 &a, const m128 &b) { return diffrich64_128(a, b); } u32 simd_diffrich64(const m256 &a, const m256 &b) { return diffrich64_256(a, b); } u32 simd_diffrich64(const m384 &a, const m384 &b) { return diffrich64_384(a, b); } u32 simd_diffrich64(const m512 &a, const m512 &b) { return diffrich64_512(a, b); } void simd_store(void *ptr, const m128 &a) { store128(ptr, a); } void simd_store(void *ptr, const m256 &a) { store256(ptr, a); } void simd_store(void *ptr, const m384 &a) { store384(ptr, a); } void simd_store(void *ptr, const m512 &a) { store512(ptr, a); } void simd_load(m128 *a, const void *ptr) { *a = load128(ptr); } void simd_load(m256 *a, const void *ptr) { *a = load256(ptr); } void simd_load(m384 *a, const void *ptr) { *a = load384(ptr); } void simd_load(m512 *a, const void *ptr) { *a = load512(ptr); } void simd_loadu(m128 *a, const void *ptr) { *a = loadu128(ptr); } void simd_loadu(m256 *a, const void *ptr) { *a = loadu256(ptr); } void simd_loadu(m384 *a, const void *ptr) { *a = loadu384(ptr); } void simd_loadu(m512 *a, const void *ptr) { *a = loadu512(ptr); } void simd_storebytes(void *ptr, const m128 &a, unsigned i) { storebytes128(ptr, a, i); } void simd_storebytes(void *ptr, const m256 &a, unsigned i) { storebytes256(ptr, a, i); } void simd_storebytes(void *ptr, const m384 &a, unsigned i) { storebytes384(ptr, a, i); } void simd_storebytes(void *ptr, const m512 &a, unsigned i) { storebytes512(ptr, a, i); } void simd_loadbytes(m128 *a, const void *ptr, unsigned i) { *a = loadbytes128(ptr, i); } void simd_loadbytes(m256 *a, const void *ptr, unsigned i) { *a = loadbytes256(ptr, i); } void simd_loadbytes(m384 *a, const void *ptr, unsigned i) { *a = loadbytes384(ptr, i); } void simd_loadbytes(m512 *a, const void *ptr, unsigned i) { *a = loadbytes512(ptr, i); } template class SimdUtilsTest : public testing::Test { // empty }; typedef ::testing::Types SimdTypes; TYPED_TEST_CASE(SimdUtilsTest, SimdTypes); // // The tests themselves. // TYPED_TEST(SimdUtilsTest, zero) { const TypeParam zeroes = simd_zeroes(); // Should have no bits on. char cmp[sizeof(zeroes)]; memset(cmp, 0, sizeof(zeroes)); ASSERT_EQ(0, memcmp(cmp, &zeroes, sizeof(zeroes))); } TYPED_TEST(SimdUtilsTest, ones) { const TypeParam ones = simd_ones(); // Should have all bits on. char cmp[sizeof(ones)]; memset(cmp, 0xff, sizeof(ones)); ASSERT_EQ(0, memcmp(cmp, &ones, sizeof(ones))); } TYPED_TEST(SimdUtilsTest, and1) { const TypeParam zeroes = simd_zeroes(); const TypeParam ones = simd_ones(); TypeParam result; result = simd_and(zeroes, ones); EXPECT_FALSE(simd_diff(result, zeroes)); result = simd_and(ones, zeroes); EXPECT_FALSE(simd_diff(result, zeroes)); result = simd_and(zeroes, zeroes); EXPECT_FALSE(simd_diff(result, zeroes)); result = simd_and(ones, ones); EXPECT_FALSE(simd_diff(result, ones)); } TYPED_TEST(SimdUtilsTest, and2) { TypeParam a, b; memset(&a, 0x33, sizeof(a)); memset(&b, 0x55, sizeof(b)); union { TypeParam simd; char bytes[sizeof(TypeParam)]; } c; c.simd = simd_and(a, b); const char expected = 0x33 & 0x55; for (size_t i = 0; i < sizeof(c); i++) { EXPECT_EQ(expected, c.bytes[i]); } } TEST(SimdUtils, diff256) { const unsigned total_bits = 256; // Test identical cases ASSERT_EQ(0U, diff256(zeroes256(), zeroes256())); ASSERT_EQ(0U, diff256(ones256(), ones256())); for (unsigned i = 0; i < total_bits; i++) { m256 a = setbit(i); m256 b = setbit(i); ASSERT_EQ(0U, diff256(a, b)); } // Cases that differ in one 32-bit word for (unsigned i = 0; i < total_bits; i++) { m256 a = setbit(i); u32 rv = diff256(zeroes256(), a); ASSERT_EQ(1U, rv); } } TYPED_TEST(SimdUtilsTest, or1) { const TypeParam zeroes = simd_zeroes(); const TypeParam ones = simd_ones(); TypeParam result; result = simd_or(zeroes, ones); EXPECT_FALSE(simd_diff(result, ones)); result = simd_or(ones, zeroes); EXPECT_FALSE(simd_diff(result, ones)); result = simd_or(zeroes, zeroes); EXPECT_FALSE(simd_diff(result, zeroes)); result = simd_or(ones, ones); EXPECT_FALSE(simd_diff(result, ones)); } TYPED_TEST(SimdUtilsTest, or2) { TypeParam a, b; memset(&a, 0x33, sizeof(a)); memset(&b, 0x55, sizeof(b)); for (unsigned j = 0; j < 8; j++) { for (unsigned i = 0; i < 32; i++) { m256 x = setbit(j*32+i); m256 y = zeroes256(); ASSERT_EQ(1U << j, diffrich256(x, y)) << "bit " << j*32+i << " not happy"; } } union { TypeParam simd; char bytes[sizeof(TypeParam)]; } c; c.simd = simd_or(a, b); const char expected = 0x33 | 0x55; for (size_t i = 0; i < sizeof(c); i++) { EXPECT_EQ(expected, c.bytes[i]); } } TYPED_TEST(SimdUtilsTest, xor1) { const TypeParam zeroes = simd_zeroes(); const TypeParam ones = simd_ones(); TypeParam result; result = simd_xor(zeroes, ones); EXPECT_FALSE(simd_diff(result, ones)); result = simd_xor(ones, zeroes); EXPECT_FALSE(simd_diff(result, ones)); result = simd_xor(zeroes, zeroes); EXPECT_FALSE(simd_diff(result, zeroes)); result = simd_xor(ones, ones); EXPECT_FALSE(simd_diff(result, zeroes)); } TYPED_TEST(SimdUtilsTest, xor2) { TypeParam a, b; memset(&a, 0x33, sizeof(a)); memset(&b, 0x55, sizeof(b)); union { TypeParam simd; char bytes[sizeof(TypeParam)]; } c; c.simd = simd_xor(a, b); const char expected = 0x33 ^ 0x55; for (size_t i = 0; i < sizeof(c); i++) { EXPECT_EQ(expected, c.bytes[i]); } } TYPED_TEST(SimdUtilsTest, andnot1) { const TypeParam zeroes = simd_zeroes(); const TypeParam ones = simd_ones(); TypeParam result; result = simd_andnot(zeroes, ones); EXPECT_FALSE(simd_diff(result, ones)); result = simd_andnot(ones, zeroes); EXPECT_FALSE(simd_diff(result, zeroes)); result = simd_andnot(zeroes, zeroes); EXPECT_FALSE(simd_diff(result, zeroes)); result = simd_andnot(ones, ones); EXPECT_FALSE(simd_diff(result, zeroes)); } TYPED_TEST(SimdUtilsTest, andnot2) { TypeParam a, b; memset(&a, 0x33, sizeof(a)); memset(&b, 0x55, sizeof(b)); union { TypeParam simd; char bytes[sizeof(TypeParam)]; } c; c.simd = simd_andnot(a, b); const char expected = ~0x33 & 0x55; for (size_t i = 0; i < sizeof(c); i++) { EXPECT_EQ(expected, c.bytes[i]); } } TYPED_TEST(SimdUtilsTest, not1) { const TypeParam zeroes = simd_zeroes(); const TypeParam ones = simd_ones(); TypeParam result; result = simd_not(zeroes); EXPECT_FALSE(simd_diff(result, ones)); result = simd_not(ones); EXPECT_FALSE(simd_diff(result, zeroes)); } TYPED_TEST(SimdUtilsTest, not2) { TypeParam a; memset(&a, 0x33, sizeof(a)); union { TypeParam simd; char bytes[sizeof(TypeParam)]; } c; c.simd = simd_not(a); const char expected = ~0x33; for (size_t i = 0; i < sizeof(c); i++) { EXPECT_EQ(expected, c.bytes[i]); } } TYPED_TEST(SimdUtilsTest, isnonzero) { TypeParam a = simd_zeroes(); EXPECT_FALSE(simd_isnonzero(a)); a = simd_ones(); EXPECT_TRUE(simd_isnonzero(a)); union { TypeParam simd; char bytes[sizeof(TypeParam)]; } c; // Try every 1-bit case. for (size_t i = 0; i < sizeof(a); i++) { for (size_t j = 0; j < 8; j++) { memset(&c.simd, 0, sizeof(c.simd)); c.bytes[i] = 1 << j; EXPECT_TRUE(simd_isnonzero(c.simd)); } } } TYPED_TEST(SimdUtilsTest, clearbit) { const unsigned int total_bits = sizeof(TypeParam) * 8; const TypeParam ones = simd_ones(); for (unsigned int i = 0; i < total_bits; i++) { TypeParam a = simd_ones(); simd_clearbit(&a, i); ASSERT_NE(0, simd_diff(a, ones)) << "bit " << i << " wasn't cleared"; TypeParam mask = setbit(i); ASSERT_EQ(0, simd_diff(ones, simd_or(a, mask))) << "clearing bit " << i << " caused collateral damage"; } } TYPED_TEST(SimdUtilsTest, testbit) { const unsigned int total_bits = sizeof(TypeParam) * 8; const TypeParam ones = simd_ones(); // First, all bits are on in 'ones'. for (unsigned int i = 0; i < total_bits; i++) { ASSERT_EQ(1, simd_testbit(ones, i)) << "bit " << i << " is on"; } // Try individual bits; only 'i' should be on. for (unsigned int i = 0; i < total_bits; i++) { TypeParam a = setbit(i); for (unsigned int j = 0; j < total_bits; j++) { ASSERT_EQ(i == j ? 1 : 0, simd_testbit(a, j)) << "bit " << i << " is wrong"; } } } TYPED_TEST(SimdUtilsTest, setbit) { const unsigned int total_bits = sizeof(TypeParam) * 8; // Try individual bits; only 'i' should be on. for (unsigned int i = 0; i < total_bits; i++) { TypeParam a = setbit(i); TypeParam x = simd_zeroes(); simd_setbit(&x, i); ASSERT_FALSE(simd_diff(a, x)); } TypeParam a = simd_zeroes(); // turn on all bits for (unsigned int i = 0; i < total_bits; i++) { simd_setbit(&a, i); } ASSERT_FALSE(simd_diff(simd_ones(), a)); } TYPED_TEST(SimdUtilsTest, diffrich) { const unsigned total_bits = sizeof(TypeParam) * 8; const TypeParam zeroes = simd_zeroes(); const TypeParam ones = simd_ones(); // Test identical cases EXPECT_EQ(0U, simd_diffrich(zeroes, zeroes)); EXPECT_EQ(0U, simd_diffrich(ones, ones)); for (unsigned i = 0; i < total_bits; i++) { TypeParam a = setbit(i); TypeParam b = setbit(i); EXPECT_EQ(0U, simd_diffrich(a, b)); } // and nothing is on in zeroes for (unsigned int i = 0; i < total_bits; i++) { ASSERT_EQ(0, simd_testbit(zeroes, i)) << "bit " << i << " is off"; } // All-zeroes and all-ones differ in all words EXPECT_EQ((1U << (total_bits / 32)) - 1, simd_diffrich(zeroes, ones)); // Cases that differ in one 32-bit word for (unsigned i = 0; i < total_bits; i++) { TypeParam a = setbit(i); u32 rv = simd_diffrich(zeroes, a); EXPECT_EQ(1U << i / 32, rv); } } TYPED_TEST(SimdUtilsTest, diffrich64) { const unsigned total_bits = sizeof(TypeParam) * 8; const TypeParam zeroes = simd_zeroes(); const TypeParam ones = simd_ones(); // Test identical cases EXPECT_EQ(0U, simd_diffrich64(zeroes, zeroes)); EXPECT_EQ(0U, simd_diffrich64(ones, ones)); for (unsigned i = 0; i < total_bits; i++) { TypeParam a = setbit(i); TypeParam b = setbit(i); EXPECT_EQ(0U, simd_diffrich64(a, b)); } // All-zeroes and all-ones differ in all words, which will result in every // second bit being on. EXPECT_EQ(((1U << (total_bits / 32)) - 1) & 0x55555555u, simd_diffrich64(zeroes, ones)); // Cases that differ in one 64-bit word for (unsigned i = 0; i < total_bits; i++) { TypeParam a = setbit(i); u32 rv = simd_diffrich64(zeroes, a); EXPECT_EQ(1U << ((i / 64) * 2), rv); } } // Unaligned load TYPED_TEST(SimdUtilsTest, loadu) { const TypeParam ones = simd_ones(); const size_t mem_len = sizeof(ones) * 2; unique_ptr mem_array = ue2::make_unique(mem_len); char *mem = mem_array.get(); for (size_t offset = 1; offset < sizeof(ones); offset++) { memset(mem, 0, mem_len); memset(mem + offset, 0xff, sizeof(ones)); TypeParam a; simd_loadu(&a, mem + offset); ASSERT_EQ(0, simd_diff(a, ones)); } } // Aligned load and store TYPED_TEST(SimdUtilsTest, load_store) { union { TypeParam simd; char bytes[sizeof(TypeParam)]; } a; for (size_t i = 0; i < sizeof(a); i++) { a.bytes[i] = (char)(i % 256); } aligned_unique_ptr mem_ptr = aligned_zmalloc_unique(sizeof(a)); char *mem = mem_ptr.get(); ASSERT_EQ(0, (size_t)mem % 16U); memset(mem, 0, sizeof(a)); simd_store(mem, a.simd); ASSERT_EQ(0, memcmp(mem, a.bytes, sizeof(a))); TypeParam b; simd_load(&b, mem); ASSERT_FALSE(simd_diff(a.simd, b)); } // Packed load and store TYPED_TEST(SimdUtilsTest, loadbytes_storebytes) { union { TypeParam simd; char bytes[sizeof(TypeParam)]; } a; for (size_t i = 0; i < sizeof(a); i++) { a.bytes[i] = (char)(i % 256); } char mem[sizeof(TypeParam)]; for (size_t i = 1; i < sizeof(TypeParam); i++) { memset(mem, 0xff, sizeof(TypeParam)); simd_storebytes(mem, a.simd, i); union { TypeParam simd; char bytes[sizeof(TypeParam)]; } b; simd_loadbytes(&b.simd, mem, i); // First i bytes should match a, remaining bytes are zero. (Note that // this takes endianness into account) for (size_t j = 0; j < sizeof(TypeParam); j++) { size_t idx = j; ASSERT_EQ(j < i ? a.bytes[idx] : 0, b.bytes[idx]); } } } TEST(SimdUtilsTest, movq) { m128 simd; simd = ones128(); u64a r = movq(simd); ASSERT_EQ((u64a)(~0), r); char cmp[sizeof(m128)]; memset(cmp, 0x80, sizeof(m128)); simd = set16x8(0x80); r = movq(simd); ASSERT_EQ(0, memcmp(cmp, &simd, sizeof(simd))); ASSERT_EQ(0, memcmp(cmp, &r, sizeof(r))); simd = _mm_set_epi64x(~0LL, 0x123456789abcdef); r = movq(simd); ASSERT_EQ(r, 0x123456789abcdef); } TEST(SimdUtilsTest, set16x8) { char cmp[sizeof(m128)]; for (unsigned i = 0; i < 256; i++) { m128 simd = set16x8(i); memset(cmp, i, sizeof(simd)); ASSERT_EQ(0, memcmp(cmp, &simd, sizeof(simd))); } } TEST(SimdUtilsTest, set4x32) { u32 cmp[4] = { 0x12345678, 0x12345678, 0x12345678, 0x12345678 }; m128 simd = set4x32(cmp[0]); ASSERT_EQ(0, memcmp(cmp, &simd, sizeof(simd))); } #if defined(__AVX2__) TEST(SimdUtilsTest, set32x8) { char cmp[sizeof(m256)]; for (unsigned i = 0; i < 256; i++) { m256 simd = set32x8(i); memset(cmp, i, sizeof(simd)); ASSERT_EQ(0, memcmp(cmp, &simd, sizeof(simd))); } } TEST(SimdUtilsTest, set2x128) { char cmp[sizeof(m256)]; for (unsigned i = 0; i < 256; i++) { m128 x = set16x8(i); m256 y = set32x8(i); m256 z = set2x128(x); memset(cmp, i, sizeof(z)); ASSERT_EQ(0, memcmp(cmp, &z, sizeof(z))); ASSERT_EQ(0, memcmp(&y, &z, sizeof(z))); } } #endif TEST(SimdUtilsTest, variableByteShift128) { char base[] = "0123456789ABCDEF"; m128 in = loadu128(base); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 0), variable_byte_shift_m128(in, 0))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 1), variable_byte_shift_m128(in, -1))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 2), variable_byte_shift_m128(in, -2))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 3), variable_byte_shift_m128(in, -3))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 4), variable_byte_shift_m128(in, -4))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 5), variable_byte_shift_m128(in, -5))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 6), variable_byte_shift_m128(in, -6))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 7), variable_byte_shift_m128(in, -7))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 8), variable_byte_shift_m128(in, -8))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 9), variable_byte_shift_m128(in, -9))); EXPECT_TRUE(!diff128(rshiftbyte_m128(in, 10), variable_byte_shift_m128(in, -10))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 0), variable_byte_shift_m128(in, 0))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 1), variable_byte_shift_m128(in, 1))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 2), variable_byte_shift_m128(in, 2))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 3), variable_byte_shift_m128(in, 3))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 4), variable_byte_shift_m128(in, 4))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 5), variable_byte_shift_m128(in, 5))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 6), variable_byte_shift_m128(in, 6))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 7), variable_byte_shift_m128(in, 7))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 8), variable_byte_shift_m128(in, 8))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 9), variable_byte_shift_m128(in, 9))); EXPECT_TRUE(!diff128(lshiftbyte_m128(in, 10), variable_byte_shift_m128(in, 10))); EXPECT_TRUE(!diff128(zeroes128(), variable_byte_shift_m128(in, 16))); EXPECT_TRUE(!diff128(zeroes128(), variable_byte_shift_m128(in, -16))); } TEST(SimdUtilsTest, max_u8_m128) { char base1[] = "0123456789ABCDE\xfe"; char base2[] = "!!23455889aBCd\xff\xff"; char expec[] = "0123456889aBCd\xff\xff"; m128 in1 = loadu128(base1); m128 in2 = loadu128(base2); m128 result = max_u8_m128(in1, in2); EXPECT_TRUE(!diff128(result, loadu128(expec))); } TEST(SimdUtilsTest, min_u8_m128) { char base1[] = "0123456789ABCDE\xfe"; char base2[] = "!!23455889aBCd\xff\xff"; char expec[] = "!!23455789ABCDE\xfe"; m128 in1 = loadu128(base1); m128 in2 = loadu128(base2); m128 result = min_u8_m128(in1, in2); EXPECT_TRUE(!diff128(result, loadu128(expec))); } TEST(SimdUtilsTest, sadd_u8_m128) { unsigned char base1[] = {0, 0x80, 0xff, 'A', '1', '2', '3', '4', '1', '2', '3', '4', '1', '2', '3', '4'}; unsigned char base2[] = {'a', 0x80, 'b', 'A', 0x10, 0x10, 0x10, 0x10, 0x30, 0x30, 0x30, 0x30, 0, 0, 0, 0}; unsigned char expec[] = {'a', 0xff, 0xff, 0x82, 'A', 'B', 'C', 'D', 'a', 'b', 'c', 'd', '1', '2', '3', '4'}; m128 in1 = loadu128(base1); m128 in2 = loadu128(base2); m128 result = sadd_u8_m128(in1, in2); EXPECT_TRUE(!diff128(result, loadu128(expec))); } TEST(SimdUtilsTest, sub_u8_m128) { unsigned char base1[] = {'a', 0xff, 0xff, 0x82, 'A', 'B', 'C', 'D', 'a', 'b', 'c', 'd', '1', '2', '3', '4'}; unsigned char base2[] = {0, 0x80, 0xff, 'A', '1', '2', '3', '4', '1', '2', '3', '4', '1', '2', '3', '4'}; unsigned char expec[] = {'a', 0x7f, 0, 'A', 0x10, 0x10, 0x10, 0x10, 0x30, 0x30, 0x30, 0x30, 0, 0, 0, 0}; m128 in1 = loadu128(base1); m128 in2 = loadu128(base2); m128 result = sub_u8_m128(in1, in2); EXPECT_TRUE(!diff128(result, loadu128(expec))); } } // namespace hyperscan-4.4.1/unit/internal/graph.cpp0000644000175000017500000012723713055426554020713 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2017, 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/graph.h" #include "util/ue2_graph.h" #include #include #include #include #include using namespace boost; using namespace std; using namespace ue2; typedef adjacency_list unit_graph; typedef unit_graph::vertex_descriptor unit_vertex; typedef unit_graph::edge_descriptor unit_edge; TEST(graph_util, parallel) { unit_graph g; ASSERT_FALSE(has_parallel_edge(g)); unit_vertex v1 = add_vertex(g); unit_vertex v2 = add_vertex(g); ASSERT_FALSE(has_parallel_edge(g)); add_edge(v1, v2, g); ASSERT_FALSE(has_parallel_edge(g)); add_edge(v2, v1, g); ASSERT_FALSE(has_parallel_edge(g)); add_edge(v2, v1, g); ASSERT_TRUE(has_parallel_edge(g)); } TEST(graph_util, dag) { unit_graph g; ASSERT_TRUE(is_dag(g)); unit_vertex v1 = add_vertex(g); unit_vertex v2 = add_vertex(g); ASSERT_TRUE(is_dag(g)); add_edge(v1, v2, g); unit_vertex v3 = add_vertex(g); add_edge(v1, v3, g); add_edge(v2, v3, g); ASSERT_TRUE(is_dag(g)); add_edge(v2, v2, g); ASSERT_FALSE(is_dag(g)); ASSERT_TRUE(is_dag(g, true)); /* only cycle is self loop */ unit_vertex v4 = add_vertex(g); add_edge(v3, v4, g); add_edge(v4, v1, g); ASSERT_FALSE(is_dag(g, true)); /* now have a large cycle */ } TEST(graph_util, degrees) { unit_graph g; unit_vertex a = add_vertex(g); unit_vertex b = add_vertex(g); unit_vertex c = add_vertex(g); unit_vertex d = add_vertex(g); unit_vertex e = add_vertex(g); unit_vertex f = add_vertex(g); add_edge(a, b, g); add_edge(b, c, g); add_edge(d, e, g); add_edge(f, a, g); add_edge(f, b, g); add_edge(f, c, g); unit_graph::vertex_iterator vi, ve; tie(vi, ve) = vertices(g); ASSERT_FALSE(anySelfLoop(g, vi, ve)); add_edge(b, b, g); tie(vi, ve) = vertices(g); ASSERT_TRUE(anySelfLoop(g, vi, ve)); add_edge(e, e, g); ASSERT_FALSE(isLeafNode(a, g)); ASSERT_FALSE(isLeafNode(b, g)); ASSERT_TRUE( isLeafNode(c, g)); ASSERT_FALSE(isLeafNode(d, g)); ASSERT_FALSE( isLeafNode(e, g)); ASSERT_FALSE(isLeafNode(f, g)); ASSERT_FALSE(hasSelfLoop(a, g)); ASSERT_TRUE( hasSelfLoop(b, g)); ASSERT_FALSE(hasSelfLoop(c, g)); ASSERT_FALSE(hasSelfLoop(d, g)); ASSERT_TRUE( hasSelfLoop(e, g)); ASSERT_FALSE(hasSelfLoop(f, g)); ASSERT_EQ((size_t)1, proper_out_degree(a, g)); ASSERT_EQ((size_t)1, proper_out_degree(b, g)); ASSERT_EQ((size_t)0, proper_out_degree(c, g)); ASSERT_EQ((size_t)1, proper_out_degree(d, g)); ASSERT_EQ((size_t)0, proper_out_degree(e, g)); ASSERT_EQ((size_t)3, proper_out_degree(f, g)); ASSERT_EQ((size_t)1, proper_in_degree(a, g)); ASSERT_EQ((size_t)2, proper_in_degree(b, g)); ASSERT_EQ((size_t)2, proper_in_degree(c, g)); ASSERT_EQ((size_t)0, proper_in_degree(d, g)); ASSERT_EQ((size_t)1, proper_in_degree(e, g)); ASSERT_TRUE( has_successor(a, g)); ASSERT_TRUE( has_successor(b, g)); ASSERT_FALSE(has_successor(c, g)); ASSERT_TRUE( has_successor(d, g)); ASSERT_TRUE( has_successor(e, g)); ASSERT_TRUE( has_successor(f, g)); ASSERT_TRUE( has_proper_successor(a, g)); ASSERT_TRUE( has_proper_successor(b, g)); ASSERT_FALSE(has_proper_successor(c, g)); ASSERT_TRUE( has_proper_successor(d, g)); ASSERT_FALSE(has_proper_successor(e, g)); ASSERT_TRUE( has_proper_successor(f, g)); } struct SimpleV { size_t index; string test_v = "SimpleV"; }; struct SimpleE { size_t index; string test_e = "SimpleE"; }; struct SimpleG : public ue2_graph { }; TEST(ue2_graph, graph_concept) { static_assert(std::is_same::vertex_descriptor>::value, "vertex_descriptor"); static_assert(std::is_same::edge_descriptor>::value, "edge_descriptor"); static_assert(std::is_same::directed_category>::value, "directed_category"); static_assert(std::is_same::edge_parallel_category>::value, "edge_parallel_category"); static_assert(std::is_same::traversal_category>::value, "traversal_category"); UNUSED SimpleG::vertex_descriptor n = SimpleG::null_vertex(); BOOST_CONCEPT_ASSERT((GraphConcept)); } TEST(ue2_graph, vertex_list_concept) { BOOST_CONCEPT_ASSERT((VertexListGraphConcept)); } TEST(ue2_graph, edge_list_concept) { BOOST_CONCEPT_ASSERT((EdgeListGraphConcept)); } TEST(ue2_graph, incidence_concept) { BOOST_CONCEPT_ASSERT((IncidenceGraphConcept)); } TEST(ue2_graph, bidi_concept) { BOOST_CONCEPT_ASSERT((BidirectionalGraphConcept)); } TEST(ue2_graph, mutable_concept) { BOOST_CONCEPT_ASSERT((MutableGraphConcept)); } TEST(ue2_graph, property_concept) { static_assert(std::is_same::value, "vertex_property_type"); static_assert(std::is_same::value, "edge_property_type"); /* Although documented as part of the MutablePropertyGraph concept, * (vertex|edge)_property_type don't appear to exist in the traits for any * existing graph types and the typedefs are not installed by default */ // static_assert(std::is_same< // typename graph_traits::vertex_property_type, // SimpleV>::value, // "vertex_property_type"); // static_assert(std::is_same< // typename graph_traits::edge_property_type, // SimpleE>::value, // "edge_property_type"); /* However, there does seem to be an undocumented templated structure * paralleling the main graph_traits */ static_assert(std::is_same< typename vertex_property_type::type, SimpleV>::value, "vertex_property_type"); static_assert(std::is_same< typename edge_property_type::type, SimpleE>::value, "edge_property_type"); BOOST_CONCEPT_ASSERT((VertexMutablePropertyGraphConcept)); BOOST_CONCEPT_ASSERT((EdgeMutablePropertyGraphConcept)); } TEST(ue2_graph, add_vertex) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); } TEST(ue2_graph, add_and_remove_vertex) { SimpleG g; ASSERT_EQ(0U, num_vertices(g)); SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_EQ(1U, num_vertices(g)); ASSERT_NE(SimpleG::null_vertex(), a); auto p = vertices(g); ASSERT_NE(p.first, p.second); ASSERT_EQ(a, *p.first); ++p.first; ASSERT_EQ(p.first, p.second); remove_vertex(a, g); ASSERT_EQ(0U, num_vertices(g)); auto q = vertices(g); ASSERT_EQ(q.first, q.second); } TEST(ue2_graph, add_edge) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); SimpleG::vertex_descriptor b = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), b); ASSERT_NE(a, b); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); ASSERT_EQ(a, source(p.first, g)); ASSERT_EQ(b, target(p.first, g)); auto q = edge(a, b, g); ASSERT_TRUE(q.second); ASSERT_EQ(p.second, q.first); } TEST(ue2_graph, add_remove_edge1) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); SimpleG::vertex_descriptor b = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), b); ASSERT_NE(a, b); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); ASSERT_EQ(a, source(p.first, g)); ASSERT_EQ(b, target(p.first, g)); remove_edge(p.first, g); auto q = edge(a, b, g); ASSERT_FALSE(q.second); ASSERT_EQ(q.first, SimpleG::null_edge()); ASSERT_EQ(0U, num_edges(g)); } TEST(ue2_graph, add_remove_edge2) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); SimpleG::vertex_descriptor b = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), b); ASSERT_NE(a, b); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); ASSERT_EQ(a, source(p.first, g)); ASSERT_EQ(b, target(p.first, g)); remove_edge(a, b, g); auto q = edge(a, b, g); ASSERT_FALSE(q.second); ASSERT_EQ(q.first, SimpleG::null_edge()); ASSERT_EQ(0U, num_edges(g)); } TEST(ue2_graph, add_edge_clear1) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); SimpleG::vertex_descriptor b = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), b); ASSERT_NE(a, b); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); ASSERT_EQ(a, source(p.first, g)); ASSERT_EQ(b, target(p.first, g)); clear_vertex(a, g); auto q = edge(a, b, g); ASSERT_FALSE(q.second); ASSERT_EQ(q.first, SimpleG::null_edge()); ASSERT_EQ(0U, num_edges(g)); } TEST(ue2_graph, add_edge_clear2) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); SimpleG::vertex_descriptor b = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), b); ASSERT_NE(a, b); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); ASSERT_EQ(a, source(p.first, g)); ASSERT_EQ(b, target(p.first, g)); clear_vertex(b, g); auto q = edge(a, b, g); ASSERT_FALSE(q.second); ASSERT_EQ(q.first, SimpleG::null_edge()); ASSERT_EQ(0U, num_edges(g)); } TEST(ue2_graph, add_edge_clear_out) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); SimpleG::vertex_descriptor b = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), b); ASSERT_NE(a, b); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); ASSERT_EQ(a, source(p.first, g)); ASSERT_EQ(b, target(p.first, g)); clear_out_edges(a, g); auto q = edge(a, b, g); ASSERT_FALSE(q.second); ASSERT_EQ(q.first, SimpleG::null_edge()); ASSERT_EQ(0U, num_edges(g)); } TEST(ue2_graph, add_edge_clear_in) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); SimpleG::vertex_descriptor b = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), b); ASSERT_NE(a, b); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); ASSERT_EQ(a, source(p.first, g)); ASSERT_EQ(b, target(p.first, g)); clear_in_edges(b, g); auto q = edge(a, b, g); ASSERT_FALSE(q.second); ASSERT_EQ(q.first, SimpleG::null_edge()); ASSERT_EQ(0U, num_edges(g)); } TEST(ue2_graph, add_remove_edge_iter) { SimpleG g; SimpleG::vertex_descriptor a = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), a); SimpleG::vertex_descriptor b = add_vertex(g); ASSERT_NE(SimpleG::null_vertex(), b); ASSERT_NE(a, b); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); ASSERT_EQ(a, source(p.first, g)); ASSERT_EQ(b, target(p.first, g)); remove_edge(edges(g).first, g); auto q = edge(a, b, g); ASSERT_FALSE(q.second); ASSERT_EQ(q.first, SimpleG::null_edge()); ASSERT_EQ(0U, num_edges(g)); } TEST(ue2_graph, vertices_0) { SimpleG g; auto p = vertices(g); ASSERT_EQ(p.first, p.second); } TEST(ue2_graph, vertices_1) { SimpleG g; SimpleG::vertex_iterator vi; SimpleG::vertex_iterator ve; auto a = add_vertex(g); ASSERT_EQ(1U, num_vertices(g)); tie(vi, ve) = vertices(g); ASSERT_EQ(a, *vi++); ASSERT_EQ(vi, ve); auto b = add_vertex(g); auto c = add_vertex(g); auto d = add_vertex(g); ASSERT_EQ(4U, num_vertices(g)); tie(vi, ve) = vertices(g); ASSERT_EQ(a, *vi++); ASSERT_EQ(b, *vi++); ASSERT_EQ(c, *vi++); ASSERT_EQ(d, *vi++); ASSERT_EQ(vi, ve); remove_vertex(c, g); ASSERT_EQ(3U, num_vertices(g)); tie(vi, ve) = vertices(g); ASSERT_EQ(a, *vi++); ASSERT_EQ(b, *vi++); ASSERT_EQ(d, *vi++); ASSERT_EQ(vi, ve); remove_vertex(a, g); ASSERT_EQ(2U, num_vertices(g)); tie(vi, ve) = vertices(g); ASSERT_EQ(b, *vi++); ASSERT_EQ(d, *vi++); ASSERT_EQ(vi, ve); auto e = add_vertex(g); ASSERT_EQ(3U, num_vertices(g)); tie(vi, ve) = vertices(g); ASSERT_EQ(b, *vi++); ASSERT_EQ(d, *vi++); ASSERT_EQ(e, *vi++); ASSERT_EQ(vi, ve); remove_vertex(e, g); ASSERT_EQ(2U, num_vertices(g)); tie(vi, ve) = vertices(g); ASSERT_EQ(b, *vi++); ASSERT_EQ(d, *vi++); ASSERT_EQ(vi, ve); remove_vertex(b, g); remove_vertex(d, g); ASSERT_EQ(0U, num_vertices(g)); tie(vi, ve) = vertices(g); ASSERT_EQ(vi, ve); } TEST(ue2_graph, out_edges_1) { SimpleG g; auto a = add_vertex(g); ASSERT_EQ(1U, num_vertices(g)); ASSERT_EQ(0U, out_degree(a, g)); SimpleG::out_edge_iterator ei; SimpleG::out_edge_iterator ee; tie(ei, ee) = out_edges(a, g); ASSERT_TRUE(ei == ee); auto p = add_edge(a, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); SimpleG::edge_descriptor e1 = p.first; ASSERT_EQ(1U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ei, ee); p = add_edge(a, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(2U, num_edges(g)); SimpleG::edge_descriptor e2 = p.first; ASSERT_EQ(2U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); } TEST(ue2_graph, out_edges_2) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto c = add_vertex(g); ASSERT_EQ(3U, num_vertices(g)); ASSERT_EQ(0U, out_degree(a, g)); SimpleG::out_edge_iterator ei; SimpleG::out_edge_iterator ee; tie(ei, ee) = out_edges(a, g); ASSERT_TRUE(ei == ee); auto p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); SimpleG::edge_descriptor e1 = p.first; ASSERT_EQ(1U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ei, ee); p = add_edge(a, c, g); ASSERT_TRUE(p.second); ASSERT_EQ(2U, num_edges(g)); SimpleG::edge_descriptor e2 = p.first; ASSERT_EQ(2U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); p = add_edge(c, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(3U, num_edges(g)); ASSERT_EQ(2U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); p = add_edge(b, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(4U, num_edges(g)); ASSERT_EQ(2U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); remove_edge(a, c, g); ASSERT_EQ(3U, num_edges(g)); ASSERT_EQ(1U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ei, ee); p = add_edge(a, a, g); ASSERT_EQ(4U, num_edges(g)); ASSERT_TRUE(p.second); SimpleG::edge_descriptor e3 = p.first; ASSERT_EQ(2U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e3, *ei++); ASSERT_EQ(ei, ee); clear_out_edges(a, g); ASSERT_EQ(2U, num_edges(g)); ASSERT_EQ(0U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(ei, ee); } TEST(ue2_graph, in_edges_1) { SimpleG g; auto a = add_vertex(g); ASSERT_EQ(1U, num_vertices(g)); ASSERT_EQ(0U, in_degree(a, g)); SimpleG::in_edge_iterator ei; SimpleG::in_edge_iterator ee; tie(ei, ee) = in_edges(a, g); ASSERT_TRUE(ei == ee); auto p = add_edge(a, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); SimpleG::edge_descriptor e1 = p.first; ASSERT_EQ(1U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ei, ee); p = add_edge(a, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(2U, num_edges(g)); SimpleG::edge_descriptor e2 = p.first; ASSERT_EQ(2U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); } TEST(ue2_graph, in_edges_2) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto c = add_vertex(g); ASSERT_EQ(3U, num_vertices(g)); ASSERT_EQ(0U, in_degree(a, g)); SimpleG::in_edge_iterator ei; SimpleG::in_edge_iterator ee; tie(ei, ee) = in_edges(a, g); ASSERT_TRUE(ei == ee); auto p = add_edge(b, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); SimpleG::edge_descriptor e1 = p.first; ASSERT_EQ(1U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ei, ee); p = add_edge(c, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(2U, num_edges(g)); SimpleG::edge_descriptor e2 = p.first; ASSERT_EQ(2U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); p = add_edge(c, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(3U, num_edges(g)); ASSERT_EQ(2U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); p = add_edge(a, b, g); ASSERT_TRUE(p.second); ASSERT_EQ(4U, num_edges(g)); ASSERT_EQ(2U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); remove_edge(c, a, g); ASSERT_EQ(3U, num_edges(g)); ASSERT_EQ(1U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ei, ee); p = add_edge(a, a, g); ASSERT_EQ(4U, num_edges(g)); ASSERT_TRUE(p.second); SimpleG::edge_descriptor e3 = p.first; ASSERT_EQ(2U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e3, *ei++); ASSERT_EQ(ei, ee); clear_in_edges(a, g); ASSERT_EQ(2U, num_edges(g)); ASSERT_EQ(0U, in_degree(a, g)); tie(ei, ee) = in_edges(a, g); ASSERT_EQ(ei, ee); } TEST(ue2_graph, parallel_1) { SimpleG g; SimpleG::vertex_iterator vi; SimpleG::vertex_iterator ve; auto a = add_vertex(g); ASSERT_EQ(1U, num_vertices(g)); ASSERT_EQ(0U, out_degree(a, g)); SimpleG::out_edge_iterator ei; SimpleG::out_edge_iterator ee; tie(ei, ee) = out_edges(a, g); ASSERT_TRUE(ei == ee); auto p = add_edge(a, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(1U, num_edges(g)); SimpleG::edge_descriptor e1 = p.first; ASSERT_EQ(1U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ei, ee); p = add_edge(a, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(2U, num_edges(g)); SimpleG::edge_descriptor e2 = p.first; ASSERT_EQ(2U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); remove_edge(e1, g); ASSERT_EQ(1U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ei, ee); p = add_edge(a, a, g); ASSERT_TRUE(p.second); ASSERT_EQ(2U, num_edges(g)); SimpleG::edge_descriptor e3 = p.first; ASSERT_EQ(2U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(e2, *ei++); ASSERT_EQ(e3, *ei++); ASSERT_EQ(ei, ee); remove_edge(a, a, g); ASSERT_EQ(0U, out_degree(a, g)); tie(ei, ee) = out_edges(a, g); ASSERT_EQ(ei, ee); } TEST(ue2_graph, edges_0a) { SimpleG g; auto p = edges(g); ASSERT_EQ(p.first, p.second); } TEST(ue2_graph, edges_0b) { SimpleG g; add_vertex(g); ASSERT_EQ(1U, num_vertices(g)); auto p = edges(g); ASSERT_EQ(p.first, p.second); } TEST(ue2_graph, edges_0c) { SimpleG g; add_vertex(g); add_vertex(g); ASSERT_EQ(2U, num_vertices(g)); auto p = edges(g); ASSERT_EQ(p.first, p.second); } TEST(ue2_graph, edges_1a) { SimpleG g; ASSERT_EQ(0U, num_edges(g)); auto v = add_vertex(g); ASSERT_EQ(0U, num_edges(g)); auto e1 = add_edge(v, v, g).first; SimpleG::edge_iterator ei, ee; ASSERT_EQ(1U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ee, ei); remove_edge(e1, g); ASSERT_EQ(0U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(ee, ei); } TEST(ue2_graph, edges_1b) { SimpleG g; ASSERT_EQ(0U, num_edges(g)); auto u = add_vertex(g); auto v = add_vertex(g); ASSERT_EQ(0U, num_edges(g)); auto e1 = add_edge(u, v, g).first; SimpleG::edge_iterator ei, ee; ASSERT_EQ(1U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ee, ei); remove_edge(e1, g); ASSERT_EQ(0U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(ee, ei); } TEST(ue2_graph, edges_1c) { SimpleG g; ASSERT_EQ(0U, num_edges(g)); auto u = add_vertex(g); auto v = add_vertex(g); ASSERT_EQ(0U, num_edges(g)); auto e1 = add_edge(v, u, g).first; SimpleG::edge_iterator ei, ee; ASSERT_EQ(1U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ee, ei); remove_edge(e1, g); ASSERT_EQ(0U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(ee, ei); } TEST(ue2_graph, edges_1d) { SimpleG g; ASSERT_EQ(0U, num_edges(g)); UNUSED auto u = add_vertex(g); UNUSED auto v = add_vertex(g); auto w = add_vertex(g); auto x = add_vertex(g); UNUSED auto y = add_vertex(g); UNUSED auto z = add_vertex(g); ASSERT_EQ(0U, num_edges(g)); auto e1 = add_edge(w, x, g).first; SimpleG::edge_iterator ei, ee; ASSERT_EQ(1U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ee, ei); remove_edge(e1, g); ASSERT_EQ(0U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(ee, ei); } TEST(ue2_graph, edges_2a) { SimpleG g; ASSERT_EQ(0U, num_edges(g)); auto v = add_vertex(g); ASSERT_EQ(0U, num_edges(g)); auto e1 = add_edge(v, v, g).first; auto e2 = add_edge(v, v, g).first; SimpleG::edge_iterator ei, ee; ASSERT_EQ(2U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ee, ei); remove_edge(e1, g); ASSERT_EQ(1U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ee, ei); remove_edge(e2, g); ASSERT_EQ(0U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(ee, ei); } TEST(ue2_graph, edges_2b) { SimpleG g; ASSERT_EQ(0U, num_edges(g)); auto u = add_vertex(g); auto v = add_vertex(g); ASSERT_EQ(0U, num_edges(g)); auto e1 = add_edge(u, v, g).first; auto e2 = add_edge(v, u, g).first; SimpleG::edge_iterator ei, ee; ASSERT_EQ(2U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e1, *ei++); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ee, ei); remove_edge(e1, g); ASSERT_EQ(1U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e2, *ei++); ASSERT_EQ(ee, ei); remove_edge(e2, g); ASSERT_EQ(0U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(ee, ei); } TEST(ue2_graph, edges_2c) { SimpleG g; ASSERT_EQ(0U, num_edges(g)); UNUSED auto s = add_vertex(g); UNUSED auto t = add_vertex(g); auto u = add_vertex(g); UNUSED auto v = add_vertex(g); auto w = add_vertex(g); auto x = add_vertex(g); UNUSED auto y = add_vertex(g); UNUSED auto z = add_vertex(g); ASSERT_EQ(0U, num_edges(g)); auto e1 = add_edge(w, x, g).first; auto e2 = add_edge(u, x, g).first; SimpleG::edge_iterator ei, ee; ASSERT_EQ(2U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e2, *ei++); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ee, ei); clear_in_edges(x, g); ASSERT_EQ(0U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(ee, ei); } TEST(ue2_graph, edges_3a) { SimpleG g; ASSERT_EQ(0U, num_edges(g)); UNUSED auto s = add_vertex(g); UNUSED auto t = add_vertex(g); auto u = add_vertex(g); auto v = add_vertex(g); auto w = add_vertex(g); auto x = add_vertex(g); UNUSED auto y = add_vertex(g); auto z = add_vertex(g); ASSERT_EQ(0U, num_edges(g)); auto e1 = add_edge(w, x, g).first; auto e2 = add_edge(u, v, g).first; auto e3 = add_edge(u, z, g).first; SimpleG::edge_iterator ei, ee; ASSERT_EQ(3U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(e2, *ei++); ASSERT_EQ(e3, *ei++); ASSERT_EQ(e1, *ei++); ASSERT_EQ(ee, ei); remove_edge(e1, g); ASSERT_EQ(2U, num_edges(g)); clear_out_edges(u, g); ASSERT_EQ(0U, num_edges(g)); tie(ei, ee) = edges(g); ASSERT_EQ(ee, ei); } TEST(ue2_graph, degree) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto c = add_vertex(g); auto d = add_vertex(g); add_edge(a, b, g); add_edge(a, c, g); add_edge(a, d, g); ASSERT_EQ(3U, degree(a, g)); ASSERT_EQ(1U, degree(b, g)); ASSERT_EQ(1U, degree(c, g)); ASSERT_EQ(1U, degree(d, g)); add_edge(b, c, g); ASSERT_EQ(3U, degree(a, g)); ASSERT_EQ(2U, degree(b, g)); ASSERT_EQ(2U, degree(c, g)); ASSERT_EQ(1U, degree(d, g)); add_edge(d, d, g); ASSERT_EQ(3U, degree(a, g)); ASSERT_EQ(2U, degree(b, g)); ASSERT_EQ(2U, degree(c, g)); ASSERT_EQ(3U, degree(d, g)); add_edge(b, a, g); ASSERT_EQ(4U, degree(a, g)); ASSERT_EQ(3U, degree(b, g)); ASSERT_EQ(2U, degree(c, g)); ASSERT_EQ(3U, degree(d, g)); add_edge(b, a, g); ASSERT_EQ(5U, degree(a, g)); ASSERT_EQ(4U, degree(b, g)); ASSERT_EQ(2U, degree(c, g)); ASSERT_EQ(3U, degree(d, g)); add_edge(d, d, g); ASSERT_EQ(5U, degree(a, g)); ASSERT_EQ(4U, degree(b, g)); ASSERT_EQ(2U, degree(c, g)); ASSERT_EQ(5U, degree(d, g)); } TEST(ue2_graph, adj) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto c = add_vertex(g); auto d = add_vertex(g); add_edge(a, b, g); add_edge(a, c, g); add_edge(a, d, g); add_edge(b, a, g); add_edge(b, b, g); SimpleG::adjacency_iterator ai, ae; tie(ai, ae) = adjacent_vertices(a, g); ASSERT_EQ(b, *ai++); ASSERT_EQ(c, *ai++); ASSERT_EQ(d, *ai++); ASSERT_EQ(ai, ae); tie(ai, ae) = adjacent_vertices(b, g); ASSERT_EQ(a, *ai++); ASSERT_EQ(b, *ai++); ASSERT_EQ(ai, ae); tie(ai, ae) = adjacent_vertices(c, g); ASSERT_EQ(ai, ae); tie(ai, ae) = adjacent_vertices(d, g); ASSERT_EQ(ai, ae); } TEST(ue2_graph, inv_adj) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto c = add_vertex(g); auto d = add_vertex(g); add_edge(a, b, g); add_edge(a, c, g); add_edge(a, d, g); add_edge(b, a, g); add_edge(b, b, g); SimpleG::inv_adjacency_iterator ai, ae; tie(ai, ae) = inv_adjacent_vertices(a, g); ASSERT_EQ(b, *ai++); ASSERT_EQ(ai, ae); tie(ai, ae) = inv_adjacent_vertices(b, g); ASSERT_EQ(a, *ai++); ASSERT_EQ(b, *ai++); ASSERT_EQ(ai, ae); tie(ai, ae) = inv_adjacent_vertices(c, g); ASSERT_EQ(a, *ai++); ASSERT_EQ(ai, ae); tie(ai, ae) = inv_adjacent_vertices(d, g); ASSERT_EQ(a, *ai++); ASSERT_EQ(ai, ae); } TEST(ue2_graph, square_brackets_v) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto c = add_vertex(g); auto d = add_vertex(g); ASSERT_EQ(0U, g[a].index); ASSERT_EQ(1U, g[b].index); ASSERT_EQ(2U, g[c].index); ASSERT_EQ(3U, g[d].index); ASSERT_EQ("SimpleV", g[a].test_v); ASSERT_EQ("SimpleV", g[b].test_v); ASSERT_EQ("SimpleV", g[c].test_v); ASSERT_EQ("SimpleV", g[d].test_v); g[a].test_v = "a"; g[b].test_v = "b"; g[c].test_v = "c"; g[d].test_v = "d"; ASSERT_EQ("a", g[a].test_v); ASSERT_EQ("b", g[b].test_v); ASSERT_EQ("c", g[c].test_v); ASSERT_EQ("d", g[d].test_v); } TEST(ue2_graph, square_brackets_e) { SimpleG g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto b = add_edge(u, v, g).first; auto c = add_edge(u, u, g).first; auto d = add_edge(v, u, g).first; ASSERT_EQ(0U, g[a].index); ASSERT_EQ(1U, g[b].index); ASSERT_EQ(2U, g[c].index); ASSERT_EQ(3U, g[d].index); ASSERT_EQ("SimpleE", g[a].test_e); ASSERT_EQ("SimpleE", g[b].test_e); ASSERT_EQ("SimpleE", g[c].test_e); ASSERT_EQ("SimpleE", g[d].test_e); g[a].test_e = "a"; g[b].test_e = "b"; g[c].test_e = "c"; g[d].test_e = "d"; ASSERT_EQ("a", g[a].test_e); ASSERT_EQ("b", g[b].test_e); ASSERT_EQ("c", g[c].test_e); ASSERT_EQ("d", g[d].test_e); } TEST(ue2_graph, vertex_ordering_1) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto c = add_vertex(g); auto d = add_vertex(g); ASSERT_LE(a, b); ASSERT_LE(a, c); ASSERT_LE(a, d); ASSERT_LE(b, c); ASSERT_LE(b, d); ASSERT_LE(c, d); g[a].index = 5; g[b].index = 0; g[c].index = 3; g[d].index = 1; ASSERT_LE(a, b); ASSERT_LE(a, c); ASSERT_LE(a, d); ASSERT_LE(b, c); ASSERT_LE(b, d); ASSERT_LE(c, d); } TEST(ue2_graph, vertex_ordering_2) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto c = add_vertex(g); auto d = add_vertex(g); set s; s.insert(a); s.insert(b); s.insert(c); s.insert(d); auto it = s.begin(); ASSERT_EQ(a, *it++); ASSERT_EQ(b, *it++); ASSERT_EQ(c, *it++); ASSERT_EQ(d, *it++); ASSERT_EQ(it, s.end()); g[a].index = 5; g[b].index = 0; g[c].index = 3; g[d].index = 1; it = s.begin(); ASSERT_EQ(a, *it++); ASSERT_EQ(b, *it++); ASSERT_EQ(c, *it++); ASSERT_EQ(d, *it++); ASSERT_EQ(it, s.end()); } TEST(ue2_graph, get_v_2_arg) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto pm = get(&SimpleV::test_v, g); ASSERT_EQ("SimpleV", pm[a]); ASSERT_EQ("SimpleV", pm[b]); pm[a] = "a"; pm[b] = "b"; ASSERT_EQ("a", pm[a]); ASSERT_EQ("b", pm[b]); ASSERT_EQ("a", g[a].test_v); ASSERT_EQ("b", g[b].test_v); g[a].test_v = "X"; g[b].test_v = "Y"; ASSERT_EQ("X", pm[a]); ASSERT_EQ("Y", pm[b]); ASSERT_EQ("X", get(pm, a)); ASSERT_EQ("Y", get(pm, b)); put(pm, a, "A"); put(pm, b, "B"); ASSERT_EQ("A", g[a].test_v); ASSERT_EQ("B", g[b].test_v); } TEST(ue2_graph, get_v_2_arg_const) { SimpleG g; const SimpleG &gg = g; auto a = add_vertex(g); auto b = add_vertex(g); auto pm = get(&SimpleV::test_v, gg); ASSERT_EQ("SimpleV", pm[a]); ASSERT_EQ("SimpleV", pm[b]); g[a].test_v = "a"; g[b].test_v = "b"; ASSERT_EQ("a", pm[a]); ASSERT_EQ("b", pm[b]); ASSERT_EQ("a", get(pm, a)); ASSERT_EQ("b", get(pm, b)); } TEST(ue2_graph, get_e_2_arg) { SimpleG g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto b = add_edge(v, u, g).first; auto pm = get(&SimpleE::test_e, g); ASSERT_EQ("SimpleE", pm[a]); ASSERT_EQ("SimpleE", pm[b]); pm[a] = "a"; pm[b] = "b"; ASSERT_EQ("a", pm[a]); ASSERT_EQ("b", pm[b]); ASSERT_EQ("a", g[a].test_e); ASSERT_EQ("b", g[b].test_e); g[a].test_e = "X"; g[b].test_e = "Y"; ASSERT_EQ("X", pm[a]); ASSERT_EQ("Y", pm[b]); ASSERT_EQ("X", get(pm, a)); ASSERT_EQ("Y", get(pm, b)); put(pm, a, "A"); put(pm, b, "B"); ASSERT_EQ("A", g[a].test_e); ASSERT_EQ("B", g[b].test_e); } TEST(ue2_graph, get_e_2_arg_const) { SimpleG g; const SimpleG &gg = g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto b = add_edge(v, u, g).first; auto pm = get(&SimpleE::test_e, gg); ASSERT_EQ("SimpleE", pm[a]); ASSERT_EQ("SimpleE", pm[b]); g[a].test_e = "a"; g[b].test_e = "b"; ASSERT_EQ("a", pm[a]); ASSERT_EQ("b", pm[b]); ASSERT_EQ("a", get(pm, a)); ASSERT_EQ("b", get(pm, b)); } TEST(ue2_graph, get_v_3_arg) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); ASSERT_EQ("SimpleV", get(&SimpleV::test_v, g, a)); ASSERT_EQ("SimpleV", get(&SimpleV::test_v, g, a)); get(&SimpleV::test_v, g, a) = "a"; get(&SimpleV::test_v, g, b) = "b"; ASSERT_EQ("a", get(&SimpleV::test_v, g, a)); ASSERT_EQ("b", get(&SimpleV::test_v, g, b)); ASSERT_EQ("a", g[a].test_v); ASSERT_EQ("b", g[b].test_v); g[a].test_v = "X"; g[b].test_v = "Y"; ASSERT_EQ("X", get(&SimpleV::test_v, g, a)); ASSERT_EQ("Y", get(&SimpleV::test_v, g, b)); //std::decay::type x = "A"; put(&SimpleV::test_v, g, a, "A"); put(&SimpleV::test_v, g, b, "B"); ASSERT_EQ("A", g[a].test_v); ASSERT_EQ("B", g[b].test_v); } TEST(ue2_graph, get_v_3_arg_const) { SimpleG g; const SimpleG &gg = g; auto a = add_vertex(g); auto b = add_vertex(g); ASSERT_EQ("SimpleV", get(&SimpleV::test_v, gg, a)); ASSERT_EQ("SimpleV", get(&SimpleV::test_v, gg, b)); g[a].test_v = "a"; g[b].test_v = "b"; ASSERT_EQ("a", get(&SimpleV::test_v, gg, a)); ASSERT_EQ("b", get(&SimpleV::test_v, gg, b)); } TEST(ue2_graph, get_e_3_arg) { SimpleG g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto b = add_edge(v, u, g).first; ASSERT_EQ("SimpleE", get(&SimpleE::test_e, g, a)); ASSERT_EQ("SimpleE", get(&SimpleE::test_e, g, b)); get(&SimpleE::test_e, g, a) = "a"; get(&SimpleE::test_e, g, b) = "b"; ASSERT_EQ("a", get(&SimpleE::test_e, g, a)); ASSERT_EQ("b", get(&SimpleE::test_e, g, b)); ASSERT_EQ("a", g[a].test_e); ASSERT_EQ("b", g[b].test_e); g[a].test_e = "X"; g[b].test_e = "Y"; ASSERT_EQ("X", get(&SimpleE::test_e, g, a)); ASSERT_EQ("Y", get(&SimpleE::test_e, g, b)); } TEST(ue2_graph, get_e_3_arg_const) { SimpleG g; const SimpleG &gg = g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto b = add_edge(v, u, g).first; ASSERT_EQ("SimpleE", get(&SimpleE::test_e, gg, a)); ASSERT_EQ("SimpleE", get(&SimpleE::test_e, gg, b)); g[a].test_e = "a"; g[b].test_e = "b"; ASSERT_EQ("a", get(&SimpleE::test_e, gg, a)); ASSERT_EQ("b", get(&SimpleE::test_e, gg, b)); } TEST(ue2_graph, get_vertex_index) { SimpleG g; auto a = add_vertex(g); auto pm = get(vertex_index, g); ASSERT_EQ(0U, pm(a)); pm(a) = 1; ASSERT_EQ(1U, pm[a]); ASSERT_EQ(1U, g[a].index); ASSERT_EQ(1U, get(vertex_index, g, a)); } TEST(ue2_graph, get_vertex_index_const) { SimpleG g; const SimpleG &gg = g; auto a = add_vertex(g); auto pm = get(vertex_index, gg); ASSERT_EQ(0U, pm(a)); g[a].index = 1; ASSERT_EQ(1U, pm[a]); ASSERT_EQ(1U, get(vertex_index, gg, a)); } TEST(ue2_graph, get_edge_index) { SimpleG g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto pm = get(edge_index, g); ASSERT_EQ(0U, pm(a)); pm(a) = 1; ASSERT_EQ(1U, pm[a]); ASSERT_EQ(1U, g[a].index); ASSERT_EQ(1U, get(edge_index, g, a)); } TEST(ue2_graph, get_edge_index_const) { SimpleG g; const SimpleG &gg = g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto pm = get(edge_index, gg); ASSERT_EQ(0U, pm(a)); g[a].index = 1; ASSERT_EQ(1U, pm[a]); ASSERT_EQ(1U, get(edge_index, gg, a)); } TEST(ue2_graph, get_vertex_all) { SimpleG g; auto a = add_vertex(g); auto pm = get(vertex_all, g); ASSERT_EQ(0U, pm(a).index); pm(a).index = 1; ASSERT_EQ(1U, pm[a].index); ASSERT_EQ(1U, g[a].index); ASSERT_EQ(1U, get(vertex_all, g, a).index); auto &a_all = get(vertex_all, g, a); ASSERT_EQ(1U, a_all.index); g[a].index = 2; ASSERT_EQ(2U, a_all.index); } TEST(ue2_graph, get_vertex_all_const) { SimpleG g; const SimpleG &gg = g; auto a = add_vertex(g); auto pm = get(vertex_all, gg); ASSERT_EQ(0U, pm(a).index); g[a].index = 1; ASSERT_EQ(1U, pm[a].index); ASSERT_EQ(1U, get(vertex_all, gg, a).index); auto &a_all = get(vertex_all, gg, a); ASSERT_EQ(1U, a_all.index); g[a].index = 2; ASSERT_EQ(2U, a_all.index); } TEST(ue2_graph, get_vertex_bundle) { SimpleG g; auto a = add_vertex(g); auto pm = get(vertex_bundle, g); ASSERT_EQ(0U, pm(a).index); pm(a).index = 1; ASSERT_EQ(1U, pm[a].index); ASSERT_EQ(1U, g[a].index); ASSERT_EQ(1U, get(vertex_bundle, g, a).index); auto &a_bundle = get(vertex_bundle, g, a); ASSERT_EQ(1U, a_bundle.index); g[a].index = 2; ASSERT_EQ(2U, a_bundle.index); } TEST(ue2_graph, get_vertex_bundle_const) { SimpleG g; const SimpleG &gg = g; auto a = add_vertex(g); auto pm = get(vertex_bundle, gg); ASSERT_EQ(0U, pm(a).index); g[a].index = 1; ASSERT_EQ(1U, pm[a].index); ASSERT_EQ(1U, get(vertex_bundle, gg, a).index); auto &a_bundle = get(vertex_bundle, gg, a); ASSERT_EQ(1U, a_bundle.index); g[a].index = 2; ASSERT_EQ(2U, a_bundle.index); } TEST(ue2_graph, get_edge_all) { SimpleG g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto pm = get(edge_all, g); ASSERT_EQ(0U, pm(a).index); pm(a).index = 1; ASSERT_EQ(1U, pm[a].index); ASSERT_EQ(1U, g[a].index); ASSERT_EQ(1U, get(edge_all, g, a).index); auto &a_all = get(edge_all, g, a); ASSERT_EQ(1U, a_all.index); g[a].index = 2; ASSERT_EQ(2U, a_all.index); } TEST(ue2_graph, get_edge_all_const) { SimpleG g; const SimpleG &gg = g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto pm = get(edge_all, gg); ASSERT_EQ(0U, pm(a).index); g[a].index = 1; ASSERT_EQ(1U, pm[a].index); ASSERT_EQ(1U, get(edge_all, gg, a).index); auto &a_all = get(edge_all, gg, a); ASSERT_EQ(1U, a_all.index); g[a].index = 2; ASSERT_EQ(2U, a_all.index); } TEST(ue2_graph, get_edge_bundle) { SimpleG g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto pm = get(edge_bundle, g); ASSERT_EQ(0U, pm(a).index); pm(a).index = 1; ASSERT_EQ(1U, pm[a].index); ASSERT_EQ(1U, g[a].index); ASSERT_EQ(1U, get(edge_bundle, g, a).index); auto &a_bundle = get(edge_bundle, g, a); ASSERT_EQ(1U, a_bundle.index); g[a].index = 2; ASSERT_EQ(2U, a_bundle.index); } TEST(ue2_graph, get_edge_bundle_const) { SimpleG g; const SimpleG &gg = g; auto u = add_vertex(g); auto v = add_vertex(g); auto a = add_edge(u, v, g).first; auto pm = get(edge_bundle, gg); ASSERT_EQ(0U, pm(a).index); g[a].index = 1; ASSERT_EQ(1U, pm[a].index); ASSERT_EQ(1U, get(edge_bundle, gg, a).index); auto &a_bundle = get(edge_bundle, gg, a); ASSERT_EQ(1U, a_bundle.index); g[a].index = 2; ASSERT_EQ(2U, a_bundle.index); } TEST(ue2_graph, add_vertex_prop) { SimpleG g; SimpleV vp; vp.index = 42; vp.test_v = "prop"; auto u = add_vertex(vp, g); auto v = add_vertex(vp, g); ASSERT_EQ(0U, g[u].index); ASSERT_EQ(1U, g[v].index); ASSERT_EQ("prop", g[u].test_v); ASSERT_EQ("prop", g[v].test_v); } TEST(ue2_graph, add_edge_prop) { SimpleG g; SimpleE ep; ep.index = 42; ep.test_e = "prop"; auto u = add_vertex(g); auto v = add_vertex(g); auto e = add_edge(u, v, ep, g).first; auto f = add_edge(u, v, ep, g).first; ASSERT_EQ(0U, g[e].index); ASSERT_EQ(1U, g[f].index); ASSERT_EQ("prop", g[e].test_e); ASSERT_EQ("prop", g[f].test_e); } TEST(ue2_graph, reverse_graph) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto e = add_edge(a, b, g).first; reverse_graph rg(g); auto index_map = get(vertex_index, rg); ASSERT_EQ(0U, rg[a].index); ASSERT_EQ(1U, rg[b].index); ASSERT_EQ(0U, rg[e].index); ASSERT_EQ(0U, get(vertex_index, rg, a)); ASSERT_EQ(1U, get(vertex_index, rg, b)); ASSERT_EQ(0U, get(edge_index, rg, edge(b, a, rg).first)); ASSERT_EQ(0U, index_map(a)); ASSERT_EQ(1U, index_map(b)); ASSERT_TRUE(edge(b, a, rg).second); ASSERT_FALSE(edge(a, b, rg).second); } TEST(ue2_graph, reverse_graph_const) { SimpleG g; auto a = add_vertex(g); auto b = add_vertex(g); auto e = add_edge(a, b, g).first; reverse_graph rg(g); auto index_map = get(&SimpleV::index, rg); // Note: reverse_graph fails to make bundles const so things break. // ASSERT_EQ(0U, rg[a].index); // ASSERT_EQ(1U, rg[b].index); // ASSERT_EQ(0U, rg[e].index); ASSERT_EQ(0U, get(vertex_index, g, a)); ASSERT_EQ(1U, get(vertex_index, g, b)); ASSERT_EQ(0U, get(edge_index, g, e)); ASSERT_EQ(0U, index_map(a)); ASSERT_EQ(1U, index_map(b)); ASSERT_TRUE(edge(b, a, rg).second); ASSERT_FALSE(edge(a, b, rg).second); } TEST(ue2_graph, default_param) { struct TestGraph : ue2_graph { }; TestGraph g; auto v = add_vertex(g); auto e = add_edge(v, v, g).first; ASSERT_EQ(0U, get(vertex_index, g, v)); ASSERT_EQ(0U, get(edge_index, g, e)); #if !defined(_MSC_VER) /* This makes MSVC up to VS2015 sad in ways that shouldn't happen. */ ASSERT_EQ(0U, get(&ue2::graph_detail::default_edge_property::index, g, e)); #endif } hyperscan-4.4.1/unit/internal/shuffle.cpp0000644000175000017500000001733213055426554021240 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/simd_utils.h" #include "nfa/limex_shuffle.h" namespace { // Switch one bit on in a bitmask. template Mask setbit(unsigned int bit) { union { Mask simd; char bytes[sizeof(Mask)]; } cf; memset(cf.bytes, 0, sizeof(Mask)); cf.bytes[bit / 8] = 1U << (bit % 8); return cf.simd; } TEST(Shuffle, PackedExtract32_1) { // Try all possible one-bit masks for (unsigned int i = 0; i < 32; i++) { // shuffle a single 1 bit to the front u32 mask = 1U << i; EXPECT_EQ(1U, pext32(mask, mask)); EXPECT_EQ(1U, pext32(~0U, mask)); // we should get zero out of these cases EXPECT_EQ(0U, pext32(0, mask)); EXPECT_EQ(0U, pext32(~mask, mask)); // we should get zero out of all the other bit positions for (unsigned int j = 0; (j != i && j < 32); j++) { EXPECT_EQ(0U, pext32((1U << j), mask)); } } } TEST(Shuffle, PackedExtract32_2) { // All 32 bits in mask are on u32 mask = ~0U; EXPECT_EQ(0U, pext32(0, mask)); EXPECT_EQ(mask, pext32(mask, mask)); for (unsigned int i = 0; i < 32; i++) { EXPECT_EQ(1U << i, pext32(1U << i, mask)); } } TEST(Shuffle, PackedExtract32_3) { // Try setting every second bit u32 mask = 0; for (unsigned int i = 0; i < 32; i += 2) { mask |= 1U << i; } // Test both cases (all even bits, all odd bits) EXPECT_EQ((1U << 16) - 1, pext32(mask, mask)); EXPECT_EQ((1U << 16) - 1, pext32(~mask, ~mask)); EXPECT_EQ(0U, pext32(~mask, mask)); EXPECT_EQ(0U, pext32(mask, ~mask)); for (unsigned int i = 0; i < 32; i += 2) { EXPECT_EQ(1U << (i/2), pext32(1U << i, mask)); EXPECT_EQ(0U, pext32(1U << i, ~mask)); EXPECT_EQ(1U << (i/2), pext32(1U << (i+1), ~mask)); EXPECT_EQ(0U, pext32(1U << (i+1), mask)); } } TEST(Shuffle, PackedExtract64_1) { // Try all possible one-bit masks for (unsigned int i = 0; i < 64; i++) { // shuffle a single 1 bit to the front u64a mask = 1ULL << i; EXPECT_EQ(1U, pext64(mask, mask)); EXPECT_EQ(1U, pext64(~0ULL, mask)); // we should get zero out of these cases EXPECT_EQ(0U, pext64(0, mask)); EXPECT_EQ(0U, pext64(~mask, mask)); // we should get zero out of all the other bit positions for (unsigned int j = 0; (j != i && j < 64); j++) { EXPECT_EQ(0U, pext64((1ULL << j), mask)); } } } TEST(Shuffle, PackedExtract64_2) { // Fill first half of mask u64a mask = 0x00000000ffffffffULL; EXPECT_EQ(0U, pext64(0, mask)); EXPECT_EQ(0xffffffffU, pext64(mask, mask)); for (unsigned int i = 0; i < 32; i++) { EXPECT_EQ(1U << i, pext64(1ULL << i, mask)); } // Fill second half of mask mask = 0xffffffff00000000ULL; EXPECT_EQ(0U, pext64(0, mask)); EXPECT_EQ(0xffffffffU, pext64(mask, mask)); for (unsigned int i = 32; i < 64; i++) { EXPECT_EQ(1U << (i - 32), pext64(1ULL << i, mask)); } // Try one in the middle mask = 0x0000ffffffff0000ULL; EXPECT_EQ(0U, pext64(0, mask)); EXPECT_EQ(0xffffffffU, pext64(mask, mask)); for (unsigned int i = 16; i < 48; i++) { EXPECT_EQ(1U << (i - 16), pext64(1ULL << i, mask)); } } TEST(Shuffle, PackedExtract64_3) { // Try setting every second bit (note: 32 bits, the max we can shuffle) u64a mask = 0; for (unsigned int i = 0; i < 64; i += 2) { mask |= 1ULL << i; } // Test both cases (all even bits, all odd bits) EXPECT_EQ(0xffffffffU, pext64(mask, mask)); EXPECT_EQ(0xffffffffU, pext64(~mask, ~mask)); EXPECT_EQ(0U, pext64(~mask, mask)); EXPECT_EQ(0U, pext64(mask, ~mask)); for (unsigned int i = 0; i < 64; i += 2) { EXPECT_EQ(1U << (i/2), pext64(1ULL << i, mask)); EXPECT_EQ(0U, pext64(1ULL << i, ~mask)); EXPECT_EQ(1U << (i/2), pext64(1ULL << (i+1), ~mask)); EXPECT_EQ(0U, pext64(1ULL << (i+1), mask)); } } template static void build_pshufb_masks_onebit(unsigned int bit, T *permute, T *compare) { static_assert(sizeof(T) == sizeof(m128) || sizeof(T) == sizeof(m256), "should be valid type"); // permute mask has 0x80 in all bytes except the one we care about memset(permute, 0x80, sizeof(*permute)); memset(compare, 0, sizeof(*compare)); char *pmsk = (char *)permute; char *cmsk = (char *)compare; u8 off = (bit >= 128) ? 0x10 : 0; pmsk[off] = bit/8; cmsk[off] = ~(1 << (bit % 8)); } TEST(Shuffle, PackedExtract128_1) { // Try all possible one-bit masks for (unsigned int i = 0; i < 128; i++) { // shuffle a single 1 bit to the front m128 permute, compare; build_pshufb_masks_onebit(i, &permute, &compare); EXPECT_EQ(1U, packedExtract128(setbit(i), permute, compare)); EXPECT_EQ(1U, packedExtract128(ones128(), permute, compare)); // we should get zero out of these cases EXPECT_EQ(0U, packedExtract128(zeroes128(), permute, compare)); EXPECT_EQ(0U, packedExtract128(not128(setbit(i)), permute, compare)); // we should get zero out of all the other bit positions for (unsigned int j = 0; (j != i && j < 128); j++) { EXPECT_EQ(0U, packedExtract128(setbit(j), permute, compare)); } } } #if defined(__AVX2__) TEST(Shuffle, PackedExtract256_1) { // Try all possible one-bit masks for (unsigned int i = 0; i < 256; i++) { // shuffle a single 1 bit to the front m256 permute, compare; build_pshufb_masks_onebit(i, &permute, &compare); EXPECT_EQ(1U, packedExtract256(setbit(i), permute, compare)); EXPECT_EQ(1U, packedExtract256(ones256(), permute, compare)); // we should get zero out of these cases EXPECT_EQ(0U, packedExtract256(zeroes256(), permute, compare)); EXPECT_EQ(0U, packedExtract256(not256(setbit(i)), permute, compare)); // we should get zero out of all the other bit positions for (unsigned int j = 0; (j != i && j < 256); j++) { EXPECT_EQ(0U, packedExtract256(setbit(j), permute, compare)); } } } #endif } // namespace hyperscan-4.4.1/unit/internal/repeat.cpp0000644000175000017500000010414613055426554021064 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "nfa/limex_ring.h" #include "nfa/repeat.h" #include "nfa/repeatcompile.h" #include "util/depth.h" #include "util/make_unique.h" #include #include #include using namespace std; using namespace testing; using namespace ue2; struct RepeatTestInfo { enum RepeatType type; depth repeatMin; depth repeatMax; }; static ostream& operator<<(ostream &os, const RepeatInfo &info) { os << "{" << info.repeatMin; if (info.repeatMin == info.repeatMax) { os << "}"; } else if (info.repeatMax == REPEAT_INF) { os << ",}"; } else { os << "," << info.repeatMax << "}"; } os << " " << repeatTypeName(info.type); os << " (period " << info.minPeriod << ")"; return os; } class RepeatTest : public TestWithParam { protected: virtual void SetUp() { test_info = GetParam(); info.type = test_info.type; info.repeatMin = test_info.repeatMin; info.repeatMax = test_info.repeatMax.is_finite() ? (u32)test_info.repeatMax : REPEAT_INF; info.minPeriod = 0; RepeatStateInfo rsi(test_info.type, test_info.repeatMin, test_info.repeatMax, 0); info.packedCtrlSize = rsi.packedCtrlSize; info.stateSize = rsi.stateSize; info.horizon = rsi.horizon; std::copy(rsi.packedFieldSizes.begin(), rsi.packedFieldSizes.end(), info.packedFieldSizes); ctrl = new RepeatControl(); state_int = new char[info.stateSize + 7]; /* state may have mmbits */ state = state_int + 7; } virtual void TearDown() { delete ctrl; delete [] state_int; } RepeatTestInfo test_info; // Test params RepeatInfo info; // Repeat info structure RepeatControl *ctrl; char *state; private: char *state_int; }; static const RepeatTestInfo repeatTests[] = { // Fixed repeats -- ring model { REPEAT_RING, 2, 2 }, { REPEAT_RING, 4, 4 }, { REPEAT_RING, 10, 10 }, { REPEAT_RING, 16, 16 }, { REPEAT_RING, 20, 20 }, { REPEAT_RING, 30, 30 }, { REPEAT_RING, 50, 50 }, { REPEAT_RING, 64, 64 }, { REPEAT_RING, 65, 65 }, { REPEAT_RING, 100, 100 }, { REPEAT_RING, 200, 200 }, { REPEAT_RING, 1000, 1000 }, { REPEAT_RING, 4100, 4100 }, { REPEAT_RING, 16000, 16000 }, // {0, N} repeats -- last model { REPEAT_LAST, 0, 4 }, { REPEAT_LAST, 0, 10 }, { REPEAT_LAST, 0, 20 }, { REPEAT_LAST, 0, 30 }, { REPEAT_LAST, 0, 50 }, { REPEAT_LAST, 0, 100 }, { REPEAT_LAST, 0, 200 }, { REPEAT_LAST, 0, 1000 }, { REPEAT_LAST, 0, 16000 }, // {0, N} repeats -- ring model (though we use 'last' model in practice) { REPEAT_RING, 0, 2 }, { REPEAT_RING, 0, 4 }, { REPEAT_RING, 0, 10 }, { REPEAT_RING, 0, 20 }, { REPEAT_RING, 0, 30 }, { REPEAT_RING, 0, 50 }, { REPEAT_RING, 0, 64 }, { REPEAT_RING, 0, 65 }, { REPEAT_RING, 0, 100 }, { REPEAT_RING, 0, 200 }, { REPEAT_RING, 0, 1000 }, { REPEAT_RING, 0, 16000 }, // {N, M} repeats -- ring model { REPEAT_RING, 2, 3 }, { REPEAT_RING, 1, 4 }, { REPEAT_RING, 5, 10 }, { REPEAT_RING, 10, 20 }, { REPEAT_RING, 10, 50 }, { REPEAT_RING, 50, 60 }, { REPEAT_RING, 100, 200 }, { REPEAT_RING, 1, 200 }, { REPEAT_RING, 10, 16000 }, { REPEAT_RING, 10000, 16000 }, // {N, M} repeats -- range model { REPEAT_RANGE, 1, 4 }, { REPEAT_RANGE, 5, 10 }, { REPEAT_RANGE, 10, 20 }, { REPEAT_RANGE, 10, 50 }, { REPEAT_RANGE, 50, 60 }, { REPEAT_RANGE, 100, 200 }, { REPEAT_RANGE, 1, 200 }, { REPEAT_RANGE, 10, 16000 }, { REPEAT_RANGE, 10000, 16000 }, // {N,M} repeats -- small bitmap model { REPEAT_BITMAP, 1, 2 }, { REPEAT_BITMAP, 5, 10 }, { REPEAT_BITMAP, 10, 20 }, { REPEAT_BITMAP, 20, 40 }, { REPEAT_BITMAP, 1, 63 }, { REPEAT_BITMAP, 50, 63 }, // {N,M} repeats -- trailer model { REPEAT_TRAILER, 1, 2 }, { REPEAT_TRAILER, 8, 8 }, { REPEAT_TRAILER, 0, 8 }, { REPEAT_TRAILER, 10, 20 }, { REPEAT_TRAILER, 1, 32 }, { REPEAT_TRAILER, 64, 64 }, { REPEAT_TRAILER, 1, 64 }, { REPEAT_TRAILER, 1, 100 }, { REPEAT_TRAILER, 1, 2000 }, { REPEAT_TRAILER, 50, 200 }, { REPEAT_TRAILER, 50, 1000 }, { REPEAT_TRAILER, 64, 1024 }, // {N,} repeats -- first model { REPEAT_FIRST, 0, depth::infinity() }, { REPEAT_FIRST, 1, depth::infinity() }, { REPEAT_FIRST, 4, depth::infinity() }, { REPEAT_FIRST, 10, depth::infinity() }, { REPEAT_FIRST, 50, depth::infinity() }, { REPEAT_FIRST, 100, depth::infinity() }, { REPEAT_FIRST, 1000, depth::infinity() }, { REPEAT_FIRST, 3000, depth::infinity() }, { REPEAT_FIRST, 10000, depth::infinity() }, // {,} repeats -- always { REPEAT_ALWAYS, 0, depth::infinity() }, }; INSTANTIATE_TEST_CASE_P(Repeat, RepeatTest, ValuesIn(repeatTests)); TEST_P(RepeatTest, MatchSuccess) { SCOPED_TRACE(testing::Message() << "Repeat: " << info); u64a offset = 1000; repeatStore(&info, ctrl, state, offset, 0); for (u32 i = info.repeatMin; i <= info.repeatMax; i++) { enum TriggerResult rv = processTugTrigger(&info, ctrl, state, offset + i); if (rv == TRIGGER_SUCCESS_CACHE) { rv = TRIGGER_SUCCESS; } ASSERT_EQ(TRIGGER_SUCCESS, rv); } } TEST_P(RepeatTest, MatchNegSuccess) { SCOPED_TRACE(testing::Message() << "Repeat: " << info); // Write a top at offset 1000. const u64a offset = 1000; repeatStore(&info, ctrl, state, offset, 0); // Write another match at offset 1002, using is_alive=0 (i.e. the repeat // was killed between these two tops). repeatStore(&info, ctrl, state, offset + 2, 0); enum TriggerResult rv; // Match at offset + repeatMin should fail, while offset + repeatMin + 2 // should succeed. if (info.repeatMin > 2) { rv = processTugTrigger(&info, ctrl, state, offset + info.repeatMin); ASSERT_EQ(TRIGGER_FAIL, rv); } rv = processTugTrigger(&info, ctrl, state, offset + info.repeatMin + 2); if (rv == TRIGGER_SUCCESS_CACHE) { rv = TRIGGER_SUCCESS; } ASSERT_EQ(TRIGGER_SUCCESS, rv); } TEST_P(RepeatTest, MatchFail) { SCOPED_TRACE(testing::Message() << "Repeat: " << info); // Write a match at offset 1000. const u64a offset = 1000; repeatStore(&info, ctrl, state, offset, 0); // Test for a match, if possible, at offset + repeatMin - 1. enum TriggerResult rv; if (info.repeatMin > 0) { u64a testOffset = offset + info.repeatMin - 1; rv = processTugTrigger(&info, ctrl, state, testOffset); ASSERT_EQ(TRIGGER_FAIL, rv); } // Match after repeatMax should fail as well. if (info.repeatMax != REPEAT_INF) { u64a testOffset = offset + info.repeatMax + 1; rv = processTugTrigger(&info, ctrl, state, testOffset); ASSERT_EQ(TRIGGER_STALE, rv); } } // Fill the ring with matches. TEST_P(RepeatTest, FillRing) { if (info.repeatMax == REPEAT_INF) { return; } const u64a offset = 1000; repeatStore(&info, ctrl, state, offset, 0); for (u64a i = 1; i <= info.repeatMax; i++) { repeatStore(&info, ctrl, state, offset + i, 1); } // We should be able to see matches for all of these (beyond the last top offset). enum TriggerResult rv; for (u64a i = offset + info.repeatMax; i <= offset + info.repeatMax + info.repeatMin; i++) { rv = processTugTrigger(&info, ctrl, state, i); if (rv == TRIGGER_SUCCESS_CACHE) { rv = TRIGGER_SUCCESS; } ASSERT_EQ(TRIGGER_SUCCESS, rv); } } TEST_P(RepeatTest, FindTops) { SCOPED_TRACE(testing::Message() << "Repeat: " << info); /* REPEAT_ALWAYS has no state and so does not track top locations */ if (info.type == REPEAT_ALWAYS) { return; } repeatStore(&info, ctrl, state, 1000, 0); ASSERT_EQ(1000, repeatLastTop(&info, ctrl, state)); repeatStore(&info, ctrl, state, 2000, 1); if (info.type == REPEAT_FIRST) { ASSERT_EQ(1000, repeatLastTop(&info, ctrl, state)); } else { ASSERT_EQ(2000, repeatLastTop(&info, ctrl, state)); } repeatStore(&info, ctrl, state, 3000, 0); ASSERT_EQ(3000, repeatLastTop(&info, ctrl, state)); } TEST_P(RepeatTest, NextMatch) { SCOPED_TRACE(testing::Message() << "Repeat: " << info); u64a top = 10000000ULL; repeatStore(&info, ctrl, state, top, 0); u64a i = top + info.repeatMin; if (info.repeatMin != 0) { // First match after the top should be at top+min. ASSERT_EQ(i, repeatNextMatch(&info, ctrl, state, top)); } while (i < info.repeatMax) { ASSERT_EQ(i + 1, repeatNextMatch(&info, ctrl, state, i)); i++; } if (info.repeatMax != REPEAT_INF) { ASSERT_EQ(0, repeatNextMatch(&info, ctrl, state, top + info.repeatMax)); } } TEST_P(RepeatTest, NextMatchFilledRepeat) { // This test is only really appropriate for repeat models that store more // than one top. if (info.type != REPEAT_RING && info.type != REPEAT_RANGE) { return; } SCOPED_TRACE(testing::Message() << "Repeat: " << info); u64a top = 10000000ULL; repeatStore(&info, ctrl, state, top, 0); for (u64a i = 1; i <= info.repeatMax; i++) { repeatStore(&info, ctrl, state, top + i, 1); } u64a last_top = top + info.repeatMax; u64a i = top + info.repeatMin; if (info.repeatMin != 0) { // First match after the initial top should be at top+min. ASSERT_EQ(i, repeatNextMatch(&info, ctrl, state, top)); } while (i < last_top + info.repeatMax) { ASSERT_EQ(i + 1, repeatNextMatch(&info, ctrl, state, i)); i++; } if (info.repeatMax != REPEAT_INF) { ASSERT_EQ(0, repeatNextMatch(&info, ctrl, state, last_top + info.repeatMax)); } } TEST_P(RepeatTest, TwoTops) { SCOPED_TRACE(testing::Message() << "Repeat: " << info); // Only appropriate for tests that store more than one top. if (info.type == REPEAT_FIRST || info.type == REPEAT_LAST || info.type == REPEAT_ALWAYS) { return; } const u32 top_range = info.repeatMax; // Limit the scope of this test for runtime brevity. For small cases, we // check every offset, but for bigger ones we use a bigger step. const u32 iter_step = std::max(1u, top_range / 256u); const u64a top1 = 10000ull; for (u32 i = 1; i < top_range; i += iter_step) { const u64a top2 = top1 + i; SCOPED_TRACE(testing::Message() << "Tops at offsets " << top1 << " and " << top2); repeatStore(&info, ctrl, state, top1, 0); ASSERT_EQ(top1, repeatLastTop(&info, ctrl, state)); repeatStore(&info, ctrl, state, top2, 1); ASSERT_EQ(top2, repeatLastTop(&info, ctrl, state)); // We should have those matches from the top1 match window that are // greater than or equal to top2. for (u64a j = std::max(top1 + info.repeatMin, top2); j <= top1 + info.repeatMax; j++) { ASSERT_EQ(REPEAT_MATCH, repeatHasMatch(&info, ctrl, state, j)) << j << " should be a match due to top 1"; } // If the two match windows don't overlap, we should have some // non-matching positions between them. for (u64a j = top1 + info.repeatMax + 1; j < top2 + info.repeatMin; j++) { ASSERT_EQ(REPEAT_NOMATCH, repeatHasMatch(&info, ctrl, state, j)) << j << " should not be a match"; } // We should have all the matches in the match window from top 2. for (u64a j = top2 + info.repeatMin; j <= top2 + info.repeatMax; j++) { ASSERT_EQ(REPEAT_MATCH, repeatHasMatch(&info, ctrl, state, j)) << j << " should be a match due to top 2"; } // One past the end should be stale. u64a past_end = top2 + info.repeatMax + 1; ASSERT_EQ(REPEAT_STALE, repeatHasMatch(&info, ctrl, state, past_end)) << "repeat should be stale at " << past_end; } } TEST_P(RepeatTest, Pack) { SCOPED_TRACE(testing::Message() << "Repeat: " << info); u64a offset = 1000; repeatStore(&info, ctrl, state, offset, 0); // We should be able to pack and then unpack the control block at any // offset up to repeatMin and get a match at both the min and max repeats. unique_ptr packed = ue2::make_unique(info.packedCtrlSize); for (u32 i = 0; i < info.repeatMax; i++) { SCOPED_TRACE(testing::Message() << "i=" << i); const u64a pack_offset = offset + i; memset(packed.get(), 0xff, info.packedCtrlSize); repeatPack(packed.get(), &info, ctrl, pack_offset); memset(ctrl, 0xff, sizeof(*ctrl)); repeatUnpack(packed.get(), &info, pack_offset, ctrl); // We should have a match at every offset in [offset + repeatMin, // offset + repeatMax]. For brevity, we just check the first one and // the last one. u64a first = offset + std::max(i, info.repeatMin); u64a last = offset + info.repeatMax; ASSERT_EQ(REPEAT_MATCH, repeatHasMatch(&info, ctrl, state, first)) << "repeat should have match at " << first; ASSERT_EQ(REPEAT_MATCH, repeatHasMatch(&info, ctrl, state, last)) << "repeat should have match at " << last; } } TEST_P(RepeatTest, LargeGap) { SCOPED_TRACE(testing::Message() << "Repeat: " << info); if (info.repeatMax == REPEAT_INF) { return; // Test not valid for FIRST-type repeats. } for (int i = 0; i < 64; i++) { u64a top1 = 1000; repeatStore(&info, ctrl, state, top1, 0); // first top ASSERT_EQ(top1, repeatLastTop(&info, ctrl, state)); // Add a second top after a gap of 2^i bytes. u64a top2 = top1 + (1ULL << i); repeatStore(&info, ctrl, state, top2, 1); // second top ASSERT_EQ(top2, repeatLastTop(&info, ctrl, state)); } } static const u32 sparsePeriods[] = { 2, 4, 6, 8, 10, 12, 15, 18, 20, 22, 24, 26, 28, 30, /* 40, 50, 60, 80, 100, 120, 150, 180, 200, 250, 300, 350, 400,*/ }; static const RepeatTestInfo sparseRepeats[] = { // Fixed repeats { REPEAT_SPARSE_OPTIMAL_P, 10, 10 }, { REPEAT_SPARSE_OPTIMAL_P, 20, 20 }, { REPEAT_SPARSE_OPTIMAL_P, 40, 40 }, { REPEAT_SPARSE_OPTIMAL_P, 80, 80 }, { REPEAT_SPARSE_OPTIMAL_P, 100, 100 }, { REPEAT_SPARSE_OPTIMAL_P, 150, 150 }, { REPEAT_SPARSE_OPTIMAL_P, 200, 200 }, { REPEAT_SPARSE_OPTIMAL_P, 250, 250 }, { REPEAT_SPARSE_OPTIMAL_P, 300, 300 }, { REPEAT_SPARSE_OPTIMAL_P, 350, 350 }, { REPEAT_SPARSE_OPTIMAL_P, 400, 400 }, { REPEAT_SPARSE_OPTIMAL_P, 500, 500 }, { REPEAT_SPARSE_OPTIMAL_P, 600, 600 }, { REPEAT_SPARSE_OPTIMAL_P, 800, 800 }, { REPEAT_SPARSE_OPTIMAL_P, 1000, 1000 }, { REPEAT_SPARSE_OPTIMAL_P, 1500, 1500 }, { REPEAT_SPARSE_OPTIMAL_P, 2000, 2000 }, { REPEAT_SPARSE_OPTIMAL_P, 2500, 2500 }, { REPEAT_SPARSE_OPTIMAL_P, 3000, 3000 }, { REPEAT_SPARSE_OPTIMAL_P, 3500, 3500 }, { REPEAT_SPARSE_OPTIMAL_P, 4000, 4000 }, { REPEAT_SPARSE_OPTIMAL_P, 4500, 4500 }, { REPEAT_SPARSE_OPTIMAL_P, 5000, 5000 }, { REPEAT_SPARSE_OPTIMAL_P, 65534, 65534 }, // {N, M} repeats { REPEAT_SPARSE_OPTIMAL_P, 10, 20 }, { REPEAT_SPARSE_OPTIMAL_P, 20, 40 }, { REPEAT_SPARSE_OPTIMAL_P, 40, 80 }, { REPEAT_SPARSE_OPTIMAL_P, 80, 100 }, { REPEAT_SPARSE_OPTIMAL_P, 100, 120 }, { REPEAT_SPARSE_OPTIMAL_P, 150, 180 }, { REPEAT_SPARSE_OPTIMAL_P, 200, 400 }, { REPEAT_SPARSE_OPTIMAL_P, 250, 500 }, { REPEAT_SPARSE_OPTIMAL_P, 300, 400 }, { REPEAT_SPARSE_OPTIMAL_P, 350, 500 }, { REPEAT_SPARSE_OPTIMAL_P, 400, 500 }, { REPEAT_SPARSE_OPTIMAL_P, 500, 600 }, { REPEAT_SPARSE_OPTIMAL_P, 600, 700 }, { REPEAT_SPARSE_OPTIMAL_P, 800, 1000 }, { REPEAT_SPARSE_OPTIMAL_P, 1000, 1200 }, { REPEAT_SPARSE_OPTIMAL_P, 1500, 1800 }, { REPEAT_SPARSE_OPTIMAL_P, 2000, 4000 }, { REPEAT_SPARSE_OPTIMAL_P, 2500, 3000 }, { REPEAT_SPARSE_OPTIMAL_P, 3000, 3500 }, { REPEAT_SPARSE_OPTIMAL_P, 3500, 4000 }, { REPEAT_SPARSE_OPTIMAL_P, 4000, 8000 }, { REPEAT_SPARSE_OPTIMAL_P, 4500, 8000 }, { REPEAT_SPARSE_OPTIMAL_P, 5000, 5001 }, { REPEAT_SPARSE_OPTIMAL_P, 60000, 65534 } }; static void test_sparse2entry(const RepeatInfo *info, RepeatControl *ctrl, char *state, u64a second) { SCOPED_TRACE(testing::Message() << "Repeat: " << *info); SCOPED_TRACE(second); if (second > info->repeatMax || second < info->minPeriod) { return; } u64a offset = 1000; u64a exit = offset + info->repeatMin; repeatStore(info, ctrl, state, offset, 0); ASSERT_EQ(offset, repeatLastTop(info, ctrl, state)); u64a offset2 = 1000 + second; u64a exit2 = offset2 + info->repeatMin; repeatStore(info, ctrl, state, offset2, 1); ASSERT_EQ(offset2, repeatLastTop(info, ctrl, state)); u32 range = info->repeatMax - info->repeatMin; for (u32 i = offset2; i < offset + info->repeatMax * 2 + 100; i++) { SCOPED_TRACE(i); RepeatMatch r = repeatHasMatch(info, ctrl, state, i); if ((i >= exit && i <= exit + range) || (i >= exit2 && i <= exit2 + range)) { ASSERT_EQ(REPEAT_MATCH, r); } else if (i > exit2 + range) { ASSERT_EQ(REPEAT_STALE, r); } else { ASSERT_EQ(REPEAT_NOMATCH, r); } } ASSERT_EQ(MAX(exit + range + 1, exit2), repeatNextMatch(info, ctrl, state, exit + range)); ASSERT_EQ(MAX(exit + range + 2, exit2), repeatNextMatch(info, ctrl, state, exit + range + 1)); ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state, exit2 - 1)); ASSERT_EQ(0, repeatNextMatch(info, ctrl, state, exit2 + range)); } static void test_sparse3entry(const RepeatInfo *info, RepeatControl *ctrl, char *state, u64a diff) { SCOPED_TRACE(testing::Message() << "Repeat:" << *info); SCOPED_TRACE(diff); if (diff * 2 > info->repeatMax || diff < info->minPeriod) { return; } u64a offset = 1000; u64a exit = offset + info->repeatMin; repeatStore(info, ctrl, state, offset, 0); ASSERT_EQ(offset, repeatLastTop(info, ctrl, state)); u64a offset2 = 1000 + diff; u64a exit2 = offset2 + info->repeatMin; repeatStore(info, ctrl, state, offset2, 1); ASSERT_EQ(offset2, repeatLastTop(info, ctrl, state)); u64a offset3 = 1000 + 2 * diff; u64a exit3 = offset3 + info->repeatMin; repeatStore(info, ctrl, state, offset3, 1); ASSERT_EQ(offset3, repeatLastTop(info, ctrl, state)); u32 range = info->repeatMax - info->repeatMin; for (u32 i = offset2; i < offset + info->repeatMax * 2 + 100; i++) { SCOPED_TRACE(i); RepeatMatch r = repeatHasMatch(info, ctrl, state, i); if((i >= exit && i <= exit + range)|| (i >= exit2 && i <= exit2 + range) || (i >= exit3 && i <= exit3 + range)) { ASSERT_EQ(REPEAT_MATCH, r); } else if (i > exit3 + range) { ASSERT_EQ(REPEAT_STALE, r); } else { ASSERT_EQ(REPEAT_NOMATCH, r); } } ASSERT_EQ(MAX(exit + range + 1, exit2), repeatNextMatch(info, ctrl, state, exit + range)); ASSERT_EQ(MAX(exit + range + 2, exit2), repeatNextMatch(info, ctrl, state, exit + range + 1)); ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state, exit2 - 1)); ASSERT_EQ(MAX(exit2 + range + 1, exit3), repeatNextMatch(info, ctrl, state, exit2 + range)); ASSERT_EQ(MAX(exit2 + range + 2, exit3), repeatNextMatch(info, ctrl, state, exit2 + range + 1)); ASSERT_EQ(exit3, repeatNextMatch(info, ctrl, state, exit3 - 1)); ASSERT_EQ(0, repeatNextMatch(info, ctrl, state, exit3 + range)); } static void test_sparse3entryNeg(const RepeatInfo *info, RepeatControl *ctrl, char *state, u64a diff) { SCOPED_TRACE(testing::Message() << "Repeat:" << *info); SCOPED_TRACE(diff); if (diff * 2 > info->repeatMax || diff < info->minPeriod) { return; } u64a offset = 1000; repeatStore(info, ctrl, state, offset, 0); ASSERT_EQ(offset, repeatLastTop(info, ctrl, state)); u64a offset2 = 1000 + diff; repeatStore(info, ctrl, state, offset2, 0); ASSERT_EQ(offset2, repeatLastTop(info, ctrl, state)); u64a offset3 = 1000 + 2 * diff; u64a exit3 = offset3 + info->repeatMin; repeatStore(info, ctrl, state, offset3, 0); ASSERT_EQ(offset3, repeatLastTop(info, ctrl, state)); u32 range = info->repeatMax - info->repeatMin; for (u32 i = offset3; i < offset + info->repeatMax * 2 + 100; i++) { SCOPED_TRACE(i); RepeatMatch r = repeatHasMatch(info, ctrl, state, i); if(i >= exit3 && i <= exit3 + range) { ASSERT_EQ(REPEAT_MATCH, r); } else if (i > exit3 + range) { ASSERT_EQ(REPEAT_STALE, r); } else { ASSERT_EQ(REPEAT_NOMATCH, r); } } } static void test_sparse3entryExpire(const RepeatInfo *info, RepeatControl *ctrl, char *state, u64a diff) { SCOPED_TRACE(testing::Message() << "Repeat:" << *info); SCOPED_TRACE(diff); if (diff * 2 > info->repeatMax || diff < info->minPeriod) { return; } u64a offset = 1000; repeatStore(info, ctrl, state, offset, 0); ASSERT_EQ(offset, repeatLastTop(info, ctrl, state)); u64a offset2 = 1000 + diff; repeatStore(info, ctrl, state, offset2, 1); ASSERT_EQ(offset2, repeatLastTop(info, ctrl, state)); u64a offset3 = 1000 + 2 * info->repeatMax; u64a exit3 = offset3 + info->repeatMin; repeatStore(info, ctrl, state, offset3, 1); ASSERT_EQ(offset3, repeatLastTop(info, ctrl, state)); u32 range = info->repeatMax - info->repeatMin; for (u32 i = offset3; i < offset3 + info->repeatMax + 100; i++) { SCOPED_TRACE(i); RepeatMatch r = repeatHasMatch(info, ctrl, state, i); if(i >= exit3 && i <= exit3 + range) { ASSERT_EQ(REPEAT_MATCH, r); } else if (i > exit3 + range) { ASSERT_EQ(REPEAT_STALE, r); } else { ASSERT_EQ(REPEAT_NOMATCH, r); } } } class SparseOptimalTest : public TestWithParam > { protected: virtual void SetUp() { u32 period; tie(period, test_info) = GetParam(); RepeatStateInfo rsi(REPEAT_SPARSE_OPTIMAL_P, test_info.repeatMin, test_info.repeatMax, period); ptr = new char[sizeof(RepeatInfo) + sizeof(u64a) * (rsi.patchSize + 2)]; info = (struct RepeatInfo *)ptr; info->type = REPEAT_SPARSE_OPTIMAL_P; info->repeatMin = test_info.repeatMin; info->repeatMax = test_info.repeatMax; info->minPeriod = period; info->packedCtrlSize = rsi.packedCtrlSize; info->stateSize = rsi.stateSize; info->horizon = rsi.horizon; std::copy(rsi.packedFieldSizes.begin(), rsi.packedFieldSizes.end(), info->packedFieldSizes); info->patchCount = rsi.patchCount; info->patchSize = rsi.patchSize; info->encodingSize = rsi.encodingSize; info->patchesOffset = rsi.patchesOffset; u32 repeatMax = info->patchSize; u64a *table = (u64a *)(ROUNDUP_PTR((ptr + sizeof(RepeatInfo)), alignof(u64a))); for (u32 i = 0; i < repeatMax + 1; i++) { table[i] = rsi.table[i]; } ctrl = new RepeatControl(); state_int = new char[info->stateSize + 7]; /* state may have mmbits */ state = state_int + 7; } virtual void TearDown() { delete ctrl; delete[] state_int; delete[] ptr; } RepeatTestInfo test_info; // Test params RepeatInfo *info; // Repeat info structure RepeatControl *ctrl; char *state; private: char *ptr; char *state_int; }; TEST_P(SparseOptimalTest, Simple1) { SCOPED_TRACE(testing::Message() << "Repeat: " << *info); u64a offset = 1000; repeatStore(info, ctrl, state, offset, 0); ASSERT_EQ(1000U, repeatLastTop(info, ctrl, state)); for (u32 i = 0; i < info->repeatMax * 2 + 100; i++) { SCOPED_TRACE(i); RepeatMatch r = repeatHasMatch(info, ctrl, state, offset + i); if (i >= info->repeatMin && i <= info->repeatMax) { ASSERT_EQ(REPEAT_MATCH, r); } else if (i > info->repeatMax) { ASSERT_EQ(REPEAT_STALE, r); } else { ASSERT_EQ(REPEAT_NOMATCH, r); } } u64a exp = 1000 + info->repeatMin; ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1000)); ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1001)); ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1002)); ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1003)); ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMin - 5)); ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMin - 4)); ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMin - 3)); ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMin - 2)); ASSERT_EQ(exp, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMin - 1)); ASSERT_EQ(0U, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMax)); ASSERT_EQ(0U, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMax + 1)); ASSERT_EQ(0U, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMax * 2 - 1)); ASSERT_EQ(0U, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMax * 2)); ASSERT_EQ(0U, repeatNextMatch(info, ctrl, state, 1000 + info->repeatMax * 2 + 1)); ASSERT_EQ(0U, repeatNextMatch(info, ctrl, state, 100000)); } TEST_P(SparseOptimalTest, TwoTopsNeg) { SCOPED_TRACE(testing::Message() << "Repeat: " << *info); u32 patch_count = info->patchCount; u32 patch_size = info->patchSize; u64a offset = 1000; u64a exit = offset + info->repeatMin; repeatStore(info, ctrl, state, offset, 0); ASSERT_EQ(offset, repeatLastTop(info, ctrl, state)); u64a offset2 = 1000 + patch_count * patch_size; u64a exit2 = offset2 + info->repeatMin; repeatStore(info, ctrl, state, offset2, 1); ASSERT_EQ(offset2, repeatLastTop(info, ctrl, state)); u32 range = info->repeatMax - info->repeatMin; for (u32 i = offset2; i < offset + info->repeatMax * 2 + 100; i++) { SCOPED_TRACE(i); RepeatMatch r = repeatHasMatch(info, ctrl, state, i); if (i >= exit2 && i <= exit2 + range) { ASSERT_EQ(REPEAT_MATCH, r); } else if (i > exit2 + range) { ASSERT_EQ(REPEAT_STALE, r); } else { ASSERT_EQ(REPEAT_NOMATCH, r); } } const struct RepeatRingControl *xs = (const struct RepeatRingControl *) ctrl; ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state, MAX(xs->offset, exit))); ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state, MAX(xs->offset, exit + 1))); ASSERT_EQ(exit2, repeatNextMatch(info, ctrl, state, exit2 - 1)); ASSERT_EQ(0, repeatNextMatch(info, ctrl, state, exit2 + range)); } TEST_P(SparseOptimalTest, Simple2a) { test_sparse2entry(info, ctrl, state, info->minPeriod); } TEST_P(SparseOptimalTest, Simple2b) { test_sparse2entry(info, ctrl, state, info->repeatMax - 1); } TEST_P(SparseOptimalTest, Simple2c) { test_sparse2entry(info, ctrl, state, info->repeatMax); } TEST_P(SparseOptimalTest, Simple2d) { test_sparse2entry(info, ctrl, state, info->minPeriod + 1); } TEST_P(SparseOptimalTest, Simple2e) { test_sparse2entry(info, ctrl, state, 2 * info->minPeriod - 1); } TEST_P(SparseOptimalTest, Simple3a) { test_sparse3entry(info, ctrl, state, info->minPeriod); test_sparse3entryNeg(info, ctrl, state, info->minPeriod); test_sparse3entryExpire(info, ctrl, state, info->minPeriod); } TEST_P(SparseOptimalTest, Simple3b) { test_sparse3entry(info, ctrl, state, info->repeatMax / 2 - 1); test_sparse3entryNeg(info, ctrl, state, info->repeatMax / 2 - 1); test_sparse3entryExpire(info, ctrl, state, info->repeatMax / 2 - 1); } TEST_P(SparseOptimalTest, Simple3c) { test_sparse3entry(info, ctrl, state, info->repeatMax / 2); test_sparse3entryNeg(info, ctrl, state, info->repeatMax / 2); test_sparse3entryExpire(info, ctrl, state, info->repeatMax / 2); } TEST_P(SparseOptimalTest, Simple3d) { test_sparse3entry(info, ctrl, state, info->minPeriod + 1); test_sparse3entryNeg(info, ctrl, state, info->minPeriod + 1); test_sparse3entryExpire(info, ctrl, state, info->minPeriod + 1); } TEST_P(SparseOptimalTest, Simple3e) { test_sparse3entry(info, ctrl, state, 2 * info->minPeriod - 1); test_sparse3entryNeg(info, ctrl, state, 2 * info->minPeriod - 1); test_sparse3entryExpire(info, ctrl, state, 2 * info->minPeriod - 1); } TEST_P(SparseOptimalTest, LargeGap) { SCOPED_TRACE(testing::Message() << "Repeat: " << *info); for (int i = 0; i < 64; i++) { u64a top1 = 1000; repeatStore(info, ctrl, state, top1, 0); // first top ASSERT_EQ(top1, repeatLastTop(info, ctrl, state)); // Add a second top after a gap of 2^i bytes. u64a top2 = top1 + (1ULL << i); if (top2 - top1 < info->minPeriod) { continue; // not a valid top } repeatStore(info, ctrl, state, top2, 1); // second top ASSERT_EQ(top2, repeatLastTop(info, ctrl, state)); } } TEST_P(SparseOptimalTest, ThreeTops) { SCOPED_TRACE(testing::Message() << "Repeat: " << *info); u32 patch_count = info->patchCount; u32 patch_size = info->patchSize; if (patch_count < 3) { return; } u64a offset = 1000; repeatStore(info, ctrl, state, offset, 0); ASSERT_EQ(offset, repeatLastTop(info, ctrl, state)); u64a offset2 = 1000 + 2 * patch_size - 1; u64a exit2 = offset2 + info->repeatMin; repeatStore(info, ctrl, state, offset2, 1); ASSERT_EQ(offset2, repeatLastTop(info, ctrl, state)); u64a offset3 = 1000 + patch_count * patch_size; u64a exit3 = offset3 + info->repeatMin; repeatStore(info, ctrl, state, offset3, 1); ASSERT_EQ(offset3, repeatLastTop(info, ctrl, state)); for (u32 i = offset2 + info->repeatMin; i <= offset2 + info->repeatMax; i++) { ASSERT_EQ(REPEAT_MATCH, repeatHasMatch(info, ctrl, state, i)); } for (u32 i = offset2 + info->repeatMax + 1; i < offset3 + info->repeatMin; i++) { ASSERT_EQ(REPEAT_NOMATCH, repeatHasMatch(info, ctrl, state, i)); } for (u32 i = offset3 + info->repeatMin; i <= offset3 + info->repeatMax; i++) { ASSERT_EQ(REPEAT_MATCH, repeatHasMatch(info, ctrl, state, i)); } u32 range = info->repeatMax - info->repeatMin; ASSERT_EQ(MAX(exit2 + range + 1, exit3), repeatNextMatch(info, ctrl, state, exit2 + range)); ASSERT_EQ(MAX(exit2 + range + 2, exit3), repeatNextMatch(info, ctrl, state, exit2 + range + 1)); ASSERT_EQ(exit3, repeatNextMatch(info, ctrl, state, exit3 - 1)); ASSERT_EQ(0, repeatNextMatch(info, ctrl, state, exit3 + range)); } TEST_P(SparseOptimalTest, FillTops) { SCOPED_TRACE(testing::Message() << "Repeat: " << *info); u32 patch_count = info->patchCount; u32 patch_size = info->patchSize; u32 min_period = info->minPeriod; u64a offset = 1000; u64a exit = offset + info->repeatMin; repeatStore(info, ctrl, state, offset, 0); ASSERT_EQ(offset, repeatLastTop(info, ctrl, state)); u64a offset2; for (u32 i = min_period; i < patch_count * patch_size; i += min_period) { offset2 = offset + i; repeatStore(info, ctrl, state, offset2, 1); ASSERT_EQ(offset2, repeatLastTop(info, ctrl, state)); } u64a exit2; for (u32 i = 0; i < patch_count * patch_size; i += min_period) { exit2 = exit + i; for (u32 j = exit2 + info->repeatMin; j <= offset + info->repeatMax; j++) { ASSERT_EQ(REPEAT_MATCH, repeatHasMatch(info, ctrl, state, j)); } } } INSTANTIATE_TEST_CASE_P(SparseOptimal, SparseOptimalTest, Combine(ValuesIn(sparsePeriods), ValuesIn(sparseRepeats))); hyperscan-4.4.1/unit/internal/bitfield.cpp0000644000175000017500000002603413055426554021365 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/bitfield.h" #include "util/ue2_containers.h" #include using namespace ue2; template std::ostream& operator<<(std::ostream &os, const bitfield &bf) { const size_t npos = bitfield::npos; os << "{"; size_t i = bf.find_first(); while (i != npos) { os << i; i = bf.find_next(i); if (i != npos) { os << ", "; } } os << "}"; return os; } template class BitfieldTest : public testing::Test {}; typedef ::testing::Types< bitfield<1>, bitfield<8>, bitfield<32>, bitfield<64>, bitfield<100>, bitfield<127>, bitfield<129>, bitfield<300>, bitfield<512>, bitfield<2048>, bitfield<10000> > BitfieldTypes; TYPED_TEST_CASE(BitfieldTest, BitfieldTypes); TYPED_TEST(BitfieldTest, empty) { TypeParam a; EXPECT_TRUE(a.none()); EXPECT_EQ(0, a.count()); } TYPED_TEST(BitfieldTest, set1) { TypeParam a; const size_t size = a.size(); const size_t npos = TypeParam::npos; for (size_t i = 0; i < size; i++) { a.clear(); EXPECT_TRUE(a.none()); a.set(i); EXPECT_FALSE(a.none()); EXPECT_TRUE(a.test(i)); EXPECT_EQ(i, a.find_first()); EXPECT_EQ(npos, a.find_next(i)); EXPECT_EQ(1, a.count()); a.clear(i); EXPECT_TRUE(a.none()); EXPECT_FALSE(a.test(i)); EXPECT_EQ(npos, a.find_first()); EXPECT_EQ(0, a.count()); } } // Tests set(), find_first(), find_next(). TYPED_TEST(BitfieldTest, setn) { const size_t size = TypeParam().size(); const size_t strides[] = { 600, 256, 80, 17, 7, 3 }; for (size_t s = 0; s < ARRAY_LENGTH(strides); s++) { const size_t step = strides[s]; TypeParam a; size_t num = 0; for (size_t i = 0; i < size; i += step, num++) { a.set(i); } EXPECT_EQ(num, a.count()); ASSERT_EQ(0, a.find_first()); size_t count = 1; for (size_t i = a.find_next(0); i != TypeParam::npos; i = a.find_next(i), count++) { ASSERT_EQ(count * step, i); } ASSERT_EQ(num, count); } } TYPED_TEST(BitfieldTest, allbits) { TypeParam a; a.setall(); EXPECT_FALSE(a.none()); EXPECT_TRUE(a.all()); EXPECT_EQ(a.size(), a.count()); a.flip(); EXPECT_TRUE(a.none()); EXPECT_FALSE(a.all()); EXPECT_EQ(0, a.count()); } TYPED_TEST(BitfieldTest, allbits2) { TypeParam a; a.set(); // alias for setall EXPECT_FALSE(a.none()); EXPECT_TRUE(a.all()); EXPECT_EQ(a.size(), a.count()); a.flip(); EXPECT_TRUE(a.none()); EXPECT_FALSE(a.all()); EXPECT_EQ(0, a.count()); } TYPED_TEST(BitfieldTest, flipn) { TypeParam a; a.setall(); EXPECT_FALSE(a.none()); EXPECT_TRUE(a.all()); EXPECT_EQ(a.size(), a.count()); const size_t size = a.size(); for (size_t i = 0; i < size; i++) { a.flip(i); EXPECT_FALSE(a.test(i)); EXPECT_EQ(size - i - 1, a.count()); } EXPECT_TRUE(a.none()); } TYPED_TEST(BitfieldTest, flip_on) { TypeParam a; EXPECT_TRUE(a.none()); const size_t size = a.size(); for (size_t i = 0; i < size; i++) { a.flip(i); EXPECT_TRUE(a.test(i)); EXPECT_EQ(i + 1, a.count()); } EXPECT_TRUE(a.all()); } TYPED_TEST(BitfieldTest, equality_copy) { TypeParam a, b; const size_t size = a.size(); size_t step = (size + 6) / 7; ASSERT_NE(0, step); for (size_t i = 0; i < size; i += step) { a.set(i); b.set(i); } EXPECT_EQ(a, b); EXPECT_EQ(a.hash(), b.hash()); TypeParam c(a); // copy EXPECT_EQ(a, c); EXPECT_EQ(b, c); EXPECT_EQ(c.hash(), a.hash()); EXPECT_EQ(c.hash(), b.hash()); c.clear(c.find_first()); EXPECT_EQ(a.count() - 1, c.count()); EXPECT_NE(a, c); } TYPED_TEST(BitfieldTest, trivial_operations) { const TypeParam a = ~TypeParam(); // all ones const TypeParam b; // all zeroes ASSERT_TRUE(a.all()); ASSERT_TRUE(b.none()); EXPECT_EQ(a, ~b); EXPECT_EQ(b, ~a); EXPECT_EQ(a, a | b); EXPECT_EQ(b, a & b); TypeParam c; c = a; // assignment EXPECT_EQ(c, a); c &= b; EXPECT_EQ(b, c); // all zeroes c |= a; EXPECT_EQ(a, c); // all ones c = a ^ b; EXPECT_EQ(a, c); } TYPED_TEST(BitfieldTest, even_odd) { TypeParam even, odd; const size_t size = even.size(); for (size_t i = 0; i < size; i++) { if (i % 2) { odd.set(i); } else { even.set(i); } } for (size_t i = 0; i < size; i++) { if (i % 2) { EXPECT_TRUE(odd.test(i)) << "odd should contain " << i; EXPECT_FALSE(even.test(i)) << "even should not contain " << i; } else { EXPECT_TRUE(even.test(i)) << "even should contain " << i; EXPECT_FALSE(odd.test(i)) << "odd should not contain " << i; } } EXPECT_TRUE(even != odd); EXPECT_FALSE(even == odd); EXPECT_TRUE((even | odd).all()); EXPECT_TRUE((even ^ odd).all()); EXPECT_TRUE((even & odd).none()); } TYPED_TEST(BitfieldTest, operator_lt) { const TypeParam a = ~TypeParam(); // all ones const TypeParam b; // all zeroes ASSERT_TRUE(a.all()); ASSERT_TRUE(b.none()); // Just some trivial tests; we have no particular ordering requirements for // bitfield, so long as an ordering exists. EXPECT_FALSE(a < a); EXPECT_FALSE(b < b); EXPECT_TRUE(b < a); } TYPED_TEST(BitfieldTest, find_first) { TypeParam a; a.setall(); ASSERT_TRUE(a.all()); const size_t size = a.size(); for (size_t i = 0; i < size; ++i) { ASSERT_EQ(i, a.find_first()); a.clear(i); } ASSERT_TRUE(a.none()); const size_t npos = TypeParam::npos; ASSERT_EQ(npos, a.find_first()); } TYPED_TEST(BitfieldTest, find_last) { TypeParam a; a.setall(); ASSERT_TRUE(a.all()); const size_t size = a.size(); for (size_t i = size; i > 0; i--) { ASSERT_EQ(i - 1, a.find_last()); a.clear(i - 1); } ASSERT_TRUE(a.none()); const size_t npos = TypeParam::npos; ASSERT_EQ(npos, a.find_last()); } TYPED_TEST(BitfieldTest, find_next_all) { TypeParam a; a.setall(); ASSERT_TRUE(a.all()); ASSERT_EQ(0, a.find_first()); const size_t size = a.size(); for (size_t i = 1; i < size; ++i) { ASSERT_EQ(i, a.find_next(i - 1)); } const size_t npos = TypeParam::npos; ASSERT_EQ(npos, a.find_next(size - 1)); } TYPED_TEST(BitfieldTest, find_next_npos) { TypeParam a; const size_t size = a.size(); const size_t npos = TypeParam::npos; for (size_t i = 0; i < size; ++i) { a.clear(); a.set(i); ASSERT_EQ(i, a.find_first()); ASSERT_EQ(npos, a.find_next(i)); } } TYPED_TEST(BitfieldTest, find_next_last) { TypeParam a; const size_t size = a.size(); const size_t last = size - 1; for (size_t i = 0; i < last; ++i) { a.clear(); a.set(i); a.set(last); ASSERT_EQ(i, a.find_first()); ASSERT_EQ(last, a.find_next(i)); } } TYPED_TEST(BitfieldTest, find_nth_one) { TypeParam a; const size_t size = a.size(); const size_t npos = TypeParam::npos; for (size_t i = 0; i < size; ++i) { a.clear(); a.set(i); ASSERT_EQ(i, a.find_nth(0)); if (1 < size) { ASSERT_EQ(npos, a.find_nth(1)); } } } TYPED_TEST(BitfieldTest, find_nth_all) { TypeParam a; const size_t size = a.size(); a.setall(); for (size_t i = 0; i < size; ++i) { ASSERT_EQ(i, a.find_nth(i)); } } TYPED_TEST(BitfieldTest, find_nth_sparse) { TypeParam a; const size_t size = a.size(); const size_t stride = std::max(size / 31, size_t{3}); std::vector bits; for (size_t i = 0; i < size; i += stride) { a.set(i); bits.push_back(i); } ASSERT_EQ(bits.size(), a.count()); for (size_t n = 0; n < bits.size(); n++) { ASSERT_EQ(bits[n], a.find_nth(n)); } } TYPED_TEST(BitfieldTest, unordered_set) { const size_t size = TypeParam::size(); // Exercise the hash_value free function by adding bitfields to an // unordered_set. ue2::unordered_set s; s.reserve(size); for (size_t i = 0; i < size; ++i) { TypeParam a; a.set(i); s.insert(a); } ASSERT_EQ(size, s.size()); for (size_t i = 0; i < size; ++i) { TypeParam a; a.set(i); ASSERT_TRUE(s.find(a) != s.end()); } } TYPED_TEST(BitfieldTest, set_range_one) { TypeParam a; const size_t size = a.size(); for (size_t i = 0; i < size; ++i) { a.clear(); a.set_range(i, i); TypeParam b; b.set(i); ASSERT_EQ(b, a); } } TYPED_TEST(BitfieldTest, set_range_all) { TypeParam a; const size_t size = a.size(); a.set_range(0, size - 1); TypeParam b; b.setall(); ASSERT_EQ(b, a); } TYPED_TEST(BitfieldTest, set_range_part) { TypeParam a; const size_t size = a.size(); const size_t part = size / 3; if (part < 1) { return; } for (size_t i = 0; i < size - part; ++i) { SCOPED_TRACE(i); a.clear(); a.set_range(i, i + part); for (size_t j = i; j <= i + part; j++) { ASSERT_TRUE(a.test(j)) << "bit " << j << " should be on!"; } // only the set bits should be on. ASSERT_EQ(part + 1, a.count()); } } hyperscan-4.4.1/unit/internal/rose_mask.cpp0000644000175000017500000003164113055426554021566 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "rose/validate_mask.h" #include "gtest/gtest.h" #define ONES64 0xffffffffffffffffULL /* valid_data_mask is flexible, don't need to be fixed in Info */ struct ValidateMaskTestInfo { u64a data; u64a and_mask; u64a cmp_mask; u64a neg_mask; }; static const ValidateMaskTestInfo testBasic[] = { /* data is randomly picked */ {0x1234abcd4321dcbaULL, 0xff09bbdd7f7ffeffULL, 0x1200abcd4561dcbbULL, 0xffff00ffULL}, /* data = "VaLiDaTe" */ {0x56614c6944615465ULL, 0xe0feffffdf7b5480ULL, 0x40614c6946615400ULL, 0xff0000ff000000ULL}, /* data = "\0\0\0MASK\0" */ {0x4d41534b00ULL, 0xfffffefebfdf002cULL, 0x5536344c0173002cULL, 0xffffff0000ff00ffULL}, /* data = "FOo14foo" */ {0x464f6f3134666f6fULL, 0xdfdffffef8c0f000ULL, 0x46466f3030406000ULL, 0xff000000000000ULL}, /* data = "FOo14foo" with different cmp_mask and neg_mask*/ {0x464f6f3134666f6fULL, 0xdfdffffef8c0f000ULL, 0x44464f3034606f60ULL, 0xffffff00ffffffffULL}, }; /* * generate 37 different valid_data_mask * 8 from 0xff to 0xff00000000000000 * 7 from 0xffff to 0xffff000000000000 * ... * 0xffffffffffffffff and 0 */ static int initLegalValidMasks(u64a validMasks[]) { u64a data = ONES64; int num = 0; for (int i = 0; i < 64; i += 8) { for (int j = 0; j <= i; j += 8) { validMasks[num] = data << j; num++; } data >>= 8; } validMasks[num] = 0; num++; return num; } /* * generate all 256 neg_masks * including 0, 0xff, 0xff00,..., 0xffffffffffffffff */ static int initLegalNegMasks(u64a negMasks[]) { u64a data = 0; u64a offset; int num = 0; while (data != ONES64) { negMasks[num] = data; num++; offset = (data | (data +1)) ^ data; data += 0xfeULL * offset + 1; } negMasks[num] = data; num++; return num; } /* * check all legal valid_mask(37 different) for validateMask[] */ TEST(ValidateMask, ValidMaskTests) { u64a validMasks[256]; int num = initLegalValidMasks(validMasks); for (const auto &t : testBasic) { for (int i = 0; i < num; i++) { EXPECT_EQ(1, validateMask(t.data, validMasks[i], t.and_mask, t.cmp_mask, t.neg_mask)); } } } /* * fix neg_mask to 0 and ONES64, * check output of ValidateMask on different valid_mask, * for neg_mask = 0, */ TEST(ValidateMask, AdvancedValidMaskTests) { u64a validMasks[256]; int num = initLegalValidMasks(validMasks); int bool_result; for (const auto &t: testBasic) { for (int i = 0; i < num; i++) { bool_result = !(validMasks[i] & t.neg_mask); EXPECT_EQ(bool_result, validateMask(t.data, validMasks[i], t.and_mask, t.cmp_mask, 0)); bool_result = (validMasks[i] | t.neg_mask) == t.neg_mask; EXPECT_EQ(bool_result, validateMask(t.data, validMasks[i], t.and_mask, t.cmp_mask, ONES64)); } } } /* * test every pair of valid_data_mask and neg_mask * and compute the expect output by a formula */ TEST(ValidateMask, FullTests) { u64a validMasks[256]; u64a negMasks[256]; int vm_num = initLegalValidMasks(validMasks); int nm_num = initLegalNegMasks(negMasks); int bool_result; for (const auto &t: testBasic) { for (int i = 0; i < vm_num; i++) { for (int j = 0; j < nm_num; j++) { /* * treat t.neg_mask as a truthtable (a negative truthtable) * we expect validateMask output 1 if and only if * the truthtable(tt) and neg_mask(nm) looks same * under "&" operation with valid_data_mask(vdm) * that is * output = (tt & vdm) == (nm & vdm) ? 1 : 0; */ bool_result = (t.neg_mask & validMasks[i]) == (negMasks[j] & validMasks[i]); EXPECT_EQ(bool_result, validateMask(t.data, validMasks[i], t.and_mask, t.cmp_mask, negMasks[j])); } } } } /* * drop the original validateMask[].neg_mask * and test more neg_mask and valid_mask manually */ TEST(ValidateMask, ManualTest_0) { const auto &t = testBasic[0]; EXPECT_EQ(1, validateMask(t.data, ONES64 << 8, t.and_mask, t.cmp_mask, 0xffff0000ULL)); EXPECT_EQ(1, validateMask(t.data, (ONES64 << 16) >> 8, t.and_mask, t.cmp_mask, 0xffff0000ULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 << 16, t.and_mask, t.cmp_mask, 0xffffff00ULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 << 24, t.and_mask, t.cmp_mask, 0xff00ffffULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 >> 32, t.and_mask, t.cmp_mask, 0xffffffff00ffULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 >> 40, t.and_mask, t.cmp_mask, 0xff00ffULL)); EXPECT_EQ(1, validateMask(t.data, 0, t.and_mask, t.cmp_mask, ONES64)); EXPECT_EQ(1, validateMask(t.data, 0, t.and_mask, t.cmp_mask, ~t.neg_mask)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 16, t.and_mask, t.cmp_mask, 0xff0000ffULL)); EXPECT_EQ(0, validateMask(t.data, ONES64, t.and_mask, t.cmp_mask, 0xffff0000ULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 >> 32, t.and_mask, t.cmp_mask, 0xff00ffULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 8, t.and_mask, t.cmp_mask, 0xffffffffULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 16, t.and_mask, t.cmp_mask, 0xff0000ffULL)); } TEST(ValidateMask, ManualTest_1) { const auto &t = testBasic[1]; EXPECT_EQ(1, validateMask(t.data, ONES64 << 16, t.and_mask, t.cmp_mask, 0xff0000ff00ffffULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 << 32, t.and_mask, t.cmp_mask, 0xff000000000000ULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 << 32, t.and_mask, t.cmp_mask, 0xff0000ffff00ffULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 << 56, t.and_mask, t.cmp_mask, 0)); EXPECT_EQ(1, validateMask(t.data, ONES64 >> 8, t.and_mask, t.cmp_mask, 0xffff0000ff000000ULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 >> 16, t.and_mask, t.cmp_mask, 0xff000000ULL)); EXPECT_EQ(1, validateMask(t.data, (ONES64 << 32) >> 16, t.and_mask, t.cmp_mask, 0xff00ff00)); EXPECT_EQ(1, validateMask(t.data, ONES64 >> 40, t.and_mask, t.cmp_mask, 0xff00000000ULL)); EXPECT_EQ(0, validateMask(t.data, ONES64, t.and_mask, t.cmp_mask, 0)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 48, t.and_mask, t.cmp_mask, 0)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 56, t.and_mask, t.cmp_mask, 0xff00000000000000ULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 16, t.and_mask, t.cmp_mask, 0xff0000ffff0000ULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 >> 8, t.and_mask, t.cmp_mask, 0xff000000ULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 >> 16, t.and_mask, t.cmp_mask, 0xffff000000ULL)); EXPECT_EQ(0, validateMask(t.data, (ONES64 << 40) >> 16, t.and_mask, t.cmp_mask, 0xff000000000000ULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 8, t.and_mask, t.cmp_mask, ONES64)); } TEST(ValidateMask, ManualTest_2) { const auto &t = testBasic[2]; EXPECT_EQ(1, validateMask(t.data, ONES64 << 24, t.and_mask, t.cmp_mask, 0xffffff0000000000ULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 << 56, t.and_mask, t.cmp_mask, 0xff00000000000000ULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 << 56, t.and_mask, t.cmp_mask, 0xff00ffffff00ffffULL)); EXPECT_EQ(1, validateMask(t.data, 0, t.and_mask, t.cmp_mask, ONES64)); EXPECT_EQ(1, validateMask(t.data, ONES64 >> 24, t.and_mask, t.cmp_mask, 0xff00ffULL)); EXPECT_EQ(1, validateMask(t.data, ONES64 >> 32, t.and_mask, t.cmp_mask, 0xffff00ff00ffULL)); EXPECT_EQ(1, validateMask(t.data, (ONES64 << 32) >> 24, t.and_mask, t.cmp_mask, 0xff0000ULL)); EXPECT_EQ(1, validateMask(t.data, (ONES64 << 32) >> 24, t.and_mask, t.cmp_mask, 0xff00ffULL)); EXPECT_EQ(1, validateMask(t.data, (ONES64 << 56) >> 40, t.and_mask, t.cmp_mask, 0xff0000ULL)); EXPECT_EQ(1, validateMask(t.data, (ONES64 << 56) >> 32, t.and_mask, t.cmp_mask, 0)); EXPECT_EQ(1, validateMask(t.data, ONES64 >> 40, t.and_mask, t.cmp_mask, 0xffffffff00ffULL)); EXPECT_EQ(0, validateMask(t.data, ONES64, t.and_mask, t.cmp_mask, 0)); EXPECT_EQ(0, validateMask(t.data, ONES64, t.and_mask, t.cmp_mask, ONES64)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 56, t.and_mask, t.cmp_mask, 0)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 48, t.and_mask, t.cmp_mask, 0xff00000000000000ULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 << 8, t.and_mask, t.cmp_mask, 0xffffff00000000ffULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 >> 32, t.and_mask, t.cmp_mask, 0xffff00ULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 >> 32, t.and_mask, t.cmp_mask, 0xffffffULL)); EXPECT_EQ(0, validateMask(t.data, ONES64 >> 16, t.and_mask, t.cmp_mask, 0xff00ffULL)); EXPECT_EQ(0, validateMask(t.data, (ONES64 << 32) >> 24, t.and_mask, t.cmp_mask, 0)); EXPECT_EQ(0, validateMask(t.data, (ONES64 << 32) >> 24, t.and_mask, t.cmp_mask, 0xffffff00000000ffULL)); EXPECT_EQ(0, validateMask(t.data, (ONES64 << 32) >> 24, t.and_mask, t.cmp_mask, 0xffffff000000ff00ULL)); EXPECT_EQ(0, validateMask(t.data, (ONES64 << 56) >> 40, t.and_mask, t.cmp_mask, 0)); EXPECT_EQ(0, validateMask(t.data, (ONES64 << 56) >> 48, t.and_mask, t.cmp_mask, 0xff00ULL)); } hyperscan-4.4.1/unit/internal/nfagraph_util.cpp0000644000175000017500000002643613055426554022434 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "nfagraph/ng.h" #include "nfagraph/ng_split.h" #include "nfagraph/ng_util.h" using namespace std; using namespace boost; using namespace ue2; TEST(NFAGraph, split1) { NGHolder src, lhs, rhs; NFAVertex a = add_vertex(src); NFAVertex b = add_vertex(src); NFAVertex c = add_vertex(src); NFAVertex d = add_vertex(src); NFAVertex e = add_vertex(src); NFAVertex f = add_vertex(src); NFAVertex g = add_vertex(src); NFAVertex h = add_vertex(src); NFAVertex i = add_vertex(src); src[a].char_reach = CharReach('a'); src[b].char_reach = CharReach('b'); src[c].char_reach = CharReach('c'); src[d].char_reach = CharReach('d'); src[e].char_reach = CharReach('e'); src[f].char_reach = CharReach('f'); src[g].char_reach = CharReach('g'); src[h].char_reach = CharReach('h'); src[i].char_reach = CharReach('i'); add_edge(src.start, a, src); add_edge(f, src.acceptEod, src); add_edge(a, b, src); add_edge(b, c, src); add_edge(c, d, src); add_edge(d, e, src); add_edge(e, f, src); add_edge(c, g, src); add_edge(g, b, src); add_edge(d, h, src); add_edge(h, c, src); add_edge(c, i, src); add_edge(i, c, src); NFAVertex pivot = c; ue2::unordered_map lhs_map; ue2::unordered_map rhs_map; splitGraph(src, pivot, &lhs, &lhs_map, &rhs, &rhs_map); ASSERT_EQ(3U + N_SPECIALS, num_vertices(lhs)); for (NFAVertex v : vertices_range(lhs)) { if (is_special(v, lhs)) { continue; } u32 cr = lhs[v].char_reach.find_first(); SCOPED_TRACE(cr); ASSERT_TRUE((cr >= 'a' && cr <= 'c')); } ASSERT_EQ(8U + N_SPECIALS, num_vertices(rhs) ); for (NFAVertex v : vertices_range(rhs)) { if (is_special(v, rhs)) { continue; } u32 cr = rhs[v].char_reach.find_first(); SCOPED_TRACE(cr); ASSERT_TRUE(cr >= 'b' && cr <= 'i'); } } TEST(NFAGraph, split2) { NGHolder src, lhs, rhs; NFAVertex a = add_vertex(src); NFAVertex b = add_vertex(src); NFAVertex c = add_vertex(src); NFAVertex d = add_vertex(src); src[a].char_reach = CharReach('a'); src[b].char_reach = CharReach('b'); src[c].char_reach = CharReach('c'); src[d].char_reach = CharReach('d'); add_edge(src.start, a, src); add_edge(d, src.acceptEod, src); add_edge(a, b, src); add_edge(b, c, src); add_edge(c, d, src); add_edge(d, b, src); NFAVertex pivot = c; ue2::unordered_map lhs_map; ue2::unordered_map rhs_map; splitGraph(src, pivot, &lhs, &lhs_map, &rhs, &rhs_map); ASSERT_EQ(3U + N_SPECIALS, num_vertices(lhs)); for (NFAVertex v : vertices_range(lhs)) { if (is_special(v, lhs)) { continue; } u32 cr = lhs[v].char_reach.find_first(); SCOPED_TRACE(cr); ASSERT_TRUE(cr >= 'a' && cr <= 'c'); } ASSERT_EQ(3U + N_SPECIALS, num_vertices(rhs) ); for (NFAVertex v : vertices_range(rhs)) { if (is_special(v, rhs)) { continue; } u32 cr = rhs[v].char_reach.find_first(); SCOPED_TRACE(cr); ASSERT_TRUE(cr >= 'b' && cr <= 'd'); } } TEST(NFAGraph, split3) { NGHolder src, lhs, rhs; NFAVertex a = add_vertex(src); NFAVertex b = add_vertex(src); NFAVertex c = add_vertex(src); NFAVertex d = add_vertex(src); NFAVertex e = add_vertex(src); NFAVertex f = add_vertex(src); NFAVertex g = add_vertex(src); NFAVertex h = add_vertex(src); NFAVertex i = add_vertex(src); src[a].char_reach = CharReach('a'); src[b].char_reach = CharReach('b'); src[c].char_reach = CharReach('c'); src[d].char_reach = CharReach('d'); src[e].char_reach = CharReach('e'); src[f].char_reach = CharReach('f'); src[g].char_reach = CharReach('g'); src[h].char_reach = CharReach('h'); src[i].char_reach = CharReach('i'); add_edge(src.start, a, src); add_edge(src.start, e, src); add_edge(i, src.acceptEod, src); add_edge(a, b, src); add_edge(b, c, src); add_edge(c, d, src); add_edge(e, f, src); add_edge(f, g, src); add_edge(h, i, src); add_edge(c, h, src); add_edge(d, h, src); add_edge(g, h, src); vector pivots; pivots.push_back(c); pivots.push_back(d); pivots.push_back(g); ue2::unordered_map lhs_map; ue2::unordered_map rhs_map; splitGraph(src, pivots, &lhs, &lhs_map, &rhs, &rhs_map); ASSERT_EQ(7U + N_SPECIALS, num_vertices(lhs)); for (NFAVertex v : vertices_range(lhs)) { if (is_special(v, lhs)) { continue; } u32 cr = lhs[v].char_reach.find_first(); SCOPED_TRACE(cr); ASSERT_TRUE((cr >= 'a' && cr <= 'g')); } ASSERT_EQ(2U + N_SPECIALS, num_vertices(rhs) ); for (NFAVertex v : vertices_range(rhs)) { if (is_special(v, rhs)) { continue; } u32 cr = rhs[v].char_reach.find_first(); SCOPED_TRACE(cr); ASSERT_TRUE(cr >= 'h' && cr <= 'i'); } } TEST(NFAGraph, split4) { NGHolder src, lhs, rhs; NFAVertex a = add_vertex(src); NFAVertex b = add_vertex(src); NFAVertex c = add_vertex(src); NFAVertex d = add_vertex(src); NFAVertex e = add_vertex(src); NFAVertex f = add_vertex(src); NFAVertex g = add_vertex(src); NFAVertex h = add_vertex(src); NFAVertex i = add_vertex(src); src[a].char_reach = CharReach('a'); src[b].char_reach = CharReach('b'); src[c].char_reach = CharReach('c'); src[d].char_reach = CharReach('d'); src[e].char_reach = CharReach('e'); src[f].char_reach = CharReach('f'); src[g].char_reach = CharReach('g'); src[h].char_reach = CharReach('h'); src[i].char_reach = CharReach('i'); add_edge(src.start, a, src); add_edge(src.start, e, src); add_edge(i, src.acceptEod, src); add_edge(a, b, src); add_edge(b, c, src); add_edge(c, d, src); add_edge(e, f, src); add_edge(f, g, src); add_edge(h, i, src); add_edge(c, h, src); add_edge(d, h, src); add_edge(g, h, src); /* loops */ add_edge(g, e, src); add_edge(d, d, src); vector pivots; pivots.push_back(c); pivots.push_back(d); pivots.push_back(g); ue2::unordered_map lhs_map; ue2::unordered_map rhs_map; splitGraph(src, pivots, &lhs, &lhs_map, &rhs, &rhs_map); ASSERT_EQ(7U + N_SPECIALS, num_vertices(lhs)); for (NFAVertex v : vertices_range(lhs)) { if (is_special(v, lhs)) { continue; } u32 cr = lhs[v].char_reach.find_first(); SCOPED_TRACE(cr); ASSERT_TRUE((cr >= 'a' && cr <= 'g')); } ASSERT_TRUE(edge(lhs_map[g], lhs_map[e], lhs).second); ASSERT_TRUE(edge(lhs_map[d], lhs_map[d], lhs).second); ASSERT_EQ(2U + N_SPECIALS, num_vertices(rhs) ); for (NFAVertex v : vertices_range(rhs)) { if (is_special(v, rhs)) { continue; } u32 cr = rhs[v].char_reach.find_first(); SCOPED_TRACE(cr); ASSERT_TRUE(cr >= 'h' && cr <= 'i'); } } TEST(NFAGraph, cyclicVerts1) { NGHolder g; NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); add_edge(a, b, g); add_edge(b, a, g); auto cyclics = find_vertices_in_cycles(g); ASSERT_EQ(flat_set({g.startDs, a, b}), cyclics); } TEST(NFAGraph, cyclicVerts2) { NGHolder g; NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); NFAVertex d = add_vertex(g); NFAVertex e = add_vertex(g); add_edge(g.start, a, g); add_edge(a, b, g); add_edge(b, c, g); add_edge(c, a, g); add_edge(c, d, g); add_edge(a, e, g); auto cyclics = find_vertices_in_cycles(g); ASSERT_EQ(flat_set({g.startDs, a, b, c}), cyclics); } TEST(NFAGraph, cyclicVerts3) { NGHolder g; NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); NFAVertex d = add_vertex(g); NFAVertex e = add_vertex(g); NFAVertex f = add_vertex(g); NFAVertex h = add_vertex(g); add_edge(g.start, a, g); add_edge(g.start, d, g); add_edge(a, b, g); add_edge(b, c, g); add_edge(b, f, g); add_edge(c, a, g); add_edge(b, d, g); add_edge(d, e, g); add_edge(e, b, g); add_edge(f, h, g); add_edge(h, h, g); auto cyclics = find_vertices_in_cycles(g); ASSERT_EQ(flat_set({g.startDs, a, b, c, d, e, h}), cyclics); } TEST(NFAGraph, cyclicVerts4) { NGHolder g; NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); NFAVertex d = add_vertex(g); NFAVertex e = add_vertex(g); NFAVertex f = add_vertex(g); NFAVertex h = add_vertex(g); add_edge(g.start, a, g); add_edge(g.start, d, g); add_edge(a, b, g); add_edge(b, c, g); add_edge(b, d, g); add_edge(c, e, g); add_edge(d, e, g); add_edge(e, a, g); add_edge(e, f, g); add_edge(f, h, g); auto cyclics = find_vertices_in_cycles(g); ASSERT_EQ(flat_set({g.startDs, a, b, c, d, e}), cyclics); } TEST(NFAGraph, cyclicVerts5) { NGHolder g; NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); NFAVertex d = add_vertex(g); NFAVertex e = add_vertex(g); add_edge(g.start, a, g); add_edge(g.start, e, g); add_edge(a, b, g); add_edge(b, c, g); add_edge(c, b, g); add_edge(c, d, g); add_edge(e, c, g); auto cyclics = find_vertices_in_cycles(g); ASSERT_EQ(flat_set({g.startDs, b, c}), cyclics); } hyperscan-4.4.1/unit/internal/rvermicelli.cpp0000644000175000017500000001701513055426554022117 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "nfa/vermicelli.h" #define BOUND (~(VERM_BOUNDARY - 1)) TEST(RVermicelli, ExecNoMatch1) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { for (size_t j = 0; j < 16; j++) { const u8 *begin = (const u8 *)t1 + i; const u8 *end = (const u8 *)t1 + strlen(t1) - j; const u8 *rv = rvermicelliExec('a', 0, begin, end); ASSERT_EQ(begin - 1, rv); rv = rvermicelliExec('B', 0, begin, end); ASSERT_EQ(begin - 1, rv); rv = rvermicelliExec('A', 1, begin, end); ASSERT_EQ(begin - 1, rv); } } } TEST(RVermicelli, Exec1) { char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 48, (size_t)rv); rv = rvermicelliExec('A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 48, (size_t)rv); } } TEST(RVermicelli, Exec2) { char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 48, (size_t)rv); rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 48, (size_t)rv); } } TEST(RVermicelli, Exec3) { char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbaaaaaaaaaaaaaaaaaaaaaaAbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 47, (size_t)rv); rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 48, (size_t)rv); } } TEST(RVermicelli, Exec4) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[16 + i] = 'a'; const u8 *rv = rvermicelliExec('a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[16 + i], (size_t)rv); rv = rvermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[16 + i], (size_t)rv); } } TEST(RDoubleVermicelli, Exec1) { char t1[] = "bbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = rvermicelliDoubleExec('a', 'b', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 50, (size_t)rv); rv = rvermicelliDoubleExec('A', 'B', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 50, (size_t)rv); rv = rvermicelliDoubleExec('b', 'a', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 49, (size_t)rv); rv = rvermicelliDoubleExec('B', 'A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 49, (size_t)rv); } } TEST(RDoubleVermicelli, Exec2) { char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 52, (size_t)rv); rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 52, (size_t)rv); } } TEST(RDoubleVermicelli, Exec3) { /* 012345678901234567890123 */ char t1[] = "bbbbbbbbbbbbbbbbbaAaaAAaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = rvermicelliDoubleExec('A', 'a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i ); ASSERT_EQ((size_t)t1 + 23, (size_t)rv); rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 52, (size_t)rv); rv = rvermicelliDoubleExec('A', 'A', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 22, (size_t)rv); rv = rvermicelliDoubleExec('a', 'A', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)t1 + 21, (size_t)rv); } } TEST(RDoubleVermicelli, Exec4) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[32 + i] = 'a'; t1[32 + i - 1] = 'a'; const u8 *rv = rvermicelliDoubleExec('a', 'a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[32 + i], (size_t)rv); rv = rvermicelliDoubleExec('A', 'A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[32 + i], (size_t)rv); } } TEST(RDoubleVermicelli, Exec5) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { for (size_t j = 1; j <= 16; j++) { t1[strlen(t1) - i - j] = 'a'; const u8 *rv = rvermicelliDoubleExec('b', 'a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1) - i); ASSERT_EQ((size_t)&t1[strlen(t1) - i - j], (size_t)rv); rv = rvermicelliDoubleExec('B', 'A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1) -i ); ASSERT_EQ((size_t)&t1[strlen(t1) - i - j], (size_t)rv); t1[strlen(t1) - i - j] = 'b'; } } } hyperscan-4.4.1/unit/internal/nfagraph_redundancy.cpp0000644000175000017500000001755113055426554023611 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** * Unit tests for checking the removeRedundancy code in * nfagraph/ng_redundancy.cpp. */ #include "config.h" #include "gtest/gtest.h" #include "nfagraph_common.h" #include "grey.h" #include "hs.h" #include "parser/Component.h" #include "parser/Parser.h" #include "compiler/compiler.h" #include "nfagraph/ng.h" #include "nfagraph/ng_builder.h" #include "nfagraph/ng_redundancy.h" #include "nfagraph/ng_edge_redundancy.h" #include "util/target_info.h" using namespace std; using namespace ue2; TEST(NFAGraph, RemoveRedundancy1) { // Build a small graph with a redundant vertex: (a|b)c // The character reachability should be merged into: [ab]c CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("(a|b)c", cc, 0)); ASSERT_TRUE(graph.get() != nullptr); NGHolder &g = *graph; // Run removeRedundancy removeRedundancy(g, SOM_NONE); // Our graph should only have two non-special nodes ASSERT_EQ((size_t)N_SPECIALS + 2, num_vertices(g)); // Dot-star start state should be connected to itself and a single other // vertex ASSERT_EQ(2U, out_degree(graph->startDs, g)); // That single vertex should have reachability [ab] NFAVertex v = NGHolder::null_vertex(); for (NFAVertex t : adjacent_vertices_range(graph->startDs, g)) { v = t; if (v != graph->startDs) { break; } } const CharReach &cr = g[v].char_reach; ASSERT_EQ(2U, cr.count()); ASSERT_TRUE(cr.test('a')); ASSERT_TRUE(cr.test('b')); // There should be a single edge from v to a node with char reachability 'c' ASSERT_EQ(1U, out_degree(v, g)); NFAVertex v2 = *(adjacent_vertices(v, g).first); const CharReach &cr2 = g[v2].char_reach; ASSERT_EQ(1U, cr2.count()); ASSERT_TRUE(cr2.test('c')); // 'c' should have an edge to accept ASSERT_TRUE(edge(v2, graph->accept, g).second); } TEST(NFAGraph, RemoveRedundancy2) { // Build a small graph with a redundant vertex: a.*b?c // The dot-star should swallow the 'b?', leaving a.*c CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("a.*b?c", cc, HS_FLAG_DOTALL)); ASSERT_TRUE(graph.get() != nullptr); NGHolder &g = *graph; // Run removeRedundancy removeRedundancy(g, SOM_NONE); // Our graph should now have only 3 non-special vertices ASSERT_EQ((size_t)N_SPECIALS + 3, num_vertices(g)); // Dot-star start state should be connected to itself and a single other // vertex ASSERT_EQ(2U, out_degree(graph->startDs, g)); // That single vertex should have reachability [a] NFAVertex v = NGHolder::null_vertex(); for (NFAVertex t : adjacent_vertices_range(graph->startDs, g)) { v = t; if (v != graph->startDs) { break; } } const CharReach &cr = g[v].char_reach; ASSERT_EQ(1U, cr.count()); ASSERT_TRUE(cr.test('a')); // 'a' should have two out edges: one to a dot with a cycle (.*) and one to // 'c' ASSERT_EQ(2U, out_degree(v, g)); NFAVertex dotstar = NGHolder::null_vertex(); NFAVertex vc = NGHolder::null_vertex(); for (NFAVertex t : adjacent_vertices_range(v, g)) { const CharReach &cr2 = g[t].char_reach; if (cr2.count() == 1 && cr2.test('c')) { vc = t; } else if (cr2.all()) { dotstar = t; } else { FAIL(); } } ASSERT_TRUE(vc != NGHolder::null_vertex()); ASSERT_TRUE(dotstar != NGHolder::null_vertex()); // Dot-star node should have a self-loop and an edge to vertex 'c' ASSERT_EQ(2U, out_degree(dotstar, g)); ASSERT_EQ(2U, in_degree(vc, g)); ASSERT_TRUE(edge(dotstar, dotstar, g).second); ASSERT_TRUE(edge(dotstar, vc, g).second); // 'c' should have an edge to accept ASSERT_TRUE(edge(vc, graph->accept, g).second); } TEST(NFAGraph, RemoveRedundancy3) { CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("foobar.*(a|b)?teakettle", cc, 0)); ASSERT_TRUE(graph.get() != nullptr); unsigned countBefore = num_vertices(*graph); removeRedundancy(*graph, SOM_NONE); // The '(a|b)?' construction (two states) should have disappeared, leaving // this expr as 'foobar.*teakettle' ASSERT_EQ(countBefore - 2, num_vertices(*graph)); } TEST(NFAGraph, RemoveRedundancy4) { CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("foo([A-Z]|a|b|q)", cc, 0)); ASSERT_TRUE(graph.get() != nullptr); unsigned countBefore = num_vertices(*graph); removeRedundancy(*graph, SOM_NONE); // We should end up with the alternation collapsing into one state ASSERT_EQ(countBefore - 3, num_vertices(*graph)); } TEST(NFAGraph, RemoveRedundancy5) { CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("[0-9]?badgerbrush", cc, 0)); ASSERT_TRUE(graph.get() != nullptr); unsigned countBefore = num_vertices(*graph); removeRedundancy(*graph, SOM_NONE); // Since we don't return a start offset, the first state ('[0-9]?') is // redundant. ASSERT_EQ(countBefore - 1, num_vertices(*graph)); } TEST(NFAGraph, RemoveEdgeRedundancy1) { CompileContext cc(false, false, get_current_target(), Grey()); auto graph = constructGraphWithCC("A+hatstand", cc, HS_FLAG_DOTALL); ASSERT_TRUE(graph.get() != nullptr); unsigned countBefore = num_edges(*graph); removeEdgeRedundancy(*graph, SOM_NONE, cc); // One edge (the self-loop on the leading A+) should have been removed. ASSERT_EQ(countBefore - 1, num_edges(*graph)); } TEST(NFAGraph, RemoveEdgeRedundancy2) { CompileContext cc(false, false, get_current_target(), Grey()); auto graph = constructGraphWithCC("foo.*A*bar", cc, HS_FLAG_DOTALL); ASSERT_TRUE(graph.get() != nullptr); size_t numEdgesBefore = num_edges(*graph); size_t numVertsBefore = num_vertices(*graph); removeEdgeRedundancy(*graph, SOM_NONE, cc); // The .* should swallow up the A* and its self-loop. ASSERT_EQ(numEdgesBefore - 4, num_edges(*graph)); ASSERT_EQ(numVertsBefore - 1, num_vertices(*graph)); } hyperscan-4.4.1/unit/internal/masked_move.cpp0000644000175000017500000000443613055426554022077 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include #include "gtest/gtest.h" #include "util/masked_move.h" namespace { #if defined(__AVX2__) bool try_mask_len(const u8 *buf, u8 *target, size_t len) { memset(target, 0, 32); memcpy(target, buf, len); m256 mask = masked_move256_len(buf, len); return (0 == memcmp((u8 *)&mask, target, 32)); } static const char *alpha = "0123456789abcdefghijklmnopqrstuvwxyz0123456789abcde" "fghijklmnopqrstuvwxyz0123456789abcdefghijklmnopqrst" "uvwxyz"; TEST(MaskedMove, tymm) { const u8 *buf = (const u8 *)alpha; u8 target[32]; for (int len = 4; len <= 32; len++) { EXPECT_TRUE(try_mask_len(buf, target, len)) << "len: " << len; } } #endif } // namespace hyperscan-4.4.1/unit/internal/utf8_validate.cpp0000644000175000017500000000766113055426554022347 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "parser/utf8_validate.h" #include "ue2common.h" #include "util/string_util.h" #include "gtest/gtest.h" using namespace testing; using namespace ue2; struct ValidUtf8TestInfo { std::string str; bool is_valid; }; // Helper for gtest. static void PrintTo(const ValidUtf8TestInfo &t, ::std::ostream *os) { *os << "(\"" << printable(t.str) << "\", " << t.is_valid << ")"; } static ValidUtf8TestInfo valid_utf8_tests[] = { // Trivial ASCII. {"foobar", true}, {"0", true}, {"\x7e", true}, {"hatstand\tteakettle\tbadgerbrush\n", true}, // Some valid UTF-8: Movie titles! {"À bout de souffle", true}, {"拳銃ã¯ä¿ºã®ãƒ‘スãƒãƒ¼ãƒˆ", true}, {"大醉俠", true}, {"龙门客栈", true}, {"ê³µë™ê²½ë¹„구역", true}, {"জলসাঘর", true}, // Invalid one-byte caseS. {"\x7f", false}, // These bytes should never appear in a UTF-8 stream. {"\xc0", false}, {"\xc1", false}, {"\xf5", false}, {"\xf6", false}, {"\xf7", false}, {"\xf8", false}, {"\xf9", false}, {"\xfa", false}, {"\xfc", false}, {"\xfd", false}, {"\xfe", false}, {"\xff", false}, {"\xff", false}, // Examples from RFC-3629 section 7. {"\x41\xe2\x89\xa2\xce\x91\x2e", true}, {"\xed\x95\x9c\xea\xb5\xad\xec\x96\xb4", true}, {"\xe6\x97\xa5\xe6\x9c\xac\xe8\xaa\x9e", true}, {"\xef\xbb\xbf\xf0\xa3\x8e\xb4", true}, // Examples from RFC-3629 section 10. (security concerns) {"/../", true}, {"\x2f\xc0\xae\x2e\x2f", false}, // overlong // Overlong encodings {"\xc0\xc1", false}, // 'a' as two bytes {"\xe0\x80\xc1", false}, // 'a' as three bytes {"\xf0\x80\x80\xc1", false}, // 'a' as four bytes /* invalid continuing bytes */ {"\xd1\xf1", false}, {"\xef\xbf\xf1", false}, {"\xef\xf1\xbf", false}, {"\xf1\xf1\xf1\xf1", false}, {"\xf1\xbf\xbf\xf1", false}, {"\xf1\xbf\xf1\xbf", false}, {"\xf1\xf1\xbf\xbf", false}, // UTF-16 surrogates {"\xed\xa0\x80", false}, // U+D800 {"\xed\xb2\x80", false}, // U+DC80 }; class ValidUtf8Test : public TestWithParam {}; INSTANTIATE_TEST_CASE_P(ValidUtf8, ValidUtf8Test, ValuesIn(valid_utf8_tests)); TEST_P(ValidUtf8Test, check) { const auto &info = GetParam(); ASSERT_EQ(info.is_valid, isValidUtf8(info.str.c_str())) << "String is: " << printable(info.str) << std::endl; } hyperscan-4.4.1/unit/internal/pack_bits.cpp0000644000175000017500000001221513055426554021536 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/pack_bits.h" #include "util/make_unique.h" #include "ue2common.h" #include #include #include using std::unique_ptr; using std::vector; template class PackBits : public testing::Test {}; typedef ::testing::Types PackBitsTypes; TYPED_TEST_CASE(PackBits, PackBitsTypes); // Templated wrappers around the pack_bits_{32,64} functions. template void pack_bits(char *out, const T *v, const u32 *bits, unsigned elements); template void unpack_bits(T *v, const char *in, const u32 *bits, unsigned elements); template <> void pack_bits(char *out, const u32 *v, const u32 *bits, unsigned elements) { return pack_bits_32(out, v, bits, elements); } template <> void pack_bits(char *out, const u64a *v, const u32 *bits, unsigned elements) { return pack_bits_64(out, v, bits, elements); } template <> void unpack_bits(u32 *v, const char *in, const u32 *bits, unsigned elements) { return unpack_bits_32(v, (const u8 *)in, bits, elements); } template <> void unpack_bits(u64a *v, const char *in, const u32 *bits, unsigned elements) { return unpack_bits_64(v, (const u8 *)in, bits, elements); } template size_t packed_size(const vector &bits) { size_t num_bits = 0; for (size_t i = 0; i < bits.size(); i++) { num_bits += bits[i]; } return ROUNDUP_N(num_bits, 8U) / 8U; } template void test_pack_and_unpack(const vector &v, const vector &bits) { const u32 max_bits = sizeof(T) * 8U; const u32 elements = bits.size(); // Temporary char array to pack into. const size_t mem_size = packed_size(bits); unique_ptr mem = ue2::make_unique(mem_size); pack_bits(&mem[0], &v[0], &bits[0], elements); vector v2(elements, 0xcafecafeu); // Output vector. unpack_bits(&v2[0], &mem[0], &bits[0], elements); for (u32 i = 0; i < elements; i++) { // Check that v2[i] contains the bits[i] low bits of v[i]. T mask = bits[i] == max_bits ? ~(T)0 : ((T)1U << bits[i]) - 1; ASSERT_EQ(v[i] & mask, v2[i]) << "element " << i << " mismatch"; } } TYPED_TEST(PackBits, AllZeroes) { for (u32 i = 1; i < 32; i++) { SCOPED_TRACE(i); vector v(i, 0); vector bits(i, sizeof(TypeParam) * 8U); // all bits test_pack_and_unpack(v, bits); } } TYPED_TEST(PackBits, AllOnes) { for (u32 i = 1; i < 32; i++) { SCOPED_TRACE(i); vector v(i, ~((TypeParam)0)); for (u32 num_bits = 0; num_bits < sizeof(TypeParam) * 8U; num_bits++) { vector bits(i, num_bits); test_pack_and_unpack(v, bits); } } } TYPED_TEST(PackBits, SomeOnes) { for (u32 i = 1; i < 32; i++) { SCOPED_TRACE(i); vector v(i, ~((TypeParam)0)); // One bit from v[0], two bits from v[1] ... vector bits(i); for (u32 j = 0; j < i; j++) { } test_pack_and_unpack(v, bits); // And in reverse std::reverse(bits.begin(), bits.end()); test_pack_and_unpack(v, bits); } } TYPED_TEST(PackBits, Holes) { for (u32 i = 1; i < 32; i++) { SCOPED_TRACE(i); vector v(i, ~((TypeParam)0)); // No bits from odd-numbered words. vector bits(i); for (u32 j = 0; j < i; j++) { bits[j] = j % 2 ? 0 : sizeof(TypeParam) * 8U; } test_pack_and_unpack(v, bits); } } hyperscan-4.4.1/unit/internal/truffle.cpp0000644000175000017500000004036713055426554021257 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "nfa/truffle.h" #include "nfa/trufflecompile.h" #include "util/charreach.h" #include "util/simd_utils.h" using namespace ue2; TEST(Truffle, CompileDot) { m128 mask1, mask2; memset(&mask1, 0, sizeof(mask1)); memset(&mask2, 0, sizeof(mask2)); CharReach chars; chars.setall(); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); CharReach out = truffle2cr((u8 *)&mask1, (u8 *)&mask2); ASSERT_EQ(out, chars); } TEST(Truffle, CompileChars) { m128 mask1, mask2; CharReach chars; // test one char at a time for (u32 c = 0; c < 256; ++c) { mask1 = zeroes128(); mask2 = zeroes128(); chars.clear(); chars.set((u8)c); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); CharReach out = truffle2cr((u8 *)&mask1, (u8 *)&mask2); ASSERT_EQ(out, chars); } // set all chars up to dot for (u32 c = 0; c < 256; ++c) { mask1 = zeroes128(); mask2 = zeroes128(); chars.set((u8)c); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); CharReach out = truffle2cr((u8 *)&mask1, (u8 *)&mask2); ASSERT_EQ(out, chars); } // unset all chars from dot for (u32 c = 0; c < 256; ++c) { mask1 = zeroes128(); mask2 = zeroes128(); chars.clear((u8)c); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); CharReach out = truffle2cr((u8 *)&mask1, (u8 *)&mask2); ASSERT_EQ(out, chars); } } TEST(Truffle, ExecNoMatch1) { m128 mask1, mask2; memset(&mask1, 0, sizeof(mask1)); memset(&mask2, 0, sizeof(mask2)); CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb\xff"; for (size_t i = 0; i < 16; i++) { const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + strlen(t1), (size_t)rv); } } TEST(Truffle, ExecNoMatch2) { m128 mask1, mask2; CharReach chars; chars.set('a'); chars.set('B'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + strlen(t1), (size_t)rv); } } TEST(Truffle, ExecNoMatch3) { m128 mask1, mask2; CharReach chars; chars.set('V'); /* V = 0x56, e = 0x65 */ truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; for (size_t i = 0; i < 16; i++) { const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + strlen(t1), (size_t)rv); } } TEST(Truffle, ExecMiniMatch0) { m128 lo, hi; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); char t1[] = "a"; const u8 *rv = truffleExec(lo, hi, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1, (size_t)rv); } TEST(Truffle, ExecMiniMatch1) { m128 lo, hi; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); char t1[] = "bbbbbbbabbb"; const u8 *rv = truffleExec(lo, hi, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 7, (size_t)rv); } TEST(Truffle, ExecMiniMatch2) { m128 lo, hi; CharReach chars; chars.set(0); truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); char t1[] = "bbbbbbb\0bbb"; const u8 *rv = truffleExec(lo, hi, (u8 *)t1, (u8 *)t1 + 11); ASSERT_EQ((size_t)t1 + 7, (size_t)rv); } TEST(Truffle, ExecMiniMatch3) { m128 lo, hi; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); char t1[] = "\0\0\0\0\0\0\0a\0\0\0"; const u8 *rv = truffleExec(lo, hi, (u8 *)t1, (u8 *)t1 + 11); ASSERT_EQ((size_t)t1 + 7, (size_t)rv); } TEST(Truffle, ExecMatchBig) { m128 lo, hi; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); std::array t1; t1.fill('b'); t1[120] = 'a'; for (size_t i = 0; i < 16; i++) { const u8 *rv = truffleExec(lo, hi, (u8 *)t1.data() + i, (u8 *)t1.data() + 399); ASSERT_LE(((size_t)t1.data() + 120) & ~0xf, (size_t)rv); } } TEST(Truffle, ExecMatch1) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(Truffle, ExecMatch2) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(Truffle, ExecMatch3) { m128 mask1, mask2; CharReach chars; chars.set('a'); chars.set('B'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbBaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(Truffle, ExecMatch4) { m128 mask1, mask2; CharReach chars; chars.set('a'); chars.set('C'); chars.set('A'); chars.set('c'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbAaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t2[] = "bbbbbbbbbbbbbbbbbCaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t3[] = "bbbbbbbbbbbbbbbbbcaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; char t4[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = truffleExec(mask1, mask2, (u8 *)t2 + i, (u8 *)t2 + strlen(t1)); ASSERT_EQ((size_t)t2 + 17, (size_t)rv); rv = truffleExec(mask1, mask2, (u8 *)t3 + i, (u8 *)t3 + strlen(t3)); ASSERT_EQ((size_t)t3 + 17, (size_t)rv); rv = truffleExec(mask1, mask2, (u8 *)t4 + i, (u8 *)t4 + strlen(t4)); ASSERT_EQ((size_t)t4 + 17, (size_t)rv); } } TEST(Truffle, ExecMatch5) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[48 - i] = 'a'; const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); } } TEST(Truffle, ExecMatch6) { m128 mask1, mask2; CharReach chars; // [0-Z] - includes some graph chars chars.setRange('0', 'Z'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); std::array t1; t1.fill('*'); // it's full of stars! for (u8 c = '0'; c <= 'Z'; c++) { t1[17] = c; const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1.data(), (u8 *)t1.data() + 128); ASSERT_EQ((size_t)t1.data() + 17, (size_t)rv); } } TEST(Truffle, ExecMatch7) { m128 mask1, mask2; CharReach chars; // hi bits chars.setRange(127, 255); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); std::array t1; t1.fill('*'); // it's full of stars! for (unsigned int c = 127; c <= 255; c++) { t1[40] = (u8)c; const u8 *rv = truffleExec(mask1, mask2, (u8 *)t1.data(), (u8 *)t1.data() + 128); ASSERT_EQ((size_t)t1.data() + 40, (size_t)rv); } } TEST(ReverseTruffle, ExecNoMatch1) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_EQ((const u8 *)(t1 - 1), rv); } } TEST(ReverseTruffle, ExecNoMatch2) { m128 mask1, mask2; CharReach chars; chars.set('a'); chars.set('B'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_EQ((const u8 *)(t1 - 1), rv); } } TEST(ReverseTruffle, ExecNoMatch3) { m128 mask1, mask2; CharReach chars; chars.set('V'); /* V = 0x56, e = 0x65 */ truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); char t1[] = "eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_EQ((const u8 *)(t1 - 1), rv); } } TEST(ReverseTruffle, ExecMiniMatch0) { m128 lo, hi; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&lo, (u8 *)&hi); char t1[] = "a"; const u8 *rv = rtruffleExec(lo, hi, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1, (size_t)rv); } TEST(ReverseTruffle, ExecMiniMatch1) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbabbbb"; size_t len = strlen(t1); const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t1 + 7, rv); } TEST(ReverseTruffle, ExecMiniMatch2) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "babbbbbabbbb"; size_t len = strlen(t1); const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t1 + 7, rv); } TEST(ReverseTruffle, ExecMatch1) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbabbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t1 + 17, rv); } } TEST(ReverseTruffle, ExecMatch2) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbabbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t1 + 32, rv); } } TEST(ReverseTruffle, ExecMatch3) { m128 mask1, mask2; CharReach chars; chars.set('a'); chars.set('B'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaBbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('B', (char)*rv); ASSERT_EQ((const u8 *)t1 + 32, rv); } // check that we match the 'a' bytes as well. ASSERT_EQ('B', t1[32]); t1[32] = 'b'; for (size_t i = 0; i < 16; i++) { const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len - i); ASSERT_NE((const u8 *)t1 - 1, rv); // not found EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t1 + 31, rv); } } TEST(ReverseTruffle, ExecMatch4) { m128 mask1, mask2; CharReach chars; chars.set('a'); chars.set('C'); chars.set('A'); chars.set('c'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); /* 0123456789012345678901234567890 */ char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaAbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; char t2[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaCbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; char t3[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaacbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; char t4[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaabbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < 16; i++) { const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len - i); EXPECT_EQ('A', (char)*rv); ASSERT_EQ((const u8 *)t1 + 32, rv); rv = rtruffleExec(mask1, mask2, (u8 *)t2, (u8 *)t2 + len - i); EXPECT_EQ('C', (char)*rv); ASSERT_EQ((const u8 *)t2 + 32, rv); rv = rtruffleExec(mask1, mask2, (u8 *)t3, (u8 *)t3 + len - i); EXPECT_EQ('c', (char)*rv); ASSERT_EQ((const u8 *)t3 + 32, rv); rv = rtruffleExec(mask1, mask2, (u8 *)t4, (u8 *)t4 + len - i); EXPECT_EQ('a', (char)*rv); ASSERT_EQ((const u8 *)t4 + 32, rv); } } TEST(ReverseTruffle, ExecMatch5) { m128 mask1, mask2; CharReach chars; chars.set('a'); truffleBuildMasks(chars, (u8 *)&mask1, (u8 *)&mask2); char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; size_t len = strlen(t1); for (size_t i = 0; i < len; i++) { t1[i] = 'a'; const u8 *rv = rtruffleExec(mask1, mask2, (u8 *)t1, (u8 *)t1 + len); ASSERT_EQ((const u8 *)t1 + i, rv); } } hyperscan-4.4.1/unit/internal/nfagraph_repeat.cpp0000644000175000017500000000741613055426554022734 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "nfagraph_common.h" #include "gtest/gtest.h" #include "nfagraph/ng_repeat.h" #include "nfagraph/ng_util.h" #include "util/depth.h" #include "hs_compile.h" using namespace std; using namespace testing; using namespace ue2; static UNUSED std::ostream& operator<<(std::ostream &os, const depth &d) { // We reimplement depth::str, as it's only available if dump support is // compiled in. if (d.is_unreachable()) { os << "unr"; return os; } else if (d.is_infinite()) { os << "inf"; return os; } u32 val = d; // finite val os << val; return os; } struct PureRepeatTest { string pattern; depth minBound; depth maxBound; }; class NFAPureRepeatTest : public TestWithParam { }; static const PureRepeatTest pureRepeatTests[] = { { "^.*", 0, depth::infinity() }, { "^.+", 1, depth::infinity() }, { "^.", 1, 1 }, { "^..", 2, 2 }, { "^.?.", 1, 2 }, { "^.{1,2}", 1, 2 }, { "^.{1,3}", 1, 3 }, { "^.{1,10}", 1, 10 }, { "^.{1,200}", 1, 200 }, { "^.{200}", 200, 200 }, { "^.{0,}", 0, depth::infinity() }, { "^.{1,}", 1, depth::infinity() }, { "^.{2,}", 2, depth::infinity() }, { "^.{10,}", 10, depth::infinity() }, { "^.{200,}", 200, depth::infinity() }, { "^.{5000,}", 5000, depth::infinity() }, { "^.{0,1}", 0, 1 }, { "^.{0,2}", 0, 2 }, { "^.{0,100}", 0, 100 }, { "^.{0,5000}", 0, 5000 }, { "^x{10}x{20,30}", 30, 40 }, { "^..?..?..?..?..?", 5, 10 } }; INSTANTIATE_TEST_CASE_P(PureRepeat, NFAPureRepeatTest, ValuesIn(pureRepeatTests)); TEST_P(NFAPureRepeatTest, Check) { const PureRepeatTest &t = GetParam(); SCOPED_TRACE(testing::Message() << "Pattern: " << t.pattern); auto w = constructGraph(t.pattern, HS_FLAG_ALLOWEMPTY); ASSERT_TRUE(w != nullptr); clearReports(*w); PureRepeat repeat; bool result = isPureRepeat(*w, repeat); ASSERT_EQ(true, result); ASSERT_EQ(t.minBound, repeat.bounds.min); ASSERT_EQ(t.maxBound, repeat.bounds.max); } // for google test void PrintTo(const PureRepeatTest &p, ::std::ostream *os) { *os << "PureRepeatTest: " << p.pattern << "{" << p.minBound << ',' << p.maxBound << '}'; } hyperscan-4.4.1/unit/internal/limex_nfa.cpp0000644000175000017500000003235713055426554021552 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "grey.h" #include "compiler/compiler.h" #include "nfa/limex_internal.h" #include "nfa/nfa_api.h" #include "nfa/nfa_api_util.h" #include "nfa/nfa_internal.h" #include "nfagraph/ng.h" #include "nfagraph/ng_limex.h" #include "nfagraph/ng_util.h" #include "util/alloc.h" #include "util/target_info.h" using namespace std; using namespace testing; using namespace ue2; static const string SCAN_DATA = "___foo______\n___foofoo_foo_^^^^^^^^^^^^^^^^^^" "^^^^__bar_bar______0_______z_____bar"; static const u32 MATCH_REPORT = 1024; static int onMatch(u64a, u64a, ReportID, void *ctx) { unsigned *matches = (unsigned *)ctx; (*matches)++; return MO_CONTINUE_MATCHING; } // Parameterized with LimEx model and target flags. class LimExModelTest : public TestWithParam { protected: virtual void SetUp() { type = GetParam(); hs_platform_info plat; hs_error_t err = hs_populate_platform(&plat); ASSERT_EQ(HS_SUCCESS, err); target_t target(plat); matches = 0; const string expr = "(foo.*bar)|end\\z"; const unsigned flags = 0; CompileContext cc(false, false, target, Grey()); ReportManager rm(cc.grey); ParsedExpression parsed(0, expr.c_str(), flags, 0); unique_ptr g = buildWrapper(rm, cc, parsed); ASSERT_TRUE(g != nullptr); clearReports(*g); rm.setProgramOffset(0, MATCH_REPORT); const map fixed_depth_tops; const map>> triggers; bool compress_state = false; nfa = constructNFA(*g, &rm, fixed_depth_tops, triggers, compress_state, type, cc); ASSERT_TRUE(nfa != nullptr); full_state = aligned_zmalloc_unique(nfa->scratchStateSize); stream_state = aligned_zmalloc_unique(nfa->streamStateSize); } virtual void initQueue() { q.nfa = nfa.get(); q.cur = 0; q.end = 0; q.state = full_state.get(); q.streamState = stream_state.get(); q.offset = 0; q.buffer = (const u8 *)SCAN_DATA.c_str(); q.length = SCAN_DATA.size(); q.history = nullptr; q.hlength = 0; q.scratch = nullptr; /* limex does not use scratch */ q.report_current = 0; q.cb = onMatch; q.context = &matches; } // NFA type (enum NFAEngineType) int type; // Match count unsigned matches; // Compiled NFA structure. aligned_unique_ptr nfa; // Space for full state. aligned_unique_ptr full_state; // Space for stream state. aligned_unique_ptr stream_state; // Queue structure. struct mq q; }; INSTANTIATE_TEST_CASE_P( LimEx, LimExModelTest, Range((int)LIMEX_NFA_32, (int)LIMEX_NFA_512)); TEST_P(LimExModelTest, StateSize) { ASSERT_TRUE(nfa != nullptr); hs_platform_info plat; hs_error_t err = hs_populate_platform(&plat); ASSERT_EQ(HS_SUCCESS, err); target_t target(plat); // About all we can say is that any NFA should require at least one byte of // state space. EXPECT_LT(0, nfa->scratchStateSize); EXPECT_LT(0, nfa->streamStateSize); } TEST_P(LimExModelTest, QueueExec) { ASSERT_TRUE(nfa != nullptr); initQueue(); nfaQueueInitState(nfa.get(), &q); u64a end = SCAN_DATA.size(); pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); nfaQueueExec(nfa.get(), &q, end); ASSERT_EQ(3, matches); } TEST_P(LimExModelTest, CompressExpand) { ASSERT_TRUE(nfa != nullptr); u32 real_state_size = nfa->scratchStateSize; /* Only look at 8 bytes for limex 64 (rather than the padding) */ if (nfa->type == LIMEX_NFA_64) { real_state_size = sizeof(u64a); } initQueue(); nfaQueueInitState(nfa.get(), &q); // Do some scanning. u64a end = SCAN_DATA.size(); pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); nfaQueueExec(nfa.get(), &q, end); // Compress state. nfaQueueCompressState(nfa.get(), &q, end); // Expand state into a new copy and check that it matches the original // uncompressed state. aligned_unique_ptr state_copy = aligned_zmalloc_unique(nfa->scratchStateSize); char *dest = state_copy.get(); memset(dest, 0xff, nfa->scratchStateSize); nfaExpandState(nfa.get(), dest, q.streamState, q.offset, queue_prev_byte(&q, end)); ASSERT_TRUE(std::equal(dest, dest + real_state_size, full_state.get())); } TEST_P(LimExModelTest, InitCompressedState0) { ASSERT_TRUE(nfa != nullptr); // 64-bit NFAs assume during compression that they have >= 5 bytes of // compressed NFA state, which isn't true for our 8-state test pattern. We // skip this test for just these models. if (nfa->scratchStateSize == 8) { return; } // Trivial case: init at zero, like we do with outfixes. char rv = nfaInitCompressedState(nfa.get(), 0, stream_state.get(), '\0'); ASSERT_NE(0, rv); } TEST_P(LimExModelTest, QueueExecToMatch) { ASSERT_TRUE(nfa != nullptr); initQueue(); nfaQueueInitState(nfa.get(), &q); u64a end = SCAN_DATA.size(); pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); // FIRST MATCH (of three). char rv = nfaQueueExecToMatch(nfa.get(), &q, end); ASSERT_EQ(MO_MATCHES_PENDING, rv); ASSERT_EQ(0, matches); ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q)); nfaReportCurrentMatches(nfa.get(), &q); ASSERT_EQ(1, matches); // SECOND MATCH (of three). rv = nfaQueueExecToMatch(nfa.get(), &q, end); ASSERT_EQ(MO_MATCHES_PENDING, rv); ASSERT_EQ(1, matches); ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q)); nfaReportCurrentMatches(nfa.get(), &q); ASSERT_EQ(2, matches); // THIRD MATCH (of three). rv = nfaQueueExecToMatch(nfa.get(), &q, end); ASSERT_EQ(MO_MATCHES_PENDING, rv); ASSERT_EQ(2, matches); ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q)); nfaReportCurrentMatches(nfa.get(), &q); ASSERT_EQ(3, matches); // No more. rv = nfaQueueExecToMatch(nfa.get(), &q, end); ASSERT_EQ(MO_ALIVE, rv); ASSERT_EQ(3, matches); } TEST_P(LimExModelTest, QueueExecRose) { ASSERT_TRUE(nfa != nullptr); initQueue(); // For rose, there's no callback or context. q.cb = nullptr; q.context = nullptr; nfaQueueInitState(nfa.get(), &q); u64a end = SCAN_DATA.size(); pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); char rv = nfaQueueExecRose(nfa.get(), &q, MATCH_REPORT); ASSERT_EQ(MO_MATCHES_PENDING, rv); pushQueue(&q, MQE_START, end); ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q)); } TEST_P(LimExModelTest, CheckFinalState) { ASSERT_TRUE(nfa != nullptr); initQueue(); nfaQueueInitState(nfa.get(), &q); // Do some scanning. u64a end = SCAN_DATA.size(); pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); nfaQueueExec(nfa.get(), &q, end); ASSERT_EQ(3, matches); // Check for EOD matches. char rv = nfaCheckFinalState(nfa.get(), full_state.get(), stream_state.get(), end, onMatch, &matches); ASSERT_EQ(MO_CONTINUE_MATCHING, rv); } // For testing the _B_Reverse backwards-scanning block-mode path. class LimExReverseTest : public TestWithParam { protected: virtual void SetUp() { type = GetParam(); matches = 0; const string expr = "foo.*bar"; const unsigned flags = 0; CompileContext cc(false, false, get_current_target(), Grey()); ReportManager rm(cc.grey); ParsedExpression parsed(0, expr.c_str(), flags, 0); unique_ptr g = buildWrapper(rm, cc, parsed); ASSERT_TRUE(g != nullptr); clearReports(*g); // Reverse the graph and add some reports on the accept vertices. NGHolder g_rev(NFA_REV_PREFIX); reverseHolder(*g, g_rev); clearReports(g_rev); for (NFAVertex v : inv_adjacent_vertices_range(g_rev.accept, g_rev)) { g_rev[v].reports.insert(0); } nfa = constructReversedNFA(g_rev, type, cc); ASSERT_TRUE(nfa != nullptr); } // NFA type (enum NFAEngineType) int type; // Match count unsigned matches; // Compiled NFA structure. aligned_unique_ptr nfa; }; INSTANTIATE_TEST_CASE_P(LimExReverse, LimExReverseTest, Range((int)LIMEX_NFA_32, (int)LIMEX_NFA_512)); TEST_P(LimExReverseTest, BlockExecReverse) { ASSERT_TRUE(nfa != nullptr); u64a offset = 0; const u8 *buf = (const u8 *)SCAN_DATA.c_str(); const size_t buflen = SCAN_DATA.size(); const u8 *hbuf = nullptr; const size_t hlen = 0; nfaBlockExecReverse(nfa.get(), offset, buf, buflen, hbuf, hlen, onMatch, &matches); ASSERT_EQ(3, matches); } // Test the ZOMBIE path. static const string ZOMBIE_SCAN_DATA = "braaaiiiiiins!!!!!"; class LimExZombieTest : public TestWithParam { protected: virtual void SetUp() { type = GetParam(); matches = 0; const string expr = "bra+i+ns.*"; const unsigned flags = HS_FLAG_DOTALL; CompileContext cc(true, false, get_current_target(), Grey()); ParsedExpression parsed(0, expr.c_str(), flags, 0); ReportManager rm(cc.grey); unique_ptr g = buildWrapper(rm, cc, parsed); ASSERT_TRUE(g != nullptr); clearReports(*g); rm.setProgramOffset(0, MATCH_REPORT); const map fixed_depth_tops; const map>> triggers; bool compress_state = false; nfa = constructNFA(*g, &rm, fixed_depth_tops, triggers, compress_state, type, cc); ASSERT_TRUE(nfa != nullptr); full_state = aligned_zmalloc_unique(nfa->scratchStateSize); stream_state = aligned_zmalloc_unique(nfa->streamStateSize); } virtual void initQueue() { q.nfa = nfa.get(); q.cur = 0; q.end = 0; q.state = full_state.get(); q.streamState = stream_state.get(); q.offset = 0; q.buffer = (const u8 *)ZOMBIE_SCAN_DATA.c_str(); q.length = ZOMBIE_SCAN_DATA.length(); q.history = nullptr; q.hlength = 0; q.scratch = nullptr; /* limex does not use scratch */ q.report_current = 0; q.cb = onMatch; q.context = &matches; } // NFA type (enum NFAEngineType) int type; // Match count unsigned matches; // Compiled NFA structure. aligned_unique_ptr nfa; // Space for full state. aligned_unique_ptr full_state; // Space for stream state. aligned_unique_ptr stream_state; // Queue structure. struct mq q; }; INSTANTIATE_TEST_CASE_P(LimExZombie, LimExZombieTest, Range((int)LIMEX_NFA_32, (int)LIMEX_NFA_512)); TEST_P(LimExZombieTest, GetZombieStatus) { ASSERT_TRUE(nfa != nullptr); ASSERT_TRUE(nfa->flags & NFA_ZOMBIE); initQueue(); nfaQueueInitState(nfa.get(), &q); // Not a zombie yet ASSERT_EQ(NFA_ZOMBIE_NO, nfaGetZombieStatus(nfa.get(), &q, 0)); u64a end = q.length; pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); nfaQueueExec(nfa.get(), &q, end); ASSERT_EQ(6, matches); // one plus the number of '!' chars // The .* at the end of the pattern should have turned us into a zombie... ASSERT_EQ(NFA_ZOMBIE_ALWAYS_YES, nfaGetZombieStatus(nfa.get(), &q, end)); } hyperscan-4.4.1/unit/internal/nfagraph_equivalence.cpp0000644000175000017500000005043213055426554023751 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ /** * Unit tests for checking the removeGraphEquivalences code in * nfagraph/ng_equivalence.cpp. */ #include "config.h" #include "gtest/gtest.h" #include "nfagraph_common.h" #include "grey.h" #include "hs.h" #include "parser/Component.h" #include "parser/Parser.h" #include "compiler/compiler.h" #include "nfagraph/ng.h" #include "nfagraph/ng_builder.h" #include "nfagraph/ng_equivalence.h" #include "nfagraph/ng_misc_opt.h" #include "util/target_info.h" using namespace std; using namespace ue2; // left equivalence TEST(NFAGraph, RemoveEquivalence1) { // Build a small graph with a redundant vertex: (ab|ac) // The graph should be merged into: a(b|c) CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("(ab|ac)", cc, 0)); ASSERT_TRUE(graph != nullptr); NGHolder &g = *graph; g.kind = NFA_SUFFIX; // Run reduceGraphEquivalences ASSERT_TRUE(reduceGraphEquivalences(g, cc)); // Our graph should only have three non-special nodes ASSERT_EQ((size_t)N_SPECIALS + 3, num_vertices(g)); // Start dot start state should have edges to itself and one vertex ASSERT_EQ(2U, out_degree(g.startDs, g)); // Accept state should have two incoming edges ASSERT_EQ(2U, in_degree(g.accept, g)); // Find a vertex that goes right after startDs NFAVertex a = NGHolder::null_vertex(); for (NFAVertex v : adjacent_vertices_range(g.startDs, g)) { a = v; if (a == g.startDs) { continue; } // check if it has the right char reach const CharReach &tmpcr = g[a].char_reach; ASSERT_EQ(1U, tmpcr.count()); ASSERT_TRUE(tmpcr.test('a')); } // check if we found our vertex ASSERT_TRUE(a != NGHolder::null_vertex()); // There should be two edges from v to nodes with reachability 'b' and 'c' NFAVertex b = NGHolder::null_vertex(); NFAVertex c = NGHolder::null_vertex(); for (NFAVertex tmp : adjacent_vertices_range(a, g)) { const CharReach &tmpcr = g[tmp].char_reach; ASSERT_EQ(1U, tmpcr.count()); if (tmpcr.test('b')) { b = tmp; } else if (tmpcr.test('c')) { c = tmp; } else { FAIL(); } } // check if we found our vertices ASSERT_TRUE(b != NGHolder::null_vertex()); ASSERT_TRUE(c != NGHolder::null_vertex()); // both vertices should have an edge to accept ASSERT_TRUE(edge(b, g.accept, g).second); ASSERT_TRUE(edge(c, g.accept, g).second); } // right equivalence TEST(NFAGraph, RemoveEquivalence2) { // Build a small graph with a redundant vertex: (ba|ca) // The graph should be merged into: (b|c)a CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("(ba|ca)", cc, 0)); ASSERT_TRUE(graph != nullptr); NGHolder &g = *graph; g.kind = NFA_SUFFIX; // Run reduceGraphEquivalences ASSERT_TRUE(reduceGraphEquivalences(g, cc)); // Our graph should only have two non-special nodes ASSERT_EQ((size_t)N_SPECIALS + 3, num_vertices(g)); // Start dot start state should have edges to itself and two more vertices ASSERT_EQ(3U, out_degree(g.startDs, g)); // Accept start state should have edges from one vertex only ASSERT_EQ(1U, in_degree(g.accept, g)); // Find a vertex leading to accept NFAVertex a = NGHolder::null_vertex(); for (NFAVertex v : inv_adjacent_vertices_range(g.accept, g)) { a = v; if (a == g.accept) { continue; } // check if it has the right char reach const CharReach &tmpcr = g[a].char_reach; ASSERT_EQ(1U, tmpcr.count()); ASSERT_TRUE(tmpcr.test('a')); } // check if we found our vertex ASSERT_TRUE(a != NGHolder::null_vertex()); // There should be two edges from v to nodes with reachability 'b' and 'c' NFAVertex b = NGHolder::null_vertex(); NFAVertex c = NGHolder::null_vertex(); for (NFAVertex tmp : inv_adjacent_vertices_range(a, g)) { const CharReach &tmpcr = g[tmp].char_reach; ASSERT_EQ(1U, tmpcr.count()); if (tmpcr.test('b')) { b = tmp; } else if (tmpcr.test('c')) { c = tmp; } else { FAIL(); } } // check if we found our vertices ASSERT_TRUE(b != NGHolder::null_vertex()); ASSERT_TRUE(c != NGHolder::null_vertex()); // both new vertices should have edges from startDs ASSERT_TRUE(edge(g.startDs, b, g).second); ASSERT_TRUE(edge(g.startDs, c, g).second); } // more complex left equivalence TEST(NFAGraph, RemoveEquivalence3) { // Build a small graph with a redundant vertex: a(..)+X|a(..)+Y // The graph should be merged into: a(..)+(X|Y) CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("a(..)+X|a(..)+Y", cc, HS_FLAG_DOTALL)); ASSERT_TRUE(graph != nullptr); NGHolder &g = *graph; g.kind = NFA_SUFFIX; // Run reduceGraphEquivalences ASSERT_TRUE(reduceGraphEquivalences(g, cc)); // Our graph should only have five non-special nodes ASSERT_EQ((size_t)N_SPECIALS + 5, num_vertices(g)); // Start dot start state should have edges to itself and one vertex ASSERT_EQ(2U, out_degree(g.startDs, g)); // Accept state should have two incoming edges ASSERT_EQ(2U, in_degree(g.accept, g)); // Find a vertex 'a' that goes right after startDs NFAVertex a = NGHolder::null_vertex(); for (NFAVertex v : adjacent_vertices_range(g.startDs, g)) { a = v; if (a == g.startDs) { continue; } // check if it has the right char reach const CharReach &tmpcr = g[a].char_reach; ASSERT_EQ(1U, tmpcr.count()); ASSERT_TRUE(tmpcr.test('a')); } // check if we found our 'a' ASSERT_TRUE(a != NGHolder::null_vertex()); // There should be an edge from 'a' to '.' ASSERT_EQ(1U, out_degree(a, g)); NFAVertex dot1 = *(adjacent_vertices(a, g).first); // check if this is a dot const CharReach dot1cr = g[dot1].char_reach; ASSERT_TRUE(dot1cr.all()); // After dot1, there should be another '.' ASSERT_EQ(1U, out_degree(dot1, g)); NFAVertex dot2 = *(adjacent_vertices(dot1, g).first); // check its char reach as well const CharReach dot2cr = g[dot2].char_reach; ASSERT_TRUE(dot2cr.all()); // the second dot should have three edges - to dot1, and to X and Y // first, check an edge to dot1 ASSERT_EQ(3U, out_degree(dot2, g)); ASSERT_TRUE(edge(dot2, dot1, g).second); // now, let's find X and Y nodes NFAVertex X = NGHolder::null_vertex(); NFAVertex Y = NGHolder::null_vertex(); for (NFAVertex tmp : adjacent_vertices_range(dot2, g)) { // we already know about dot1, so skip it if (tmp == dot1) { continue; } const CharReach tmpcr = g[tmp].char_reach; ASSERT_EQ(1U, tmpcr.count()); if (tmpcr.test('X')) { X = tmp; } else if (tmpcr.test('Y')) { Y = tmp; } else { FAIL(); } } // check if we found both vertices ASSERT_TRUE(X != NGHolder::null_vertex()); ASSERT_TRUE(Y != NGHolder::null_vertex()); // finally, check if these two vertices only have edges to accept ASSERT_EQ(1U, out_degree(X, g)); ASSERT_EQ(1U, out_degree(Y, g)); ASSERT_TRUE(edge(X, g.accept, g).second); ASSERT_TRUE(edge(Y, g.accept, g).second); } // more complex right equivalence TEST(NFAGraph, RemoveEquivalence4) { // Build a small graph with a redundant vertex: X(..)+a|Y(..)+a // The graph should be merged into: (X|Y)(..)+a CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("X(..)+a|Y(..)+a", cc, HS_FLAG_DOTALL)); ASSERT_TRUE(graph != nullptr); NGHolder &g = *graph; g.kind = NFA_SUFFIX; // Run reduceGraphEquivalences ASSERT_TRUE(reduceGraphEquivalences(g, cc)); // Our graph should only have five non-special nodes ASSERT_EQ((size_t)N_SPECIALS + 5, num_vertices(g)); // Start dot start state should have edges to itself and two vertices ASSERT_EQ(3U, out_degree(g.startDs, g)); // Accept state should have one incoming edge ASSERT_EQ(1U, in_degree(g.accept, g)); // Find X and Y nodes that are connected to startDs NFAVertex X = NGHolder::null_vertex(); NFAVertex Y = NGHolder::null_vertex(); for (NFAVertex tmp : adjacent_vertices_range(g.startDs, g)) { // skip startDs if (tmp == g.startDs) { continue; } // get char reach const CharReach tmpcr = g[tmp].char_reach; ASSERT_EQ(1U, tmpcr.count()); if (tmpcr.test('X')) { X = tmp; } else if (tmpcr.test('Y')) { Y = tmp; } else { FAIL(); } } // check if we found both vertices ASSERT_TRUE(X != NGHolder::null_vertex()); ASSERT_TRUE(Y != NGHolder::null_vertex()); // now, find first dot from X ASSERT_EQ(1U, out_degree(X, g)); NFAVertex dot1 = *(adjacent_vertices(X, g).first); // make sure Y also has an edge to that dot ASSERT_EQ(1U, out_degree(Y, g)); ASSERT_TRUE(edge(Y, dot1, g).second); // now, verify that it's actually a dot const CharReach dot1cr = g[dot1].char_reach; ASSERT_TRUE(dot1cr.all()); // the first dot has one edge to another dot ASSERT_EQ(1U, out_degree(dot1, g)); NFAVertex dot2 = *(adjacent_vertices(dot1, g).first); // verify it's a dot const CharReach dot2cr = g[dot2].char_reach; ASSERT_TRUE(dot2cr.all()); // second dot should have two edges - to dot1 and to 'a' ASSERT_EQ(2U, out_degree(dot2, g)); ASSERT_TRUE(edge(dot2, dot1, g).second); // now find 'a' NFAVertex a = NGHolder::null_vertex(); for (NFAVertex tmp : adjacent_vertices_range(dot2, g)) { // skip dot1 if (tmp == dot1) { continue; } // get char reach const CharReach tmpcr = g[tmp].char_reach; ASSERT_EQ(1U, tmpcr.count()); if (tmpcr.test('a')) { a = tmp; } else { FAIL(); } } // make sure we found our 'a' ASSERT_TRUE(a != NGHolder::null_vertex()); // now, check if 'a' has an edge to accept ASSERT_EQ(1U, out_degree(a, g)); ASSERT_TRUE(edge(a, g.accept, g).second); } // catching UE-2693 TEST(NFAGraph, RemoveEquivalence5) { // Build a small graph with a redundant vertex: [^\x00][^x00]*[\\x00] // The graph should be merged into: [^\x00]*[\x00] CompileContext cc(false, false, get_current_target(), Grey()); unique_ptr graph(constructGraphWithCC("[^\\x00][^\\x00]*[\\x00]", cc, 0)); ASSERT_TRUE(graph != nullptr); NGHolder &g = *graph; g.kind = NFA_PREFIX; // Run reduceGraphEquivalences ASSERT_TRUE(reduceGraphEquivalences(g, cc)); // Our graph should only have two non-special nodes ASSERT_EQ((size_t)N_SPECIALS + 2, num_vertices(g)); // Start dot start state should have edges to itself and one vertex ASSERT_EQ(2U, out_degree(g.startDs, g)); // Accept state should have one incoming edge ASSERT_EQ(1U, in_degree(g.accept, g)); // find first vertex and ensure it has a self loop NFAVertex v = NGHolder::null_vertex(); for (NFAVertex t : adjacent_vertices_range(g.startDs, g)) { v = t; if (v == g.startDs) { continue; } // check if it has the right char reach const CharReach &tmpcr = g[v].char_reach; ASSERT_EQ(255U, tmpcr.count()); ASSERT_TRUE(!tmpcr.test(0)); ASSERT_TRUE(edge(v, v, g).second); } // check if we found our vertex ASSERT_TRUE(v != NGHolder::null_vertex()); // now, find the vertex leading to accept NFAVertex v2 = NGHolder::null_vertex(); for (NFAVertex tmp : adjacent_vertices_range(v, g)) { // skip self-loop if (tmp == v) { continue; } v2 = tmp; // get char reach const CharReach tmpcr = g[tmp].char_reach; ASSERT_EQ(1U, tmpcr.count()); ASSERT_TRUE(tmpcr.test(0)); ASSERT_TRUE(edge(tmp, g.accept, g).second); } // check if we found our vertex ASSERT_TRUE(v2 != NGHolder::null_vertex()); } // catching UE-2692 TEST(NFAGraph, RemoveEquivalence6) { // Build a small graph with two redundant vertices: ^(.*|.*)a // The graph should be merged into: a unique_ptr graph(constructGraph("^(.*|.*)a", HS_FLAG_DOTALL)); ASSERT_TRUE(graph != nullptr); NGHolder &g = *graph; // Run mergeCyclicDotStars ASSERT_TRUE(mergeCyclicDotStars(g)); // Our graph should only have one non-special node ASSERT_EQ((size_t)N_SPECIALS + 1, num_vertices(g)); // Start dot start state should have edges to itself and one vertex ASSERT_EQ(2U, out_degree(g.startDs, g)); // Accept state should have one incoming edge ASSERT_EQ(1U, in_degree(g.accept, g)); // find that vertex and ensure it has no self loops and an edge to accept NFAVertex v = NGHolder::null_vertex(); for (NFAVertex t : adjacent_vertices_range(g.startDs, g)) { v = t; if (v == g.startDs) { continue; } // check if it has the right char reach const CharReach &tmpcr = g[v].char_reach; ASSERT_EQ(1U, tmpcr.count()); ASSERT_TRUE(tmpcr.test('a')); ASSERT_TRUE(!edge(v, v, g).second); ASSERT_TRUE(edge(v, g.accept, g).second); } // check if we found our vertex ASSERT_TRUE(v != NGHolder::null_vertex()); } // catching UE-2692 TEST(NFAGraph, RemoveEquivalence7) { // Build a small graph with no redundant vertices: ^.+a // Make sure we don't merge anything unique_ptr graph(constructGraph("^.+a", HS_FLAG_DOTALL)); ASSERT_TRUE(graph != nullptr); NGHolder &g = *graph; // Run mergeCyclicDotStars ASSERT_FALSE(mergeCyclicDotStars(g)); // Our graph should have two non-special nodes ASSERT_EQ((size_t)N_SPECIALS + 2, num_vertices(g)); // Start dot start state should have an edge to itself only ASSERT_EQ(1U, out_degree(g.startDs, g)); // Start should have edges to startDs and one other vertex ASSERT_EQ(2U, out_degree(g.start, g)); // Accept state should have one incoming edge ASSERT_EQ(1U, in_degree(g.accept, g)); // find that vertex and ensure it's a dot self loop and has one outgoing edge NFAVertex v = NGHolder::null_vertex(); for (NFAVertex t : adjacent_vertices_range(g.start, g)) { if (t == g.startDs) { continue; } v = t; // check if it has the right char reach const CharReach &tmpcr = g[v].char_reach; ASSERT_TRUE(tmpcr.all()); ASSERT_TRUE(edge(v, v, g).second); ASSERT_EQ(1U, proper_out_degree(v, g)); } // check if we found our vertex ASSERT_TRUE(v != NGHolder::null_vertex()); // find the next vertex and ensure it has an edge to accept NFAVertex v2 = NGHolder::null_vertex(); for (NFAVertex t : adjacent_vertices_range(v, g)) { // skip self loop if (t == v) { continue; } v2 = t; // check if it has the right char reach const CharReach &tmpcr = g[v2].char_reach; ASSERT_EQ(1U, tmpcr.count()); ASSERT_TRUE(tmpcr.test('a')); ASSERT_TRUE(!edge(v2, v2, g).second); ASSERT_EQ(1U, proper_out_degree(v2, g)); ASSERT_TRUE(edge(v2, g.accept, g).second); } // check if we found our vertex ASSERT_TRUE(v2 != NGHolder::null_vertex()); } TEST(NFAGraph, RemoveEquivalence_Reports1) { CompileContext cc(false, false, get_current_target(), Grey()); NGHolder g(NFA_SUFFIX); NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); add_edge(g.start, a, g); add_edge(a, b, g); add_edge(a, c, g); add_edge(b, g.accept, g); add_edge(c, g.accept, g); g[b].reports.insert(0); g[c].reports.insert(1); ASSERT_TRUE(reduceGraphEquivalences(g, cc)); ASSERT_EQ(num_vertices(g), N_SPECIALS + 2); /* b, c should be merged */ ASSERT_EQ(in_degree(g.accept, g), 1); } TEST(NFAGraph, RemoveEquivalence_Reports2) { CompileContext cc(false, false, get_current_target(), Grey()); NGHolder g(NFA_SUFFIX); NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); add_edge(g.start, a, g); add_edge(a, b, g); add_edge(a, c, g); add_edge(b, g.accept, g); add_edge(c, g.acceptEod, g); g[b].reports.insert(0); g[c].reports.insert(1); ASSERT_TRUE(reduceGraphEquivalences(g, cc)); ASSERT_EQ(num_vertices(g), N_SPECIALS + 3); /* b, c should not be merged */ ASSERT_EQ(in_degree(g.accept, g), 1); ASSERT_EQ(in_degree(g.acceptEod, g), 2); } TEST(NFAGraph, RemoveEquivalence_Reports3) { CompileContext cc(false, false, get_current_target(), Grey()); NGHolder g(NFA_SUFFIX); NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); add_edge(g.start, a, g); add_edge(a, b, g); add_edge(a, c, g); add_edge(b, g.accept, g); add_edge(c, g.acceptEod, g); g[b].reports.insert(0); g[c].reports.insert(0); ASSERT_TRUE(reduceGraphEquivalences(g, cc)); ASSERT_EQ(num_vertices(g), N_SPECIALS + 2); /* b, c should be merged */ ASSERT_EQ(in_degree(g.accept, g), 1); ASSERT_EQ(in_degree(g.acceptEod, g), 2); } TEST(NFAGraph, RemoveEquivalence_Reports4) { CompileContext cc(false, false, get_current_target(), Grey()); NGHolder g(NFA_SUFFIX); NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); NFAVertex d = add_vertex(g); add_edge(g.start, a, g); add_edge(a, b, g); add_edge(a, c, g); add_edge(c, d, g); add_edge(d, d, g); add_edge(b, g.accept, g); g[b].reports.insert(0); ASSERT_TRUE(reduceGraphEquivalences(g, cc)); ASSERT_EQ(num_vertices(g), N_SPECIALS + 3); /* b, c should be merged */ ASSERT_EQ(in_degree(g.accept, g), 1); ASSERT_EQ(in_degree(g.acceptEod, g), 1); } TEST(NFAGraph, RemoveEquivalence_Reports5) { CompileContext cc(false, false, get_current_target(), Grey()); NGHolder g(NFA_SUFFIX); NFAVertex a = add_vertex(g); NFAVertex b = add_vertex(g); NFAVertex c = add_vertex(g); NFAVertex d = add_vertex(g); add_edge(g.start, a, g); add_edge(a, b, g); add_edge(a, c, g); add_edge(c, d, g); add_edge(d, d, g); add_edge(b, g.acceptEod, g); g[b].reports.insert(0); ASSERT_TRUE(reduceGraphEquivalences(g, cc)); ASSERT_EQ(num_vertices(g), N_SPECIALS + 3); /* b, c should be merged */ ASSERT_EQ(in_degree(g.accept, g), 0); ASSERT_EQ(in_degree(g.acceptEod, g), 2); } hyperscan-4.4.1/unit/internal/parser.cpp0000644000175000017500000000727013055426554021100 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "parser/Component.h" #include "parser/Parser.h" #include "parser/dump.h" #include "parser/prefilter.h" #include "parser/unsupported.h" #include "hs.h" #include using namespace ue2; using std::ostringstream; using std::unique_ptr; struct PatternInfo { const char *expr; unsigned int flags; }; class ParserTest : public testing::TestWithParam {}; TEST_P(ParserTest, clone) { const PatternInfo &info = GetParam(); SCOPED_TRACE(info.expr); // This tests that we can parse expr and then clone it, then verifies that // the cloned component tree matches the original (using dump code for // serialisation) ParseMode mode(info.flags); unique_ptr c(parse(info.expr, mode)); ASSERT_TRUE(c != nullptr); #if defined(DUMP_SUPPORT) ostringstream oss; dumpTree(oss, c.get()); #endif unique_ptr c_copy(c->clone()); ASSERT_TRUE(c_copy != nullptr); c.reset(); // free original c #if defined(DUMP_SUPPORT) ostringstream oss_copy; dumpTree(oss_copy, c_copy.get()); ASSERT_EQ(oss.str(), oss_copy.str()); #endif } TEST_P(ParserTest, prefilter) { const PatternInfo &info = GetParam(); SCOPED_TRACE(info.expr); ParseMode mode(info.flags); unique_ptr c(parse(info.expr, mode)); ASSERT_TRUE(c != nullptr); prefilterTree(c, mode); ASSERT_TRUE(c != nullptr); // Should now be supported. ASSERT_NO_THROW(checkUnsupported(*c)); } static const PatternInfo patterns[] = { { "easy literal", 0 }, { "foo|bar|baz", 0 }, { "(?>\\d+)foo", 0 }, { "\\bhello\\b", 0 }, { "a+ b+? c++", 0 }, { "^bi-anchored$", 0 }, { "\\C", 0 }, { "\\X", HS_FLAG_UTF8 }, { "\\w+", HS_FLAG_UTF8 | HS_FLAG_UCP }, { "foo(?!bar).*baz", 0 }, { "(hatstand.*teakettle){2,} badgerbrush(es)? \\1", 0 }, { "a (pine)?(?(1)apple)", 0 }, { "^(?(?=hello)[a-z]+|[a-z]{3})", 0 }, }; INSTANTIATE_TEST_CASE_P(Parser, ParserTest, testing::ValuesIn(patterns)); // teach google-test how to print a param void PrintTo(const PatternInfo &p, ::std::ostream *os) { *os << p.expr << ":" << p.flags; } hyperscan-4.4.1/unit/internal/bitutils.cpp0000644000175000017500000003422013055426554021436 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/bitutils.h" #include "util/popcount.h" // open coded implementations to test against static u32 our_clz(u32 x) { u32 n; if (x == 0) return(32); n = 0; if (x <= 0x0000FFFF) { n = n + 16; x = x << 16; } if (x <= 0x00FFFFFF) { n = n + 8; x = x << 8; } if (x <= 0x0FFFFFFF) { n = n + 4; x = x << 4; } if (x <= 0x3FFFFFFF) { n = n + 2; x = x << 2; } if (x <= 0x7FFFFFFF) { n = n + 1; } return n; } static u32 our_clzll(u64a x) { // Synthesise from 32-bit variant. u32 high = x >> 32; if (high) { return our_clz(high); } return 32 + our_clz(x); } TEST(BitUtils, findAndClearLSB32_1) { // test that it can find every single-bit case for (unsigned int i = 0; i < 32; i++) { u32 input = 1 << i; u32 idx = findAndClearLSB_32(&input); EXPECT_EQ(i, idx); EXPECT_EQ(0U, input); } } TEST(BitUtils, findAndClearLSB32_2) { // test that we get all 32 indices from an all-ones input u32 input = ~0; unsigned int count = 0; while (input != 0) { ASSERT_GT(32U, count); u32 expected_output = input & (input - 1); u32 idx = findAndClearLSB_32(&input); EXPECT_EQ(count, idx); EXPECT_EQ(expected_output, input); count++; } EXPECT_EQ(32U, count); } TEST(BitUtils, findAndClearLSB64_1) { // test that it can find every single-bit case for (unsigned int i = 0; i < 64; i++) { u64a input = 1ULL << i; u32 idx = findAndClearLSB_64(&input); EXPECT_EQ(i, idx); EXPECT_EQ(0U, input); } } TEST(BitUtils, findAndClearLSB64_2) { // test that we get all 32 indices from an all-ones input u64a input = ~0; unsigned int count = 0; while (input != 0) { ASSERT_GT(64U, count); u64a expected_output = input & (input - 1); u32 idx = findAndClearLSB_64(&input); EXPECT_EQ(count, idx); EXPECT_EQ(expected_output, input); count++; } EXPECT_EQ(64U, count); } TEST(BitUtils, findAndClearMSB32_1) { // test that it can find every single-bit case for (unsigned int i = 0; i < 32; i++) { u32 input = 1 << i; u32 idx = findAndClearMSB_32(&input); EXPECT_EQ(i, idx); EXPECT_EQ(0U, input); } } TEST(BitUtils, findAndClearMSB32_2) { // test that we get all 32 indices from an all-ones input u32 input = ~0; unsigned int count = 0; while (input != 0) { ASSERT_GT(32U, count); u32 offset = our_clz(input); u32 expected_output = input ^ (1ULL << (31 - our_clz(input))); u32 idx = findAndClearMSB_32(&input); EXPECT_EQ(offset, count); EXPECT_EQ(offset, 31 - idx); EXPECT_EQ(expected_output, input); count++; } EXPECT_EQ(32U, count); } TEST(BitUtils, findAndClearMSB64_1) { // test that it can find every single-bit case for (unsigned int i = 0; i < 64; i++) { u64a input = 1ULL << i; u32 idx = findAndClearMSB_64(&input); EXPECT_EQ(i, idx); EXPECT_EQ(0U, input); } } TEST(BitUtils, findAndClearMSB64_2) { // test that we get all 64 indices from an all-ones input u64a input = ~0; unsigned int count = 0; while (input != 0) { u32 offset = our_clzll(input); u64a expected_output = input ^ (1ULL << (63 - our_clzll(input))); u32 idx = findAndClearMSB_64(&input); EXPECT_EQ(offset, 63 - idx); EXPECT_EQ(offset, count); EXPECT_EQ(expected_output, input); count++; } EXPECT_EQ(64U, count); } TEST(BitUtils, popcount32) { // some simple tests EXPECT_EQ(0U, popcount32(0)); EXPECT_EQ(16U, popcount32(0x0000ffffU)); EXPECT_EQ(16U, popcount32(0xffff0000U)); EXPECT_EQ(16U, popcount32(0xf0f0f0f0U)); EXPECT_EQ(32U, popcount32(0xffffffffU)); EXPECT_EQ(32U, popcount32(0xffffffffU)); // single bits for (u32 i = 0; i < 32; i++) { EXPECT_EQ(1U, popcount32(1U << i)); } // random EXPECT_EQ(13U, popcount32(668732496U)); EXPECT_EQ(15U, popcount32(872800073U)); EXPECT_EQ(15U, popcount32(2831496658U)); EXPECT_EQ(12U, popcount32(2895271296U)); } TEST(BitUtils, popcount64) { // some simple tests EXPECT_EQ(0U, popcount64(0)); EXPECT_EQ(16U, popcount64(0x000000000000ffffULL)); EXPECT_EQ(16U, popcount64(0xffff000000000000ULL)); EXPECT_EQ(32U, popcount64(0xf0f0f0f0f0f0f0f0ULL)); EXPECT_EQ(32U, popcount64(0xffffffff00000000ULL)); EXPECT_EQ(32U, popcount64(0x00000000ffffffffULL)); EXPECT_EQ(64U, popcount64(0xffffffffffffffffULL)); // single bits for (u32 i = 0; i < 64; i++) { EXPECT_EQ(1U, popcount64(1ULL << i)); } // random EXPECT_EQ(13U, popcount64(668732496ULL)); EXPECT_EQ(15U, popcount64(872800073ULL)); EXPECT_EQ(15U, popcount64(2831496658ULL)); EXPECT_EQ(12U, popcount64(2895271296ULL)); EXPECT_EQ(25U, popcount64(1869119247322218496ULL)); EXPECT_EQ(31U, popcount64(16235371884097357824ULL)); EXPECT_EQ(17U, popcount64(9354015527977637888ULL)); } TEST(BitUtils, clz32) { for (u32 i = 0; i < 32; i++) { EXPECT_EQ(31 - i, clz32(1 << i)); } } TEST(BitUtils, clz64) { for (u64a i = 0; i < 64; i++) { EXPECT_EQ(63 - i, clz64(1ULL << i)); } } TEST(BitUtils, ctz32) { EXPECT_EQ(0U, ctz32(0x1U)); EXPECT_EQ(15U, ctz32(0x8000)); } TEST(BitUtils, ctz64) { EXPECT_EQ(0U, ctz64(0x1ULL)); EXPECT_EQ(15U, ctz64(0x8000ULL)); } TEST(BitUtils, compress32) { const u32 all_ones = 0xffffffffu; const u32 odd_bits = 0x55555555u; const u32 even_bits = 0xaaaaaaaau; EXPECT_EQ(0, compress32(0, 0)); EXPECT_EQ(0, compress32(0, 1u)); EXPECT_EQ(0, compress32(0, all_ones)); EXPECT_EQ(all_ones, compress32(all_ones, all_ones)); EXPECT_EQ(0xffffu, compress32(odd_bits, odd_bits)); EXPECT_EQ(0xffffu, compress32(even_bits, even_bits)); EXPECT_EQ(0, compress32(odd_bits, even_bits)); EXPECT_EQ(0, compress32(even_bits, odd_bits)); // Some single-bit tests. for (u32 i = 0; i < 32; i++) { const u32 one_bit = 1u << i; EXPECT_EQ(0, compress32(0, one_bit)); EXPECT_EQ(1u, compress32(one_bit, one_bit)); EXPECT_EQ(one_bit, compress32(one_bit, all_ones)); if (i % 2) { EXPECT_EQ(1u << (i / 2), compress32(one_bit, even_bits)); EXPECT_EQ(0, compress32(one_bit, odd_bits)); } else { EXPECT_EQ(1u << (i / 2), compress32(one_bit, odd_bits)); EXPECT_EQ(0, compress32(one_bit, even_bits)); } } } TEST(BitUtils, compress64) { const u64a all_ones = 0xffffffffffffffffull; const u64a odd_bits = 0x5555555555555555ull; const u64a even_bits = 0xaaaaaaaaaaaaaaaaull; EXPECT_EQ(0, compress64(0, 0)); EXPECT_EQ(0, compress64(0, 1u)); EXPECT_EQ(0, compress64(0, all_ones)); EXPECT_EQ(all_ones, compress64(all_ones, all_ones)); EXPECT_EQ(0xffffffffull, compress64(odd_bits, odd_bits)); EXPECT_EQ(0xffffffffull, compress64(even_bits, even_bits)); EXPECT_EQ(0, compress64(odd_bits, even_bits)); EXPECT_EQ(0, compress64(even_bits, odd_bits)); // Some single-bit tests. for (u32 i = 0; i < 64; i++) { const u64a one_bit = 1ull << i; EXPECT_EQ(0, compress64(0, one_bit)); EXPECT_EQ(1ull, compress64(one_bit, one_bit)); EXPECT_EQ(one_bit, compress64(one_bit, all_ones)); if (i % 2) { EXPECT_EQ(1ull << (i / 2), compress64(one_bit, even_bits)); EXPECT_EQ(0, compress64(one_bit, odd_bits)); } else { EXPECT_EQ(1ull << (i / 2), compress64(one_bit, odd_bits)); EXPECT_EQ(0, compress64(one_bit, even_bits)); } } } TEST(BitUtils, expand32) { const u32 all_ones = 0xffffffffu; const u32 odd_bits = 0x55555555u; const u32 even_bits = 0xaaaaaaaau; EXPECT_EQ(0, expand32(0, 0)); EXPECT_EQ(0, expand32(0, 1u)); EXPECT_EQ(0, expand32(0, all_ones)); EXPECT_EQ(all_ones, expand32(all_ones, all_ones)); EXPECT_EQ(odd_bits, expand32(0xffffu, odd_bits)); EXPECT_EQ(even_bits, expand32(0xffffu, even_bits)); EXPECT_EQ(0, expand32(0xffff0000u, even_bits)); EXPECT_EQ(0, expand32(0xffff0000u, odd_bits)); EXPECT_EQ(1u, expand32(1u, odd_bits)); EXPECT_EQ(2u, expand32(1u, even_bits)); // Some single-bit tests. for (u32 i = 0; i < 32; i++) { const u32 one_bit = 1u << i; EXPECT_EQ(0, expand32(0, one_bit)); EXPECT_EQ(one_bit, expand32(1u, one_bit)); EXPECT_EQ(one_bit, expand32(one_bit, all_ones)); EXPECT_EQ(one_bit, expand32(1u << (i / 2), i % 2 ? even_bits : odd_bits)); } } TEST(BitUtils, expand64) { const u64a all_ones = 0xffffffffffffffffull; const u64a odd_bits = 0x5555555555555555ull; const u64a even_bits = 0xaaaaaaaaaaaaaaaaull; EXPECT_EQ(0, expand64(0, 0)); EXPECT_EQ(0, expand64(0, 1ull)); EXPECT_EQ(0, expand64(0, all_ones)); EXPECT_EQ(all_ones, expand64(all_ones, all_ones)); EXPECT_EQ(odd_bits, expand64(0xffffffffull, odd_bits)); EXPECT_EQ(even_bits, expand64(0xffffffffull, even_bits)); EXPECT_EQ(0, expand64(0xffffffff00000000ull, even_bits)); EXPECT_EQ(0, expand64(0xffffffff00000000ull, odd_bits)); EXPECT_EQ(1u, expand64(1u, odd_bits)); EXPECT_EQ(2u, expand64(1u, even_bits)); // Some single-bit tests. for (u32 i = 0; i < 64; i++) { const u64a one_bit = 1ull << i; EXPECT_EQ(0, expand64(0, one_bit)); EXPECT_EQ(one_bit, expand64(1ull, one_bit)); EXPECT_EQ(one_bit, expand64(one_bit, all_ones)); EXPECT_EQ(one_bit, expand64(1ull << (i / 2), i % 2 ? even_bits : odd_bits)); } } TEST(BitUtils, bf_op_1) { u64a a = 0; for (u32 i = 0; i < 64; i++) { char rv = bf64_set(&a, i); ASSERT_EQ(0, rv); if (i == 63) { ASSERT_EQ(~0ULL, a); } else { ASSERT_EQ((1ULL << (i + 1)) - 1, a); } rv = bf64_set(&a, i); ASSERT_EQ(1, rv); if (i == 63) { ASSERT_EQ(~0ULL, a); } else { ASSERT_EQ((1ULL << (i + 1)) - 1, a); } u64a b = 0; rv = bf64_set(&b, i); ASSERT_EQ(0, rv); ASSERT_EQ(1ULL << i, b); rv = bf64_set(&b, i); ASSERT_EQ(1, rv); ASSERT_EQ(1ULL << i, b); bf64_unset(&b, i); ASSERT_EQ(0, b); } ASSERT_EQ(~0ULL, a); } TEST(BitUtils, bf_it_1) { ASSERT_EQ(~0U, bf64_iterate(0ULL, ~0U)); ASSERT_EQ(~0U, bf64_iterate(0ULL, 0)); ASSERT_EQ(~0U, bf64_iterate(0ULL, 1)); ASSERT_EQ(~0U, bf64_iterate(0ULL, 63)); ASSERT_EQ(0, bf64_iterate(1ULL, ~0U)); ASSERT_EQ(~0U, bf64_iterate(1ULL, 0)); ASSERT_EQ(~0U, bf64_iterate(1ULL, 1)); ASSERT_EQ(~0U, bf64_iterate(1ULL, 63)); ASSERT_EQ(1, bf64_iterate(2ULL, ~0U)); ASSERT_EQ(1, bf64_iterate(2ULL, 0)); ASSERT_EQ(~0U, bf64_iterate(2ULL, 1)); ASSERT_EQ(~0U, bf64_iterate(2ULL, 63)); ASSERT_EQ(0, bf64_iterate(3ULL, ~0U)); ASSERT_EQ(1, bf64_iterate(3ULL, 0)); ASSERT_EQ(~0U, bf64_iterate(3ULL, 1)); ASSERT_EQ(~0U, bf64_iterate(3ULL, 63)); ASSERT_EQ(63, bf64_iterate(1ULL << 63, ~0U)); ASSERT_EQ(63, bf64_iterate(1ULL << 63, 0)); ASSERT_EQ(63, bf64_iterate(1ULL << 63, 1)); ASSERT_EQ(~0U, bf64_iterate(1ULL << 63, 63)); } TEST(BitUtils, rank_in_mask32) { for (u32 i = 0; i < 32; i++) { ASSERT_EQ(i, rank_in_mask32(0xffffffff, i)); ASSERT_EQ(0, rank_in_mask32(1U << i, i)); } ASSERT_EQ(0, rank_in_mask32(0xf0f0f0f0, 4)); ASSERT_EQ(1, rank_in_mask32(0xf0f0f0f0, 5)); ASSERT_EQ(3, rank_in_mask32(0xf0f0f0f0, 7)); ASSERT_EQ(7, rank_in_mask32(0xf0f0f0f0, 15)); ASSERT_EQ(15, rank_in_mask32(0xf0f0f0f0, 31)); } TEST(BitUtils, rank_in_mask64) { for (u32 i = 0; i < 64; i++) { ASSERT_EQ(i, rank_in_mask64(0xffffffffffffffffULL, i)); ASSERT_EQ(0, rank_in_mask64(1ULL << i, i)); } ASSERT_EQ(0, rank_in_mask64(0xf0f0f0f0f0f0f0f0ULL, 4)); ASSERT_EQ(1, rank_in_mask64(0xf0f0f0f0f0f0f0f0ULL, 5)); ASSERT_EQ(3, rank_in_mask64(0xf0f0f0f0f0f0f0f0ULL, 7)); ASSERT_EQ(7, rank_in_mask64(0xf0f0f0f0f0f0f0f0ULL, 15)); ASSERT_EQ(15, rank_in_mask64(0xf0f0f0f0f0f0f0f0ULL, 31)); ASSERT_EQ(31, rank_in_mask64(0xf0f0f0f0f0f0f0f0ULL, 63)); } #if defined(HAVE_PEXT) && defined(ARCH_64_BIT) TEST(BitUtils, pdep64) { u64a data = 0xF123456789ABCDEF; ASSERT_EQ(0xfULL, pdep64(data, 0xf)); ASSERT_EQ(0xefULL, pdep64(data, 0xff)); ASSERT_EQ(0xf0ULL, pdep64(data, 0xf0)); ASSERT_EQ(0xfULL, pdep64(data, 0xf)); ASSERT_EQ(0xef0ULL, pdep64(data, 0xff0)); ASSERT_EQ(0xef00ULL, pdep64(data, 0xff00)); ASSERT_EQ(0xd0e0f00ULL, pdep64(data, 0xf0f0f00)); } #endif hyperscan-4.4.1/unit/internal/database.cpp0000644000175000017500000000443613055426554021351 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "hs.h" #include "compiler/compiler.h" #include "crc32.h" #include "database.h" #include "ue2common.h" #include "util/target_info.h" #include "gtest/gtest.h" #include using namespace ue2; TEST(DB, flagsToPlatform) { hs_platform_info p; memset(&p, 0, sizeof(p)); p.cpu_features = 0; #if defined(__AVX2__) p.cpu_features |= HS_CPU_FEATURES_AVX2; #endif platform_t pp = target_to_platform(target_t(p)); ASSERT_EQ(pp, hs_current_platform); } TEST(CRC, alignments) { std::array a; a.fill('a'); // test the crc32c function at different alignments for (u8 i = 0; i < 32; i++) { u32 crc = Crc32c_ComputeBuf(0, (u8 *)a.data() + i, 4000); ASSERT_EQ(crc, 0x94f04377U); } } hyperscan-4.4.1/unit/internal/nfagraph_width.cpp0000644000175000017500000000650213055426554022566 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "nfagraph_common.h" #include "gtest/gtest.h" #include "compiler/compiler.h" #include "nfagraph/ng.h" #include "nfagraph/ng_builder.h" #include "nfagraph/ng_width.h" #include "grey.h" #include "util/target_info.h" #include "util/depth.h" using namespace std; using namespace testing; using namespace ue2; struct WidthTest { string pattern; depth minWidth; depth maxWidth; }; class NFAWidthTest : public TestWithParam { }; static const WidthTest widthTests[] = { { "()", 0, 0 }, { "a", 1, 1 }, { "a?b", 1, 2 }, { "foobar", 6, 6 }, { "foo(bar)?", 3, 6 }, { "(a|ab|abc|abcd)", 1, 4 }, { "foo.*bar", 6, depth::infinity() }, { "foo(bar)*", 3, depth::infinity() }, { "foo(bar)+", 6, depth::infinity() }, { "foo(bar){1,3}", 6, 12 }, { "(abcd)+", 4, depth::infinity() }, { "foo\\z", 3, 3 }, { "^foo", 3, 3 }, { "^foo|bar.*baz", 3, depth::infinity() }, { "^foobar.*|baz", 3, depth::infinity() }, { "foo(\\z|bar)", 3, 6 }, { "foo(|bar\\z)", 3, 6 }, { "foo.{0,15}bar", 6, 21 }, { "foo.{0,15}.*bar", 6, depth::infinity() }, { "(?smi)^(aa[^a]aa$|a|a+\\Z|a)", 1, depth::infinity() } }; INSTANTIATE_TEST_CASE_P(NFAWidth, NFAWidthTest, ValuesIn(widthTests)); TEST_P(NFAWidthTest, Check) { const WidthTest &t = GetParam(); SCOPED_TRACE(testing::Message() << "Pattern: " << t.pattern); unique_ptr w(constructGraph(t.pattern, 0)); ASSERT_EQ(t.minWidth, findMinWidth(*w)); ASSERT_EQ(t.maxWidth, findMaxWidth(*w)); } // for google test void PrintTo(const WidthTest &w, ::std::ostream *os) { *os << "WidthTest: " << w.pattern << "{" << w.minWidth << ','; if (w.maxWidth == depth::infinity()) { *os << "inf"; } else { *os << w.maxWidth; } *os << '}'; } hyperscan-4.4.1/unit/internal/multiaccel_matcher.cpp0000644000175000017500000002435413055426554023433 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ extern "C" { #include "nfa/accel.h" // wrapping in extern C to make sure run_accel works } #include "config.h" #include "src/ue2common.h" #include "gtest/gtest.h" #include "nfagraph/ng_limex_accel.h" #include "nfa/accelcompile.h" #include "nfa/multivermicelli.h" #include "nfa/multishufti.h" #include "nfa/multitruffle.h" #include "util/alloc.h" #include "util/charreach.h" #include #include #include #include #include using namespace ue2; using namespace std; using namespace testing; // test parameters structure struct MultiaccelTestParam { string match_pattern; u32 match_pattern_start_idx; u32 match_idx; bool test_all_offsets; u8 match_len1; u8 match_len2; MultibyteAccelInfo::multiaccel_type type; }; // buffer size is constant static const u32 BUF_SIZE = 200; // strings, out of which CharReach will be generated static const string VERM_CR = "a"; static const string V_NC_CR = "aA"; static const string SHUF_CR = "abcdefghijklmnopqrstuvwxyz"; static const string TRUF_CR = "\x11\x22\x33\x44\x55\x66\x77\x88\x99"; // Parameterized test case for multiaccel patterns. class MultiaccelTest : public TestWithParam { protected: virtual void SetUp() { // set up is deferred until the actual test, since we can't compile // any accel schemes unless we know CharReach const MultiaccelTestParam &p = GetParam(); // reserve space in our buffer buffer = (u8 *)aligned_zmalloc(BUF_SIZE); // store the index where we expect to see the match. note that it may // be different from where the match pattern has started since we may // have a flooded match (i.e. a match preceded by almost-match) or a // no-match (in which case "match" index is at the end of the buffer). match_idx = p.match_idx; // make note if we need to test all offsets - sometimes we don't, for // example when testing partial or no-match. test_all_offsets = p.test_all_offsets; } char getChar(const CharReach &cr) { assert(cr.count() > 0); auto dist = uniform_int_distribution(0, cr.count() - 1); size_t result = cr.find_nth(dist(prng)); assert(result != CharReach::npos); return (char)result; } // char generator char getChar(const CharReach &cr, bool match) { return getChar(match ? cr : ~cr); } // appends a string with matches/unmatches according to input match pattern void getMatch(u8 *result, u32 start, const string &pattern, const CharReach &cr) { for (const auto &c : pattern) { result[start++] = getChar(cr, c == '1'); } } // appends non-matching noise of certain lengths void getNoise(u8 *result, u32 start, u32 len, const CharReach &cr) { for (unsigned i = 0; i < len; i++) { result[start + i] = getChar(cr, false); } } // deferred buffer generation, as we don't know CharReach before we run the test void GenerateBuffer(const CharReach &cr) { const MultiaccelTestParam &p = GetParam(); // step 1: fill prefix with non-matching noise u32 start = 0; getNoise(buffer, start, p.match_pattern_start_idx, cr); // step 2: add a match start += p.match_pattern_start_idx; getMatch(buffer, start, p.match_pattern, cr); // step 3: fill in the rest of the buffer with non-matching noise start += p.match_pattern.size(); getNoise(buffer, start, BUF_SIZE - p.match_pattern.size() - p.match_pattern_start_idx, cr); } // deferred accel scheme generation, as we don't know CharReach before we run the test void CompileAccelScheme(const CharReach &cr, AccelAux *aux) { const MultiaccelTestParam &p = GetParam(); AccelInfo ai; ai.single_stops = cr; // dummy CharReach to prevent red tape accel ai.ma_len1 = p.match_len1; ai.ma_len2 = p.match_len2; ai.multiaccel_stops = cr; ai.ma_type = p.type; buildAccelAux(ai, aux); // now, verify we've successfully built our accel scheme, *and* that it's // a multibyte scheme ASSERT_TRUE(aux->accel_type >= ACCEL_MLVERM && aux->accel_type <= ACCEL_MDSGTRUFFLE); } virtual void TearDown() { aligned_free(buffer); } // We want our tests to be deterministic, so we use a PRNG in the test // fixture. mt19937 prng; u32 match_idx; u8 *buffer; bool test_all_offsets; }; static void runTest(const u8 *buffer, AccelAux *aux, unsigned match_idx, bool test_all_offsets) { const u8 *start = buffer; const u8 *end = start + BUF_SIZE; const u8 *match = start + match_idx; // comparing indexes into the buffer is easier to understand than pointers if (test_all_offsets) { // run_accel can only scan >15 byte buffers u32 end_offset = min(match_idx, BUF_SIZE - 15); for (unsigned offset = 0; offset < end_offset; offset++) { const u8 *ptr = run_accel(aux, (start + offset), end); unsigned idx = ptr - start; ASSERT_EQ(match_idx, idx); } } else { const u8 *ptr = run_accel(aux, start, end); unsigned idx = ptr - start; ASSERT_EQ(match_idx, idx); } } TEST_P(MultiaccelTest, TestVermicelli) { AccelAux aux = {0}; CharReach cr(VERM_CR); GenerateBuffer(cr); CompileAccelScheme(cr, &aux); runTest(buffer, &aux, match_idx, test_all_offsets); } TEST_P(MultiaccelTest, TestVermicelliNocase) { AccelAux aux = {0}; CharReach cr(V_NC_CR); GenerateBuffer(cr); CompileAccelScheme(cr, &aux); runTest(buffer, &aux, match_idx, test_all_offsets); } TEST_P(MultiaccelTest, TestShufti) { AccelAux aux = {0}; CharReach cr(SHUF_CR); GenerateBuffer(cr); CompileAccelScheme(cr, &aux); runTest(buffer, &aux, match_idx, test_all_offsets); } TEST_P(MultiaccelTest, TestTruffle) { AccelAux aux = {0}; CharReach cr(TRUF_CR); GenerateBuffer(cr); CompileAccelScheme(cr, &aux); runTest(buffer, &aux, match_idx, test_all_offsets); } static const MultiaccelTestParam multiaccelTests[] = { // long matcher // full, partial, flooded, nomatch {"11111", 180, 180, true, 5, 0, MultibyteAccelInfo::MAT_LONG}, {"111", 197, 197, true, 5, 0, MultibyteAccelInfo::MAT_LONG}, {"1111011111", 177, 182, false, 5, 0, MultibyteAccelInfo::MAT_LONG}, {"1111011110", 177, 200, false, 5, 0, MultibyteAccelInfo::MAT_LONG}, // long-grab matcher // full, partial, flooded, nomatch {"111110", 180, 180, true, 5, 0, MultibyteAccelInfo::MAT_LONGGRAB}, {"111", 197, 197, true, 5, 0, MultibyteAccelInfo::MAT_LONGGRAB}, {"11111111110", 177, 182, false, 5, 0, MultibyteAccelInfo::MAT_LONGGRAB}, {"11110111101", 177, 200, false, 5, 0, MultibyteAccelInfo::MAT_LONGGRAB}, // shift matcher // full, partial, flooded, nomatch {"11001", 180, 180, true, 4, 0, MultibyteAccelInfo::MAT_SHIFT}, {"110", 197, 197, true, 4, 0, MultibyteAccelInfo::MAT_SHIFT}, {"1001011001", 177, 182, false, 4, 0, MultibyteAccelInfo::MAT_SHIFT}, {"1101001011", 177, 200, false, 4, 0, MultibyteAccelInfo::MAT_SHIFT}, // shift-grab matcher // full, partial, flooded, nomatch {"10111", 180, 180, true, 4, 0, MultibyteAccelInfo::MAT_SHIFTGRAB}, {"101", 197, 197, true, 4, 0, MultibyteAccelInfo::MAT_SHIFTGRAB}, {"1110010111", 177, 182, false, 4, 0, MultibyteAccelInfo::MAT_SHIFTGRAB}, {"1100101100", 177, 200, false, 4, 0, MultibyteAccelInfo::MAT_SHIFTGRAB}, // doubleshift matcher // full, partial (one and two shifts), flooded, nomatch {"110111", 180, 180, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFT}, {"110", 197, 197, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFT}, {"1101", 196, 196, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFT}, {"1100100101", 178, 182, false, 3, 2, MultibyteAccelInfo::MAT_DSHIFT}, {"1101001101", 177, 200, false, 3, 2, MultibyteAccelInfo::MAT_DSHIFT}, // doubleshift-grab matcher // full, partial (one and two shifts), flooded, nomatch {"100101", 180, 180, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB}, {"100", 197, 197, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB}, {"1011", 196, 196, true, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB}, {"11111101101", 177, 182, false, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB}, {"1111110111", 177, 200, false, 3, 2, MultibyteAccelInfo::MAT_DSHIFTGRAB}, }; INSTANTIATE_TEST_CASE_P(Multiaccel, MultiaccelTest, ValuesIn(multiaccelTests)); // boring stuff for google test void PrintTo(const MultiaccelTestParam &p, ::std::ostream *os) { *os << "MultiaccelTestParam: " << p.match_pattern; } hyperscan-4.4.1/unit/internal/unicode_set.cpp0000644000175000017500000001711113055426554022100 0ustar sleuthkidsleuthkid/* * 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. */ #include "gtest/gtest.h" #include "config.h" #include "ue2common.h" #include "util/unicode_set.h" using namespace ue2; TEST(unicode_set, basic_1) { CodePointSet cps; EXPECT_TRUE(cps.none()); EXPECT_EQ(INVALID_UNICODE, cps.at(0)); cps.set('a'); EXPECT_FALSE(cps.none()); EXPECT_EQ(1U, cps.count()); EXPECT_EQ('a', cps.at(0)); EXPECT_EQ(INVALID_UNICODE, cps.at(1)); cps.unset('a'); EXPECT_TRUE(cps.none()); EXPECT_EQ(0U, cps.count()); EXPECT_EQ(INVALID_UNICODE, cps.at(0)); } TEST(unicode_set, range_1) { CodePointSet cps; cps.setRange('b', 'y'); EXPECT_EQ(24U, cps.count()); EXPECT_EQ('b', cps.at(0)); EXPECT_EQ('y', cps.at(23)); EXPECT_EQ(INVALID_UNICODE, cps.at(24)); cps.setRange('B', 'Y'); EXPECT_EQ(48U, cps.count()); EXPECT_EQ('B', cps.at(0)); EXPECT_EQ('Y', cps.at(23)); EXPECT_EQ('b', cps.at(24)); EXPECT_EQ('y', cps.at(47)); EXPECT_EQ(INVALID_UNICODE, cps.at(48)); CodePointSet cps2 = cps; cps2.unsetRange('B', 'y'); EXPECT_TRUE(cps2.none()); cps2 = cps; EXPECT_FALSE(cps2.none()); cps2.unsetRange(0, 'y'); EXPECT_TRUE(cps2.none()); cps2 = cps; EXPECT_FALSE(cps2.none()); cps2.unsetRange('B', MAX_UNICODE); EXPECT_TRUE(cps2.none()); } TEST(unicode_set, range_2) { CodePointSet cps; cps.setRange('A', 'Z'); EXPECT_EQ(26U, cps.count()); EXPECT_EQ('A', cps.at(0)); EXPECT_EQ('Z', cps.at(25)); EXPECT_EQ(INVALID_UNICODE, cps.at(26)); CodePointSet cps2 = cps; cps2.setRange('E', 'K'); EXPECT_TRUE(cps == cps2); EXPECT_FALSE(cps != cps2); cps2.setRange('a', 'z'); EXPECT_EQ(52U, cps2.count()); EXPECT_EQ('A', cps2.at(0)); EXPECT_EQ('Z', cps2.at(25)); EXPECT_EQ('a', cps2.at(26)); EXPECT_EQ('z', cps2.at(51)); EXPECT_EQ(INVALID_UNICODE, cps2.at(52)); CodePointSet cps3 = cps2; cps3.setRange('a', 'f'); EXPECT_TRUE(cps3 == cps2); cps3.set('g'); EXPECT_TRUE(cps3 == cps2); cps3.setRange('g', 'z'); EXPECT_TRUE(cps3 == cps2); EXPECT_TRUE(cps3.isSubset(cps2)); EXPECT_TRUE(cps2.isSubset(cps3)); EXPECT_TRUE(cps3.isSubset(cps)); EXPECT_FALSE(cps.isSubset(cps3)); } TEST(unicode_set, range_3) { CodePointSet cps; cps.setRange(1000, 10000); EXPECT_EQ(9001, cps.count()); EXPECT_EQ(1000, cps.at(0)); EXPECT_EQ(10000, cps.at(9000)); cps.unsetRange(2000, 3000); EXPECT_EQ(8000, cps.count()); EXPECT_EQ(1000, cps.at(0)); EXPECT_EQ(1999, cps.at(999)); EXPECT_EQ(3001, cps.at(1000)); EXPECT_EQ(10000, cps.at(7999)); cps.setRange(1500, 3500); EXPECT_EQ(9001, cps.count()); EXPECT_EQ(1000, cps.at(0)); EXPECT_EQ(10000, cps.at(9000)); } TEST(unicode_set, subset) { CodePointSet a; a.setRange(0, 99); CodePointSet b; b.setRange(100, 199); CodePointSet c; c.setRange(200, 299); CodePointSet ab; ab.setRange(0, 199); CodePointSet ac; ac.setRange(0, 99); ac.setRange(200, 299); CodePointSet bc; bc.setRange(100, 299); CodePointSet abc; abc.setRange(0, 299); CodePointSet e; EXPECT_TRUE(abc.isSubset(a)); EXPECT_TRUE(abc.isSubset(b)); EXPECT_TRUE(abc.isSubset(c)); EXPECT_TRUE(abc.isSubset(e)); EXPECT_TRUE(abc.isSubset(ab)); EXPECT_TRUE(abc.isSubset(ac)); EXPECT_TRUE(abc.isSubset(bc)); EXPECT_TRUE(abc.isSubset(abc)); EXPECT_TRUE(ab.isSubset(a)); EXPECT_TRUE(ab.isSubset(b)); EXPECT_FALSE(ab.isSubset(c)); EXPECT_TRUE(ab.isSubset(e)); EXPECT_TRUE(ab.isSubset(ab)); EXPECT_FALSE(ab.isSubset(ac)); EXPECT_FALSE(ab.isSubset(bc)); EXPECT_FALSE(ab.isSubset(abc)); EXPECT_TRUE(ac.isSubset(a)); EXPECT_FALSE(ac.isSubset(b)); EXPECT_TRUE(ac.isSubset(c)); EXPECT_TRUE(ac.isSubset(e)); EXPECT_FALSE(ac.isSubset(ab)); EXPECT_TRUE(ac.isSubset(ac)); EXPECT_FALSE(ac.isSubset(bc)); EXPECT_FALSE(ac.isSubset(abc)); EXPECT_FALSE(bc.isSubset(a)); EXPECT_TRUE(bc.isSubset(b)); EXPECT_TRUE(bc.isSubset(c)); EXPECT_TRUE(bc.isSubset(e)); EXPECT_FALSE(bc.isSubset(ab)); EXPECT_FALSE(bc.isSubset(ac)); EXPECT_TRUE(bc.isSubset(bc)); EXPECT_FALSE(bc.isSubset(abc)); EXPECT_TRUE(a.isSubset(a)); EXPECT_FALSE(a.isSubset(b)); EXPECT_FALSE(a.isSubset(c)); EXPECT_TRUE(a.isSubset(e)); EXPECT_FALSE(a.isSubset(ab)); EXPECT_FALSE(a.isSubset(ac)); EXPECT_FALSE(a.isSubset(bc)); EXPECT_FALSE(a.isSubset(abc)); EXPECT_FALSE(b.isSubset(a)); EXPECT_TRUE(b.isSubset(b)); EXPECT_FALSE(b.isSubset(c)); EXPECT_TRUE(b.isSubset(e)); EXPECT_FALSE(b.isSubset(ab)); EXPECT_FALSE(b.isSubset(ac)); EXPECT_FALSE(b.isSubset(bc)); EXPECT_FALSE(b.isSubset(abc)); EXPECT_FALSE(c.isSubset(a)); EXPECT_FALSE(c.isSubset(b)); EXPECT_TRUE(c.isSubset(c)); EXPECT_TRUE(c.isSubset(e)); EXPECT_FALSE(c.isSubset(ab)); EXPECT_FALSE(c.isSubset(ac)); EXPECT_FALSE(c.isSubset(bc)); EXPECT_FALSE(c.isSubset(abc)); EXPECT_FALSE(e.isSubset(a)); EXPECT_FALSE(e.isSubset(b)); EXPECT_FALSE(e.isSubset(c)); EXPECT_TRUE(e.isSubset(e)); EXPECT_FALSE(e.isSubset(ab)); EXPECT_FALSE(e.isSubset(ac)); EXPECT_FALSE(e.isSubset(bc)); EXPECT_FALSE(e.isSubset(abc)); } TEST(unicode_set, set_op) { CodePointSet a; a.setRange(0, 99); CodePointSet b; b.setRange(100, 199); CodePointSet c; c.setRange(200, 299); CodePointSet ab; ab.setRange(0, 199); CodePointSet ac; ac.setRange(0, 99); ac.setRange(200, 299); CodePointSet bc; bc.setRange(100, 299); CodePointSet abc; abc.setRange(0, 299); CodePointSet e; CodePointSet t = a; t |= a; EXPECT_TRUE(t == a); t |= e; EXPECT_TRUE(t == a); t |= b; EXPECT_TRUE(t == ab); t |= b; EXPECT_TRUE(t == ab); t |= a; EXPECT_TRUE(t == ab); t |= ac; EXPECT_TRUE(t == abc); t -= e; EXPECT_TRUE(t == abc); t -= b; EXPECT_TRUE(t == ac); t -= b; EXPECT_TRUE(t == ac); t -= bc; EXPECT_TRUE(t == a); t -= abc; EXPECT_TRUE(t == e); } hyperscan-4.4.1/unit/internal/flat_set.cpp0000644000175000017500000002511413055426554021402 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "util/ue2_containers.h" #include "ue2common.h" #include "gtest/gtest.h" #include #include #include #include using std::string; using std::tie; using std::vector; using namespace ue2; template std::ostream &operator<<(std::ostream &os, const flat_set &f) { os << "{"; for (auto it = begin(f); it != end(f); ++it) { os << *it; if (it != end(f)) { os << ", "; } } os << "}"; return os; } TEST(flat_set, empty) { flat_set f; EXPECT_TRUE(f.begin() == f.end()); EXPECT_TRUE(f.cbegin() == f.cend()); EXPECT_TRUE(f.rbegin() == f.rend()); EXPECT_TRUE(f.crbegin() == f.crend()); EXPECT_TRUE(f.empty()); EXPECT_EQ(0, f.size()); EXPECT_EQ(0, f.count(10)); } TEST(flat_set, clear) { flat_set f = {1000, 2000, 3000}; EXPECT_EQ(3, f.size()); EXPECT_FALSE(f.empty()); f.clear(); EXPECT_EQ(0, f.size()); EXPECT_TRUE(f.empty()); } TEST(flat_set, one_element) { flat_set f; EXPECT_TRUE(f.empty()); f.insert(10); EXPECT_FALSE(f.empty()); EXPECT_EQ(1, f.size()); EXPECT_EQ(1, f.count(10)); EXPECT_EQ(0, f.count(11)); ASSERT_FALSE(f.begin() == f.end()); ASSERT_FALSE(f.cbegin() == f.cend()); ASSERT_FALSE(f.rbegin() == f.rend()); ASSERT_FALSE(f.crbegin() == f.crend()); EXPECT_EQ(10, *f.begin()); EXPECT_EQ(10, *f.cbegin()); EXPECT_EQ(10, *f.rbegin()); EXPECT_EQ(10, *f.crbegin()); EXPECT_TRUE(std::next(f.begin()) == f.end()); EXPECT_TRUE(std::next(f.cbegin()) == f.cend()); EXPECT_TRUE(std::next(f.rbegin()) == f.rend()); EXPECT_TRUE(std::next(f.crbegin()) == f.crend()); } TEST(flat_set, some_elements) { vector input = { 10, 5, 2000, 1, 300 }; flat_set f; for (const auto &v : input) { f.insert(v); } ASSERT_FALSE(f.empty()); ASSERT_EQ(5, f.size()); ASSERT_EQ(1, *f.begin()); ASSERT_EQ(2000, *f.rbegin()); ASSERT_TRUE(std::is_sorted(f.begin(), f.end())); for (const auto &v : input) { ASSERT_TRUE(f.find(v) != f.end()); ASSERT_EQ(v, *f.find(v)); } ASSERT_TRUE(f.find(2) == f.end()); ASSERT_TRUE(f.find(300000) == f.end()); } TEST(flat_set, dupe_elements) { flat_set f; f.insert(10); f.insert(50); f.insert(10); f.insert(50); ASSERT_FALSE(f.empty()); ASSERT_EQ(2, f.size()); ASSERT_EQ(10, *f.begin()); ASSERT_EQ(50, *f.rbegin()); } TEST(flat_set, init_ctor) { flat_set f = {1000, 900, 800, 800, 700, 100, 500}; // unsorted + dupe ASSERT_EQ(6, f.size()); ASSERT_TRUE(std::is_sorted(f.begin(), f.end())); } TEST(flat_set, insert_ilist) { flat_set f; ASSERT_EQ(0, f.size()); f.insert({10, 30, 20}); ASSERT_EQ(3, f.size()); f.insert({10, 30, 20}); // dupes ASSERT_EQ(3, f.size()); f.insert({100, 50}); ASSERT_EQ(5, f.size()); ASSERT_TRUE(std::is_sorted(f.begin(), f.end())); } TEST(flat_set, custom_compare) { flat_set> f; ASSERT_EQ(0, f.size()); f.insert({1, 2, 3, 4, 5, 6, 7, 8, 9, 10}); ASSERT_EQ(10, f.size()); ASSERT_EQ(10, *f.begin()); ASSERT_EQ(1, *f.rbegin()); ASSERT_TRUE(std::is_sorted(f.begin(), f.end(), f.key_comp())); ASSERT_TRUE(std::is_sorted(f.begin(), f.end(), f.value_comp())); ASSERT_TRUE(std::is_sorted(f.begin(), f.end(), std::greater())); } TEST(flat_set, erase_values) { vector input = { 10, 5, 2000, 1, 300 }; flat_set f(input.begin(), input.end()); ASSERT_EQ(input.size(), f.size()); for (const auto &v : input) { ASSERT_TRUE(f.find(v) != f.end()); f.erase(v); ASSERT_TRUE(f.find(v) == f.end()); } ASSERT_TRUE(f.empty()); } TEST(flat_set, erase_iter) { vector input = { 10, 5, 2000, 1, 300 }; flat_set f(input.begin(), input.end()); ASSERT_EQ(input.size(), f.size()); for (const auto &v : input) { auto it = f.find(v); ASSERT_TRUE(it != f.end()); f.erase(it); ASSERT_TRUE(f.find(v) == f.end()); } ASSERT_TRUE(f.empty()); } TEST(flat_set, erase_iters) { flat_set f = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; ASSERT_EQ(10, f.size()); auto first = f.find(3); ASSERT_NE(end(f), first); auto last = f.find(8); ASSERT_NE(end(f), last); f.erase(first, last); ASSERT_EQ(5, f.size()); ASSERT_EQ(flat_set({1, 2, 8, 9, 10}), f); } TEST(flat_set, erase_empty_range) { flat_set f = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; const flat_set f2 = f; // copy ASSERT_EQ(f, f2); // Erasing (it, it) should do nothing. for (const auto &val : f2) { auto it = f.find(val); f.erase(it, it); ASSERT_EQ(f2, f); } } namespace { class MovableOnly { public: MovableOnly(size_t val_in, const string &name_in) : val(val_in), name(name_in) {} bool operator<(const MovableOnly &other) const { return tie(val, name) < tie(other.val, other.name); } // Can't copy-construct or copy-assign. MovableOnly(const MovableOnly &) = delete; MovableOnly &operator=(const MovableOnly &) = delete; // Moves are OK though. MovableOnly(MovableOnly &&) = default; MovableOnly &operator=(MovableOnly &&) = default; size_t val; string name; }; } // namespace TEST(flat_set, emplace) { flat_set f; ASSERT_TRUE(f.empty()); auto rv = f.emplace(10, string("hatstand")); ASSERT_NE(end(f), rv.first); ASSERT_EQ(10, rv.first->val); ASSERT_TRUE(rv.second); rv = f.emplace(30, string("badgerbrush")); ASSERT_NE(end(f), rv.first); ASSERT_EQ(30, rv.first->val); ASSERT_TRUE(rv.second); rv = f.emplace(20, string("teakettle")); ASSERT_NE(end(f), rv.first); ASSERT_EQ(20, rv.first->val); ASSERT_TRUE(rv.second); ASSERT_EQ(3, f.size()); ASSERT_TRUE(std::is_sorted(begin(f), end(f))); rv = f.emplace(10, string("hatstand")); // dupe ASSERT_FALSE(rv.second); ASSERT_EQ(3, f.size()); ASSERT_TRUE(std::is_sorted(begin(f), end(f))); } TEST(flat_set, swap) { flat_set a = {1, 2, 4, 8, 16, 32, 64}; flat_set b = {1, 2, 3, 4, 5, 6, 7}; swap(a, b); EXPECT_EQ(7, a.size()); EXPECT_EQ(7, b.size()); EXPECT_EQ(7, *a.rbegin()); EXPECT_EQ(64, *b.rbegin()); } TEST(flat_set, iter) { const vector vec = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // sorted flat_set f(begin(vec), end(vec)); ASSERT_EQ(vec.size(), f.size()); ASSERT_TRUE(std::equal(f.begin(), f.end(), vec.begin())); ASSERT_TRUE(std::equal(f.rbegin(), f.rend(), vec.rbegin())); } TEST(flat_set, iter_interop) { const vector vec = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // sorted flat_set f(begin(vec), end(vec)); ASSERT_EQ(vec.size(), f.size()); const auto &cf = f; // const reference // Forward flat_set::iterator mutable_begin = f.begin(); ASSERT_EQ(f.cbegin(), mutable_begin); ASSERT_EQ(cf.begin(), mutable_begin); flat_set::iterator mutable_end = f.end(); ASSERT_EQ(f.cend(), mutable_end); ASSERT_EQ(cf.end(), mutable_end); ASSERT_EQ(f.size(), std::distance(mutable_begin, mutable_end)); ASSERT_EQ(f.size(), mutable_end - mutable_begin); ASSERT_EQ(f.size(), mutable_end - f.cbegin()); ASSERT_EQ(f.size(), f.cend() - mutable_begin); // Reverse flat_set::reverse_iterator mutable_rbegin = f.rbegin(); ASSERT_EQ(f.crbegin(), mutable_rbegin); ASSERT_EQ(cf.rbegin(), mutable_rbegin); flat_set::reverse_iterator mutable_rend = f.rend(); ASSERT_EQ(f.crend(), mutable_rend); ASSERT_EQ(cf.rend(), mutable_rend); ASSERT_EQ(f.size(), std::distance(mutable_rbegin, mutable_rend)); ASSERT_EQ(f.size(), mutable_rend - mutable_rbegin); ASSERT_EQ(f.size(), mutable_rend - f.crbegin()); ASSERT_EQ(f.size(), f.crend() - mutable_rbegin); } TEST(flat_set, compare_ops) { flat_set f1 = {1, 2, 3, 4, 5}; flat_set f1_copy = f1; flat_set f2 = {2, 4, 6, 8, 10}; EXPECT_TRUE(f1 == f1); EXPECT_TRUE(f1 == f1_copy); EXPECT_FALSE(f1 == f2); EXPECT_FALSE(f1 != f1); EXPECT_FALSE(f1 != f1_copy); EXPECT_TRUE(f1 != f2); EXPECT_FALSE(f1 < f1); EXPECT_FALSE(f1 < f1_copy); EXPECT_TRUE(f1 < f2); EXPECT_TRUE(f1 <= f1); EXPECT_TRUE(f1 <= f1_copy); EXPECT_TRUE(f1 <= f2); EXPECT_FALSE(f1 > f1); EXPECT_FALSE(f1 > f1_copy); EXPECT_FALSE(f1 > f2); EXPECT_TRUE(f1 >= f1); EXPECT_TRUE(f1 >= f1_copy); EXPECT_FALSE(f1 >= f2); } TEST(flat_set, get_allocator) { // Not a very interesting test, but it should pass valgrind leak tests, // etc. Just testing the default allocator for now. flat_set f; const u32 num = 10; u32 *data = f.get_allocator().allocate(num); for (u32 i = 0; i < num; i++) { data[i] = i; } for (u32 i = 0; i < num; i++) { ASSERT_EQ(i, data[i]); } f.get_allocator().deallocate(data, num); } TEST(flat_set, max_size) { flat_set f; ASSERT_LE(1ULL << 24, f.max_size()); } hyperscan-4.4.1/unit/internal/multi_bit.cpp0000644000175000017500000011350713055426554021575 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "ue2common.h" #include "util/compile_error.h" #include "util/make_unique.h" #include "util/multibit.h" #include "util/multibit_build.h" #include #include #include using namespace std; using namespace testing; using namespace ue2; namespace { class mmbit_holder { public: mmbit_holder() {} explicit mmbit_holder(u32 num_bits, u32 excess = 0) : data(ue2::make_unique(mmbit_size(num_bits) + 7 + excess)) {} void init(u32 num_bits) { assert(!data); data = ue2::make_unique(mmbit_size(num_bits) + 7); } operator u8 *() { assert(data); return data.get() + 7; } operator const u8 *() const { assert(data); return data.get() + 7; } private: unique_ptr data = nullptr; }; } static void fill_mmbit(u8 *ba, u32 test_size) { fill_n(ba, mmbit_size(test_size), 0xff); } TEST(MultiBit, Set1) { const u32 test_size = 32; mmbit_holder ba(test_size); fill_mmbit(ba, test_size); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, 32)); ASSERT_FALSE(mmbit_isset(ba, 32, 0)); mmbit_set(ba, 32, 0); ASSERT_TRUE(mmbit_isset(ba, 32, 0)); ASSERT_TRUE(mmbit_any(ba, 32)); ASSERT_FALSE(mmbit_isset(ba, 32, 31)); mmbit_set(ba, 32, 31); ASSERT_TRUE(mmbit_isset(ba, 32, 31)); } TEST(MultiBit, Set2) { const u32 test_size = 64; mmbit_holder ba(test_size); fill_mmbit(ba, test_size); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, 64)); for (u32 i = 0; i < 64; i++) { ASSERT_FALSE(mmbit_isset(ba, 64, i)); } ASSERT_FALSE(mmbit_isset(ba, 64, 0)); mmbit_set(ba, 64, 0); ASSERT_TRUE(mmbit_isset(ba, 64, 0)); for (u32 i = 1; i < 64; i++) { ASSERT_FALSE(mmbit_isset(ba, 64, i)); } ASSERT_TRUE(mmbit_any(ba, 64)); ASSERT_FALSE(mmbit_isset(ba, 64, 31)); mmbit_set(ba, 64, 31); ASSERT_TRUE(mmbit_isset(ba, 64, 31)); ASSERT_FALSE(mmbit_isset(ba, 64, 32)); mmbit_set(ba, 64, 32); ASSERT_TRUE(mmbit_isset(ba, 64, 32)); ASSERT_FALSE(mmbit_isset(ba, 64, 48)); mmbit_set(ba, 64, 48); ASSERT_TRUE(mmbit_isset(ba, 64, 48)); } TEST(MultiBit, Set3) { const u32 test_size = 1030; mmbit_holder ba(test_size); fill_mmbit(ba, test_size); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); ASSERT_FALSE(mmbit_isset(ba, test_size, 0)); mmbit_set(ba, test_size, 0); ASSERT_TRUE(mmbit_isset(ba, test_size, 0)); ASSERT_TRUE(mmbit_any(ba, test_size)); ASSERT_FALSE(mmbit_isset(ba, test_size, 31)); mmbit_set(ba, test_size, 31); ASSERT_TRUE(mmbit_isset(ba, test_size, 31)); ASSERT_FALSE(mmbit_isset(ba, test_size, 32)); mmbit_set(ba, test_size, 32); ASSERT_TRUE(mmbit_isset(ba, test_size, 32)); ASSERT_FALSE(mmbit_isset(ba, test_size, 48)); mmbit_set(ba, test_size, 48); ASSERT_TRUE(mmbit_isset(ba, test_size, 48)); ASSERT_FALSE(mmbit_isset(ba, test_size, 60)); mmbit_set(ba, test_size, 60); ASSERT_TRUE(mmbit_isset(ba, test_size, 60)); ASSERT_FALSE(mmbit_isset(ba, test_size, 1029)); mmbit_set(ba, test_size, 1029); ASSERT_TRUE(mmbit_isset(ba, test_size, 1029)); } TEST(MultiBit, Set4) { const u32 test_size = 1025; mmbit_holder ba(test_size); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); for (u32 i = 0; i < test_size; i++) { ASSERT_FALSE(mmbit_isset(ba, test_size, i)); mmbit_set(ba, test_size, i); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); ASSERT_EQ(i, mmbit_iterate(ba, test_size, MMB_INVALID)); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, i)); mmbit_unset(ba, test_size, i); ASSERT_FALSE(mmbit_isset(ba, test_size, i)); } } TEST(MultiBit, Set5) { const u32 test_size = 33000; mmbit_holder ba(test_size); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); for (u32 i = 0; i < test_size; i += 8) { ASSERT_FALSE(mmbit_isset(ba, test_size, i)); mmbit_set(ba, test_size, i); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); ASSERT_EQ(i, mmbit_iterate(ba, test_size, MMB_INVALID)); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, i)); mmbit_unset(ba, test_size, i); ASSERT_FALSE(mmbit_isset(ba, test_size, i)); } } TEST(MultiBit, Set8) { const u32 test_size = 8; mmbit_holder ba(test_size); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); for (u32 i = 0; i < test_size; i++) { ASSERT_FALSE(mmbit_isset(ba, test_size, i)); mmbit_set(ba, test_size, i); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); ASSERT_EQ(i, mmbit_iterate(ba, test_size, MMB_INVALID)); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, i)); mmbit_unset(ba, test_size, i); ASSERT_FALSE(mmbit_isset(ba, test_size, i)); } } TEST(MultiBit, Set16) { const u32 test_size = 16; mmbit_holder ba(test_size); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); for (u32 i = 0; i < test_size; i++) { ASSERT_FALSE(mmbit_isset(ba, test_size, i)); mmbit_set(ba, test_size, i); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); ASSERT_EQ(i, mmbit_iterate(ba, test_size, MMB_INVALID)); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, i)); mmbit_unset(ba, test_size, i); ASSERT_FALSE(mmbit_isset(ba, test_size, i)); } } TEST(MultiBit, It1) { const u32 test_size = 32; mmbit_holder ba(test_size); mmbit_clear(ba, test_size); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, MMB_INVALID)); for (u32 i = 0; i < test_size; i+=3) { mmbit_set(ba, test_size, i); } ASSERT_EQ(0U, mmbit_iterate(ba, test_size, MMB_INVALID)); for (u32 i = 0; i < 29; i++) { ASSERT_EQ(i/3 * 3 + 3, mmbit_iterate(ba, test_size, i)); } for (u32 i = 0; i < test_size; i++) { mmbit_set(ba, test_size, i); } ASSERT_EQ(0U, mmbit_iterate(ba, test_size, MMB_INVALID)); for (u32 i = 1; i < test_size; i++) { ASSERT_EQ(i, mmbit_iterate(ba, test_size, i - 1)); } } TEST(MultiBit, It2) { mmbit_holder ba(64); mmbit_clear(ba, 64); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, 64, MMB_INVALID)); for (u32 i = 0; i < 64; i+=3) { mmbit_set(ba, 64, i); } ASSERT_EQ(0U, mmbit_iterate(ba, 64, MMB_INVALID)); for (u32 i = 0; i < 62; i++) { ASSERT_EQ(i/3 * 3 + 3, mmbit_iterate(ba, 64, i)); } for (u32 i = 0; i < 64; i++) { mmbit_set(ba, 64, i); } ASSERT_EQ(0U, mmbit_iterate(ba, 64, MMB_INVALID)); for (u32 i = 1; i < 64; i++) { ASSERT_EQ(i, mmbit_iterate(ba, 64, i - 1)); } } TEST(MultiBit, It3) { const size_t test_size = 60; mmbit_holder ba(test_size, 4); fill_n((u8 *)ba, mmbit_size(test_size) + 4, 0xff); mmbit_clear(ba, test_size); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, MMB_INVALID)); for (u32 i = 0; i < test_size; i+=3) { mmbit_set(ba, test_size, i); } ASSERT_EQ(0U, mmbit_iterate(ba, test_size, MMB_INVALID)); for (u32 i = 0; i < test_size - 3; i++) { ASSERT_EQ(i/3 * 3 + 3, mmbit_iterate(ba, test_size, i)); } for (u32 i = 0; i < test_size; i++) { mmbit_set(ba, test_size, i); } ASSERT_EQ(0U, mmbit_iterate(ba, test_size, MMB_INVALID)); for (u32 i = 1; i < test_size; i++) { ASSERT_EQ(i, mmbit_iterate(ba, test_size, i - 1)); } } // We provide both test size and stride so that larger tests don't take forever // checking every single key. struct MultiBitTestParam { u32 size; u32 stride; }; // Parameterized test case for bounded iterator, rather that propagating // copypasta. Allocates space as given. class MultiBitTest : public TestWithParam { protected: virtual void SetUp() { const MultiBitTestParam &p = GetParam(); test_size = p.size; stride = p.stride; ba.init(test_size); // blast with ones for the lulz fill_mmbit(ba, test_size); } virtual void TearDown() { } u32 test_size; // number of bits in the multibit u32 stride; // stride to use for scans mmbit_holder ba; // multibit storage }; TEST_P(MultiBitTest, BoundedIteratorSingle) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Set one bit on and run some checks. for (u64a i = 0; i < test_size; i += stride) { SCOPED_TRACE(i); mmbit_clear(ba, test_size); mmbit_set(ba, test_size, i); // Scanning from the start to our bit should find nothing. ASSERT_EQ(MMB_INVALID, mmbit_iterate_bounded(ba, test_size, i, i)); // Scanning from the start to the end should find our bit. ASSERT_EQ(i, mmbit_iterate_bounded(ba, test_size, 0, test_size)); // Scanning from our bit to one past it should find itself. ASSERT_EQ(i, mmbit_iterate_bounded(ba, test_size, i, i + 1)); // Scanning from our bit to the end should find itself. ASSERT_EQ(i, mmbit_iterate_bounded(ba, test_size, i, test_size)); // Scanning from one past our bit to the end should find nothing. if (i != test_size - 1) { // Ordinary iterator. ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, i)); // Bounded iterator. ASSERT_EQ(MMB_INVALID, mmbit_iterate_bounded(ba, test_size, i + 1, test_size)); } } } TEST_P(MultiBitTest, BoundedIteratorAll) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Switch everything on. fill_mmbit(ba, test_size); for (u64a i = 0; i < test_size; i += stride) { if (i != 0) { ASSERT_EQ(0U, mmbit_iterate_bounded(ba, test_size, 0, i)); } ASSERT_EQ(i, mmbit_iterate_bounded(ba, test_size, i, i+1)); ASSERT_EQ(i, mmbit_iterate_bounded(ba, test_size, i, test_size)); } } TEST_P(MultiBitTest, BoundedIteratorEven) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Set every even-numbered bit and see what we can see. mmbit_clear(ba, test_size); for (u64a i = 0; i < test_size; i += 2) { mmbit_set(ba, test_size, i); } u32 even_stride = stride % 2 ? stride + 1 : stride; for (u64a i = 0; i < test_size; i += even_stride) { // Scanning from each even bit to the end should find itself. ASSERT_EQ(i, mmbit_iterate_bounded(ba, test_size, i, test_size)); // Scanning from i to i+1 should find itself. ASSERT_EQ(i, mmbit_iterate_bounded(ba, test_size, i, i+1)); // Scanning from i+1 to i+2 should find nothing. if (i+1 < test_size) { ASSERT_EQ(MMB_INVALID, mmbit_iterate_bounded(ba, test_size, i+1, i+2)); } // Scanning from i+1 to the end should find i+2. if (i+2 < test_size) { ASSERT_EQ(i+2, mmbit_iterate_bounded(ba, test_size, i+1, test_size)); } } } TEST_P(MultiBitTest, BoundedIteratorOdd) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Set every odd-numbered bit and see what we can see. mmbit_clear(ba, test_size); for (u64a i = 1; i < test_size; i += 2) { mmbit_set(ba, test_size, i); } u32 even_stride = stride % 2 ? stride + 1 : stride; for (u64a i = 0; i < test_size; i += even_stride) { // Scanning from each even bit to the end should find i+1. if (i+1 < test_size) { ASSERT_EQ(i+1, mmbit_iterate_bounded(ba, test_size, i, test_size)); } // Scanning from i to i+1 should find nothing. ASSERT_EQ(MMB_INVALID, mmbit_iterate_bounded(ba, test_size, i, i+1)); // Scanning from i+1 to i+2 should find i+1. if (i+1 < test_size) { ASSERT_EQ(i+1, mmbit_iterate_bounded(ba, test_size, i+1, i+2)); } // Scanning from i+1 to the end should find i+1. if (i+1 < test_size) { ASSERT_EQ(i+1, mmbit_iterate_bounded(ba, test_size, i+1, test_size)); } } } TEST_P(MultiBitTest, Set) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); for (u64a i = 0; i < test_size; i += stride) { SCOPED_TRACE(i); // set a bit that wasn't set before ASSERT_FALSE(mmbit_isset(ba, test_size, i)); ASSERT_FALSE(mmbit_set(ba, test_size, i)); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); // set it again, should return true ASSERT_TRUE(mmbit_set(ba, test_size, i)); // clear it and make sure it's gone mmbit_unset(ba, test_size, i); ASSERT_FALSE(mmbit_isset(ba, test_size, i)); // set it again, should return false ASSERT_FALSE(mmbit_set(ba, test_size, i)); } } TEST_P(MultiBitTest, Iter) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); mmbit_clear(ba, test_size); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, MMB_INVALID)); for (u64a i = 0; i < test_size; i += stride) { SCOPED_TRACE(i); mmbit_clear(ba, test_size); mmbit_set(ba, test_size, i); ASSERT_EQ(i, mmbit_iterate(ba, test_size, MMB_INVALID)); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, i)); } } TEST_P(MultiBitTest, IterAll) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); mmbit_clear(ba, test_size); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, MMB_INVALID)); // Set all bits. for (u64a i = 0; i < test_size; i += stride) { mmbit_set(ba, test_size, i); } // Find all bits. u32 it = MMB_INVALID; for (u64a i = 0; i < test_size; i += stride) { ASSERT_EQ(i, mmbit_iterate(ba, test_size, it)); it = i; } } TEST_P(MultiBitTest, AnyPrecise) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any_precise(ba, test_size)); for (u64a i = 0; i < test_size; i += stride) { SCOPED_TRACE(i); mmbit_clear(ba, test_size); mmbit_set(ba, test_size, i); ASSERT_TRUE(mmbit_any_precise(ba, test_size)); } } TEST_P(MultiBitTest, Any) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); for (u64a i = 0; i < test_size; i += stride) { SCOPED_TRACE(i); mmbit_clear(ba, test_size); mmbit_set(ba, test_size, i); ASSERT_TRUE(mmbit_any(ba, test_size)); } } TEST_P(MultiBitTest, All) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_all(ba, test_size)); for (u64a i = 0; i < test_size - 1; i += stride) { SCOPED_TRACE(i); mmbit_set(ba, test_size, i); ASSERT_FALSE(mmbit_all(ba, test_size)); } // Set all bits. fill_mmbit(ba, test_size); ASSERT_TRUE(mmbit_all(ba, test_size)); } TEST_P(MultiBitTest, UnsetRange1) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Set all bits. fill_mmbit(ba, test_size); // Use mmbit_unset_range to switch off any single bit. for (u64a i = 0; i < test_size; i += stride) { SCOPED_TRACE(i); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); mmbit_unset_range(ba, test_size, i, i + 1); ASSERT_FALSE(mmbit_isset(ba, test_size, i)); } } TEST_P(MultiBitTest, UnsetRange2) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // XXX: slow on large cases, so we skip those. if (stride > 1) { return; } // Set all bits. fill_mmbit(ba, test_size); // Use mmbit_unset_range to switch off all bits. mmbit_unset_range(ba, test_size, 0, test_size); for (u64a i = 0; i < test_size; i += stride) { SCOPED_TRACE(i); ASSERT_FALSE(mmbit_isset(ba, test_size, i)); } } TEST_P(MultiBitTest, UnsetRange3) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Use mmbit_unset_range to switch off bits in chunks of 3. for (u64a i = 0; i < test_size - 3; i += stride) { // Switch on the bit before, the bits in question, and the bit after. if (i > 0) { mmbit_set(ba, test_size, i - 1); } for (u64a j = i; j < min(i + 4, (u64a)test_size); j++) { mmbit_set(ba, test_size, j); } // Switch off the chunk. mmbit_unset_range(ba, test_size, i, i + 3); ASSERT_FALSE(mmbit_isset(ba, test_size, i)); ASSERT_FALSE(mmbit_isset(ba, test_size, i + 1)); ASSERT_FALSE(mmbit_isset(ba, test_size, i + 2)); // Bits on either side should be intact. if (i > 0) { ASSERT_TRUE(mmbit_isset(ba, test_size, i - 1)); } if (i + 3 < test_size) { ASSERT_TRUE(mmbit_isset(ba, test_size, i + 3)); } } } TEST_P(MultiBitTest, InitRangeAll) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Use mmbit_init_range to set all the bits. mmbit_init_range(ba, test_size, 0, test_size); // Make sure they're all set. for (u64a i = 0; i < test_size; i += stride) { SCOPED_TRACE(i); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); } } TEST_P(MultiBitTest, InitRangeNone) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Use mmbit_set_range to set all the bits. mmbit_init_range(ba, test_size, 0, 0); // Make sure nothing's set. ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, MMB_INVALID)); } TEST_P(MultiBitTest, InitRangeOne) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); for (u64a i = 0; i < test_size; i += stride) { mmbit_init_range(ba, test_size, i, i + 1); // Only bit 'i' should be on. ASSERT_EQ(i, mmbit_iterate(ba, test_size, MMB_INVALID)); ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, i)); } } TEST_P(MultiBitTest, InitRangeChunked) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Init ranges chunk by chunk. for (u32 n = 2; n <= 10; n++) { u32 chunk_size = test_size / n; if (chunk_size == 0) break; for (u32 k = 0; k < n; k++) { u32 chunk_begin = k * chunk_size; u32 chunk_end = min(test_size, (k + 1) * chunk_size); mmbit_init_range(ba, test_size, chunk_begin, chunk_end); // First bit set should be chunk_begin. ASSERT_EQ(chunk_begin, mmbit_iterate(ba, test_size, MMB_INVALID)); // All bits in the chunk should be on. for (u64a i = chunk_begin; i < chunk_end; i += stride) { SCOPED_TRACE(i); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); } // Last bit on is chunk_end - 1. if (chunk_end) { ASSERT_EQ(MMB_INVALID, mmbit_iterate(ba, test_size, chunk_end - 1)); } } } } TEST(MultiBit, SparseIteratorBegin1) { const u32 test_size = 100; vector it; vector bits; bits.push_back(1); bits.push_back(5); bits.push_back(27); bits.push_back(35); bits.push_back(68); mmbBuildSparseIterator(it, bits, test_size); //ASSERT_EQ(4U, it.size()); // Trivial initial test: all bits in 'bits' are on, all others are off mmbit_holder ba(test_size); mmbit_clear(ba, test_size); for (size_t i = 0; i < bits.size(); i++) { mmbit_set(ba, test_size, bits[i]); } vector state(mmbit_sparse_iter_state_size(test_size)); for (u32 i = 0; i < bits.size(); i++) { u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); mmbit_unset(ba, test_size, bits[i]); ASSERT_FALSE(mmbit_isset(ba, test_size, bits[i])); } // All clear, begin should be invalid u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(MMB_INVALID, val); } TEST(MultiBit, SparseIteratorBegin2) { const u32 test_size = 40000; vector it; vector bits; bits.push_back(1); bits.push_back(256); bits.push_back(257); bits.push_back(1024); bits.push_back(8920); bits.push_back(37000); mmbBuildSparseIterator(it, bits, test_size); //ASSERT_EQ(12U, it.size()); // Trivial initial test: all bits in 'bits' are on, all others are off mmbit_holder ba(test_size); mmbit_clear(ba, test_size); for (size_t i = 0; i < bits.size(); i++) { mmbit_set(ba, test_size, bits[i]); } vector state(mmbit_sparse_iter_state_size(test_size)); for (u32 i = 0; i < bits.size(); i++) { u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); mmbit_unset(ba, test_size, bits[i]); ASSERT_FALSE(mmbit_isset(ba, test_size, bits[i])); } // All clear, begin should be invalid u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(MMB_INVALID, val); } TEST(MultiBit, SparseIteratorNext1) { const u32 test_size = 100; vector it; vector bits; bits.push_back(1); bits.push_back(5); bits.push_back(27); bits.push_back(35); bits.push_back(68); mmbBuildSparseIterator(it, bits, test_size); // Trivial initial test: all bits in 'bits' are on, all others are off mmbit_holder ba(test_size); mmbit_clear(ba, test_size); for (size_t i = 0; i < bits.size(); i++) { mmbit_set(ba, test_size, bits[i]); } vector state(mmbit_sparse_iter_state_size(test_size)); u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[0], val); ASSERT_EQ(0U, idx); for (u32 i = 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } // Same test with all bits on for (size_t i = 0; i < test_size; i++) { mmbit_set(ba, test_size, i); } val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[0], val); ASSERT_EQ(0U, idx); for (u32 i = 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } // Test with only the last half on mmbit_clear(ba, test_size); size_t last_half = bits.size()/2; for (size_t i = last_half; i < bits.size(); i++) { mmbit_set(ba, test_size, bits[i]); } val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[last_half], val); ASSERT_EQ(last_half, idx); for (u32 i = last_half + 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } } TEST(MultiBit, SparseIteratorNext2) { const u32 test_size = 40000; vector it; vector bits; bits.push_back(1); bits.push_back(256); bits.push_back(257); bits.push_back(1024); bits.push_back(1025); bits.push_back(4095); bits.push_back(4096); bits.push_back(4097); bits.push_back(8920); bits.push_back(37000); bits.push_back(39999); mmbBuildSparseIterator(it, bits, test_size); // Trivial initial test: all bits in 'bits' are on, all others are off mmbit_holder ba(test_size); mmbit_clear(ba, test_size); for (size_t i = 0; i < bits.size(); i++) { mmbit_set(ba, test_size, bits[i]); } vector state(mmbit_sparse_iter_state_size(test_size)); u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[0], val); ASSERT_EQ(0U, idx); for (u32 i = 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } // Same test with all bits on for (size_t i = 0; i < test_size; i++) { mmbit_set(ba, test_size, i); } val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[0], val); ASSERT_EQ(0U, idx); for (u32 i = 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } // Test with only the last half on mmbit_clear(ba, test_size); size_t last_half = bits.size()/2; for (size_t i = last_half; i < bits.size(); i++) { mmbit_set(ba, test_size, bits[i]); } val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[last_half], val); ASSERT_EQ(last_half, idx); for (u32 i = last_half + 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } } TEST(MultiBit, SparseIteratorNextSmall) { const u32 test_size = 15; vector it; vector bits; bits.push_back(1); bits.push_back(3); bits.push_back(6); bits.push_back(7); bits.push_back(12); bits.push_back(14); mmbBuildSparseIterator(it, bits, test_size); // Trivial initial test: all bits in 'bits' are on, all others are off mmbit_holder ba(test_size); mmbit_clear(ba, test_size); for (size_t i = 0; i < bits.size(); i++) { mmbit_set(ba, test_size, bits[i]); } vector state(mmbit_sparse_iter_state_size(test_size)); u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[0], val); ASSERT_EQ(0U, idx); for (u32 i = 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } // Same test with all bits on for (size_t i = 0; i < test_size; i++) { mmbit_set(ba, test_size, i); } val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[0], val); ASSERT_EQ(0U, idx); for (u32 i = 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } // Test with only the last half on mmbit_clear(ba, test_size); size_t last_half = bits.size()/2; for (size_t i = last_half; i < bits.size(); i++) { mmbit_set(ba, test_size, bits[i]); } val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[last_half], val); ASSERT_EQ(last_half, idx); for (u32 i = last_half + 1; i < bits.size(); i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } } TEST_P(MultiBitTest, SparseIteratorBeginAll) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Put all our bits into the sparse iterator. vector it; vector bits; bits.reserve(test_size / stride); for (u64a i = 0; i < test_size; i += stride) { bits.push_back(i); } mmbBuildSparseIterator(it, bits, test_size); // Switch all bits on in state. mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); fill_mmbit(ba, test_size); // Iterate over all bits; clear the first one and ensure that the iterator // reports the next bit as the start bit. vector state(mmbit_sparse_iter_state_size(test_size)); u32 val, idx = 0xffffffff; for (size_t i = 0, num_keys = bits.size(); i < num_keys; i++) { val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); mmbit_unset(ba, test_size, bits[i]); } // Cleared all bits, iterator should return invalid. val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(MMB_INVALID, val); } TEST_P(MultiBitTest, SparseIteratorBeginThirds) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // XXX: only run on stride=1 cases for speed. if (stride > 1) { return; } // Put all our bits into the sparse iterator vector it; vector bits(test_size); for (u32 i = 0; i != test_size; i++) { bits[i] = i; } mmbBuildSparseIterator(it, bits, test_size); // Switch every third bits on in state mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); for (u64a i = 0; i < test_size; i += 3) { mmbit_set(ba, test_size, i); } // Iterate over all bits; clear the first on bit and ensure that the // iterator reports the next on bit as the start bit. vector state(mmbit_sparse_iter_state_size(test_size)); u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(0U, val); ASSERT_EQ(0U, idx); for (u64a i = 0; i < test_size - 3; i += 3) { mmbit_unset(ba, test_size, i); val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(i+3, val); ASSERT_EQ(i+3, idx); } } TEST_P(MultiBitTest, SparseIteratorNextAll) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Put all our bits into the sparse iterator. vector it; vector bits; bits.reserve(test_size / stride); for (u64a i = 0; i < test_size; i += stride) { bits.push_back(i); } mmbBuildSparseIterator(it, bits, test_size); // Switch all bits on in state mmbit_clear(ba, test_size); ASSERT_FALSE(mmbit_any(ba, test_size)); fill_mmbit(ba, test_size); // Iterate over all bits. vector state(mmbit_sparse_iter_state_size(test_size)); u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(0U, val); ASSERT_EQ(0U, idx); for (u32 i = 1, num_keys = bits.size(); i < num_keys; i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } // All bits tested, we should now return invalid val = mmbit_sparse_iter_next(ba, test_size, bits.back(), &idx, &it[0], &state[0]); ASSERT_EQ(MMB_INVALID, val); } TEST_P(MultiBitTest, SparseIteratorNextExactStrided) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); if (stride == 1) { // This test is the same as SparseIteratorNextAll for stride 1 return; } // Put all our bits into the sparse iterator and switch them on in the // state. mmbit_clear(ba, test_size); vector it; vector bits; bits.reserve(test_size / stride); for (u64a i = 0; i < test_size; i += stride) { bits.push_back(i); mmbit_set(ba, test_size, i); } mmbBuildSparseIterator(it, bits, test_size); // Iterate over all bits. vector state(mmbit_sparse_iter_state_size(test_size)); u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(0U, val); ASSERT_EQ(0U, idx); for (u32 i = 1, num_keys = bits.size(); i < num_keys; i++) { val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(bits[i], val); ASSERT_EQ(i, idx); } // All bits tested, we should now return invalid val = mmbit_sparse_iter_next(ba, test_size, bits.back(), &idx, &it[0], &state[0]); ASSERT_EQ(MMB_INVALID, val); } TEST_P(MultiBitTest, SparseIteratorNextNone) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Put all our bits into the sparse iterator. vector it; vector bits; bits.reserve(test_size / stride); for (u64a i = 0; i < test_size; i += stride) { bits.push_back(i); } mmbBuildSparseIterator(it, bits, test_size); // Switch only the first bit on mmbit_clear(ba, test_size); mmbit_set(ba, test_size, 0); // Begin should find first bit vector state(mmbit_sparse_iter_state_size(test_size)); u32 val, idx = 0xffffffff; val = mmbit_sparse_iter_begin(ba, test_size, &idx, &it[0], &state[0]); ASSERT_EQ(0U, val); ASSERT_EQ(0U, idx); // Next should return invalid val = mmbit_sparse_iter_next(ba, test_size, val, &idx, &it[0], &state[0]); ASSERT_EQ(MMB_INVALID, val); } TEST_P(MultiBitTest, SparseIteratorUnsetAll) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // Put all our bits into the sparse iterator vector it; vector bits; bits.reserve(test_size / stride); for (u64a i = 0; i < test_size; i += stride) { bits.push_back(i); } mmbBuildSparseIterator(it, bits, test_size); // Switch all bits on mmbit_clear(ba, test_size); fill_mmbit(ba, test_size); // Run iterator unset, which should clear all bits struct mmbit_sparse_state sparse_iter_state[MAX_SPARSE_ITER_STATES]; mmbit_sparse_iter_unset(ba, test_size, &it[0], sparse_iter_state); // All bits should now be off for (u32 i = 0, num_keys = bits.size(); i < num_keys; i++) { ASSERT_FALSE(mmbit_isset(ba, test_size, bits[i])); } } TEST_P(MultiBitTest, SparseIteratorUnsetHalves) { SCOPED_TRACE(test_size); ASSERT_TRUE(ba != nullptr); // TODO: write useful striding version of this test. if (stride > 1) { return; } // Two sparse iterators: one for even bits, one for odd ones vector even, odd; for (u64a i = 0; i < test_size; i += 2) { even.push_back(i); } for (u64a i = 1; i < test_size; i += 2) { odd.push_back(i); } vector it_even, it_odd; mmbBuildSparseIterator(it_even, even, test_size); mmbBuildSparseIterator(it_odd, odd, test_size); // Switch all bits on mmbit_clear(ba, test_size); for (u32 i = 0; i != test_size; i++) { mmbit_set(ba, test_size, i); ASSERT_TRUE(mmbit_isset(ba, test_size, i)); } // Run even iterator unset, which should clear all even bits struct mmbit_sparse_state sparse_iter_state[MAX_SPARSE_ITER_STATES]; mmbit_sparse_iter_unset(ba, test_size, &it_even[0], sparse_iter_state); // All even bits are off, all odd bits are on for (u32 i = 0; i != test_size; i++) { if ((i % 2) == 0) { ASSERT_FALSE(mmbit_isset(ba, test_size, i)); } else { ASSERT_TRUE(mmbit_isset(ba, test_size, i)); } } // Run odd iterator unset, clearing the odd bits mmbit_sparse_iter_unset(ba, test_size, &it_odd[0], sparse_iter_state); // All bits should now be off for (u32 i = 0; i != test_size; i++) { ASSERT_FALSE(mmbit_isset(ba, test_size, i)); } } static const MultiBitTestParam multibitTests[] = { // We provide both test size and stride so that larger tests don't take // forever checking every single key. // Small cases, stride 1. { 4, 1 }, { 7, 1 }, { 8, 1 }, { 13, 1 }, { 16, 1 }, { 17, 1 }, { 32, 1 }, { 33, 1 }, { 57, 1 }, { 64, 1 }, { 65, 1 }, { 100, 1 }, { 128, 1 }, { 200, 1 }, { 256, 1 }, { 302, 1 }, { 1024, 1 }, { 1025, 1 }, { 2099, 1 }, { 10000, 1 }, { 32768, 1 }, { 32769, 1 }, { 200000, 1 }, // Larger cases, bigger strides. { 1U << 18, 3701 }, { 1U << 19, 3701 }, { 1U << 20, 3701 }, { 1U << 21, 3701 }, { 1U << 22, 3701 }, { 1U << 23, 3701 }, { 1U << 24, 3701 }, { 1U << 25, 3701 }, { 1U << 26, 3701 }, { 1U << 27, 7919 }, { 1U << 28, 15073 }, { 1U << 29, 24413 }, { 1U << 30, 50377 }, { 1U << 31, 104729 }, }; INSTANTIATE_TEST_CASE_P(MultiBit, MultiBitTest, ValuesIn(multibitTests)); TEST(MultiBit, SizeTooBig) { ASSERT_NO_THROW(mmbit_size(MMB_MAX_BITS)); ASSERT_THROW(mmbit_size(MMB_MAX_BITS + 1), ResourceLimitError); } hyperscan-4.4.1/unit/internal/rose_build_merge.cpp0000644000175000017500000001114613055426554023107 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "nfagraph/ng_holder.h" #include "rose/rose_build.h" #include "rose/rose_build_impl.h" #include "rose/rose_build_merge.h" #include "util/report_manager.h" #include "util/boundary_reports.h" #include "util/compile_context.h" #include "util/graph_range.h" #include "util/make_unique.h" #include "smallwrite/smallwrite_build.h" #include "som/slot_manager.h" using std::vector; using namespace ue2; static std::unique_ptr makeSuffixGraph(ReportID report) { auto h = ue2::make_unique(NFA_SUFFIX); NGHolder &g = *h; NFAVertex v = add_vertex(g); g[v].char_reach = CharReach('A', 'Z'); g[v].reports.insert(report); add_edge(g.start, v, g); add_edge(v, g.accept, g); return h; } static RoseVertex addVertex(RoseBuildImpl &build, RoseVertex parent, u32 lit_id) { RoseGraph &g = build.g; RoseVertex v = add_vertex(g); g[v].min_offset = 0; g[v].max_offset = ROSE_BOUND_INF; g[v].literals.insert(lit_id); RoseEdge e = add_edge(parent, v, g).first; g[e].minBound = 0; g[e].maxBound = ROSE_BOUND_INF; g[e].history = ROSE_ROLE_HISTORY_NONE; return v; } static size_t numUniqueSuffixGraphs(const RoseGraph &g) { ue2::unordered_set seen; for (const auto &v : vertices_range(g)) { if (g[v].suffix) { assert(g[v].suffix.graph); seen.insert(g[v].suffix.graph.get()); } } return seen.size(); } TEST(RoseMerge, uncalcLeaves_nonleaf) { Grey grey; CompileContext cc(true, false, get_current_target(), grey); ReportManager rm(cc.grey); SomSlotManager ssm(8); // som precision auto smwr = makeSmallWriteBuilder(1, rm, cc); BoundaryReports boundary; auto build_base = makeRoseBuilder(rm, ssm, *smwr, cc, boundary); ASSERT_NE(nullptr, build_base); RoseBuildImpl &build = static_cast(*build_base); RoseGraph &g = build.g; std::shared_ptr shared_suffix = makeSuffixGraph(1000); // foo with shared_suffix RoseVertex v1 = addVertex(build, build.root, build.getLiteralId(ue2_literal("foo", false), 0, ROSE_FLOATING)); g[v1].suffix.graph = shared_suffix; // foo with shared_suffix -> bar RoseVertex v2 = addVertex(build, build.root, build.getLiteralId(ue2_literal("foo", false), 0, ROSE_FLOATING)); g[v2].suffix.graph = shared_suffix; // same as v1 RoseVertex v3 = addVertex(build, v2, build.getLiteralId(ue2_literal("bar", false), 0, ROSE_FLOATING)); g[v3].reports.insert(1001); // foo with a different suffix RoseVertex v4 = addVertex(build, build.root, build.getLiteralId(ue2_literal("foo", false), 0, ROSE_FLOATING)); g[v4].suffix.graph = makeSuffixGraph(2000); ASSERT_EQ(6, num_vertices(g)); ASSERT_EQ(2, numUniqueSuffixGraphs(g)); // uncalcLeaves should leave this case alone. The suffixes on leaf nodes v1 // and v4 are not mergeable, as v1 shares its suffix with v2. uncalcLeaves(build); ASSERT_EQ(6, num_vertices(g)); ASSERT_EQ(2, numUniqueSuffixGraphs(g)); } hyperscan-4.4.1/unit/internal/charreach.cpp0000644000175000017500000002320013055426554021513 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/charreach.h" using namespace ue2; TEST(ng_charreach, init) { CharReach cr; ASSERT_EQ(0U, cr.count()); ASSERT_TRUE(cr.none()); ASSERT_FALSE(cr.all()); ASSERT_EQ(256U, cr.size()); } TEST(ng_charreach, set) { CharReach cr; ASSERT_EQ(0U, cr.count()); ASSERT_TRUE(cr.none()); ASSERT_FALSE(cr.all()); cr.set('q'); ASSERT_EQ(1U, cr.count()); cr.setall(); ASSERT_EQ(cr.size(), cr.count()); ASSERT_TRUE(cr.all()); } TEST(ng_charreach, clear) { CharReach cr; ASSERT_EQ(0U, cr.count()); ASSERT_TRUE(cr.none()); ASSERT_FALSE(cr.all()); cr.set('q'); cr.set('u'); cr.set('a'); cr.set('r'); cr.set('k'); ASSERT_EQ(5U, cr.count()); cr.clear('r'); ASSERT_EQ(4U, cr.count()); ASSERT_FALSE(cr.test('r')); cr.setall(); ASSERT_EQ(cr.size(), cr.count()); ASSERT_TRUE(cr.all()); cr.clear(0xff); ASSERT_FALSE(cr.all()); } TEST(ng_charreach, copy) { CharReach cr; cr.set('a'); cr.set('z'); CharReach cr2(cr); ASSERT_EQ(cr.count(), cr2.count()); ASSERT_TRUE(cr == cr2); } TEST(ng_charreach, assignment) { CharReach cr; cr.set('f'); cr.set('l'); cr.set('y'); CharReach cr2; cr2 = cr; ASSERT_EQ(cr.count(), cr2.count()); ASSERT_TRUE(cr == cr2); } TEST(ng_charreach, flip) { CharReach cr; ASSERT_EQ(0U, cr.count()); ASSERT_TRUE(cr.none()); cr.flip(); ASSERT_EQ(cr.size(), cr.count()); ASSERT_TRUE(cr.all()); cr.flip(); ASSERT_EQ(0U, cr.count()); ASSERT_TRUE(cr.none()); cr.flip(25); ASSERT_FALSE(cr.none()); ASSERT_FALSE(cr.all()); ASSERT_EQ(1U, cr.count()); cr.flip(); ASSERT_EQ(cr.size() - 1, cr.count()); } TEST(ng_charreach, count) { CharReach cr; cr.set(1); cr.set(2); cr.set('a'); cr.set('Z'); cr.set('m'); cr.set('~'); cr.set(210); size_t n = cr.find_first(); ASSERT_FALSE(n == CharReach::npos); unsigned int i = 0; while (n != CharReach::npos) { i++; n = cr.find_next(n); } ASSERT_EQ(i, cr.count()); } TEST(ng_charreach, string) { CharReach cr; cr.set(1); cr.set(2); cr.set('a'); cr.set('Z'); cr.set('m'); cr.set('~'); cr.set(210); ASSERT_FALSE(cr.isAlpha()); cr.flip(1); cr.flip(2); cr.flip('~'); cr.flip(210); ASSERT_TRUE(cr.isAlpha()); ASSERT_EQ("Zam", cr.to_string()); } TEST(ng_charreach, alpha) { CharReach cr; ASSERT_EQ(0U, cr.count()); ASSERT_FALSE(cr.isAlpha()); cr.set('a'); ASSERT_FALSE(0 == cr.count()); ASSERT_TRUE(cr.isAlpha()); cr.set('A'); cr.set('b'); cr.set('z'); ASSERT_TRUE(cr.isAlpha()); cr.set(1); ASSERT_FALSE(cr.isAlpha()); } TEST(ng_charreach, alpha2) { // Test all single chars. for (size_t i = 0; i < 256; i++) { CharReach cr((unsigned char)i); ASSERT_EQ((i >= 'A' && i <= 'Z') || (i >= 'a' && i <= 'z'), cr.isAlpha()) << "Failed for char i=" << i; } // Test some more complex cases. ASSERT_FALSE(CharReach::dot().isAlpha()); ASSERT_FALSE(CharReach("0123456789").isAlpha()); ASSERT_FALSE(CharReach("a0").isAlpha()); ASSERT_FALSE(CharReach("abcdef0").isAlpha()); ASSERT_FALSE(CharReach('A', 'z').isAlpha()); ASSERT_FALSE(CharReach('A', 'Z' + 1).isAlpha()); ASSERT_FALSE(CharReach('A' - 1, 'Z').isAlpha()); ASSERT_FALSE(CharReach('a', 'z' + 1).isAlpha()); ASSERT_FALSE(CharReach('a' - 1, 'z').isAlpha()); ASSERT_TRUE(CharReach('A', 'B').isAlpha()); ASSERT_TRUE(CharReach('A', 'F').isAlpha()); ASSERT_TRUE(CharReach('A', 'Z').isAlpha()); ASSERT_TRUE(CharReach('X', 'Z').isAlpha()); ASSERT_TRUE(CharReach('a', 'b').isAlpha()); ASSERT_TRUE(CharReach('a', 'z').isAlpha()); ASSERT_TRUE(CharReach("ABCDEFabcdef").isAlpha()); } TEST(ng_charreach, caseless) { CharReach cr; cr.set('a'); ASSERT_FALSE(cr.isCaselessChar()); cr.set('A'); ASSERT_TRUE(cr.isCaselessChar()); cr.set('b'); ASSERT_FALSE(cr.isCaselessChar()); cr.set('B'); ASSERT_FALSE(cr.isCaselessChar()); } TEST(ng_charreach, caseless2) { // Test every pair of characters. for (size_t i = 0; i < 256; i++) { ASSERT_FALSE(CharReach((unsigned char)i).isCaselessChar()); for (size_t j = 0; j < 256; j++) { CharReach cr; cr.set(i); cr.set(j); bool upper_lower = (i >= 'A' && i <= 'Z') && j == i + 0x20; bool lower_upper = (i >= 'a' && i <= 'z') && i == j + 0x20; bool caseless_pair = upper_lower | lower_upper; ASSERT_EQ(caseless_pair, cr.isCaselessChar()) << "Failed for i=" << i << ", j=" << j; } } } TEST(ng_charreach, bitwise) { CharReach cr; CharReach cr2; CharReach cr3; CharReach cr4; cr.set('a'); cr2.set('z'); cr3.set('a'); cr3.set('z'); ASSERT_TRUE(cr < cr3); cr4 |= cr; cr4 |= cr2; ASSERT_TRUE(cr3 == cr4); ASSERT_TRUE(cr3 == (cr | cr2)); ASSERT_TRUE(cr4 == (cr | cr2)); ASSERT_TRUE(cr == (cr & cr3)); ASSERT_TRUE(cr2 == (cr2 & cr3)); cr3 &= cr; ASSERT_FALSE(cr3.test('z')); } TEST(ng_charreach, bit5) { CharReach cr; ASSERT_TRUE(cr.isBit5Insensitive()); cr.set('a'); ASSERT_FALSE(cr.isBit5Insensitive()); cr.set('A'); ASSERT_TRUE(cr.isBit5Insensitive()); cr.set('!'); ASSERT_FALSE(cr.isBit5Insensitive()); cr.set(1); ASSERT_TRUE(cr.isBit5Insensitive()); cr.clear(); cr.set('!'); cr.set('A'); ASSERT_FALSE(cr.isBit5Insensitive()); cr.clear(); cr.set('A'); cr.set('b'); ASSERT_FALSE(cr.isBit5Insensitive()); cr.set('a'); cr.set('B'); ASSERT_TRUE(cr.isBit5Insensitive()); } TEST(ng_charreach, find_last) { CharReach cr; cr.set('a'); ASSERT_EQ(cr.find_last(), (size_t)'a'); cr.set('b'); ASSERT_EQ(cr.find_last(), (size_t)'b'); cr.set(192); ASSERT_EQ(cr.find_last(), (size_t)192); cr.set(207); ASSERT_EQ(cr.find_last(), (size_t)207); cr.set(223); ASSERT_EQ(cr.find_last(), (size_t)223); cr.set(255); ASSERT_EQ(cr.find_last(), (size_t)255); cr.clear(); ASSERT_EQ(cr.find_last(), cr.size()); cr.set(0); ASSERT_EQ(cr.find_last(), (size_t)0); cr.set(1); ASSERT_EQ(cr.find_last(), (size_t)1); } TEST(ng_charreach, setRange) { // Exhaustive test: every possible contiguous range. for (unsigned range = 0; range < 256; range++) { for (unsigned from = 0; from < 256 - range; from++) { unsigned to = from + range; CharReach cr; cr.setRange(from, to); ASSERT_EQ(from, cr.find_first()); ASSERT_EQ(to, cr.find_last()); ASSERT_EQ(range + 1, cr.count()); } } } TEST(ng_charreach, find_nth) { const size_t npos = CharReach::npos; // One bit cases. for (size_t i = 0; i < 256; i++) { CharReach cr((unsigned char)i); ASSERT_EQ(i, cr.find_nth(0)); ASSERT_EQ(npos, cr.find_nth(1)); } // All bits set. CharReach dot = CharReach::dot(); for (size_t i = 0; i < 256; i++) { ASSERT_EQ(i, dot.find_nth(i)); } // Trivial two bit cases. for (size_t i = 0; i < 128; i++) { CharReach cr; cr.set(i); cr.set(256 - i); ASSERT_EQ(i, cr.find_nth(0)); ASSERT_EQ(256 - i, cr.find_nth(1)); ASSERT_EQ(npos, cr.find_nth(3)); } // More complex case. const std::string str("\x01\x02\x03\x05\x06\x20!#$%&./0123568:;ABCDEFMNOPUYZbcdefwxyz"); CharReach cr(str); for (size_t i = 0; i < str.length(); i++) { ASSERT_EQ(str[i], cr.find_nth(i)); } ASSERT_EQ(npos, cr.find_nth(str.length())); } TEST(ng_charreach, find_empty) { const size_t npos = CharReach::npos; ASSERT_EQ(npos, CharReach().find_first()); ASSERT_EQ(npos, CharReach().find_next(npos)); } TEST(ng_charreach, dot) { CharReach dot = CharReach::dot(); ASSERT_EQ(256, dot.count()); ASSERT_TRUE(dot.all()); for (size_t i = 0; i < 256; i++) { ASSERT_TRUE(dot.test(i)); } } hyperscan-4.4.1/unit/internal/fdr.cpp0000644000175000017500000006454413055426554020366 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "ue2common.h" #include "grey.h" #include "fdr/fdr.h" #include "fdr/fdr_compile.h" #include "fdr/fdr_compile_internal.h" #include "fdr/fdr_engine_description.h" #include "fdr/teddy_compile.h" #include "fdr/teddy_engine_description.h" #include "util/alloc.h" #include "database.h" #include "gtest/gtest.h" #include #include #include #include #include using namespace std; using namespace testing; using namespace ue2; #define NO_TEDDY_FAIL_ALLOWED 0 #if(NO_TEDDY_FAIL_ALLOWED) #define CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint) ASSERT_TRUE(fdr != nullptr) #else #define CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint) \ { \ auto descr = getTeddyDescription(hint); \ if (descr && fdr == nullptr) { \ return; /* cannot build Teddy for this set of literals */ \ } else { \ ASSERT_TRUE(fdr != nullptr); \ } \ } #endif namespace { struct match { size_t start; size_t end; u32 id; match(size_t start_in, size_t end_in, u32 id_in) : start(start_in), end(end_in), id(id_in) {} bool operator==(const match &b) const { return start == b.start && end == b.end && id == b.id; } bool operator<(const match &b) const { if (id < b.id) { return true; } else if (id == b.id) { if (start < b.start) { return true; } else if (start == b.start) { return end < b.end; } } return false; } match operator+(size_t adj) { return match(start + adj, end + adj, id); } }; extern "C" { static hwlmcb_rv_t countCallback(UNUSED size_t start, UNUSED size_t end, u32, void *ctxt) { if (ctxt) { ++*(u32 *)ctxt; } return HWLM_CONTINUE_MATCHING; } static hwlmcb_rv_t decentCallback(size_t start, size_t end, u32 id, void *ctxt) { DEBUG_PRINTF("match %zu-%zu : %u\n", start, end, id); if (!ctxt) { return HWLM_CONTINUE_MATCHING; } vector *out = (vector *)ctxt; out->push_back(match(start, end, id)); return HWLM_CONTINUE_MATCHING; } static hwlmcb_rv_t decentCallbackT(size_t start, size_t end, u32 id, void *ctxt) { if (!ctxt) { return HWLM_TERMINATE_MATCHING; } vector *out = (vector *)ctxt; out->push_back(match(start, end, id)); return HWLM_TERMINATE_MATCHING; } } // extern "C" } // namespace static vector getValidFdrEngines() { const auto target = get_current_target(); vector ret; vector fdr_descriptions; getFdrDescriptions(&fdr_descriptions); for (const FDREngineDescription &d : fdr_descriptions) { if (d.isValidOnTarget(target)) { ret.push_back(d.getID()); } } vector teddy_descriptions; getTeddyDescriptions(&teddy_descriptions); for (const TeddyEngineDescription &d : teddy_descriptions) { if (d.isValidOnTarget(target)) { ret.push_back(d.getID()); } } return ret; } class FDRp : public TestWithParam { }; TEST_P(FDRp, Simple) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const char data[] = "mnopqrabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678901234567890mnopqr"; vector lits; lits.push_back(hwlmLiteral("mnopqr", 0, 0)); auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); vector matches; fdrExec(fdr.get(), (const u8 *)data, sizeof(data), 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(3U, matches.size()); EXPECT_EQ(match(0, 5, 0), matches[0]); EXPECT_EQ(match(18, 23, 0), matches[1]); EXPECT_EQ(match(78, 83, 0), matches[2]); } TEST_P(FDRp, SimpleSingle) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const char data[] = "mnopqrabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678901234567890m0m"; vector lits; lits.push_back(hwlmLiteral("m", 0, 0)); auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); vector matches; fdrExec(fdr.get(), (const u8 *)data, sizeof(data) - 1 /* skip nul */, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(4U, matches.size()); EXPECT_EQ(match(0, 0, 0), matches[0]); EXPECT_EQ(match(18, 18, 0), matches[1]); EXPECT_EQ(match(78, 78, 0), matches[2]); EXPECT_EQ(match(80, 80, 0), matches[3]); } TEST_P(FDRp, MultiLocation) { const u32 hint = GetParam(); SCOPED_TRACE(hint); vector lits; lits.push_back(hwlmLiteral("abc", 0, 1)); auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); const u32 testSize = 128; vector data(testSize, 0); for (u32 i = 0; i < testSize - 3; i++) { memcpy(data.data() + i, "abc", 3); vector matches; fdrExec(fdr.get(), data.data(), testSize, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(1U, matches.size()); EXPECT_EQ(match(i, i+2, 1), matches[0]); memset(data.data() + i, 0, 3); } } TEST_P(FDRp, Flood) { const u32 hint = GetParam(); SCOPED_TRACE(hint); vector lits; lits.push_back(hwlmLiteral("aaaa", 0, 1)); lits.push_back(hwlmLiteral("aaaaaaaa", 0, 2)); lits.push_back(hwlmLiteral("baaaaaaaa", 0, 3)); lits.push_back(hwlmLiteral("aaaaaaaab", 0, 4)); auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); const u32 testSize = 1024; vector data(testSize, 'a'); vector matches; fdrExec(fdr.get(), data.data(), testSize, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(testSize - 3 + testSize - 7, matches.size()); EXPECT_EQ(match(0, 3, 1), matches[0]); EXPECT_EQ(match(1, 4, 1), matches[1]); EXPECT_EQ(match(2, 5, 1), matches[2]); EXPECT_EQ(match(3, 6, 1), matches[3]); u32 currentMatch = 4; for (u32 i = 7; i < testSize; i++, currentMatch += 2) { EXPECT_TRUE( (match(i - 3, i, 1) == matches[currentMatch] && match(i - 7, i, 2) == matches[currentMatch+1]) || (match(i - 7, i, 2) == matches[currentMatch+1] && match(i - 3, i, 1) == matches[currentMatch]) ); } } TEST_P(FDRp, NoRepeat1) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const char data[] = "mnopqrabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678901234567890m0m"; vector lits = { hwlmLiteral("m", 0, 1, 0, HWLM_ALL_GROUPS, {}, {}) }; auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); vector matches; fdrExec(fdr.get(), (const u8 *)data, sizeof(data) - 1 /* skip nul */, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(1U, matches.size()); EXPECT_EQ(match(0, 0, 0), matches[0]); } TEST_P(FDRp, NoRepeat2) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const char data[] = "mnopqrabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678901234567890m0m"; vector lits = { hwlmLiteral("m", 0, 1, 0, HWLM_ALL_GROUPS, {}, {}), hwlmLiteral("A", 0, 42) }; auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); vector matches; fdrExec(fdr.get(), (const u8 *)data, sizeof(data) - 1 /* skip nul */, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(3U, matches.size()); EXPECT_EQ(match(0, 0, 0), matches[0]); EXPECT_EQ(match(78, 78, 0), matches[2]); } TEST_P(FDRp, NoRepeat3) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const char data[] = "mnopqrabcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678901234567890m0m"; vector lits = { hwlmLiteral("90m", 0, 1, 0, HWLM_ALL_GROUPS, {}, {}), hwlmLiteral("zA", 0, 1, 0, HWLM_ALL_GROUPS, {}, {}) }; auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); vector matches; fdrExec(fdr.get(), (const u8 *)data, sizeof(data) - 1 /* skip nul */, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(1U, matches.size()); EXPECT_EQ(match(31, 32, 0), matches[0]); } /** * \brief Helper function wrapping the FDR streaming call that ensures it is * always safe to read 16 bytes before the end of the history buffer. */ static hwlm_error_t safeExecStreaming(const FDR *fdr, const u8 *hbuf, size_t hlen, const u8 *buf, size_t len, size_t start, HWLMCallback cb, void *ctxt, hwlm_group_t groups) { array wrapped_history = {{'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'}}; if (hlen < 16) { u8 *new_hbuf = wrapped_history.data() + 16 - hlen; memcpy(new_hbuf, hbuf, hlen); hbuf = new_hbuf; } return fdrExecStreaming(fdr, hbuf, hlen, buf, len, start, cb, ctxt, groups); } TEST_P(FDRp, SmallStreaming) { const u32 hint = GetParam(); SCOPED_TRACE(hint); vector lits = {hwlmLiteral("a", 1, 1), hwlmLiteral("aardvark", 0, 10)}; auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); vector expected, matches; expected.push_back(match(0, 0, 1)); expected.push_back(match(1, 1, 1)); expected.push_back(match(2, 2, 1)); safeExecStreaming(fdr.get(), (const u8 *)"", 0, (const u8 *)"aaar", 4, 0, decentCallback, &matches, HWLM_ALL_GROUPS); for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) { EXPECT_EQ(expected[i], matches[i]); } ASSERT_TRUE(expected.size() == matches.size()); expected.clear(); matches.clear(); expected.push_back(match(6, 6, 1)); expected.push_back(match(1, 8, 10)); safeExecStreaming(fdr.get(), (const u8 *)"aaar", 4, (const u8 *)"dvark", 5, 0, decentCallback, &matches, HWLM_ALL_GROUPS); for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) { EXPECT_EQ(expected[i], matches[i] + 4); } ASSERT_EQ(expected.size(), matches.size()); } TEST_P(FDRp, SmallStreaming2) { const u32 hint = GetParam(); SCOPED_TRACE(hint); vector lits = {hwlmLiteral("a", 1, 1), hwlmLiteral("kk", 1, 2), hwlmLiteral("aardvark", 0, 10)}; auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); vector expected, matches; expected.push_back(match(6,6,1)); expected.push_back(match(7,7,1)); expected.push_back(match(11,11,1)); expected.push_back(match(6,13,10)); expected.push_back(match(13,14,2)); expected.push_back(match(14,15,2)); safeExecStreaming(fdr.get(), (const u8 *)"foobar", 6, (const u8 *)"aardvarkkk", 10, 0, decentCallback, &matches, HWLM_ALL_GROUPS); for (u32 i = 0; i < MIN(expected.size(), matches.size()); i++) { EXPECT_EQ(expected[i], matches[i] + 6); } ASSERT_EQ(expected.size(), matches.size()); } TEST_P(FDRp, LongLiteral) { const u32 hint = GetParam(); SCOPED_TRACE(hint); size_t sz; const u8 *data; vector lits; string alpha = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"; string alpha4 = alpha+alpha+alpha+alpha; lits.push_back(hwlmLiteral(alpha4.c_str(), 0,10)); auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); u32 count = 0; data = (const u8 *)alpha4.c_str(); sz = alpha4.size(); fdrExec(fdr.get(), data, sz, 0, countCallback, &count, HWLM_ALL_GROUPS); EXPECT_EQ(1U, count); count = 0; fdrExec(fdr.get(), data, sz - 1, 0, countCallback, &count, HWLM_ALL_GROUPS); EXPECT_EQ(0U, count); count = 0; fdrExec(fdr.get(), data + 1, sz - 1, 0, countCallback, &count, HWLM_ALL_GROUPS); EXPECT_EQ(0U, count); } TEST_P(FDRp, moveByteStream) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const char data[] = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ12345678901234567890"; size_t data_len = strlen(data); vector lits; lits.push_back(hwlmLiteral("mnopqr", 0, 0)); auto fdrTable0 = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdrTable0, hint); size_t size = fdrSize(fdrTable0.get()); auto fdrTable = aligned_zmalloc_unique(size); EXPECT_NE(nullptr, fdrTable); memcpy(fdrTable.get(), fdrTable0.get(), size); // bugger up original for (size_t i = 0 ; i < size; i++) { ((char *)fdrTable0.get())[i] = (i % 2) ? 0xCA : 0xFE; } // check matches vector matches; hwlm_error_t fdrStatus = fdrExec(fdrTable.get(), (const u8 *)data, data_len, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); ASSERT_EQ(1U, matches.size()); EXPECT_EQ(match(12, 17, 0), matches[0]); } TEST_P(FDRp, Stream1) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const char data1[] = "fffffffffffffffff"; const char data2[] = "ffffuuuuuuuuuuuuu"; size_t data_len1 = strlen(data1); size_t data_len2 = strlen(data2); hwlm_error_t fdrStatus = 1; vector lits; lits.push_back(hwlmLiteral("f", 0, 0)); lits.push_back(hwlmLiteral("longsigislong", 0, 1)); auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); // check matches vector matches; fdrStatus = safeExecStreaming(fdr.get(), (const u8 *)data1, data_len1, (const u8 *)data2, data_len2, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); ASSERT_EQ(4U, matches.size()); for (size_t i = 0; i < matches.size(); i++) { EXPECT_EQ(match(i, i, 0), matches[i]); } } INSTANTIATE_TEST_CASE_P(FDR, FDRp, ValuesIn(getValidFdrEngines())); typedef struct { string pattern; unsigned char alien; } pattern_alien_t; // gtest helper void PrintTo(const pattern_alien_t &t, ::std::ostream *os) { *os << "(" << t.pattern << ", " << t.alien << ")"; } class FDRpp : public TestWithParam> {}; // This test will check if matcher detects properly literals at the beginning // and at the end of unaligned buffer. It will check as well that match does // not happen if literal is partially (from 1 character up to full literal // length) is out of searched buffer - "too early" and "too late" conditions TEST_P(FDRpp, AlignAndTooEarly) { const size_t buf_alignment = 32; // Buffer should be big enough to hold two instances of matching literals // (up to 64 bytes each) and room for offset (up to 32 bytes) const size_t data_len = 5 * buf_alignment; const u32 hint = get<0>(GetParam()); SCOPED_TRACE(hint); // pattern which is used to generate literals of variable size - from 1 to 64 const string &pattern = get<1>(GetParam()).pattern; const size_t patLen = pattern.size(); const unsigned char alien = get<1>(GetParam()).alien; // allocate aligned buffer auto dataBufAligned = shared_ptr( (char *)aligned_malloc_internal(data_len, buf_alignment), aligned_free_internal); vector lits; for (size_t litLen = 1; litLen <= patLen; litLen++) { // building literal from pattern substring of variable length 1-64 lits.push_back(hwlmLiteral(string(pattern, 0, litLen), 0, 0)); auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); // check with buffer offset from aligned start from 0 to 31 for (size_t i = 0; i < buf_alignment; i++) { // fill the whole buffer with 'alien' character memset(dataBufAligned.get(), alien, data_len); // put the matching substring to the beginning of unaligned buffer memcpy(dataBufAligned.get() + i, pattern.data(), litLen); // put the matching substring to the end of unaligned buffer memcpy(dataBufAligned.get() + i + 4 * buf_alignment - litLen, pattern.data(), litLen); for (size_t j = 0; j <= litLen; j++) { vector matches; hwlm_error_t fdrStatus = fdrExec(fdr.get(), (const u8 *)dataBufAligned.get() + i + j, 4 * buf_alignment - j * 2, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); // j == 0 means that start and end matches are entirely within // searched buffer. Otherwise they are out of buffer boundaries // by j number of bytes - "too early" or "too late" conditions // j == litLen means that matches are completely put of searched buffer if (j == 0) { // we should get two and only two matches - at the beginning and // at the end of unaligned buffer ASSERT_EQ(2U, matches.size()); ASSERT_EQ(match(0, litLen - 1, 0), matches[0]); ASSERT_EQ(match(4 * buf_alignment - litLen, 4 * buf_alignment - 1, 0), matches[1]); matches.clear(); } else { // "Too early" / "too late" condition - should not match anything ASSERT_EQ(0U, matches.size()); } } } lits.clear(); } } static const pattern_alien_t test_pattern[] = { {"abaabaaabaaabbaaaaabaaaaabbaaaaaaabaabbaaaabaaaaaaaabbbbaaaaaaab", 'x'}, {"zzzyyzyzyyyyzyyyyyzzzzyyyyyyyyzyyyyyyyzzzzzyzzzzzzzzzyzzyzzzzzzz", (unsigned char)'\x99'}, {"abcdef lafjk askldfjklf alfqwei9rui 'gldgkjnooiuswfs138746453583", '\0'} }; INSTANTIATE_TEST_CASE_P(FDR, FDRpp, Combine(ValuesIn(getValidFdrEngines()), ValuesIn(test_pattern))); // This test generates an exhaustive set of short input buffers of length from // 1 to 6 (1092 buffers) and 2750 buffers of length from 7 to >64 constructed // from arbitrary set of short buffers. All buffers contain 3 characters from // the alphabet given as a parameter to the test. // Then it generates an exhaustive set of literals of length from 1 to 8 // containing first two characters from the same alphabet (510 literals) // Literals are grouped by 32 to run search on each and every buffer. // All resulting matches are checked. // Fibonacci sequence is used to generate arbitrary buffers unsigned long long fib (int n) { unsigned long long fib0 = 1, fib1 = 1, fib2 = 1; for (int i = 0; i < n; i++) { fib2 = fib1 + fib0; fib0 = fib1; fib1 = fib2; } return fib2; } class FDRpa : public TestWithParam>> {}; TEST_P(FDRpa, ShortWritings) { const u32 hint = get<0>(GetParam()); SCOPED_TRACE(hint); vector bufs; // create exhaustive buffer set for up to 6 literals: const array &alphabet = get<1>(GetParam()); for (int len = 1; len <= 6; len++) { for (int j = 0; j < (int)pow((double)3, len); j++) { string s; for (int k = 0; k < len; k++) { s += alphabet[(j / (int)pow((double)3, k) % 3)]; } bufs.push_back(s); } } size_t buflen = bufs.size(); // create arbitrary buffers from exhaustive set of previously generated 'short' for (int len = 7; len < 64; len++) { for (int i = 0; i < 10; i++) { string s; for(int j = 0; (int)s.size() < len; j++) { s += bufs[fib(i * 5 + j + (len - 6) * 10) % buflen]; } bufs.push_back(s); } } // generate exhaustive set of literals of length from 1 to 8 vector pats; for (int len = 1; len <= 8; len++) { for (int j = 0; j < (int)pow((double)2, len); j++) { string s; for (int k = 0; k < len; k++) { s += alphabet[(j >> k) & 1]; } pats.push_back(s); } } // run the literal matching through all generated literals for (size_t patIdx = 0; patIdx < pats.size();) { // group them in the sets of 32 vector testSigs; for(int i = 0; i < 32 && patIdx < pats.size(); i++, patIdx++) { testSigs.push_back(hwlmLiteral(pats[patIdx], false, patIdx)); } auto fdr = fdrBuildTableHinted(testSigs, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); // run the literal matching for the prepared set of 32 literals // on each generated buffer for (size_t bufIdx = 0; bufIdx < bufs.size(); bufIdx++) { const string &buf = bufs[bufIdx]; size_t bufLen = buf.size(); vector matches; hwlm_error_t fdrStatus = fdrExec(fdr.get(), (const u8 *)buf.data(), bufLen, 0, decentCallback, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); // build the set of expected matches using standard // stl::string::compare() function vector expMatches; for (size_t pIdx = 0; pIdx < testSigs.size(); pIdx++) { const string &pat = testSigs[pIdx].s; size_t patLen = pat.size(); for (int j = 0; j <= (int)bufLen - (int)patLen; j++) { if (!buf.compare(j, patLen, pat)) { expMatches.push_back(match(j, j + patLen - 1, testSigs[pIdx].id)); } } } // compare the set obtained matches against expected ones sort(expMatches.begin(), expMatches.end()); sort(matches.begin(), matches.end()); ASSERT_EQ(expMatches, matches); } } } static const array test_alphabet[] = { { { 'a', 'b', 'x' } }, { { 'x', 'y', 'z' } }, { { '\0', 'A', '\x20' } }, { { 'a', '\x20', (unsigned char)'\x99' } } }; INSTANTIATE_TEST_CASE_P(FDR, FDRpa, Combine(ValuesIn(getValidFdrEngines()), ValuesIn(test_alphabet))); TEST(FDR, FDRTermS) { const char data1[] = "fffffffffffffffff"; const char data2[] = "ffffuuuuuuuuuuuuu"; size_t data_len1 = strlen(data1); size_t data_len2 = strlen(data2); hwlm_error_t fdrStatus = 0; vector lits; lits.push_back(hwlmLiteral("f", 0, 0)); lits.push_back(hwlmLiteral("ff", 0, 1)); auto fdr = fdrBuildTable(lits, false, get_current_target(), Grey()); ASSERT_TRUE(fdr != nullptr); // check matches vector matches; fdrStatus = safeExecStreaming(fdr.get(), (const u8 *)data1, data_len1, (const u8 *)data2, data_len2, 0, decentCallbackT, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(HWLM_TERMINATED, fdrStatus); ASSERT_EQ(1U, matches.size()); } TEST(FDR, FDRTermB) { const char data1[] = "fffffffffffffffff"; size_t data_len1 = strlen(data1); hwlm_error_t fdrStatus = 0; vector lits; lits.push_back(hwlmLiteral("f", 0, 0)); lits.push_back(hwlmLiteral("ff", 0, 1)); auto fdr = fdrBuildTable(lits, false, get_current_target(), Grey()); ASSERT_TRUE(fdr != nullptr); // check matches vector matches; fdrStatus = fdrExec(fdr.get(), (const u8 *)data1, data_len1, 0, decentCallbackT, &matches, HWLM_ALL_GROUPS); ASSERT_EQ(HWLM_TERMINATED, fdrStatus); ASSERT_EQ(1U, matches.size()); } hyperscan-4.4.1/unit/internal/nfagraph_literal_analysis.cpp0000644000175000017500000000642213055426554025007 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include #include #include "gtest/gtest.h" #include "nfagraph/ng_literal_analysis.h" using namespace std; using namespace boost; using namespace ue2; struct LiteralSetCompressParams { set input; set output; }; void PrintTo(const LiteralSetCompressParams &p, ::std::ostream *os) { *os << "input: "; set::const_iterator it, ite; for (it = p.input.begin(), ite = p.input.end(); it != ite; ++it) { *os << it->get_string() << " "; } *os << "output: "; for (it = p.output.begin(), ite = p.output.end(); it != ite; ++it) { *os << it->get_string() << " "; } } static vector paramFactory() { vector p; p.push_back(LiteralSetCompressParams()); p.back().input.insert(ue2_literal("foobar", false)); p.back().input.insert(ue2_literal("bar", false)); p.back().output.insert(ue2_literal("bar", false)); p.push_back(LiteralSetCompressParams()); p.back().input.insert(ue2_literal("foobar", false)); p.back().input.insert(ue2_literal("fooobar", false)); p.back().input.insert(ue2_literal("foooobar", false)); p.back().input.insert(ue2_literal("fooooobar", false)); p.back().output.insert(ue2_literal("oobar", false)); return p; } class LiteralSetCompressTest : public testing::TestWithParam { protected: LiteralSetCompressTest() {} }; TEST_P(LiteralSetCompressTest, Run) { const LiteralSetCompressParams &p = GetParam(); set lits(p.input.begin(), p.input.end()); compressAndScore(lits); ASSERT_EQ(p.output, lits); } INSTANTIATE_TEST_CASE_P(NFAGraph, LiteralSetCompressTest, testing::ValuesIn(paramFactory())); hyperscan-4.4.1/unit/internal/fdr_loadval.cpp0000644000175000017500000001040113055426554022047 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "fdr/fdr_loadval.h" #include "util/alloc.h" using namespace std; using namespace testing; using namespace ue2; // Normal (unaligned) load. template T lv(const u8 *ptr, const u8 *lo, const u8 *hi); // Cautious everywhere load. template T lv_ce(const u8 *ptr, const u8 *lo, const u8 *hi); #define BUILD_LOADVALS(vtype) \ template <> vtype lv(const u8 *ptr, const u8 *lo, const u8 *hi) { \ return lv_##vtype(ptr, lo, hi); \ } \ template <> \ vtype lv_ce(const u8 *ptr, const u8 *lo, const u8 *hi) { \ return lv_##vtype##_ce(ptr, lo, hi); \ } BUILD_LOADVALS(u16) BUILD_LOADVALS(u64a) template class FDR_Loadval : public testing::Test { // empty }; typedef ::testing::Types LoadvalTypes; TYPED_TEST_CASE(FDR_Loadval, LoadvalTypes); static void fillWithBytes(u8 *ptr, size_t len) { for (size_t i = 0; i < len; i++) { ptr[i] = (u8)(i % 254 + 1); } } TYPED_TEST(FDR_Loadval, Normal) { // We should be able to do a normal load at any alignment. const size_t len = sizeof(TypeParam); aligned_unique_ptr mem_p = aligned_zmalloc_unique(len + 15); u8 * mem = mem_p.get(); ASSERT_TRUE(ISALIGNED_16(mem)); fillWithBytes(mem, len + 15); // Test all alignments. for (size_t i = 0; i < 16; i++) { const u8 *src = mem + i; TypeParam val = lv(src, src, src + len); // Should be identical to 'src' in byte order. ASSERT_EQ(0, memcmp(&val, src, len)); } } TYPED_TEST(FDR_Loadval, CautiousEverywhere) { // For a cautious backwards load, we will get zeroes for all bytes before // the 'lo' ptr or after the 'hi' ptr. const size_t len = sizeof(TypeParam); aligned_unique_ptr mem_p = aligned_zmalloc_unique(len + 1); u8 *mem = mem_p.get() + 1; // force unaligned fillWithBytes(mem, len); for (size_t i = 0; i <= len; i++) { for (size_t j = 0; j <= len; j++) { const u8 *ptr = mem; const u8 *lo = ptr + i; const u8 *hi = ptr + j; union { TypeParam val; u8 bytes[sizeof(TypeParam)]; } x; x.val = lv_ce(ptr, lo, hi); // Bytes outside [lo,hi) will be zero. for (size_t k = 0; k < len; k++) { ASSERT_EQ((k >= i && k < j) ? mem[k] : 0, x.bytes[k]); } } } } hyperscan-4.4.1/unit/internal/nfagraph_find_matches.cpp0000644000175000017500000002554513055426554024103 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "nfagraph_common.h" #include "compiler/compiler.h" #include "grey.h" #include "nfagraph/ng_builder.h" #include "nfagraph/ng.h" #include "nfagraph/ng_asserts.h" #include "hs_compile.h" #include "util/ng_find_matches.h" #include "util/target_info.h" using namespace std; using namespace testing; using namespace ue2; struct MatchesTestParams { string pattern; string input; vector> matches; unsigned flags; bool notEod; bool som; }; // teach google-test how to print a param void PrintTo(const MatchesTestParams &p, ::std::ostream *os) { *os << "( \"" << p.pattern << "\", " << "\"" << p.input << "\", " << "{"; for (const auto &match : p.matches) { *os << "P(" << match.first << ',' << match.second << "),"; } *os << "}, "; *os << "flags(" << p.flags << "), " << p.notEod << ", " << p.som << ")\n"; } class MatchesTest: public TestWithParam { }; #define P(x, y) pair((x), (y)) static const MatchesTestParams matchesTests[] = { // EOD and anchored patterns // these should produce no matches { "^foobar", "foolish", {}, 0, false, true}, { "^foobar$", "ze foobar", {}, 0, false, true}, { "^foobar$", "foobar ", {}, 0, false, true}, { "^abc\\b", "abcde", {}, 0, false, true}, { "^a\\b", "aa", {}, 0, false, true}, { "^foobar\\b", "foobarz", {}, 0, false, true}, { "^foobar", "fooq", {}, 0, false, true}, { "^foobar", "foo", {}, 0, false, true}, { "^foobar", "fooba", {}, 0, false, true}, { "^foo *bar", "foolishness bar none ", {}, 0, false, true}, { "^(abc\\s+dex?y)?(ghij|klmn).*?x?y", "abc p", {}, 0, false, true}, { "^(abc\\s+dex?y)?(ghij|klmn).*?x?y", "abc dez", {}, 0, false, true}, { "^(abc\\s+dex?y)?(ghij|klmn).*?x?y", "abc ghi", {}, 0, false, true}, { "^(abc\\s+dex?y)?(ghij|klmn).*?x?y", "abc hij", {}, 0, false, true}, { "^(abc\\s+dex?y)?(ghij|klmn).*?x?y", "abc klm", {}, 0, false, true}, { "^(abc\\s+dex?y)?(ghij|klmn).*?x?y", "abcklmn", {}, 0, false, true}, { "^.*foobar", "foobaz", {}, 0, false, true}, { "^.*foobar", "foobaz\n", {}, 0, false, true}, { "^(foo)|(bar)", "fo baz", {}, 0, false, true}, { "^((foo)|(bar))", "fo baz", {}, 0, false, true}, { "aaaaaaaa$", "AAaaAAaa", {}, 0, false, true}, { "^foo\\z", "foo\n", {}, 0, false, true}, { "^(foo){2,}", "foo", {}, 0, false, true}, // these should match { "^abc\\B", "abcde", { P(0,3) }, 0, false, true}, { "^abc\\b", "abc de", { P(0, 3) }, 0, false, true}, { "^foobar", "foobar", { P(0, 6) }, 0, false, true}, { "^foobar$", "foobar", { P(0, 6) }, 0, false, true}, { "^foobar", "foobarq", { P(0, 6) }, 0, false, true}, { "^foobar\\B", "foobarz", { P(0, 6) }, 0, false, true}, { "^foo.*bar", "foobar none ", { P(0, 6) }, 0, false, true}, { "^foo.*bar", "foo bar none ", { P(0, 7) }, 0, false, true}, { "^foo.*bar", "foo bar none ", { P(0, 10) }, 0, false, true}, { "^foo.*bar", "foolishness bar none ", { P(0, 15) }, 0, false, true}, { "^(abc\\s+dex?y)?(ghij|klmn).*?x?y", "klmny", { P(0, 5) }, 0, false, true}, { "^(abc\\s+dex?y)?(ghij|klmn).*?x?y", "abc dexyklmnxy", { P(0, 17) }, 0, false, true}, { "^.*foobar", "abcfoobar", { P(0, 9) }, 0, false, true}, { "^((foo)|(bar))", "foobar", { P(0, 3) }, 0, false, true}, { "^((foo)|(bar))", "foo bar", { P(0, 3) }, 0, false, true}, { "^(foo)|(bar)", "foobaz", { P(0, 3) }, 0, false, true}, { "^(foo)|(bar)", "foo baz", { P(0, 3) }, 0, false, true}, { "^(f[o0]+o)|(bar)", "fo0o baz", { P(0, 4) }, 0, false, true}, { "aaaaaaaa$", "AAaaAAaa", { P(0, 8) }, HS_FLAG_CASELESS, false, true}, { "^foo\\z", "foo", { P(0, 3) }, 0, false, true}, { "^foo\\Z", "foo", { P(0, 3) }, 0, false, true}, { "^foo\\Z", "foo\n", { P(0, 3) }, 0, false, true}, { "^(foo){2,}", "foofoofoo", { P(0, 6), P(0, 9)}, 0, false, true}, // try multiple matches per pattern { "^(foo)|(bar)", "foo bar", { P(0, 3), P(4, 7) }, 0, false, true}, { "^(foo)|(bar)", "foobar", { P(0, 3), P(3, 6) }, 0, false, true}, { "^(foo)+|(bar)", "foo foobar", { P(0, 3), P(7, 10) }, 0, false, true}, { "^(foo)+|(bar)", "foofoo bar", { P(0, 3), P(0, 6), P(7, 10) }, 0, false, true}, { "^(foo)|(bar)", "foobarbaz", { P(0, 3), P(3, 6) }, 0, false, true}, { "^(f[o0]+o)", "foo0obar", { P(0, 3), P(0, 5) }, 0, false, true}, { "^(f[o0]+)", "foo0obar", { P(0, 2), P(0, 3), P(0, 4), P(0, 5) }, 0, false, true}, // unanchored patterns { "\\b4\\B", "444", { P(0, 1) }, 0, false, true}, { "\\b\\w+\\b", "444 555", { P(0, 3), P(4, 7) }, 0, false, true}, { "foobar", "veryfoolish", {}, 0, false, true}, { "foo.*bar", "extreme foolishness bar none ", { P(8, 23) }, 0, false, true}, { "(abc\\s+dex?y)?(ghij|klmn).*?x?y", "abc deyghijfy", { P(0, 13) }, 0, false, true}, { "(abc\\s+dex?y)?(ghij|klmn).*?x?y", "wegf5tgghij34xy", { P(7, 15) }, 0, false, true}, { ".*foobar", "verylongfoobaz", {}, 0, false, true}, { ".*foobar", "foobaz\n", {}, 0, false, true}, { "(foo)|(bar)", "verylongfo baz", {}, 0, false, true}, { "(foo)?bar", "foobar", { P(0, 6) }, 0, false, true}, { "foo?bar", "foobar", { P(0, 6) }, 0, false, true}, { "(abc)|(bcd)", "abcd", { P(0, 3), P(1, 4) }, 0, false, true}, { "(abcd)|(bc)", "abcd", { P(0, 4), P(1, 3) }, 0, false, true}, { "(ab|cd)ef", "abcdef cdabef", { P(2, 6), P(9, 13) }, 0, false, true}, { "(foo)|(bar)", "verylongfoobbarbaz", { P(8, 11), P(12, 15) }, 0, false, true}, { "(a[aaaa]aa?((\\B)|[aa])){1,9}", "aaaaa", { P(0, 3), P(0, 4), P(0, 5) }, 0, false, true}, { "bar\\Z", "foobar\n", { P(3, 6) }, 0, false, true}, // multi-line patterns { "^foo$", "foo\nbar", { P(0, 3) }, HS_FLAG_MULTILINE, false, true}, { "^bar$", "foo\nbar", { P(4, 7) }, HS_FLAG_MULTILINE, false, true}, { "^foo$", "big foo\nbar", {}, HS_FLAG_MULTILINE, false, true}, { "^foo$", "foo\nfoo", { P(0, 3), P(4, 7) }, HS_FLAG_MULTILINE, false, true}, { "\\bfoo$", "big foo\nbar", { P(4, 7) }, HS_FLAG_MULTILINE, false, true}, { "\\Bfoo$", "bigfoo\nbar", { P(3, 6) }, HS_FLAG_MULTILINE, false, true}, { "^foo\\z", "big\nfoo", { P(4, 7) }, HS_FLAG_MULTILINE, false, true}, { "^foo\\Z", "big\nfoo\n", { P(4, 7) }, HS_FLAG_MULTILINE, false, true}, // utf8 patterns { "ab+", "\x61\x62", { P(0, 2) }, HS_FLAG_UTF8, false, true}, { "ab.+d", "\x61\x62\xf0\xa4\xad\xa2\x64", { P(0, 7) }, HS_FLAG_UTF8, false, true}, // noteod patterns { "^foobar$", "foobar", {}, 0, true, true}, { "aaaaaaaa$", "AAaaAAaa", {}, HS_FLAG_CASELESS, true, true}, { "^foo\\z", "foo", {}, 0, true, true}, { "^foo\\Z", "foo", {}, 0, true, true}, { "^foo\\Z", "foo\n", {}, 0, true, true}, // vacuous patterns (with multiline, utf8 and caseless flags) // vacuous patterns have SOM turned off, so all SOM are zero { "b*", "abc", { P(0, 0), P(0, 1), P(0, 2), P(0, 3) }, 0, false, false}, { "b*", "", { P(0, 0) }, 0, false, false}, { "(aa|b*)", "a", { P(0, 0), P(0, 1) }, 0, false, false}, { "b*", "bBb", { P(0, 0), P(0, 1), P(0, 2), P(0, 3) }, HS_FLAG_CASELESS, false, false}, { "b*", "abc", { P(0, 0), P(0, 1), P(0, 2), P(0, 3) }, HS_FLAG_MULTILINE, false, false}, { "b*", "", { P(0, 0) }, HS_FLAG_MULTILINE, false, false}, { "(aa|b*)", "a", { P(0, 0), P(0, 1) }, HS_FLAG_MULTILINE, false, false}, { "b*", "bBb", { P(0, 0), P(0, 1), P(0, 2), P(0, 3) }, HS_FLAG_MULTILINE | HS_FLAG_CASELESS, false, false}, { "b*", "abc", { P(0, 0), P(0, 1), P(0, 2), P(0, 3) }, HS_FLAG_UTF8, false, false}, { "b*", "", { P(0, 0) }, HS_FLAG_UTF8, false, false}, { "(aa|b*)", "a", { P(0, 0), P(0, 1) }, HS_FLAG_UTF8, false, false}, { "b*", "bBb", { P(0, 0), P(0, 1), P(0, 2), P(0, 3) }, HS_FLAG_UTF8 | HS_FLAG_CASELESS, false, false}, { "b*", "bBb", { P(0, 0), P(0, 1), P(0, 2), P(0, 3) }, HS_FLAG_UTF8 | HS_FLAG_CASELESS, false, false}, { ".*", "\x61\xf0\xa4\xad\xa2\x64", { P(0, 0), P(0, 1), P(0, 5), P(0, 6) }, HS_FLAG_UTF8, false, false}, { ".*", "\xf0\xa4\xad\xa2\xf0\xa4\xad\xa3\x64", { P(0, 0), P(0, 4), P(0, 8), P(0, 9) }, HS_FLAG_UTF8, false, false}, // special patterns for detecting various bugs { "(\\B.|a)*a", "\xf0\xa4\xad\xa2\x61", { P(0, 5) }, HS_FLAG_UTF8, false, true}, { ".*", "\xf0\xa4\xad", { P(0, 0), P(0, 1), P(0, 2), P(0, 3) }, 0, false, true}, { "\\Bfoo", "foo", {}, 0, false, true}, { "fo\\B", "fo_", { P(0, 2)}, 0, false, true}, { "^.*", "\xee\x80\x80\n\xee\x80\x80", { P(0, 0), P(0, 3), P(0, 4), P(0, 7)}, HS_FLAG_UTF8 | HS_FLAG_MULTILINE, false, false}, // ignore highlander patterns as they can't be easily checked }; TEST_P(MatchesTest, Check) { const MatchesTestParams &t = GetParam(); CompileContext cc(false, false, get_current_target(), Grey()); ReportManager rm(cc.grey); ParsedExpression parsed(0, t.pattern.c_str(), t.flags, 0); auto g = buildWrapper(rm, cc, parsed); bool utf8 = (t.flags & HS_FLAG_UTF8) > 0; set> matches; findMatches(*g, rm, t.input, matches, t.notEod, t.som, utf8); set> expected(begin(t.matches), end(t.matches)); ASSERT_EQ(expected, matches) << "Pattern '" << t.pattern << "' against input '" << t.input << "'"; } INSTANTIATE_TEST_CASE_P(ng_find_matches, MatchesTest, ValuesIn(matchesTests)); hyperscan-4.4.1/unit/internal/compare.cpp0000644000175000017500000001067413055426554021234 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/compare.h" #include using namespace std; using namespace testing; class compare : public TestWithParam { }; TEST_P(compare, my_our_is) { int c = GetParam(); EXPECT_EQ(!!islower(c), !!myislower(c)); EXPECT_EQ(!!isupper(c), !!myisupper(c)); EXPECT_EQ(!!isalpha(c), !!ourisalpha(c)); EXPECT_EQ(!!isprint(c), !!ourisprint(c)); } TEST_P(compare, my_to) { int c = GetParam(); EXPECT_EQ((char)tolower(c), mytolower(c)); EXPECT_EQ((char)toupper(c), mytoupper(c)); } TEST_P(compare, their32) { u32 c = (u32)GetParam(); u32 cu = (u8)toupper(c); u32 cccc = c | (c << 8) | (c << 16) | (c << 24); u32 uuuu = cu | (cu << 8) | (cu << 16) | (cu << 24); EXPECT_EQ(uuuu, theirtoupper32(cccc)); EXPECT_EQ(uuuu & 0xffU, theirtoupper32(cccc & 0xffU)); EXPECT_EQ(uuuu & 0xff00U, theirtoupper32(cccc & 0xff00U)); EXPECT_EQ(uuuu & 0xff0000U, theirtoupper32(cccc & 0xff0000U)); EXPECT_EQ(uuuu & 0xff000000U, theirtoupper32(cccc & 0xff000000U)); EXPECT_EQ(uuuu | 0xffffff00U, theirtoupper32(cccc | 0xffffff00U)); EXPECT_EQ(uuuu | 0xffff00ffU, theirtoupper32(cccc | 0xffff00ffU)); EXPECT_EQ(uuuu | 0xff00ffffU, theirtoupper32(cccc | 0xff00ffffU)); EXPECT_EQ(uuuu | 0x00ffffffU, theirtoupper32(cccc | 0x00ffffffU)); } TEST_P(compare, their64) { u64a c = (u64a)GetParam(); u64a cu = (u8)toupper(c); u64a cccc = c | (c << 8) | (c << 16) | (c << 24); cccc |= cccc << 32; u64a uuuu = cu | (cu << 8) | (cu << 16) | (cu << 24); uuuu |= uuuu << 32; EXPECT_EQ(uuuu, theirtoupper64(cccc)); EXPECT_EQ(uuuu & 0xffULL, theirtoupper64(cccc & 0xffULL)); EXPECT_EQ(uuuu & (0xffULL << 8), theirtoupper64(cccc & (0xffULL << 8))); EXPECT_EQ(uuuu & (0xffULL << 16), theirtoupper64(cccc & (0xffULL << 16))); EXPECT_EQ(uuuu & (0xffULL << 24), theirtoupper64(cccc & (0xffULL << 24))); EXPECT_EQ(uuuu & (0xffULL << 32), theirtoupper64(cccc & (0xffULL << 32))); EXPECT_EQ(uuuu & (0xffULL << 40), theirtoupper64(cccc & (0xffULL << 40))); EXPECT_EQ(uuuu & (0xffULL << 48), theirtoupper64(cccc & (0xffULL << 48))); EXPECT_EQ(uuuu & (0xffULL << 56), theirtoupper64(cccc & (0xffULL << 56))); EXPECT_EQ(uuuu & ~0xffULL, theirtoupper64(cccc & ~0xffULL)); EXPECT_EQ(uuuu & ~(0xffULL << 8), theirtoupper64(cccc & ~(0xffULL << 8))); EXPECT_EQ(uuuu & ~(0xffULL << 16), theirtoupper64(cccc & ~(0xffULL << 16))); EXPECT_EQ(uuuu & ~(0xffULL << 24), theirtoupper64(cccc & ~(0xffULL << 24))); EXPECT_EQ(uuuu & ~(0xffULL << 32), theirtoupper64(cccc & ~(0xffULL << 32))); EXPECT_EQ(uuuu & ~(0xffULL << 40), theirtoupper64(cccc & ~(0xffULL << 40))); EXPECT_EQ(uuuu & ~(0xffULL << 48), theirtoupper64(cccc & ~(0xffULL << 48))); EXPECT_EQ(uuuu & ~(0xffULL << 56), theirtoupper64(cccc & ~(0xffULL << 56))); } INSTANTIATE_TEST_CASE_P(compare, compare, Range((int)0, (int)256)); hyperscan-4.4.1/unit/internal/lbr.cpp0000644000175000017500000001752413055426554020366 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/target_info.h" #include "util/charreach.h" #include "nfa/lbr.h" #include "nfa/nfa_api.h" #include "nfa/nfa_internal.h" #include "nfa/nfa_api_util.h" #include "nfagraph/ng_lbr.h" #include "nfagraph/ng_util.h" #include "util/alloc.h" #include "util/compile_context.h" #include "grey.h" #include "nfagraph/ng.h" #include "compiler/compiler.h" #include "hs_compile.h" /* for controlling ssse3 usage */ #include using namespace std; using namespace testing; using namespace ue2; static constexpr u32 MATCH_REPORT = 1024; struct LbrTestParams { CharReach reach; u32 min; u32 max; // Ugly but simple. string make_pattern() { std::ostringstream oss; oss << "^["; for (size_t i = reach.find_first(); i != CharReach::npos; i = reach.find_next(i)) { oss << "\\x" << std::hex << std::setw(2) << std::setfill('0') << (unsigned)(i & 0xff) << std::dec; } oss << "]{" << min << "," << max << "}"; return oss.str(); } }; static int onMatch(u64a, u64a, ReportID, void *ctx) { unsigned *matches = (unsigned *)ctx; (*matches)++; return MO_CONTINUE_MATCHING; } class LbrTest : public TestWithParam { protected: virtual void SetUp() { params = GetParam(); hs_platform_info plat; hs_error_t err = hs_populate_platform(&plat); ASSERT_EQ(HS_SUCCESS, err); target_t target(plat); string pattern = params.make_pattern(); const unsigned flags = 0; const Grey grey; const CompileContext cc(true, false, target, grey); ReportManager rm(cc.grey); ParsedExpression parsed(0, pattern.c_str(), flags, 0); unique_ptr g = buildWrapper(rm, cc, parsed); ASSERT_TRUE(g != nullptr); clearReports(*g); ASSERT_TRUE(isLBR(*g, grey)); rm.setProgramOffset(0, MATCH_REPORT); /* LBR triggered by dot */ vector> triggers = {{CharReach::dot()}}; nfa = constructLBR(*g, triggers, cc, rm); ASSERT_TRUE(nfa != nullptr); full_state = aligned_zmalloc_unique(nfa->scratchStateSize); stream_state = aligned_zmalloc_unique(nfa->streamStateSize); } virtual void initQueue() { q.nfa = nfa.get(); q.cur = 0; q.end = 0; q.state = full_state.get(); q.streamState = stream_state.get(); q.offset = 0; q.buffer = nullptr; // filled in by test q.length = 0; // filled in by test q.history = nullptr; q.hlength = 0; q.scratch = nullptr; // not needed by LBR q.report_current = 0; q.cb = onMatch; q.context = &matches; } virtual string matchingCorpus(size_t len) const { string s; s.reserve(len); size_t c = params.reach.find_first(); for (size_t i = 0; i < len; i++) { s.push_back(c); c = params.reach.find_next(c); if (c == CharReach::npos) { c = params.reach.find_first(); } } return s; } // Params. LbrTestParams params; // Match count unsigned matches; // Compiled NFA structure. aligned_unique_ptr nfa; // Space for full state. aligned_unique_ptr full_state; // Space for stream state. aligned_unique_ptr stream_state; // Queue structure. struct mq q; }; static const LbrTestParams params[] = { { CharReach::dot(), 100, 100 }, { CharReach::dot(), 10, 100 }, { CharReach::dot(), 99, 100 }, { CharReach::dot(), 20, 40 }, { CharReach("A"), 32, 64 }, { CharReach("Aa"), 32, 64 }, { CharReach("0123456789ABCDEFabcdef"), 1000, 1000 }, { CharReach("0123456789ABCDEFabcdef"), 100, 1000 }, { CharReach("0123456789ABCDEFabcdef"), 950, 1000 }, { ~CharReach("a"), 128, 128 }, { ~CharReach('\x00'), 128, 256 }, { ~CharReach('\xff'), 128, 256 }, // set enough bits to create a truffle { CharReach("abcXYZ012") | CharReach('\x80') | CharReach('\x91') | CharReach('\xAA') | CharReach('\xDE') | CharReach('\xFF'), 32, 64 }, { CharReach("abcXYZ012") | CharReach('\x80') | CharReach('\x91') | CharReach('\xAA') | CharReach('\xDE') | CharReach('\xFF'), 100, 1000 }, }; INSTANTIATE_TEST_CASE_P(Lbr, LbrTest, ValuesIn(params)); TEST_P(LbrTest, MatchMin) { ASSERT_FALSE(params.reach.none()); // string of min length consisting entirely of matching chars. const string corpus = matchingCorpus(params.min); initQueue(); q.buffer = (const u8 *)corpus.c_str(); q.length = corpus.length(); u64a end = corpus.length(); nfaQueueInitState(nfa.get(), &q); pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); matches = 0; nfaQueueExec(nfa.get(), &q, end); ASSERT_EQ(1, matches); } TEST_P(LbrTest, MatchMax) { ASSERT_FALSE(params.reach.none()); // string of min length consisting entirely of matching chars. const string corpus = matchingCorpus(params.max); initQueue(); q.buffer = (const u8 *)corpus.c_str(); q.length = corpus.length(); u64a end = corpus.length(); nfaQueueInitState(nfa.get(), &q); pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); matches = 0; nfaQueueExec(nfa.get(), &q, end); ASSERT_EQ(params.max - params.min + 1, matches); } TEST_P(LbrTest, InitCompressedState0) { char rv = nfaInitCompressedState(nfa.get(), 0, stream_state.get(), '\0'); ASSERT_NE(0, rv); } TEST_P(LbrTest, QueueExecToMatch) { ASSERT_FALSE(params.reach.none()); // string of min length consisting entirely of matching chars. const string corpus = matchingCorpus(params.min); initQueue(); q.buffer = (const u8 *)corpus.c_str(); q.length = corpus.length(); u64a end = corpus.length(); nfaQueueInitState(nfa.get(), &q); pushQueue(&q, MQE_START, 0); pushQueue(&q, MQE_TOP, 0); pushQueue(&q, MQE_END, end); matches = 0; char rv = nfaQueueExecToMatch(nfa.get(), &q, end); ASSERT_EQ(MO_MATCHES_PENDING, rv); ASSERT_EQ(0, matches); ASSERT_NE(0, nfaInAcceptState(nfa.get(), MATCH_REPORT, &q)); nfaReportCurrentMatches(nfa.get(), &q); ASSERT_EQ(1, matches); } hyperscan-4.4.1/unit/internal/fdr_flood.cpp0000644000175000017500000005432513055426554021545 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "ue2common.h" #include "grey.h" #include "fdr/fdr.h" #include "fdr/fdr_compile.h" #include "fdr/fdr_compile_internal.h" #include "fdr/fdr_engine_description.h" #include "fdr/teddy_compile.h" #include "fdr/teddy_engine_description.h" #include "util/alloc.h" #include "util/bitutils.h" #include "gtest/gtest.h" using namespace std; using namespace testing; using namespace ue2; #define NO_TEDDY_FAIL_ALLOWED 0 #if(NO_TEDDY_FAIL_ALLOWED) #define CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint) ASSERT_TRUE(fdr) #else #define CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint) \ { \ auto descr = getTeddyDescription(hint); \ if (descr && fdr != nullptr) { \ return; \ } else { \ ASSERT_TRUE(fdr != nullptr); \ } \ } #endif namespace { struct match { size_t start; size_t end; u32 id; match(size_t start_in, size_t end_in, u32 id_in) : start(start_in), end(end_in), id(id_in) {} bool operator==(const match &b) const { return start == b.start && end == b.end && id == b.id; } bool operator<(const match &b) const { if (id < b.id) { return true; } else if (id == b.id) { if (start < b.start) { return true; } else if (start == b.start) { return end < b.end; } } return false; } match operator+(size_t adj) { return match(start + adj, end + adj, id); } }; template T &operator<<(T &a, const match &b) { a << "(" << b.start << ", " << b.end << ", " << b.id << ")"; return a; } template T &operator<<(T &a, const vector &b) { a << "("; for (size_t i = 0; i < b.size(); i++) { a << b[i]; } a << ")"; return a; } extern "C" { static hwlmcb_rv_t countCallback(UNUSED size_t start, UNUSED size_t end, u32 id, void *cntxt) { if (cntxt) { map *matchesCounts = (map *)cntxt; (*matchesCounts)[id]++; } return HWLM_CONTINUE_MATCHING; } } // extern "C" } // namespace static vector getValidFdrEngines() { vector ret; vector des; getFdrDescriptions(&des); for (vector::const_iterator it = des.begin(); it != des.end(); ++it) { if (it->isValidOnTarget(get_current_target())) { ret.push_back(it->getID()); } } vector tDes; getTeddyDescriptions(&tDes); for (vector::const_iterator it = tDes.begin(); it != tDes.end(); ++it) { if (it->isValidOnTarget(get_current_target())) { ret.push_back(it->getID()); } } return ret; } class FDRFloodp : public TestWithParam { }; TEST_P(FDRFloodp, NoMask) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const size_t dataSize = 1024; vector data(dataSize); u8 c = 0; while (1) { SCOPED_TRACE((unsigned int)c); u8 bit = 1 << (c & 0x7); u8 cAlt = c ^ bit; memset(&data[0], c, dataSize); vector lits; // build literals of type "aaaa", "aaab", "baaa" // of lengths 1, 2, 4, 8, 16, 32, both case-less and case-sensitive for (int i = 0; i < 6 ; i++) { string s(1 << i, c); lits.push_back(hwlmLiteral(s, false, i * 8 + 0)); s[0] = cAlt; lits.push_back(hwlmLiteral(s, false, i * 8 + 1)); lits.push_back(hwlmLiteral(s, true, i * 8 + 2)); s[0] = c; s[s.size() - 1] = cAlt; lits.push_back(hwlmLiteral(s, false, i * 8 + 3)); lits.push_back(hwlmLiteral(s, true, i * 8 + 4)); string sAlt(1 << i, cAlt); lits.push_back(hwlmLiteral(sAlt, true, i * 8 + 5)); sAlt[0] = c; lits.push_back(hwlmLiteral(sAlt, true, i * 8 + 6)); lits.push_back(hwlmLiteral(sAlt, false, i * 8 + 7)); } auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); map matchesCounts; hwlm_error_t fdrStatus = fdrExec(fdr.get(), &data[0], dataSize, 0, countCallback, (void *)&matchesCounts, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); for (u8 i = 0; i < 6 ; i++) { u32 cnt = dataSize - (1 << i) + 1; ASSERT_EQ(cnt, matchesCounts[i * 8 + 0]); ASSERT_EQ(0, matchesCounts[i * 8 + 1]); ASSERT_EQ(0, matchesCounts[i * 8 + 3]); ASSERT_EQ(i == 0 ? cnt : 0, matchesCounts[i * 8 + 7]); if (isalpha(c) && (bit == CASE_BIT)) { ASSERT_EQ(cnt, matchesCounts[i * 8 + 2]); ASSERT_EQ(cnt, matchesCounts[i * 8 + 4]); ASSERT_EQ(cnt, matchesCounts[i * 8 + 5]); ASSERT_EQ(cnt, matchesCounts[i * 8 + 6]); } else { ASSERT_EQ(0, matchesCounts[i * 8 + 2]); ASSERT_EQ(0, matchesCounts[i * 8 + 4]); ASSERT_EQ(0, matchesCounts[i * 8 + 5]); ASSERT_EQ(i == 0 ? cnt : 0, matchesCounts[i * 8 + 6]); } } matchesCounts.clear(); memset(&data[0], cAlt, dataSize); fdrStatus = fdrExec(fdr.get(), &data[0], dataSize, 0, countCallback, (void *)&matchesCounts, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); for (u8 i = 0; i < 6 ; i++) { u32 cnt = dataSize - (1 << i) + 1; ASSERT_EQ(0, matchesCounts[i * 8 + 0]); ASSERT_EQ(i == 0 ? cnt : 0, matchesCounts[i * 8 + 1]); ASSERT_EQ(i == 0 ? cnt : 0, matchesCounts[i * 8 + 3]); ASSERT_EQ(cnt, matchesCounts[i * 8 + 5]); ASSERT_EQ(0, matchesCounts[i * 8 + 7]); if (isalpha(c) && (bit == CASE_BIT)) { ASSERT_EQ(cnt, matchesCounts[i * 8 + 2]); ASSERT_EQ(cnt, matchesCounts[i * 8 + 4]); ASSERT_EQ(cnt, matchesCounts[i * 8 + 6]); } else { ASSERT_EQ(i == 0 ? cnt : 0, matchesCounts[i * 8 + 2]); ASSERT_EQ(i == 0 ? cnt : 0, matchesCounts[i * 8 + 4]); ASSERT_EQ(0, matchesCounts[i * 8 + 6]); } } if (++c == 0) { break; } } } TEST_P(FDRFloodp, WithMask) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const size_t dataSize = 1024; vector data(dataSize); u8 c = '\0'; while (1) { u8 bit = 1 << (c & 0x7); u8 cAlt = c ^ bit; SCOPED_TRACE((unsigned int)c); memset(&data[0], c, dataSize); vector lits; // literals of type "aaaa" of length 4, 12, and mask of length // 1, 2, 4, 8, 0f type "b.......", "b......b" both case-less and case-sensitive string s4(4, c); string s4Alt(4, cAlt); for (int i = 0; i < 4 ; i++) { u32 mskLen = 1 << i; vector msk(mskLen, '\0'); vector cmp(mskLen, '\0'); cmp[0] = cAlt; msk[0] = '\xff'; // msk[f0000000] cmp[c0000000] lit[aaaa] if (mskLen > s4.length()) { lits.push_back(hwlmLiteral(s4, false, false, i * 12 + 0, HWLM_ALL_GROUPS, msk, cmp)); lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 1, HWLM_ALL_GROUPS, msk, cmp)); } // msk[f0000000] cmp[e0000000] lit[EEEE] if (bit == CASE_BIT && isalpha(c)) { lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 2, HWLM_ALL_GROUPS, msk, cmp)); } // msk[E0000000] cmp[E0000000] lit[eeee] if ((cAlt & bit) == 0) { msk[0] = ~bit; lits.push_back(hwlmLiteral(s4, false, false, i * 12 + 3, HWLM_ALL_GROUPS, msk, cmp)); lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 4, HWLM_ALL_GROUPS, msk, cmp)); } // msk[f0000000] cmp[a0000000] lit[aaaa] cmp[0] = c; msk[0] = '\xff'; lits.push_back(hwlmLiteral(s4, false, false, i * 12 + 5, HWLM_ALL_GROUPS, msk, cmp)); lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 6, HWLM_ALL_GROUPS, msk, cmp)); // msk[f0000000] cmp[a0000000] lit[cccc] if (mskLen > s4Alt.length()) { lits.push_back(hwlmLiteral(s4Alt, false, false, i * 12 + 7, HWLM_ALL_GROUPS, msk, cmp)); lits.push_back(hwlmLiteral(s4Alt, true, false, i * 12 + 8, HWLM_ALL_GROUPS, msk, cmp)); } if (bit == CASE_BIT && isalpha(c)) { // msk[f0000000] cmp[e0000000] lit[EEEE] lits.push_back(hwlmLiteral(s4Alt, true, false, i * 12 + 9, HWLM_ALL_GROUPS, msk, cmp)); // msk[f0000000] cmp[e000000E] lit[eeee] cmp[mskLen - 1] = cAlt; msk[mskLen - 1] = '\xff'; lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 10, HWLM_ALL_GROUPS, msk, cmp)); // msk[f0000000] cmp[E000000E] lit[eeee] cmp[0] = cAlt; lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 11, HWLM_ALL_GROUPS, msk, cmp)); } } auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); map matchesCounts; hwlm_error_t fdrStatus = fdrExec(fdr.get(), &data[0], dataSize, 0, countCallback, &matchesCounts, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); const u32 cnt4 = dataSize - 4 + 1; for (u8 i = 0; i < 4; i++) { u32 mskLen = 1 << i; u32 cntMask = MIN(cnt4, dataSize - mskLen + 1); ASSERT_EQ(0, matchesCounts[i * 12 + 0]); ASSERT_EQ(0, matchesCounts[i * 12 + 1]); ASSERT_EQ(0, matchesCounts[i * 12 + 2]); if ((cAlt & bit) == 0) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 3]); ASSERT_EQ(cntMask, matchesCounts[i * 12 + 4]); } if (mskLen > 4) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 5]); ASSERT_EQ(cntMask, matchesCounts[i * 12 + 6]); ASSERT_EQ(0, matchesCounts[i * 12 + 7]); if (bit == CASE_BIT && isalpha(c)) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 8]); } else { ASSERT_EQ(0, matchesCounts[i * 12 + 8]); } } else { ASSERT_EQ(cnt4, matchesCounts[i * 12 + 5]); ASSERT_EQ(cnt4, matchesCounts[i * 12 + 6]); } if (bit == CASE_BIT && isalpha(c)) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 9]); ASSERT_EQ(0, matchesCounts[i * 12 + 10]); ASSERT_EQ(0, matchesCounts[i * 12 + 11]); } } memset(&data[0], cAlt, dataSize); matchesCounts.clear(); fdrStatus = fdrExec(fdr.get(), &data[0], dataSize, 0, countCallback, &matchesCounts, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); for (u8 i = 0; i < 4; i++) { u32 mskLen = 1 << i; u32 cntMask = MIN(cnt4, dataSize - mskLen + 1); ASSERT_EQ(0, matchesCounts[i * 12 + 0]); ASSERT_EQ(0, matchesCounts[i * 12 + 3]); ASSERT_EQ(0, matchesCounts[i * 12 + 5]); ASSERT_EQ(0, matchesCounts[i * 12 + 6]); ASSERT_EQ(0, matchesCounts[i * 12 + 7]); ASSERT_EQ(0, matchesCounts[i * 12 + 8]); ASSERT_EQ(0, matchesCounts[i * 12 + 9]); if (bit == CASE_BIT && isalpha(c)) { ASSERT_EQ(mskLen > 4 ? cntMask : 0, matchesCounts[i * 12 + 1]); ASSERT_EQ(cntMask, matchesCounts[i * 12 + 2]); if(islower(c)) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 4]); } else { ASSERT_EQ(0, matchesCounts[i * 12 + 4]); } ASSERT_EQ(mskLen == 1 ? cnt4 : 0, matchesCounts[i * 12 + 10]); ASSERT_EQ(cntMask, matchesCounts[i * 12 + 11]); } else { ASSERT_EQ(0, matchesCounts[i * 12 + 1]); ASSERT_EQ(0, matchesCounts[i * 12 + 2]); ASSERT_EQ(0, matchesCounts[i * 12 + 4]); ASSERT_EQ(0, matchesCounts[i * 12 + 10]); ASSERT_EQ(0, matchesCounts[i * 12 + 11]); } } if (++c == '\0') { break; } } } TEST_P(FDRFloodp, StreamingMask) { const u32 hint = GetParam(); SCOPED_TRACE(hint); const size_t fake_history_size = 16; const vector fake_history(fake_history_size, 0); const size_t dataSize = 1024; vector data(dataSize); vector tempdata(dataSize + fake_history_size); // headroom u8 c = '\0'; while (1) { u8 bit = 1 << (c & 0x7); u8 cAlt = c ^ bit; SCOPED_TRACE((unsigned int)c); memset(&data[0], c, dataSize); vector lits; // literals of type "aaaa" of length 4, 12, and mask of length // 1, 2, 4, 8, 0f type "b.......", "b......b" both case-less and case-sensitive string s4(4, c); string s4Alt(4, cAlt); for (int i = 0; i < 4 ; i++) { u32 mskLen = 1 << i; vector msk(mskLen, '\0'); vector cmp(mskLen, '\0'); cmp[0] = cAlt; msk[0] = '\xff'; // msk[f0000000] cmp[c0000000] lit[aaaa] if (mskLen > s4.length()) { lits.push_back(hwlmLiteral(s4, false, false, i * 12 + 0, HWLM_ALL_GROUPS, msk, cmp)); lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 1, HWLM_ALL_GROUPS, msk, cmp)); } // msk[f0000000] cmp[e0000000] lit[EEEE] if (bit == CASE_BIT && isalpha(c)) { lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 2, HWLM_ALL_GROUPS, msk, cmp)); } // msk[E0000000] cmp[E0000000] lit[eeee] if ((cAlt & bit) == 0) { msk[0] = ~bit; lits.push_back(hwlmLiteral(s4, false, false, i * 12 + 3, HWLM_ALL_GROUPS, msk, cmp)); lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 4, HWLM_ALL_GROUPS, msk, cmp)); } // msk[f0000000] cmp[a0000000] lit[aaaa] cmp[0] = c; msk[0] = '\xff'; lits.push_back(hwlmLiteral(s4, false, false, i * 12 + 5, HWLM_ALL_GROUPS, msk, cmp)); lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 6, HWLM_ALL_GROUPS, msk, cmp)); // msk[f0000000] cmp[a0000000] lit[cccc] if (mskLen > s4Alt.length()) { lits.push_back(hwlmLiteral(s4Alt, false, false, i * 12 + 7, HWLM_ALL_GROUPS, msk, cmp)); lits.push_back(hwlmLiteral(s4Alt, true, false, i * 12 + 8, HWLM_ALL_GROUPS, msk, cmp)); } if (bit == CASE_BIT && isalpha(c)) { // msk[f0000000] cmp[e0000000] lit[EEEE] lits.push_back(hwlmLiteral(s4Alt, true, false, i * 12 + 9, HWLM_ALL_GROUPS, msk, cmp)); // msk[f0000000] cmp[e000000E] lit[eeee] cmp[mskLen - 1] = cAlt; msk[mskLen - 1] = '\xff'; lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 10, HWLM_ALL_GROUPS, msk, cmp)); // msk[f0000000] cmp[E000000E] lit[eeee] cmp[0] = cAlt; lits.push_back(hwlmLiteral(s4, true, false, i * 12 + 11, HWLM_ALL_GROUPS, msk, cmp)); } } auto fdr = fdrBuildTableHinted(lits, false, hint, get_current_target(), Grey()); CHECK_WITH_TEDDY_OK_TO_FAIL(fdr, hint); map matchesCounts; hwlm_error_t fdrStatus; const u32 cnt4 = dataSize - 4 + 1; for (u32 streamChunk = 1; streamChunk <= 16; streamChunk *= 2) { matchesCounts.clear(); const u8 *d = data.data(); // reference past the end of fake history to allow headroom const u8 *fhist = fake_history.data() + fake_history_size; fdrStatus = fdrExecStreaming(fdr.get(), fhist, 0, d, streamChunk, 0, countCallback, &matchesCounts, HWLM_ALL_GROUPS); ASSERT_EQ(0, fdrStatus); for (u32 j = streamChunk; j < dataSize; j += streamChunk) { if (j < 16) { /* allow 16 bytes headroom on read to avoid invalid * memory read during the FDR zone creation.*/ memset(tempdata.data(), c, dataSize + fake_history_size); const u8 *tmp_d = tempdata.data() + fake_history_size; fdrStatus = fdrExecStreaming(fdr.get(), tmp_d, j, tmp_d + j, streamChunk, 0, countCallback, &matchesCounts, HWLM_ALL_GROUPS); } else { fdrStatus = fdrExecStreaming(fdr.get(), d + j - 8, 8, d + j, streamChunk, 0, countCallback, &matchesCounts, HWLM_ALL_GROUPS); } ASSERT_EQ(0, fdrStatus); } for (u8 i = 0; i < 4; i++) { u32 mskLen = 1 << i; u32 cntMask = MIN(cnt4, dataSize - mskLen + 1); ASSERT_EQ(0, matchesCounts[i * 12 + 0]); ASSERT_EQ(0, matchesCounts[i * 12 + 1]); ASSERT_EQ(0, matchesCounts[i * 12 + 2]); if ((cAlt & bit) == 0) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 3]); ASSERT_EQ(cntMask, matchesCounts[i * 12 + 4]); } if (mskLen > 4) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 5]); ASSERT_EQ(cntMask, matchesCounts[i * 12 + 6]); ASSERT_EQ(0, matchesCounts[i * 12 + 7]); if (bit == CASE_BIT && isalpha(c)) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 8]); } else { ASSERT_EQ(0, matchesCounts[i * 12 + 8]); } } else { ASSERT_EQ(cnt4, matchesCounts[i * 12 + 5]); ASSERT_EQ(cnt4, matchesCounts[i * 12 + 6]); } if (bit == CASE_BIT && isalpha(c)) { ASSERT_EQ(cntMask, matchesCounts[i * 12 + 9]); ASSERT_EQ(0, matchesCounts[i * 12 + 10]); ASSERT_EQ(0, matchesCounts[i * 12 + 11]); } } } if (++c == '\0') { break; } } } INSTANTIATE_TEST_CASE_P(FDRFlood, FDRFloodp, ValuesIn(getValidFdrEngines())); hyperscan-4.4.1/unit/internal/rose_mask_32.cpp0000644000175000017500000001630513055426554022072 0ustar sleuthkidsleuthkid/* * Copyright (c) 2016, 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. */ #include "config.h" #include "rose/validate_mask.h" #include "gtest/gtest.h" #define ONES32 0xffffffffu union RoseLookaroundMask32 { m256 a256; u8 a8[32]; }; struct ValidateMask32TestInfo { RoseLookaroundMask32 data; u32 valid_mask; RoseLookaroundMask32 and_mask; RoseLookaroundMask32 cmp_mask; u32 neg_mask; }; struct ValidateMask32InitInfo { int idx; u8 data; u8 and_mask; u8 cmp_mask; u8 neg_mask; }; static const ValidateMask32InitInfo testBasicIdx[][33] = { { {1, 0x34, 0xf8, 0x30, 0}, {2, 0x34, 0xf8, 0x30, 0}, {8, 0x23, 0xff, 0x23, 0}, {9, 0x34, 0xf8, 0x30, 0}, {10, 0x41, 0xdf, 0x41, 0}, {11, 0x63, 0xdd, 0x41, 0}, {12, 0x61, 0xdd, 0x41, 0}, {13, 0x41, 0xdf, 0x41, 0}, {14, 0x61, 0xdf, 0x41, 0}, {15, 0x41, 0xdf, 0x41, 0}, {16, 0x43, 0xdd, 0x41, 0}, {17, 0x61, 0xdd, 0x41, 0}, {23, 0x63, 0xdd, 0x41, 0}, {24, 0x4f, 0xfc, 0x4c, 0}, {25, 0x4d, 0xfc, 0x4c, 0}, {26, 0x4d, 0xfc, 0x4c, 0}, {-1, 0, 0, 0, 0}, }, { {11, 0, 0xff, 0x55, 1}, {12, 0, 0xff, 0x36, 1}, {13, 0, 0xfe, 0x34, 1}, {14, 0x4d, 0xfe, 0x4c, 0}, {15, 0x41, 0xbf, 0x01, 0}, {16, 0x53, 0xdf, 0x73, 1}, {17, 0x4b, 0, 0, 0}, {18, 0, 0x2c, 0x2c, 1}, {-1, 0, 0, 0, 0}, }, { {15, 0x46, 0xdf, 0x46, 0}, {16, 0x4f, 0xdf, 0x46, 1}, {17, 0x6f, 0xff, 0x6f, 0}, {18, 0x31, 0xfe, 0x30, 0}, {19, 0x34, 0xf8, 0x30, 0}, {20, 0x66, 0xc0, 0x40, 0}, {21, 0x6f, 0xf0, 0x60, 0}, {22, 0x6f, 0, 0, 0}, {23, 0x46, 0xdf, 0x44, 1}, {24, 0x4f, 0xdf, 0x46, 1}, {25, 0x6f, 0xff, 0x4f, 1}, {26, 0x31, 0xfe, 0x30, 0}, {27, 0x34, 0xf8, 0x34, 1}, {28, 0x66, 0xc0, 0x60, 1}, {29, 0x6f, 0xf0, 0x6f, 1}, {30, 0x6f, 0, 0x60, 1}, {-1, 0, 0, 0, 0}, }, { {31, 0x4a, 0x80, 0, 0}, {-1, 0, 0, 0, 1}, }, { {12, 0x2b, 0x3d, 0x2d, 1}, {13, 0x2b, 0x3d, 0x4c, 1}, {23, 0x4a, 0x88, 0x0a, 1}, {-1, 0, 0, 0, 0}, }, }; static void initTestInfo(ValidateMask32TestInfo &t) { t.data.a256 = zeroes256(); t.valid_mask = 0xffffffff; t.and_mask.a256 = zeroes256(); t.cmp_mask.a256 = zeroes256(); t.neg_mask = 0; }; static int testBasicInit(ValidateMask32TestInfo *testB) { int len = 0; ValidateMask32TestInfo t; for (size_t i = 0; i < ARRAY_LENGTH(testBasicIdx); i++) { initTestInfo(t); for (const auto &line: testBasicIdx[i]) { if (line.idx < 0) { break; } int index = line.idx; t.data.a8[index] = line.data; t.and_mask.a8[index] = line.and_mask; t.cmp_mask.a8[index] = line.cmp_mask; t.neg_mask |= line.neg_mask << index; } testB[i] = t; len++; } return len; } TEST(ValidateMask32, testMask32_1) { ValidateMask32TestInfo testBasic[20]; int test_len = testBasicInit(testBasic); for (int i = 0; i < test_len; i++) { const auto t = testBasic[i]; EXPECT_EQ(1, validateMask32(t.data.a256, t.valid_mask, t.and_mask.a256, t.cmp_mask.a256, t.neg_mask)); } } TEST(ValidateMask32, testMask32_2) { ValidateMask32TestInfo testBasic[20]; int test_len = testBasicInit(testBasic); for (int left = 0; left <= 32; left++) { for (int right = 0; right + left < 32; right++) { u32 valid_mask = ONES32 << (left + right) >> left; for (int i = 0; i < test_len; i++) { const auto &t = testBasic[i]; int bool_result; bool_result = !(valid_mask & t.neg_mask); EXPECT_EQ(bool_result, validateMask32(t.data.a256, valid_mask, t.and_mask.a256, t.cmp_mask.a256, 0)); bool_result = (valid_mask & t.neg_mask) == valid_mask; EXPECT_EQ(bool_result, validateMask32(t.data.a256, valid_mask, t.and_mask.a256, t.cmp_mask.a256, ONES32)); } } } } TEST(ValidateMask32, testMask32_3) { ValidateMask32TestInfo testBasic[20]; testing::internal::Random neg_mask_rand(451); int test_len = testBasicInit(testBasic); for (int left = 0; left <= 32; left++) { for (int right = 0; right + left < 32; right++) { u32 valid_mask = ONES32 << (left + right) >> left; for (int i = 0; i < test_len; i++) { const auto &t = testBasic[i]; int bool_result; for (int j = 0; j < 5000; j++) { u32 neg_mask = neg_mask_rand.Generate(1u << 31); bool_result = (neg_mask & valid_mask) == (t.neg_mask & valid_mask); EXPECT_EQ(bool_result, validateMask32(t.data.a256, valid_mask, t.and_mask.a256, t.cmp_mask.a256, neg_mask)); } } } } } hyperscan-4.4.1/unit/internal/uniform_ops.cpp0000644000175000017500000001430213055426554022136 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "gtest/gtest.h" #include "config.h" #include "ue2common.h" #include "util/uniform_ops.h" #include "util/alloc.h" using namespace ue2; TEST(Uniform, Sizes) { // We likely depend on the size of the structures in various different // places in UE2, and it's conceivable that they could vary by // platform/compiler. EXPECT_EQ(1U, sizeof(u8)); EXPECT_EQ(2U, sizeof(u16)); EXPECT_EQ(4U, sizeof(u32)); EXPECT_EQ(8U, sizeof(u64a)); EXPECT_EQ(16U, sizeof(m128)); EXPECT_EQ(32U, sizeof(m256)); EXPECT_EQ(64U, sizeof(m512)); } TEST(Uniform, loadstore_u8) { for (int i = 0; i < 8; i++) { u8 in = 1 << i; const char *cin = (const char *)(&in); u8 out = load_u8(cin); EXPECT_EQ(in, out); char ALIGN_DIRECTIVE stored[1]; store_u8(stored, in); EXPECT_EQ(0, memcmp(stored, &in, sizeof(in))); } } TEST(Uniform, loadstore_u16) { for (int i = 0; i < 16; i++) { u16 in = 1 << i; const char *cin = (const char *)(&in); u16 out = load_u16(cin); EXPECT_EQ(in, out); void *stored = aligned_zmalloc(2); store_u16(stored, in); EXPECT_EQ(0, memcmp(stored, &in, sizeof(in))); aligned_free(stored); } } TEST(Uniform, loadstore_u32) { for (int i = 0; i < 32; i++) { u32 in = 1 << i; const char *cin = (const char *)(&in); u32 out = load_u32(cin); EXPECT_EQ(in, out); void *stored = aligned_zmalloc(32/8); store_u32(stored, in); EXPECT_EQ(0, memcmp(stored, &in, sizeof(in))); aligned_free(stored); } } TEST(Uniform, loadstore_u64a) { for (int i = 0; i < 64; i++) { u64a in = 1ULL << i; const char *cin = (const char *)(&in); u64a out = load_u64a(cin); EXPECT_EQ(in, out); void *stored = aligned_zmalloc(64/8); store_u64a(stored, in); EXPECT_EQ(0, memcmp(stored, &in, sizeof(in))); aligned_free(stored); } } TEST(Uniform, loadstore_m128) { union { m128 simd; u32 words[128/32]; } in; for (int i = 0; i < 128; i++) { memset(&in, 0, sizeof(in)); in.words[i/32] = 1 << (i % 32); const char *cin = (const char *)(&in); m128 out = load_m128(cin); EXPECT_EQ(0, memcmp(&out, &in, sizeof(out))); void *stored = aligned_zmalloc(128/8); store_m128(stored, in.simd); EXPECT_EQ(0, memcmp(stored, &in, sizeof(in))); aligned_free(stored); } } TEST(Uniform, loadstore_m256) { union { m256 simd; u32 words[256/32]; } in; for (int i = 0; i < 256; i++) { memset(&in, 0, sizeof(in)); in.words[i/32] = 1 << (i % 32); const char *cin = (const char *)(&in); m256 out = load_m256(cin); EXPECT_EQ(0, memcmp(&out, &in, sizeof(out))); void *stored = aligned_zmalloc(256/8); store_m256(stored, in.simd); EXPECT_EQ(0, memcmp(stored, &in, sizeof(in))); aligned_free(stored); } } TEST(Uniform, loadstore_m512) { union { m512 simd; u32 words[512/32]; } in; for (int i = 0; i < 512; i++) { memset(&in, 0, sizeof(in)); in.words[i/32] = 1 << (i % 32); const char *cin = (const char *)(&in); m512 out = load_m512(cin); EXPECT_EQ(0, memcmp(&out, &in, sizeof(out))); void *stored = aligned_zmalloc(512/8); store_m512(stored, in.simd); EXPECT_EQ(0, memcmp(stored, &in, sizeof(in))); aligned_free(stored); } } TEST(Uniform, testbit_u32) { for (u32 i = 0; i < 32; i++) { u32 v = 0; EXPECT_EQ((char)0, testbit_u32(v, i)); v |= 1ULL << i; EXPECT_EQ((char)1, testbit_u32(v, i)); v = ~v; EXPECT_EQ((char)0, testbit_u32(v, i)); v |= 1ULL << i; EXPECT_EQ((char)1, testbit_u32(v, i)); } } TEST(Uniform, testbit_u64a) { for (u32 i = 0; i < 64; i++) { u64a v = 0; EXPECT_EQ((char)0, testbit_u64a(v, i)); v |= 1ULL << i; EXPECT_EQ((char)1, testbit_u64a(v, i)); v = ~v; EXPECT_EQ((char)0, testbit_u64a(v, i)); v |= 1ULL << i; EXPECT_EQ((char)1, testbit_u64a(v, i)); } } TEST(Uniform, clearbit_u32) { for (u32 i = 0; i < 32; i++) { u32 v = ~0U; clearbit_u32(&v, i); EXPECT_EQ((char)0, testbit_u32(v, i)); v = ~v; clearbit_u32(&v, i); EXPECT_EQ(0U, v); } } TEST(Uniform, clearbit_u64a) { for (u32 i = 0; i < 64; i++) { u64a v = ~0ULL; clearbit_u64a(&v, i); EXPECT_EQ((char)0, testbit_u64a(v, i)); v = ~v; clearbit_u64a(&v, i); EXPECT_EQ(0ULL, v); } } hyperscan-4.4.1/unit/internal/util_string.cpp0000644000175000017500000002644713055426554022156 0ustar sleuthkidsleuthkid/* * 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. */ #include "gtest/gtest.h" #include "config.h" #include "ue2common.h" #include "util/ue2string.h" using namespace ue2; TEST(string, case_iter1) { const char * const expected[] = { "3FOO-BAR", "3FOO-BAr", "3FOO-BaR", "3FOO-Bar", "3FOO-bAR", "3FOO-bAr", "3FOO-baR", "3FOO-bar", "3FOo-BAR", "3FOo-BAr", "3FOo-BaR", "3FOo-Bar", "3FOo-bAR", "3FOo-bAr", "3FOo-baR", "3FOo-bar", "3FoO-BAR", "3FoO-BAr", "3FoO-BaR", "3FoO-Bar", "3FoO-bAR", "3FoO-bAr", "3FoO-baR", "3FoO-bar", "3Foo-BAR", "3Foo-BAr", "3Foo-BaR", "3Foo-Bar", "3Foo-bAR", "3Foo-bAr", "3Foo-baR", "3Foo-bar", "3fOO-BAR", "3fOO-BAr", "3fOO-BaR", "3fOO-Bar", "3fOO-bAR", "3fOO-bAr", "3fOO-baR", "3fOO-bar", "3fOo-BAR", "3fOo-BAr", "3fOo-BaR", "3fOo-Bar", "3fOo-bAR", "3fOo-bAr", "3fOo-baR", "3fOo-bar", "3foO-BAR", "3foO-BAr", "3foO-BaR", "3foO-Bar", "3foO-bAR", "3foO-bAr", "3foO-baR", "3foO-bar", "3foo-BAR", "3foo-BAr", "3foo-BaR", "3foo-Bar", "3foo-bAR", "3foo-bAr", "3foo-baR", "3foo-bar", }; case_iter it = caseIterateBegin(ue2_literal(expected[17], true)); case_iter ite = caseIterateEnd(); u32 i = 0; for(; it != ite; ++it, ++i) { EXPECT_EQ(expected[i], *it); } EXPECT_EQ(ARRAY_LENGTH(expected), i); } TEST(string, case_iter2) { case_iter it = caseIterateBegin(ue2_literal("4A", true)); case_iter ite = caseIterateEnd(); EXPECT_TRUE(ite != it); EXPECT_EQ("4A", *it); ++it; EXPECT_TRUE(ite != it); EXPECT_EQ("4a", *it); ++it; EXPECT_TRUE(!(ite != it)); } TEST(string, case_iter3a) { ue2_literal src; src.push_back('a', false); src.push_back('B', true); src.push_back('c', false); case_iter it = caseIterateBegin(src); case_iter ite = caseIterateEnd(); EXPECT_TRUE(ite != it); EXPECT_EQ("aBc", *it); ++it; EXPECT_TRUE(ite != it); EXPECT_EQ("abc", *it); ++it; EXPECT_TRUE(!(ite != it)); } TEST(string, case_iter3b) { ue2_literal src; src.push_back('A', false); src.push_back('B', true); src.push_back('C', false); case_iter it = caseIterateBegin(src); case_iter ite = caseIterateEnd(); EXPECT_TRUE(ite != it); EXPECT_EQ("ABC", *it); ++it; EXPECT_TRUE(ite != it); EXPECT_EQ("AbC", *it); ++it; EXPECT_TRUE(!(ite != it)); } TEST(string, case_iter3c) { ue2_literal src; src.push_back('A', false); src.push_back('B', true); src.push_back('C', true); case_iter it = caseIterateBegin(src); case_iter ite = caseIterateEnd(); EXPECT_TRUE(ite != it); EXPECT_EQ("ABC", *it); ++it; EXPECT_TRUE(ite != it); EXPECT_EQ("ABc", *it); ++it; EXPECT_TRUE(ite != it); EXPECT_EQ("AbC", *it); ++it; EXPECT_TRUE(ite != it); EXPECT_EQ("Abc", *it); ++it; EXPECT_TRUE(!(ite != it)); } TEST(string, selfOverlap) { EXPECT_EQ(0U, maxStringSelfOverlap("abc", 0)); EXPECT_EQ(0U, maxStringSelfOverlap("abc", 1)); EXPECT_EQ(0U, maxStringSelfOverlap("abcA", 0)); EXPECT_EQ(1U, maxStringSelfOverlap("abcA", 1)); EXPECT_EQ(3U, maxStringSelfOverlap("aaaa", 0)); EXPECT_EQ(1U, maxStringSelfOverlap("aaAa", 0)); EXPECT_EQ(3U, maxStringSelfOverlap("aaAa", 1)); EXPECT_EQ(1U, maxStringSelfOverlap("aaba", 0)); EXPECT_EQ(2U, maxStringSelfOverlap("aabaa", 0)); EXPECT_EQ(3U, maxStringSelfOverlap("aabaab", 0)); } TEST(string, reverse0) { ue2_literal empty; EXPECT_TRUE(empty == reverse_literal(empty)); } TEST(string, reverse1) { ue2_literal fwd("0123456789", false); ue2_literal bwd("9876543210", false); EXPECT_TRUE(bwd == reverse_literal(fwd)); } TEST(string, reverse2) { ue2_literal fwd; fwd.push_back('0', false); fwd.push_back('a', false); fwd.push_back('b', true); fwd.push_back('c', true); ue2_literal bwd; bwd.push_back('c', true); bwd.push_back('b', true); bwd.push_back('a', false); bwd.push_back('0', false); EXPECT_TRUE(bwd == reverse_literal(fwd)); } TEST(string, iterator_op1) { ue2_literal abcdef("abcdef", false); ue2_literal::const_iterator b = abcdef.begin(); ue2_literal::const_iterator e = abcdef.end(); EXPECT_TRUE(b < e); EXPECT_FALSE(b > e); EXPECT_TRUE(e > b); EXPECT_FALSE(e < b); EXPECT_TRUE(e == e); EXPECT_TRUE(b == b); EXPECT_FALSE(e == b); EXPECT_TRUE(b != e); EXPECT_FALSE(b != b); EXPECT_FALSE(e != e); } TEST(string, iterator_op2) { ue2_literal empty; ue2_literal::const_iterator b = empty.begin(); ue2_literal::const_iterator e = empty.end(); EXPECT_FALSE(b > e); EXPECT_FALSE(b < e); EXPECT_TRUE(e == e); EXPECT_TRUE(b == b); EXPECT_FALSE(e != b); } TEST(string, eq) { ue2_literal empty1; ue2_literal empty2; ue2_literal abc_cs("abc", false); ue2_literal abc_nc("abc", true); ue2_literal abc_ucs("ABC", false); ue2_literal abc_unc("ABC", true); EXPECT_TRUE(empty1 == empty2); EXPECT_FALSE(empty1 != empty2); EXPECT_TRUE(abc_cs != abc_nc); EXPECT_TRUE(abc_cs != empty1); EXPECT_TRUE(abc_cs != abc_nc); EXPECT_TRUE(abc_cs != abc_ucs); EXPECT_TRUE(abc_cs != abc_unc); EXPECT_FALSE(abc_cs == abc_nc); EXPECT_FALSE(abc_cs == empty1); EXPECT_FALSE(abc_cs == abc_nc); EXPECT_FALSE(abc_cs == abc_ucs); EXPECT_FALSE(abc_cs == abc_unc); EXPECT_TRUE(abc_nc != abc_ucs); EXPECT_TRUE(abc_nc == abc_unc); EXPECT_FALSE(abc_nc == abc_ucs); EXPECT_FALSE(abc_nc != abc_unc); EXPECT_TRUE(abc_ucs != abc_unc); EXPECT_FALSE(abc_ucs == abc_unc); } TEST(string, contains_cs) { ue2_literal abc123("abc123", false); EXPECT_TRUE(contains(abc123, CharReach('a'))); EXPECT_TRUE(contains(abc123, CharReach('b'))); EXPECT_TRUE(contains(abc123, CharReach('c'))); EXPECT_TRUE(contains(abc123, CharReach('1'))); EXPECT_TRUE(contains(abc123, CharReach('2'))); EXPECT_TRUE(contains(abc123, CharReach('3'))); EXPECT_TRUE(!contains(abc123, CharReach('A'))); EXPECT_TRUE(!contains(abc123, CharReach('B'))); EXPECT_TRUE(!contains(abc123, CharReach('C'))); EXPECT_TRUE(!contains(abc123, CharReach(0x11))); EXPECT_TRUE(!contains(abc123, CharReach(0x12))); EXPECT_TRUE(!contains(abc123, CharReach(0x13))); EXPECT_TRUE(!contains(abc123, CharReach(0))); EXPECT_TRUE(!contains(abc123, CharReach('X'))); EXPECT_TRUE(!contains(abc123, CharReach('\n'))); EXPECT_TRUE(contains(abc123, CharReach::dot())); EXPECT_TRUE(contains(abc123, CharReach("Aa"))); EXPECT_TRUE(contains(abc123, CharReach("Bb"))); EXPECT_TRUE(contains(abc123, CharReach("XYZ1"))); EXPECT_TRUE(contains(abc123, CharReach("3~"))); EXPECT_TRUE(!contains(abc123, CharReach("45X"))); EXPECT_TRUE(!contains(abc123, CharReach("Bx"))); } TEST(string, contains_nc) { ue2_literal abc123("abc123", true); EXPECT_TRUE(contains(abc123, CharReach('a'))); EXPECT_TRUE(contains(abc123, CharReach('b'))); EXPECT_TRUE(contains(abc123, CharReach('c'))); EXPECT_TRUE(contains(abc123, CharReach('1'))); EXPECT_TRUE(contains(abc123, CharReach('2'))); EXPECT_TRUE(contains(abc123, CharReach('3'))); EXPECT_TRUE(contains(abc123, CharReach('A'))); EXPECT_TRUE(contains(abc123, CharReach('B'))); EXPECT_TRUE(contains(abc123, CharReach('C'))); EXPECT_TRUE(!contains(abc123, CharReach(0x11))); EXPECT_TRUE(!contains(abc123, CharReach(0x12))); EXPECT_TRUE(!contains(abc123, CharReach(0x13))); EXPECT_TRUE(!contains(abc123, CharReach(0))); EXPECT_TRUE(!contains(abc123, CharReach('X'))); EXPECT_TRUE(!contains(abc123, CharReach('\n'))); EXPECT_TRUE(contains(abc123, CharReach::dot())); EXPECT_TRUE(contains(abc123, CharReach("Aa"))); EXPECT_TRUE(contains(abc123, CharReach("Bb"))); EXPECT_TRUE(contains(abc123, CharReach("XYZ1"))); EXPECT_TRUE(contains(abc123, CharReach("3~"))); EXPECT_TRUE(!contains(abc123, CharReach("45X"))); EXPECT_TRUE(contains(abc123, CharReach("Bx"))); } TEST(string, contains_empty) { ue2_literal empty; EXPECT_TRUE(!contains(empty, CharReach('a'))); EXPECT_TRUE(!contains(empty, CharReach::dot())); } TEST(string, cat) { ue2_literal abc("abc", false); ue2_literal empty; ue2_literal def("def", true); ue2_literal abcdef; abcdef.push_back('a', false); abcdef.push_back('b', false); abcdef.push_back('c', false); abcdef.push_back('D', true); abcdef.push_back('e', true); abcdef.push_back('f', true); EXPECT_EQ(empty, empty + empty); EXPECT_EQ(abc, abc + empty); EXPECT_EQ(abc, empty + abc); EXPECT_EQ(abcdef, abc + def); } TEST(string, erase) { ue2_literal abcdefghi("abcdefghi", false); ue2_literal abc = abcdefghi; abc.erase(3, 10); EXPECT_EQ(ue2_literal("abc", false), abc); ue2_literal def = abcdefghi; def.erase(0, 3); def.erase(3); EXPECT_EQ(ue2_literal("def", false), def); ue2_literal bcdefghi = abcdefghi; bcdefghi.erase(0, 1); EXPECT_EQ(ue2_literal("bcdefghi", false), bcdefghi); } TEST(string, erase_nc) { ue2_literal abcdef; abcdef.push_back('a', false); abcdef.push_back('b', false); abcdef.push_back('c', false); abcdef.push_back('D', true); abcdef.push_back('e', true); abcdef.push_back('f', true); ue2_literal abc = abcdef; abc.erase(3, 6); EXPECT_EQ(ue2_literal("abc", false), abc); ue2_literal def = abcdef; def.erase(0, 3); EXPECT_EQ(ue2_literal("def", true), def); } hyperscan-4.4.1/unit/internal/vermicelli.cpp0000644000175000017500000004445213055426554021742 0ustar sleuthkidsleuthkid/* * Copyright (c) 2015-2016, Intel Corporation * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions are met: * * * 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. */ #include "config.h" #include "gtest/gtest.h" #include "nfa/vermicelli.h" TEST(Vermicelli, ExecNoMatch1) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { for (size_t j = 0; j < 16; j++) { const u8 *rv = vermicelliExec('a', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j), (size_t)rv); rv = vermicelliExec('B', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j), (size_t)rv); rv = vermicelliExec('A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j), (size_t)rv); } } } TEST(Vermicelli, Exec1) { char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliExec('a', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = vermicelliExec('A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(Vermicelli, Exec2) { char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliExec('a', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = vermicelliExec('A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(Vermicelli, Exec3) { char t1[] = "bbbbbbbbbbbbbbbbbAaaaaaaaaaaaaaaaaaaaaaabbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliExec('a', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 18, (size_t)rv); rv = vermicelliExec('A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(Vermicelli, Exec4) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[48 - i] = 'a'; const u8 *rv = vermicelliExec('a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); rv = vermicelliExec('A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); } } TEST(DoubleVermicelli, ExecNoMatch1) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { for (size_t j = 0; j < 16; j++) { const u8 *rv = vermicelliDoubleExec('a', 'b', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j), (size_t)rv); rv = vermicelliDoubleExec('B', 'b', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j), (size_t)rv); rv = vermicelliDoubleExec('A', 'B', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j), (size_t)rv); /* partial match */ rv = vermicelliDoubleExec('b', 'B', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j - 1), (size_t)rv); /* partial match */ rv = vermicelliDoubleExec('B', 'A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j - 1), (size_t)rv); } } } TEST(DoubleVermicelli, Exec1) { char t1[] = "bbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliDoubleExec('a', 'b', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 18, (size_t)rv); rv = vermicelliDoubleExec('A', 'B', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 18, (size_t)rv); rv = vermicelliDoubleExec('b', 'a', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = vermicelliDoubleExec('B', 'A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(DoubleVermicelli, Exec2) { char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliDoubleExec('a', 'a', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = vermicelliDoubleExec('A', 'A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(DoubleVermicelli, Exec3) { /* 012345678901234567890123 */ char t1[] = "bbbbbbbbbbbbbbbbbaAaaAAaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbb"; for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliDoubleExec('A', 'a', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 18, (size_t)rv); rv = vermicelliDoubleExec('A', 'A', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = vermicelliDoubleExec('A', 'A', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 21, (size_t)rv); rv = vermicelliDoubleExec('a', 'A', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(DoubleVermicelli, Exec4) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { t1[48 - i] = 'a'; t1[48 - i + 1] = 'a'; const u8 *rv = vermicelliDoubleExec('a', 'a', 0, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); rv = vermicelliDoubleExec('A', 'A', 1, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); } } TEST(Vermicelli, noodEarlyExit) { // searches that should fail static const u8 *lowerAlpha = (const u8*) "abcdefghijklmnopqrstuvwxyz"; const u8 *la_end = lowerAlpha + 26; EXPECT_EQ(la_end, vermicelliExec('0', 0, lowerAlpha, la_end)); EXPECT_EQ(la_end, vermicelliExec('A', 0, lowerAlpha, la_end)); // single byte match for (unsigned i = 0; i < 26; i++) { u8 byte = lowerAlpha[i]; SCOPED_TRACE(byte); EXPECT_EQ(lowerAlpha + i, vermicelliExec(byte, 0, lowerAlpha, la_end)); byte = toupper(lowerAlpha[i]); EXPECT_EQ(lowerAlpha + i, vermicelliExec(byte, 1, lowerAlpha, la_end)); } } TEST(NVermicelli, ExecNoMatch1) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { SCOPED_TRACE(i); for (size_t j = 0; j < 16; j++) { SCOPED_TRACE(j); const u8 *rv = nvermicelliExec('b', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j), (size_t)rv); rv = nvermicelliExec('B', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1) - j); ASSERT_EQ(((size_t)t1 + strlen(t1) - j), (size_t)rv); } } } TEST(NVermicelli, Exec1) { char t1[] = "bbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { SCOPED_TRACE(i); const u8 *rv = nvermicelliExec('b', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = nvermicelliExec('B', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(NVermicelli, Exec2) { char t1[] = "bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaabbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { SCOPED_TRACE(i); const u8 *rv = nvermicelliExec('b', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = nvermicelliExec('B', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); } } TEST(NVermicelli, Exec3) { char t1[] = "bbbbbbbbbbbbbbbbbBaaaaaaaaaaaaaaaaaaaaaabbbbbbbbabbbbbbbbbbbb"; for (size_t i = 0; i < 16; i++) { SCOPED_TRACE(i); const u8 *rv = nvermicelliExec('b', 0, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 17, (size_t)rv); rv = nvermicelliExec('B', 1, (u8 *)t1 + i, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)t1 + 18, (size_t)rv); } } TEST(NVermicelli, Exec4) { char t1[] = "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"; for (size_t i = 0; i < 31; i++) { SCOPED_TRACE(i); t1[48 - i] = 'a'; const u8 *rv = nvermicelliExec('b', 0, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); rv = nvermicelliExec('B', 1, (u8 *)t1, (u8 *)t1 + strlen(t1)); ASSERT_EQ((size_t)&t1[48 - i], (size_t)rv); } } TEST(DoubleVermicelliMasked, ExecNoMatch1) { std::string t1("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); const u8 *t1_raw = (const u8 *)t1.c_str(); for (size_t i = 0; i < 16; i++) { for (size_t j = 0; j < 16; j++) { const u8 *rv = vermicelliDoubleMaskedExec('a', 'b', 0xff, 0xff, t1_raw + i, t1_raw + t1.length() - i - j); ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j), (size_t)rv); rv = vermicelliDoubleMaskedExec('B', 'B', 0xff, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() - i - j); ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j), (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'B', CASE_CLEAR, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() -i - j); ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j), (size_t)rv); /* partial match */ rv = vermicelliDoubleMaskedExec('B', 'B', CASE_CLEAR, 0xff, t1_raw + i, t1_raw + t1.length() - i - j); ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j - 1), (size_t)rv); rv = vermicelliDoubleMaskedExec('B', 'A', 0xff, 0xff, t1_raw + i, t1_raw + t1.length() - i - j); ASSERT_EQ(((size_t)t1_raw + t1.length() - i - j), (size_t)rv); } } } TEST(DoubleVermicelliMasked, Exec1) { std::string t1("bbbbbbbbbbbbbbbbbbabbbbbbbbbbbbbbbbbbbbbbbbbbbbbbabbbbbbbbbbb"); const u8 *t1_raw = (const u8 *)t1.c_str(); for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliDoubleMaskedExec('a', 'b', 0xff, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'B', CASE_CLEAR, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv); rv = vermicelliDoubleMaskedExec('a', 'B', 0xff, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'b', CASE_CLEAR, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv); rv = vermicelliDoubleMaskedExec('b', 'a', 0xff, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); rv = vermicelliDoubleMaskedExec('B', 'A', CASE_CLEAR, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); } } TEST(DoubleVermicelliMasked, Exec2) { std::string t1("bbbbbbbbbbbbbbbbbaaaaaaaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbb"); const u8 *t1_raw = (const u8 *)t1.c_str(); for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliDoubleMaskedExec('a', 'a', 0xff, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'A', CASE_CLEAR, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); rv = vermicelliDoubleMaskedExec('a', 'A', 0xff, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'a', CASE_CLEAR, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); } } TEST(DoubleVermicelliMasked, Exec3) { /* 012345678901234567890123 */ std::string t1("bbbbbbbbbbbbbbbbbaAaaAAaaaaaaaaaaaaaaaaaabbbbbbbaaaaabbbbbbbb"); const u8 *t1_raw = (const u8 *)t1.c_str(); for (size_t i = 0; i < 16; i++) { const u8 *rv = vermicelliDoubleMaskedExec('A', 'a', 0xff, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'A', CASE_CLEAR, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'A', 0xff, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 21, (size_t)rv); rv = vermicelliDoubleMaskedExec('a', 'A', 0xff, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); rv = vermicelliDoubleMaskedExec('a', 'A', 0xff, CASE_CLEAR, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 17, (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'a', CASE_CLEAR, 0xff, t1_raw + i, t1_raw + t1.length() - i); ASSERT_EQ((size_t)t1_raw + 18, (size_t)rv); } } TEST(DoubleVermicelliMasked, Exec4) { std::string t1("bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb"); const u8 *t1_raw = (const u8 *)t1.c_str(); for (size_t i = 0; i < 31; i++) { t1[48 - i] = 'a'; t1[48 - i + 1] = 'a'; const u8 *rv = vermicelliDoubleMaskedExec('a', 'a', 0xff, 0xff, t1_raw, t1_raw + t1.length()); ASSERT_EQ((size_t)&t1_raw[48 - i], (size_t)rv); rv = vermicelliDoubleMaskedExec('A', 'A', CASE_CLEAR, CASE_CLEAR, t1_raw, t1_raw + t1.length()); ASSERT_EQ((size_t)&t1_raw[48 - i], (size_t)rv); } } hyperscan-4.4.1/unit/internal/nfagraph_common.h0000644000175000017500000000503713055426554022406 0ustar sleuthkidsleuthkid/* * 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 NFAGRAPH_COMMON_H #define NFAGRAPH_COMMON_H #include "compiler/compiler.h" #include "grey.h" #include "nfagraph/ng_builder.h" #include "nfagraph/ng.h" #include "nfagraph/ng_width.h" #include "util/target_info.h" namespace ue2 { // Helper function: construct a graph from an expression, flags and context. inline std::unique_ptr constructGraphWithCC(const std::string &expr, CompileContext &cc, unsigned flags) { ReportManager rm(cc.grey); ParsedExpression parsed(0, expr.c_str(), flags, 0); return buildWrapper(rm, cc, parsed); } // Helper function: construct a graph from an expression and its flags. inline std::unique_ptr constructGraph(const std::string &expr, unsigned flags) { CompileContext cc(false, false, get_current_target(), Grey()); return constructGraphWithCC(expr, cc, flags); } } // namespace ue2 #endif // NFAGRAPH_COMMON_H hyperscan-4.4.1/unit/internal/main.cpp0000644000175000017500000000335013055426554020523 0ustar sleuthkidsleuthkid/* * 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. */ #include "gtest/gtest.h" // Driver: run all the tests (defined in other source files in this directory) int main(int argc, char **argv) { testing::InitGoogleTest(&argc, argv); return RUN_ALL_TESTS(); } hyperscan-4.4.1/unit/internal/flat_map.cpp0000644000175000017500000002670413055426554021372 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "util/ue2_containers.h" #include "ue2common.h" #include "gtest/gtest.h" #include #include #include #include using namespace std; using namespace ue2; template std::ostream &operator<<(std::ostream &os, const flat_map &f) { os << "{"; for (auto it = begin(f); it != end(f); ++it) { os << "{" << it->first << ", " << it->second << "}"; if (it != end(f)) { os << ", "; } } os << "}"; return os; } template bool flat_map_is_sorted_cmp(const FlatMap &f, const Compare &cmp) { using value_type = typename FlatMap::value_type; return is_sorted(f.begin(), f.end(), [&cmp](const value_type &a, const value_type &b) { return cmp(a.first, b.first); }); } template bool flat_map_is_sorted(const FlatMap &f) { return flat_map_is_sorted_cmp(f, f.key_comp()); } TEST(flat_map, empty) { flat_map f; EXPECT_TRUE(f.begin() == f.end()); EXPECT_TRUE(f.cbegin() == f.cend()); EXPECT_TRUE(f.rbegin() == f.rend()); EXPECT_TRUE(f.crbegin() == f.crend()); EXPECT_TRUE(f.empty()); EXPECT_EQ(0, f.size()); EXPECT_EQ(0, f.count(10)); } TEST(flat_map, insert) { flat_map f; f.insert(make_pair(1, 10)); f.insert(make_pair(2, 20)); EXPECT_EQ(2, f.size()); EXPECT_TRUE(flat_map_is_sorted(f)); EXPECT_EQ(1, f.begin()->first); EXPECT_EQ(10, f.begin()->second); EXPECT_EQ(2, f.rbegin()->first); EXPECT_EQ(20, f.rbegin()->second); EXPECT_EQ(1, f.count(1)); EXPECT_EQ(1, f.count(2)); EXPECT_EQ(0, f.count(3)); } TEST(flat_map, clear) { flat_map f = {{1, 10}, {3, 30}, {2, 20}}; EXPECT_EQ(3, f.size()); EXPECT_FALSE(f.empty()); f.clear(); EXPECT_EQ(0, f.size()); EXPECT_TRUE(f.empty()); } TEST(flat_map, sorted) { vector> vec = {{7, 700}, {1, 100}, {3, 300}, {4, 400}, {2, 200}}; flat_map f(vec.begin(), vec.end()); EXPECT_EQ(vec.size(), f.size()); EXPECT_EQ(1, f.begin()->first); EXPECT_EQ(7, f.rbegin()->first); EXPECT_TRUE(flat_map_is_sorted(f)); // all our elements are there for (const auto &p : vec) { auto it = f.find(p.first); EXPECT_TRUE(it != f.end()); EXPECT_EQ(p.first, it->first); EXPECT_EQ(p.second, it->second); } // these aren't there EXPECT_TRUE(f.find(0) == f.end()); EXPECT_TRUE(f.find(5) == f.end()); EXPECT_TRUE(f.find(6) == f.end()); EXPECT_TRUE(f.find(8) == f.end()); // at() checks for (const auto &p : vec) { EXPECT_EQ(p.second, f.at(p.first)); } ASSERT_THROW(f.at(0), std::out_of_range); ASSERT_THROW(f.at(10), std::out_of_range); // operator[] for (const auto &p : vec) { EXPECT_EQ(p.second, f[p.first]); } } TEST(flat_map, dupe_keys) { vector> vec = {{7, 700}, {1, 100}, {3, 300}, {4, 400}, {2, 200}, // dupes {7, 700}, {2, 200}, {2, 200}}; flat_map f(vec.begin(), vec.end()); EXPECT_EQ(5, f.size()); ASSERT_TRUE(flat_map_is_sorted(f)); } TEST(flat_map, subscript) { flat_map f; f[1] = 10; f[3] = 30; f[2] = 20; EXPECT_EQ(3, f.size()); f[1] = 100; f[2] = 200; EXPECT_EQ(3, f.size()); ASSERT_TRUE(flat_map_is_sorted(f)); } TEST(flat_map, init_list) { flat_map f = {{1, "sydney"}, {2, "melbourne"}}; EXPECT_EQ(2, f.size()); ASSERT_TRUE(flat_map_is_sorted(f)); f.insert({{17, "adelaide"}, {14, "perth"}, {4, "brisbane" }}); EXPECT_EQ(5, f.size()); ASSERT_TRUE(flat_map_is_sorted(f)); ASSERT_EQ("sydney", f[1]); ASSERT_EQ("melbourne", f[2]); ASSERT_EQ("adelaide", f[17]); ASSERT_EQ("perth", f[14]); ASSERT_EQ("brisbane", f[4]); f[1] = "hobart"; // replace EXPECT_EQ(5, f.size()); ASSERT_EQ("hobart", f[1]); f.erase(100); // not present EXPECT_EQ(5, f.size()); f.erase(17); EXPECT_EQ(4, f.size()); EXPECT_TRUE(f.find(17) == f.end()); } TEST(flat_map, custom_compare) { flat_map> f; ASSERT_EQ(0, f.size()); f.insert({{1, 10}, {2, 20}, {3, 30}, {4, 40}, {5, 50}, {6, 60}, {7, 70}, {8, 80}, {9, 90}, {10, 100}}); ASSERT_EQ(10, f.size()); ASSERT_EQ(10, f.begin()->first); ASSERT_EQ(100, f.begin()->second); ASSERT_EQ(1, f.rbegin()->first); ASSERT_EQ(10, f.rbegin()->second); ASSERT_TRUE(flat_map_is_sorted(f)); ASSERT_TRUE(flat_map_is_sorted_cmp(f, std::greater())); } namespace { class MovableOnly { public: MovableOnly(size_t val_in, const string &name_in) : val(val_in), name(name_in) {} bool operator<(const MovableOnly &other) const { return tie(val, name) < tie(other.val, other.name); } // Can't copy-construct or copy-assign. MovableOnly(const MovableOnly &) = delete; MovableOnly &operator=(const MovableOnly &) = delete; // Moves are OK though. MovableOnly(MovableOnly &&) = default; MovableOnly &operator=(MovableOnly &&) = default; size_t val; string name; }; } // namespace TEST(flat_map, emplace) { flat_map f; ASSERT_TRUE(f.empty()); auto rv = f.emplace(10, MovableOnly(1, string("hatstand"))); ASSERT_NE(end(f), rv.first); ASSERT_EQ(1, rv.first->second.val); ASSERT_TRUE(rv.second); rv = f.emplace(30, MovableOnly(3, string("badgerbrush"))); ASSERT_NE(end(f), rv.first); ASSERT_EQ(3, rv.first->second.val); ASSERT_TRUE(rv.second); rv = f.emplace(20, MovableOnly(2, string("teakettle"))); ASSERT_NE(end(f), rv.first); ASSERT_EQ(2, rv.first->second.val); ASSERT_TRUE(rv.second); ASSERT_EQ(3, f.size()); ASSERT_TRUE(std::is_sorted(begin(f), end(f))); rv = f.emplace(10, MovableOnly(1, string("hatstand"))); // dupe ASSERT_FALSE(rv.second); ASSERT_EQ(3, f.size()); ASSERT_TRUE(std::is_sorted(begin(f), end(f))); } TEST(flat_map, swap) { flat_map a = {{0, 1}, {1, 2}, {2, 4}, {3, 8}, {4, 16}, {5, 32}}; flat_map b = {{0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}}; swap(a, b); EXPECT_EQ(6, a.size()); EXPECT_EQ(6, b.size()); EXPECT_EQ(6, a.rbegin()->second); EXPECT_EQ(32, b.rbegin()->second); } TEST(flat_map, iter) { vector> vec = {{0, 1}, {1, 2}, {2, 4}, {3, 8}, {4, 16}, {5, 32}}; flat_map f(begin(vec), end(vec)); ASSERT_EQ(vec.size(), f.size()); ASSERT_TRUE(std::equal(f.begin(), f.end(), vec.begin())); ASSERT_TRUE(std::equal(f.rbegin(), f.rend(), vec.rbegin())); } TEST(flat_map, erase_values) { vector> vec = {{0, 1}, {1, 2}, {2, 4}, {3, 8}, {4, 16}, {5, 32}}; flat_map f(begin(vec), end(vec)); ASSERT_EQ(vec.size(), f.size()); for (const auto &v : vec) { const auto &key = v.first; ASSERT_TRUE(f.find(key) != f.end()); f.erase(key); ASSERT_TRUE(f.find(key) == f.end()); } ASSERT_TRUE(f.empty()); } TEST(flat_map, erase_iter) { vector> vec = {{0, 1}, {1, 2}, {2, 4}, {3, 8}, {4, 16}, {5, 32}}; flat_map f(begin(vec), end(vec)); ASSERT_EQ(vec.size(), f.size()); for (const auto &v : vec) { const auto &key = v.first; auto it = f.find(key); ASSERT_TRUE(it != f.end()); f.erase(it); ASSERT_TRUE(f.find(key) == f.end()); } ASSERT_TRUE(f.empty()); } TEST(flat_map, erase_iters) { flat_map f = {{0, 1}, {1, 2}, {2, 4}, {3, 8}, {4, 16}, {5, 32}, {6, 64}, {7, 128}, {8, 256}, {9, 512}}; ASSERT_EQ(10, f.size()); auto first = f.find(3); ASSERT_NE(end(f), first); auto last = f.find(8); ASSERT_NE(end(f), last); f.erase(first, last); flat_map exp = {{0, 1}, {1, 2}, {2, 4}, {8, 256}, {9, 512}}; ASSERT_EQ(exp, f); } TEST(flat_map, erase_empty_range) { flat_map f = {{0, 1}, {1, 2}, {2, 4}, {3, 8}, {4, 16}, {5, 32}, {6, 64}, {7, 128}, {8, 256}, {9, 512}, {10, 1024}}; const auto f2 = f; // copy ASSERT_EQ(f, f2); // Erasing (it, it) should do nothing. for (const auto &val : f2) { auto it = f.find(val.first); f.erase(it, it); ASSERT_EQ(f2, f); } } TEST(flat_map, get_allocator) { // Not a very interesting test, but it should pass valgrind leak tests, // etc. Just testing the default allocator for now. flat_map f; const u32 num = 10; pair *data = f.get_allocator().allocate(num); for (u32 i = 0; i < num; i++) { data[i] = make_pair(i, num - i); } for (u32 i = 0; i < num; i++) { ASSERT_EQ(make_pair(i, num - i), data[i]); } f.get_allocator().deallocate(data, num); } TEST(flat_map, compare_ops) { flat_map f1 = {{0, 1}, {1, 2}, {2, 3}, {3, 4}, {4, 5}, {5, 6}}; flat_map f1_copy = f1; flat_map f2 = {{2, 1}, {4, 2}, {6, 3}, {8, 4}, {10, 5}, {12, 6}}; EXPECT_TRUE(f1 == f1); EXPECT_TRUE(f1 == f1_copy); EXPECT_FALSE(f1 == f2); EXPECT_FALSE(f1 != f1); EXPECT_FALSE(f1 != f1_copy); EXPECT_TRUE(f1 != f2); EXPECT_FALSE(f1 < f1); EXPECT_FALSE(f1 < f1_copy); EXPECT_TRUE(f1 < f2); EXPECT_TRUE(f1 <= f1); EXPECT_TRUE(f1 <= f1_copy); EXPECT_TRUE(f1 <= f2); EXPECT_FALSE(f1 > f1); EXPECT_FALSE(f1 > f1_copy); EXPECT_FALSE(f1 > f2); EXPECT_TRUE(f1 >= f1); EXPECT_TRUE(f1 >= f1_copy); EXPECT_FALSE(f1 >= f2); } TEST(flat_map, max_size) { flat_map f; ASSERT_LE(1ULL << 24, f.max_size()); } hyperscan-4.4.1/unit/internal/depth.cpp0000644000175000017500000002262613055426554020712 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "util/depth.h" #include "util/ue2_containers.h" #include "gtest/gtest.h" using namespace ue2; static UNUSED std::ostream& operator<<(std::ostream &os, const depth &d) { // We reimplement depth::str, as it's only available if dump support is // compiled in. if (d.is_unreachable()) { os << "unr"; return os; } else if (d.is_infinite()) { os << "inf"; return os; } u32 val = d; // finite val os << val; return os; } static constexpr u32 finite_values[] = { 0, 1, 2, 3, 4, 5, 6, 32, 1000, 1u << 20, depth::max_value()}; TEST(depth, ctor) { ASSERT_EQ(depth::unreachable(), depth()); // default ctor // also tests u32 conversion for (const auto &val : finite_values) { ASSERT_EQ(val, depth(val)); } ASSERT_THROW(depth(depth::max_value() + 1), DepthOverflowError); } TEST(depth, convert_throw) { ASSERT_THROW(u32 v = depth::infinity(), DepthOverflowError); ASSERT_THROW(u32 v = depth::unreachable(), DepthOverflowError); } TEST(depth, is_finite) { for (const auto &val : finite_values) { ASSERT_TRUE(depth(val).is_finite()); } ASSERT_FALSE(depth::infinity().is_finite()); ASSERT_FALSE(depth::unreachable().is_finite()); } TEST(depth, is_infinite) { for (const auto &val : finite_values) { ASSERT_FALSE(depth(val).is_infinite()); } ASSERT_TRUE(depth::infinity().is_infinite()); ASSERT_FALSE(depth::unreachable().is_infinite()); } TEST(depth, is_unreachable) { for (const auto &val : finite_values) { ASSERT_FALSE(depth(val).is_unreachable()); } ASSERT_FALSE(depth::infinity().is_unreachable()); ASSERT_TRUE(depth::unreachable().is_unreachable()); } TEST(depth, is_reachable) { for (const auto &val : finite_values) { ASSERT_TRUE(depth(val).is_reachable()); } ASSERT_TRUE(depth::infinity().is_reachable()); ASSERT_FALSE(depth::unreachable().is_reachable()); } TEST(depth, add_finite) { ASSERT_EQ(depth(1), depth(0) + depth(1)); ASSERT_EQ(depth(1), depth(1) + depth(0)); ASSERT_EQ(depth(1), depth(0) + 1); ASSERT_EQ(depth(1), depth(1) + 0); ASSERT_EQ(depth(2000), depth(1000) + depth(1000)); ASSERT_EQ(depth(2000), depth(1000) + 1000); ASSERT_EQ(depth(900), depth(1000) + s32{-100}); // overflow must throw depth d; ASSERT_THROW(d = depth::max_value() + depth(1), DepthOverflowError); ASSERT_THROW(d = depth::max_value() + 1, DepthOverflowError); // underflow must throw ASSERT_THROW(d = depth(0) + s32{-1}, DepthOverflowError); } TEST(depth, add_inf) { // adding anything finite to inf should produce inf for (const auto &val : finite_values) { ASSERT_EQ(depth::infinity(), depth::infinity() + depth(val)); ASSERT_EQ(depth::infinity(), depth(val) + depth::infinity()); } ASSERT_EQ(depth::infinity(), depth::infinity() + depth::infinity()); } TEST(depth, add_unr) { // adding anything to unr should produce unr for (const auto &val : finite_values) { ASSERT_EQ(depth::unreachable(), depth::unreachable() + depth(val)); ASSERT_EQ(depth::unreachable(), depth(val) + depth::unreachable()); } ASSERT_EQ(depth::unreachable(), depth::unreachable() + depth::infinity()); ASSERT_EQ(depth::unreachable(), depth::unreachable() + depth::unreachable()); } TEST(depth, sub_finite) { ASSERT_EQ(depth(1), depth(1) - depth(0)); ASSERT_EQ(depth(0), depth(1) - depth(1)); ASSERT_EQ(depth(0), depth(1000) - depth(1000)); // underflow should throw ASSERT_THROW(depth(0) - depth(1), DepthOverflowError); } TEST(depth, sub_inf) { // subtracting anything from inf should produce inf for (const auto &val : finite_values) { ASSERT_EQ(depth::infinity(), depth::infinity() - depth(val)); } // subtracting non-finite values must throw ASSERT_THROW(depth::infinity() - depth::infinity(), DepthOverflowError); ASSERT_THROW(depth::infinity() - depth::unreachable(), DepthOverflowError); } TEST(depth, sub_unr) { // subtracting anything from unr should produce unr for (const auto &val : finite_values) { ASSERT_EQ(depth::unreachable(), depth::unreachable() - depth(val)); } // subtracting non-finite values must throw ASSERT_THROW(depth::unreachable() - depth::infinity(), DepthOverflowError); ASSERT_THROW(depth::unreachable() - depth::unreachable(), DepthOverflowError); } TEST(depth, operators) { for (const auto &val : finite_values) { depth d(val); ASSERT_TRUE(d == d); ASSERT_FALSE(d != d); ASSERT_FALSE(d < d); ASSERT_FALSE(d > d); ASSERT_TRUE(d <= d); ASSERT_TRUE(d >= d); if (val < depth::max_value()) { depth d1(val + 1); ASSERT_FALSE(d == d1); ASSERT_TRUE(d != d1); ASSERT_TRUE(d < d1); ASSERT_FALSE(d > d1); ASSERT_TRUE(d <= d1); ASSERT_FALSE(d >= d1); } ASSERT_TRUE(d < depth::infinity()); ASSERT_TRUE(d < depth::unreachable()); ASSERT_TRUE(d <= depth::infinity()); ASSERT_TRUE(d <= depth::unreachable()); ASSERT_TRUE(d <= depth(depth::max_value())); ASSERT_TRUE(depth::infinity() > d); ASSERT_TRUE(depth::unreachable() > d); ASSERT_TRUE(depth::infinity() >= d); ASSERT_TRUE(depth::unreachable() >= d); ASSERT_TRUE(depth(depth::max_value()) >= d); ASSERT_TRUE(d != depth::infinity()); ASSERT_TRUE(d != depth::unreachable()); } ASSERT_TRUE(depth::infinity() <= depth::infinity()); ASSERT_TRUE(depth::infinity() >= depth::infinity()); ASSERT_FALSE(depth::infinity() < depth::infinity()); ASSERT_FALSE(depth::infinity() > depth::infinity()); ASSERT_TRUE(depth::infinity() == depth::infinity()); ASSERT_FALSE(depth::infinity() != depth::infinity()); ASSERT_TRUE(depth::unreachable() <= depth::unreachable()); ASSERT_TRUE(depth::unreachable() >= depth::unreachable()); ASSERT_FALSE(depth::unreachable() < depth::unreachable()); ASSERT_FALSE(depth::unreachable() > depth::unreachable()); ASSERT_TRUE(depth::unreachable() == depth::unreachable()); ASSERT_FALSE(depth::unreachable() != depth::unreachable()); } TEST(depth, u64a_operators) { for (const auto &fval : finite_values) { u64a val = fval; depth d(fval); // trivial tests against own value ASSERT_TRUE(d == val); ASSERT_FALSE(d != val); ASSERT_FALSE(d < val); ASSERT_FALSE(d > val); ASSERT_TRUE(d <= val); ASSERT_TRUE(d >= val); // tests against val + 1 ASSERT_FALSE(d == val + 1); ASSERT_TRUE(d != val + 1); ASSERT_TRUE(d < val + 1); ASSERT_FALSE(d > val + 1); ASSERT_TRUE(d <= val + 1); ASSERT_FALSE(d >= val + 1); // test inf against val ASSERT_FALSE(depth::infinity() == val); ASSERT_TRUE(depth::infinity() != val); ASSERT_FALSE(depth::infinity() < val); ASSERT_TRUE(depth::infinity() > val); ASSERT_FALSE(depth::infinity() <= val); ASSERT_TRUE(depth::infinity() >= val); // test unreachable against val ASSERT_FALSE(depth::unreachable() == val); ASSERT_TRUE(depth::unreachable() != val); ASSERT_FALSE(depth::unreachable() < val); ASSERT_TRUE(depth::unreachable() > val); ASSERT_FALSE(depth::unreachable() <= val); ASSERT_TRUE(depth::unreachable() >= val); } } TEST(depth, unordered_set) { ue2::unordered_set depths; for (const auto &val : finite_values) { depths.insert(val); } for (const auto &val : finite_values) { ASSERT_TRUE(depths.find(val) != depths.end()); } ASSERT_TRUE(depths.find(depth::infinity()) == depths.end()); ASSERT_TRUE(depths.find(depth::unreachable()) == depths.end()); ASSERT_TRUE(depths.find(depth(1337)) == depths.end()); } hyperscan-4.4.1/unit/internal/state_compress.cpp0000644000175000017500000002727013055426554022641 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/state_compress.h" #include #include using namespace std; TEST(state_compress, u32) { char buf[sizeof(u32)] = { 0 }; vector > tests = { make_tuple(0U, 0x1U, 1), make_tuple(1U, 0x1U, 1), make_tuple(0x80008000, 0x80808080, 1), make_tuple(0x9f008000, 0x80808080, 1), make_tuple(0x9fab8dfe, 0xff0fff71, 3), make_tuple(0x9fab8dfe, 0xffefff71, 4), make_tuple(0xf0f0f0f0, 0x0f0f0f0f, 4), }; for (const auto &e : tests) { u32 val; u32 mask; int len; tie(val, mask, len) = e; storecompressed32(&buf, &val, &mask, len); u32 val_out; loadcompressed32(&val_out, &buf, &mask, len); EXPECT_EQ(val & mask, val_out); } } TEST(state_compress, u64a) { char buf[sizeof(u64a)] = { 0 }; vector > tests = { make_tuple(0ULL, 0x1ULL, 1), make_tuple(1ULL, 0x1ULL, 1), make_tuple(0x80008000ULL, 0x80808080ULL, 1), make_tuple(0x9f008000ULL, 0x80808080ULL, 1), make_tuple(0x9fab8dfeULL, 0xff0fff71ULL, 3), make_tuple(0x9fab8dfeULL, 0xffefff71ULL, 4), make_tuple(0xf0f0f0f0ULL, 0x0f0f0f0fULL, 4), make_tuple(0x0123456789abcdefULL, 0x0123456789abcdefULL, 5), make_tuple(0x0123456789abcdefULL, 0xfedcba9876543210ULL, 6), make_tuple(0x0123456789abcdefULL, 0x0123456789abcdefULL, 7), make_tuple(0x0123456789abcdefULL, 0xffffffffffffffffULL, 8), }; for (const auto &e : tests) { u64a val; u64a mask; int len; tie(val, mask, len) = e; storecompressed64(&buf, &val, &mask, len); u64a val_out; loadcompressed64(&val_out, &buf, &mask, len); EXPECT_EQ(val & mask, val_out); } } TEST(state_compress, m128_1) { char buf[sizeof(m128)] = { 0 }; for (u32 i = 0; i < 16; i++) { char mask_raw[16] = { 0 }; char val_raw[16] = { 0 }; memset(val_raw, (i << 4) + 3, 16); mask_raw[i] = 0xff; val_raw[i] = i; mask_raw[15 - i] = 0xff; val_raw[15 - i] = i; m128 val; m128 mask; memcpy(&val, val_raw, sizeof(val)); memcpy(&mask, mask_raw, sizeof(mask)); storecompressed128(&buf, &val, &mask, 0); m128 val_out; loadcompressed128(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff128(and128(val, mask), val_out)); mask_raw[i] = 0x0f; mask_raw[15 - i] = 0x0f; memcpy(&mask, mask_raw, sizeof(mask)); val_raw[i] = 9; storecompressed128(&buf, &val, &mask, 0); loadcompressed128(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff128(and128(val, mask), val_out)); } } TEST(state_compress, m128_2) { char buf[sizeof(m128)] = { 0 }; char val_raw[16] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' }; m128 val; memcpy(&val, val_raw, sizeof(val)); for (u32 i = 0; i < 16; i++) { char mask_raw[16]; memset(mask_raw, 0x7f, sizeof(mask_raw)); mask_raw[i] = 0; m128 mask; memcpy(&mask, mask_raw, sizeof(mask)); storecompressed128(&buf, &val, &mask, 0); m128 val_out; loadcompressed128(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff128(and128(val, mask), val_out)); for (u32 j = i + 1; j < 16; j++) { mask_raw[j] = 0; memcpy(&mask, mask_raw, sizeof(mask)); storecompressed128(&buf, &val, &mask, 0); loadcompressed128(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff128(and128(val, mask), val_out)); mask_raw[j] = 0x7f; } } } TEST(state_compress, m256_1) { char buf[sizeof(m256)] = { 0 }; for (u32 i = 0; i < 32; i++) { char mask_raw[32] = { 0 }; char val_raw[32] = { 0 }; memset(val_raw, (i << 3) + 3, 32); mask_raw[i] = 0xff; val_raw[i] = i; mask_raw[31 - i] = 0xff; val_raw[31 - i] = i; m256 val; m256 mask; memcpy(&val, val_raw, sizeof(val)); memcpy(&mask, mask_raw, sizeof(mask)); storecompressed256(&buf, &val, &mask, 0); m256 val_out; loadcompressed256(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff256(and256(val, mask), val_out)); mask_raw[i] = 0x7; mask_raw[31 - i] = 0x1f; memcpy(&mask, mask_raw, sizeof(mask)); val_raw[i] = 5; storecompressed256(&buf, &val, &mask, 0); loadcompressed256(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff256(and256(val, mask), val_out)); } } TEST(state_compress, m256_2) { char buf[sizeof(m256)] = { 0 }; char val_raw[32] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P' }; m256 val; memcpy(&val, val_raw, sizeof(val)); for (u32 i = 0; i < 32; i++) { char mask_raw[32]; memset(mask_raw, 0x7f, sizeof(mask_raw)); mask_raw[i] = 0; m256 mask; memcpy(&mask, mask_raw, sizeof(mask)); storecompressed256(&buf, &val, &mask, 0); m256 val_out; loadcompressed256(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff256(and256(val, mask), val_out)); for (u32 j = i + 1; j < 32; j++) { mask_raw[j] = 0; memcpy(&mask, mask_raw, sizeof(mask)); storecompressed256(&buf, &val, &mask, 0); loadcompressed256(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff256(and256(val, mask), val_out)); mask_raw[j] = 0x7f; } } } TEST(state_compress, m384_1) { char buf[sizeof(m384)] = { 0 }; for (u32 i = 0; i < 48; i++) { char mask_raw[48] = { 0 }; char val_raw[48] = { 0 }; memset(val_raw, (i << 2) + 3, 48); mask_raw[i] = 0xff; val_raw[i] = i; mask_raw[47 - i] = 0xff; val_raw[47 - i] = i; m384 val; m384 mask; memcpy(&val, val_raw, sizeof(val)); memcpy(&mask, mask_raw, sizeof(mask)); storecompressed384(&buf, &val, &mask, 0); m384 val_out; loadcompressed384(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff384(and384(val, mask), val_out)); mask_raw[i] = 0x3; mask_raw[47 - i] = 0x2f; memcpy(&mask, mask_raw, sizeof(mask)); val_raw[i] = 3; storecompressed384(&buf, &val, &mask, 0); loadcompressed384(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff384(and384(val, mask), val_out)); } } TEST(state_compress, m384_2) { char buf[sizeof(m384)] = { 0 }; char val_raw[48] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Q', 'R', ' ', '-', ',', '"', ';', ':' }; m384 val; memcpy(&val, val_raw, sizeof(val)); for (u32 i = 0; i < 48; i++) { char mask_raw[48]; memset(mask_raw, 0x7f, sizeof(mask_raw)); mask_raw[i] = 0; m384 mask; memcpy(&mask, mask_raw, sizeof(mask)); storecompressed384(&buf, &val, &mask, 0); m384 val_out; loadcompressed384(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff384(and384(val, mask), val_out)); for (u32 j = i + 1; j < 48; j++) { mask_raw[j] = 0; memcpy(&mask, mask_raw, sizeof(mask)); storecompressed384(&buf, &val, &mask, 0); loadcompressed384(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff384(and384(val, mask), val_out)); mask_raw[j] = 0x7f; } } } TEST(state_compress, m512_1) { char buf[sizeof(m512)] = { 0 }; for (u32 i = 0; i < 64; i++) { char mask_raw[64] = { 0 }; char val_raw[64] = { 0 }; memset(val_raw, (i << 2) + 3, 64); mask_raw[i] = 0xff; val_raw[i] = i; mask_raw[63 - i] = 0xff; val_raw[63 - i] = i; m512 val; m512 mask; memcpy(&val, val_raw, sizeof(val)); memcpy(&mask, mask_raw, sizeof(mask)); storecompressed512(&buf, &val, &mask, 0); m512 val_out; loadcompressed512(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff512(and512(val, mask), val_out)); mask_raw[i] = 0x3; mask_raw[63 - i] = 0x2f; memcpy(&mask, mask_raw, sizeof(mask)); val_raw[i] = 3; storecompressed512(&buf, &val, &mask, 0); loadcompressed512(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff512(and512(val, mask), val_out)); } } TEST(state_compress, m512_2) { char buf[sizeof(m512)] = { 0 }; char val_raw[64] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'Q', 'R', ' ', '-', ',', '"', ';', ':', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n' }; m512 val; memcpy(&val, val_raw, sizeof(val)); for (u32 i = 0; i < 64; i++) { char mask_raw[64]; memset(mask_raw, 0x7f, sizeof(mask_raw)); mask_raw[i] = 0; m512 mask; memcpy(&mask, mask_raw, sizeof(mask)); storecompressed512(&buf, &val, &mask, 0); m512 val_out; loadcompressed512(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff512(and512(val, mask), val_out)); for (u32 j = i + 1; j < 64; j++) { mask_raw[j] = 0; memcpy(&mask, mask_raw, sizeof(mask)); storecompressed512(&buf, &val, &mask, 0); loadcompressed512(&val_out, &buf, &mask, 0); EXPECT_TRUE(!diff512(and512(val, mask), val_out)); mask_raw[j] = 0x7f; } } } hyperscan-4.4.1/unit/internal/pqueue.cpp0000644000175000017500000001752213055426554021111 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "ue2common.h" #define PQ_T u32 #define PQ_COMP(pqc_items, pqc_i, pqc_j) (pqc_items[pqc_i] > pqc_items[pqc_j]) #define PQ_COMP_B(pqc_items, pqc_i, pqc_jj) (pqc_items[pqc_i] > pqc_jj) #include "util/pqueue.h" static void sort(u32 *items, u32 count) { for (u32 i = 0; i < count; i++) { pq_insert(items, i, items[i]); } for (u32 i = 0; i < count; i++) { u32 top = *pq_top(items); pq_pop(items, count - i); items[count - i - 1] = top; } } TEST(pqueue, sort1) { u32 in[] = {1, 2, 3, 4}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort2) { u32 in[] = {1, 2, 4, 3}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort3) { u32 in[] = {1, 3, 2, 4}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort4) { u32 in[] = {1, 3, 4, 2}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort5) { u32 in[] = {1, 4, 2, 3}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort6) { u32 in[] = {1, 4, 3, 2}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort7) { u32 in[] = {2, 1, 3, 4}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort8) { u32 in[] = {2, 1, 4, 3}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort9) { u32 in[] = {2, 3, 1, 4}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort10) { u32 in[] = {2, 3, 4, 1}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort11) { u32 in[] = {2, 4, 1, 3}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort12) { u32 in[] = {2, 4, 3, 1}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort13) { u32 in[] = {3, 1, 2, 4}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort14) { u32 in[] = {3, 1, 4, 2}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort15) { u32 in[] = {3, 2, 1, 4}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort16) { u32 in[] = {3, 2, 4, 1}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort17) { u32 in[] = {3, 4, 1, 2}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort18) { u32 in[] = {3, 4, 2, 1}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort19) { u32 in[] = {4, 1, 2, 3}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort20) { u32 in[] = {4, 1, 3, 2}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort21) { u32 in[] = {4, 2, 1, 3}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort22) { u32 in[] = {4, 2, 3, 1}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort23) { u32 in[] = {4, 3, 1, 2}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, sort24) { u32 in[] = {4, 3, 2, 1}; u32 out[] = {1, 2, 3, 4}; sort(in, ARRAY_LENGTH(in)); ASSERT_EQ(0, memcmp(in, out, sizeof(in))); } TEST(pqueue, queue1) { u32 in[] = {1, 2, 3, 4, 5, 6, 7, 8}; u32 expected[] = {4, 5, 6, 7, 8, 3, 2, 1}; u32 temp[ARRAY_LENGTH(in)]; u32 output[ARRAY_LENGTH(in)]; u32 queue_size = 0; u32 i = 0, o = 0; for (; i < 4; i++) { pq_insert(temp, queue_size, in[i]); queue_size++; } while (queue_size) { output[o++] = *pq_top(temp); pq_pop(temp, queue_size); queue_size--; if (i < ARRAY_LENGTH(in)) { pq_insert(temp, queue_size, in[i++]); queue_size++; } } // for (u32 j = 0; j < o; j++) { // printf("%u\n", output[j]); // } ASSERT_EQ(0, memcmp(output, expected, sizeof(in))); } TEST(pqueue, queue2) { u32 in[] = {8, 7, 6, 5, 4, 3, 2, 1}; u32 expected[] = {8, 7, 6, 5, 4, 3, 2, 1}; u32 temp[ARRAY_LENGTH(in)]; u32 output[ARRAY_LENGTH(in)]; u32 queue_size = 0; u32 i = 0, o = 0; for (; i < 4; i++) { pq_insert(temp, queue_size, in[i]); queue_size++; } while (queue_size) { output[o++] = *pq_top(temp); pq_pop(temp, queue_size); queue_size--; if (i < ARRAY_LENGTH(in)) { pq_insert(temp, queue_size, in[i++]); queue_size++; } } ASSERT_EQ(0, memcmp(output, expected, sizeof(in))); } TEST(pqueue, queue3) { u32 in[] = {1, 8, 2, 7, 3, 6, 4, 5}; u32 expected[] = {8, 7, 6, 4, 5, 3, 2, 1}; u32 temp[ARRAY_LENGTH(in)]; u32 output[ARRAY_LENGTH(in)]; u32 queue_size = 0; u32 i = 0, o = 0; for (; i < 4; i++) { pq_insert(temp, queue_size, in[i]); queue_size++; } while (queue_size) { output[o++] = *pq_top(temp); pq_pop(temp, queue_size); queue_size--; if (i < ARRAY_LENGTH(in)) { pq_insert(temp, queue_size, in[i++]); queue_size++; } } ASSERT_EQ(0, memcmp(output, expected, sizeof(in))); } hyperscan-4.4.1/unit/internal/multiaccel_shift.cpp0000644000175000017500000000506013055426554023116 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "src/ue2common.h" #include "gtest/gtest.h" #include "nfa/multiaccel_common.h" /* * Unit tests for the shifters. * * This is a bit messy, as shifters are macros, so we're using macros to test * other macros. */ #define TEST_SHIFT(n) \ do { \ u64a val = ((u64a) 1 << n) - 1; \ JOIN(SHIFT, n)(val); \ ASSERT_EQ(val, 1); \ } while (0) TEST(MultiaccelShift, StaticShift) { TEST_SHIFT(1); TEST_SHIFT(2); TEST_SHIFT(3); TEST_SHIFT(4); TEST_SHIFT(5); TEST_SHIFT(6); TEST_SHIFT(7); TEST_SHIFT(8); TEST_SHIFT(10); TEST_SHIFT(11); TEST_SHIFT(12); TEST_SHIFT(13); TEST_SHIFT(14); TEST_SHIFT(15); TEST_SHIFT(16); TEST_SHIFT(17); TEST_SHIFT(18); TEST_SHIFT(19); TEST_SHIFT(20); TEST_SHIFT(21); TEST_SHIFT(22); TEST_SHIFT(23); TEST_SHIFT(24); TEST_SHIFT(25); TEST_SHIFT(26); TEST_SHIFT(27); TEST_SHIFT(28); TEST_SHIFT(29); TEST_SHIFT(30); TEST_SHIFT(31); TEST_SHIFT(32); } hyperscan-4.4.1/unit/internal/unaligned.cpp0000644000175000017500000000651113055426554021547 0ustar sleuthkidsleuthkid/* * 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. */ #include "config.h" #include "gtest/gtest.h" #include "util/unaligned.h" TEST(Unaligned, StoreLoad16) { char data[3]; memset(data, 0, sizeof(data)); char *ptr = &data[1]; unaligned_store_u16(ptr, (u16)~0u); ASSERT_EQ((u16)~0u, unaligned_load_u16(ptr)); unaligned_store_u16(ptr, 0u); ASSERT_EQ(0u, unaligned_load_u16(ptr)); unaligned_store_u16(ptr, (u16)0xf0f0u); ASSERT_EQ(0xf0f0u, unaligned_load_u16(ptr)); for (u32 i = 0; i < 16; i++) { const u16 val = 0x1u << i; memset(data, 0xff, sizeof(data)); unaligned_store_u16(ptr, val); ASSERT_EQ(val, unaligned_load_u16(ptr)); } } TEST(Unaligned, StoreLoad32) { char data[5]; memset(data, 0, sizeof(data)); char *ptr = &data[1]; unaligned_store_u32(ptr, ~0u); ASSERT_EQ(~0u, unaligned_load_u32(ptr)); unaligned_store_u32(ptr, 0u); ASSERT_EQ(0u, unaligned_load_u32(ptr)); unaligned_store_u32(ptr, 0xf0f0f0f0u); ASSERT_EQ(0xf0f0f0f0u, unaligned_load_u32(ptr)); for (u32 i = 0; i < 32; i++) { const u32 val = 0x1u << i; memset(data, 0xff, sizeof(data)); unaligned_store_u32(ptr, val); ASSERT_EQ(val, unaligned_load_u32(ptr)); } } TEST(Unaligned, StoreLoad64) { char data[9]; memset(data, 0, sizeof(data)); char *ptr = &data[1]; unaligned_store_u64a(ptr, ~0ull); ASSERT_EQ(~0ull, unaligned_load_u64a(ptr)); unaligned_store_u64a(ptr, 0ull); ASSERT_EQ(0ull, unaligned_load_u64a(ptr)); unaligned_store_u64a(ptr, 0xf0f0f0f0f0f0f0f0ull); ASSERT_EQ(0xf0f0f0f0f0f0f0f0ull, unaligned_load_u64a(ptr)); for (u32 i = 0; i < 64; i++) { const u64a val = 0x1ull << i; memset(data, 0xff, sizeof(data)); unaligned_store_u64a(ptr, val); ASSERT_EQ(val, unaligned_load_u64a(ptr)); } } hyperscan-4.4.1/.clang-format0000644000175000017500000000021413055426554016647 0ustar sleuthkidsleuthkidBasedOnStyle: LLVM IndentWidth: 4 UseTab: false AllowShortIfStatementsOnASingleLine: false IndentCaseLabels: false AccessModifierOffset: -4 hyperscan-4.4.1/doc/0000755000175000017500000000000013055426554015044 5ustar sleuthkidsleuthkidhyperscan-4.4.1/doc/dev-reference/0000755000175000017500000000000013055426554017556 5ustar sleuthkidsleuthkidhyperscan-4.4.1/doc/dev-reference/api_files.rst0000644000175000017500000000061713055426554022247 0ustar sleuthkidsleuthkid.. _api_files: #################### API Reference: Files #################### ********** File: hs.h ********** .. doxygenfile:: hs.h ***************** File: hs_common.h ***************** .. doxygenfile:: hs_common.h ****************** File: hs_compile.h ****************** .. doxygenfile:: hs_compile.h ****************** File: hs_runtime.h ****************** .. doxygenfile:: hs_runtime.h hyperscan-4.4.1/doc/dev-reference/_static/0000755000175000017500000000000013055426554021204 5ustar sleuthkidsleuthkidhyperscan-4.4.1/doc/dev-reference/_static/hyperscan.css0000644000175000017500000000014113055426554023706 0ustar sleuthkidsleuthkid/* Differentiate the way we display regex fragments. */ .regexp { color: darkred !important; } hyperscan-4.4.1/doc/dev-reference/intro.rst0000644000175000017500000000612113055426554021443 0ustar sleuthkidsleuthkid.. include:: .. _intro: ############ Introduction ############ Hyperscan is a software regular expression matching engine designed with high performance and flexibility in mind. It is implemented as a library that exposes a straightforward C API. The Hyperscan API itself is composed of two major components: *********** Compilation *********** These functions take a group of regular expressions, along with identifiers and option flags, and compile them into an immutable database that can be used by the Hyperscan scanning API. This compilation process performs considerable analysis and optimization work in order to build a database that will match the given expressions efficiently. If a pattern cannot be built into a database for any reason (such as the use of an unsupported expression construct, or the overflowing of a resource limit), an error will be returned by the pattern compiler. Compiled databases can be serialized and relocated, so that they can be stored to disk or moved between hosts. They can also be targeted to particular platform features (for example, the use of Intel\ |reg| Advanced Vector Extensions 2 (Intel\ |reg| AVX2) instructions). See :ref:`compilation` for more detail. ******** Scanning ******** Once a Hyperscan database has been created, it can be used to scan data in memory. Hyperscan provides several scanning modes, depending on whether the data to be scanned is available as a single contiguous block, whether it is distributed amongst several blocks in memory at the same time, or whether it is to be scanned as a sequence of blocks in a stream. Matches are delivered to the application via a user-supplied callback function that is called synchronously for each match. For a given database, Hyperscan provides several guarantees: * No memory allocations occur at runtime with the exception of two fixed-size allocations, both of which should be done ahead of time for performance-critical applications: - **Scratch space**: temporary memory used for internal data at scan time. Structures in scratch space do not persist beyond the end of a single scan call. - **Stream state**: in streaming mode only, some state space is required to store data that persists between scan calls for each stream. This allows Hyperscan to track matches that span multiple blocks of data. * The sizes of the scratch space and stream state (in streaming mode) required for a given database are fixed and determined at database compile time. This means that the memory requirements of the application are known ahead of time, and these structures can be pre-allocated if required for performance reasons. * Any pattern that has successfully been compiled by the Hyperscan compiler can be scanned against any input. There are no internal resource limits or other limitations at runtime that could cause a scan call to return an error. See :ref:`runtime` for more detail. ************ Example Code ************ Some simple example code demonstrating the use of the Hyperscan API is available in the ``examples/`` subdirectory of the Hyperscan distribution. hyperscan-4.4.1/doc/dev-reference/copyright.rst0000644000175000017500000000253013055426554022320 0ustar sleuthkidsleuthkid.. include:: ######### Copyright ######### No license (express or implied, by estoppel or otherwise) to any intellectual property rights is granted by this document. Intel disclaims all express and implied warranties, including without limitation, the implied warranties of merchantability, fitness for a particular purpose, and non-infringement, as well as any warranty arising from course of performance, course of dealing, or usage in trade. This document contains information on products, services and/or processes in development. All information provided here is subject to change without notice. Contact your Intel representative to obtain the latest forecast, schedule, specifications and roadmaps. The products and services described may contain defects or errors known as errata which may cause deviations from published specifications. Current characterized errata are available on request. Copies of documents which have an order number and are referenced in this document, or other Intel literature, may be obtained by calling 1-800-548-4725, or go to: . Intel, and the Intel logo, are trademarks of Intel Corporation in the U.S. and/or other countries. \*Other names and brands may be claimed as the property of others. Copyright |copy| 2015-2016, Intel Corporation. All rights reserved. hyperscan-4.4.1/doc/dev-reference/CMakeLists.txt0000644000175000017500000000227213055426554022321 0ustar sleuthkidsleuthkidfind_program(DOXYGEN doxygen) if (DOXYGEN STREQUAL DOXYGEN-NOTFOUND) message(STATUS "Doxygen not found, unable to generate API reference") else() configure_file("${CMAKE_CURRENT_SOURCE_DIR}/hyperscan.doxyfile.in" "${CMAKE_CURRENT_BINARY_DIR}/hyperscan.doxyfile" @ONLY) add_custom_target(dev-reference-doxygen ${DOXYGEN} ${CMAKE_CURRENT_BINARY_DIR}/hyperscan.doxyfile COMMENT "Building doxygen XML for API reference") endif() find_program(SPHINX_BUILD sphinx-build) if (SPHINX_BUILD STREQUAL SPHINX_BUILD-NOTFOUND) message(STATUS "Sphinx not found, unable to generate developer reference") else() set(SPHINX_BUILD_DIR "${CMAKE_CURRENT_BINARY_DIR}/_build") set(SPHINX_CACHE_DIR "${CMAKE_CURRENT_BINARY_DIR}/_doctrees") set(SPHINX_HTML_DIR "${CMAKE_CURRENT_BINARY_DIR}/html") configure_file("${CMAKE_CURRENT_SOURCE_DIR}/conf.py.in" "${CMAKE_CURRENT_BINARY_DIR}/conf.py" @ONLY) add_custom_target(dev-reference ${SPHINX_BUILD} -b html -c "${CMAKE_CURRENT_BINARY_DIR}" -d "${SPHINX_CACHE_DIR}" "${CMAKE_CURRENT_SOURCE_DIR}" "${SPHINX_HTML_DIR}" DEPENDS dev-reference-doxygen COMMENT "Building HTML dev reference with Sphinx") endif() hyperscan-4.4.1/doc/dev-reference/compilation.rst0000644000175000017500000004075713055426554022643 0ustar sleuthkidsleuthkid.. include:: .. _compilation: ################## Compiling Patterns ################## ******************* Building a Database ******************* The Hyperscan compiler API accepts regular expressions and converts them into a compiled pattern database that can then be used to scan data. The API provides three functions that compile regular expressions into databases: #. :c:func:`hs_compile`: compiles a single expression into a pattern database. #. :c:func:`hs_compile_multi`: compiles an array of expressions into a pattern database. All of the supplied patterns will be scanned for concurrently at scan time, with user-supplied identifiers returned when they match. #. :c:func:`hs_compile_ext_multi`: compiles an array of expressions as above, but allows :ref:`extparam` to be specified for each expression. Compilation allows the Hyperscan library to analyze the given pattern(s) and pre-determine how to scan for these patterns in an optimized fashion that would be far too expensive to compute at run-time. When compiling expressions, a decision needs to be made whether the resulting compiled patterns are to be used in a streaming, block or vectored mode: - **Streaming mode**: the target data to be scanned is a continuous stream, not all of which is available at once; blocks of data are scanned in sequence and matches may span multiple blocks in a stream. In streaming mode, each stream requires a block of memory to store its state between scan calls. - **Block mode**: the target data is a discrete, contiguous block which can be scanned in one call and does not require state to be retained. - **Vectored mode**: the target data consists of a list of non-contiguous blocks that are available all at once. As for block mode, no retention of state is required. To compile patterns to be used in streaming mode, the ``mode`` parameter of :c:func:`hs_compile` must be set to :c:member:`HS_MODE_STREAM`; similarly, block mode requires the use of :c:member:`HS_MODE_BLOCK` and vectored mode requires the use of :c:member:`HS_MODE_VECTORED`. A pattern database compiled for one mode (streaming, block or vectored) can only be used in that mode. The version of Hyperscan used to produce a compiled pattern database must match the version of Hyperscan used to scan with it. Hyperscan provides support for targeting a database at a particular CPU platform; see :ref:`instr_specialization` for details. *************** Pattern Support *************** Hyperscan supports the pattern syntax used by the PCRE library ("libpcre"), described at . However, not all constructs available in libpcre are supported. The use of unsupported constructs will result in compilation errors. The version of PCRE used to validate Hyperscan's interpretation of this syntax is 8.38. ==================== Supported Constructs ==================== The following regex constructs are supported by Hyperscan: * Literal characters and strings, with all libpcre quoting and character escapes. * Character classes such as :regexp:`.` (dot), :regexp:`[abc]`, and :regexp:`[^abc]`, as well as the predefined character classes :regexp:`\\s`, :regexp:`\\d`, :regexp:`\\w`, :regexp:`\\v`, and :regexp:`\\h` and their negated counterparts (:regexp:`\\S`, :regexp:`\\D`, :regexp:`\\W`, :regexp:`\\V`, and :regexp:`\\H`). * The POSIX named character classes :regexp:`[[:xxx:]]` and negated named character classes :regexp:`[[:^xxx:]]`. * Unicode character properties, such as :regexp:`\\p{L}`, :regexp:`\\P{Sc}`, :regexp:`\\p{Greek}`. * Quantifiers: * Quantifiers such as :regexp:`?`, :regexp:`*` and :regexp:`+` are supported when applied to arbitrary supported sub-expressions. * Bounded repeat qualifiers such as :regexp:`{n}`, :regexp:`{m,n}`, :regexp:`{n,}` are supported with limitations. * For arbitrary repeated sub-patterns: *n* and *m* should be either small or infinite, e.g. :regexp:`(a|b}{4}`, :regexp:`(ab?c?d){4,10}` or :regexp:`(ab(cd)*){6,}`. * For single-character width sub-patterns such as :regexp:`[^\\a]` or :regexp:`.` or :regexp:`x`, nearly all repeat counts are supported, except where repeats are extremely large (maximum bound greater than 32767). Stream states may be very large for large bounded repeats, e.g. :regexp:`a.{2000}b`. Note: such sub-patterns may be considerably cheaper if at the beginning or end of patterns and especially if the :c:member:`HS_FLAG_SINGLEMATCH` flag is on for that pattern. * Lazy modifiers (:regexp:`?` appended to another quantifier, e.g. :regexp:`\\w+?`) are supported but ignored (as Hyperscan reports all matches). * Parenthesization, including the named and unnamed capturing and non-capturing forms. However, capturing is ignored. * Alternation with the :regexp:`|` symbol, as in :regexp:`foo|bar`. * The anchors :regexp:`^`, :regexp:`$`, :regexp:`\\A`, :regexp:`\\Z` and :regexp:`\\z`. * Option modifiers: These allow behaviour to be switched on (with :regexp:`(?