fix: add Boyer–Moore string-search algorithm instead of SSE2

Author: qubka

cmake/platform/linux.cmake

@@ -8,7 +8,6 @@ set(PLATFORM_COMPILE_OPTIONS
 	-Wall
 	-Wno-array-bounds -Wno-attributes
 
-	-mtune=generic -mmmx -msse -msse2 -msse3 -msse4 -msse4.1 -msse4.2
 	-fvisibility=default -fPIC
 )
 

include/dynlibutils/module.hpp

@@ -11,11 +11,11 @@
 
 #include "memaddr.hpp"
 
-#include <emmintrin.h>
-
 #include <array>
 #include <cassert>
 #include <cmath>
+#include <limits>
+#include <tuple>
 #include <string>
 #include <string_view>
 #include <type_traits>
@@ -53,24 +53,14 @@ struct Section_t : public CMemory // Start address of the section.
 	std::string m_svSectionName;    // Name of the section.
 }; // struct Section_t
 
-static constexpr std::size_t s_nDefaultPatternSize = 256;
-static constexpr std::size_t s_nMaxSimdBlocks = 1 << 6; // 64 blocks = 1024 bytes per chunk.
+static constexpr std::size_t s_nDefaultPatternSize = std::numeric_limits<std::uint8_t>::max() + 1;
 
-template<std::size_t SIZE = 0l>
+template<std::size_t SIZE>
 struct Pattern_t
 {
-	static constexpr std::size_t sm_nMaxSize = SIZE;
-
-	// Constructors.
-	constexpr Pattern_t(const Pattern_t<SIZE>& copyFrom) noexcept : m_nSize(copyFrom.m_nSize), m_aBytes(copyFrom.m_aBytes), m_aMask(copyFrom.m_aMask) {}
-	constexpr Pattern_t(Pattern_t<SIZE>&& moveFrom) noexcept : m_nSize(std::move(moveFrom.m_nSize)), m_aBytes(std::move(moveFrom.m_aBytes)), m_aMask(std::move(moveFrom.m_aMask)) {}
-	constexpr Pattern_t(std::size_t size = 0, const std::array<uint8_t, SIZE>& bytes = {}, const std::array<char, SIZE>& mask = {}) noexcept : m_nSize(size), m_aBytes(bytes), m_aMask(mask) {} // Default one.
-	constexpr Pattern_t(std::size_t &&size, std::array<uint8_t, SIZE>&& bytes, const std::array<char, SIZE>&& mask) noexcept : m_nSize(std::move(size)), m_aBytes(std::move(bytes)), m_aMask(std::move(mask)) {}
-
-	// Fields. Available to anyone (so structure).
-	std::size_t m_nSize;
-	std::array<std::uint8_t, SIZE> m_aBytes;
-	std::array<char, SIZE> m_aMask;
+	std::array<std::uint8_t, SIZE == 0 ? 1 : SIZE> m_aBytes{};
+	std::array<char, SIZE == 0 ? 1 : SIZE> m_aMask{};
+	std::size_t m_nSize = SIZE;
 }; // struct Pattern_t
 
 // Concept for pattern callback.
@@ -337,7 +327,7 @@ class CAssemblyModule : public CMemory
 
 	public:
 		constexpr CSignatureView() : m_pModule(nullptr) {}
-		constexpr CSignatureView(CSignatureView&& moveFrom) : Base_t(std::move(moveFrom)), m_pModule(std::move(moveFrom.m_pModule)) {}
+		constexpr CSignatureView(CSignatureView&& other) : Base_t(other), m_pModule(std::exchange(other.m_pModule, DYNLIB_INVALID_MEMORY)) {}
 		constexpr CSignatureView(const Base_t& pattern, CAssemblyModule* module) : Base_t(pattern), m_pModule(module) {}
 		constexpr CSignatureView(Base_t&& pattern, CAssemblyModule* module) : Base_t(std::move(pattern)), m_pModule(module) {}
 
@@ -351,26 +341,27 @@ class CAssemblyModule : public CMemory
 
 		[[nodiscard]] CMemory Find(const CMemory pStart, const Section_t* pSection = nullptr) const
 		{
-			return m_pModule->FindPattern<SIZE>(CMemory(Base_t::m_aBytes.data()), std::string_view(Base_t::m_aMask.data(), Base_t::m_nSize), pStart, pSection);
+			return m_pModule->FindPattern<SIZE>(*this, pStart, pSection);
 		}
 		[[nodiscard]] CMemory OffsetAndFind(const std::ptrdiff_t offset, CMemory pStart, const Section_t* pSection = nullptr) const { return Find(pStart + offset, pSection); }
 		[[nodiscard]] CMemory OffsetFromSelfAndFind(const CMemory pStart, const Section_t* pSection = nullptr) const { return OffsetAndFind(Base_t::m_nSize, pStart, pSection); }
 		[[nodiscard]] CMemory DerefAndFind(const std::uintptr_t deref, CMemory pStart, const Section_t* pSection = nullptr) const { return Find(pStart.Deref(deref), pSection); }
-	}; // class CSignatureView<SIZE>
+	}; // class CSignatureView<N>
+
+	template<std::size_t SIZE>
+	[[nodiscard]]
+	inline auto CreateSignature(const Pattern_t<SIZE> &pattern)
+	{
+		static_assert(SIZE > 0, "Pattern size must be > 0");
+
+		return CSignatureView<SIZE>(pattern, this);
+	}
 
 private:
+	[[nodiscard]] CMemory FindSignature(const std::string_view svSignature, const std::string_view svMask, const CMemory pStartAddress, const Section_t* pModuleSection) const;
 	[[nodiscard]] CMemory GetVirtualTable(const std::string_view svTableName, bool bDecorated = false) const;
 	[[nodiscard]] CMemory GetFunction(const std::string_view svFunctionName) const noexcept;
-	CMemory GetAddress(const CCache& hKey) const noexcept;
-
-	std::string m_sPath;
-	std::string m_sLastError;
-	std::vector<Section_t> m_vecSections;
-
-	const Section_t *m_pExecutableSection;
-
-	mutable std::unordered_map<CCache, CMemory, CHash> m_mapCached;
-	DYNLIB_NUA mutable Mutex m_mutex;
+	[[nodiscard]] CMemory GetAddress(const CCache& hKey) const noexcept;
 
 public:
 	CAssemblyModule() : m_pExecutableSection(nullptr) {}
@@ -389,158 +380,34 @@ class CAssemblyModule : public CMemory
 	bool InitFromName(const std::string_view svModuleName, bool bExtension = false);
 	bool InitFromMemory(const CMemory pModuleMemory, bool bForce = true);
 
-	template<std::size_t N>
-	[[nodiscard]]
-	inline auto CreateSignature(const Pattern_t<N> &copyFrom)
-	{
-		static_assert(N > 0, "Pattern size must be > 0");
-
-		return CSignatureView<N>(copyFrom, this);
-	}
-
-	template<std::size_t N>
-	[[nodiscard]]
-	inline auto CreateSignature(Pattern_t<N> &&moveFrom)
-	{
-		static_assert(N > 0, "Pattern size must be > 0");
-
-		return CSignatureView<N>(std::move(moveFrom), this);
-	}
-
-	//-----------------------------------------------------------------------------
-	// Purpose: Finds an array of bytes in process memory using SIMD instructions
-	// Input  : *pPattern
-	//          svMask
-	//          pStartAddress
-	//          *pModuleSection
-	// Output : CMemory
-	//-----------------------------------------------------------------------------
-	template<std::size_t SIZE = (s_nDefaultPatternSize - 1) / 2>
-	inline CMemory FindPattern(const CMemoryView<std::uint8_t> pPatternMem, const std::string_view svMask, const CMemory pStartAddress, const Section_t* pModuleSection) const
-	{
-		const auto* pPattern = pPatternMem.RCastView();
-
-		CCache sKey(pPattern, svMask.size(), pStartAddress, pModuleSection);
-		if (auto pAddr = GetAddress(sKey))
-		{
-			return pAddr;
-		}
-
-		const Section_t* pSection = pModuleSection ? pModuleSection : m_pExecutableSection;
-
-		if (!pSection || !pSection->IsValid())
-			return DYNLIB_INVALID_MEMORY;
-
-		const std::uintptr_t base = pSection->GetAddr();
-		const std::size_t sectionSize = pSection->m_nSectionSize;
-		const std::size_t patternSize = svMask.size();
-
-		auto* pData = reinterpret_cast<std::uint8_t*>(base);
-		const auto* pEnd = pData + sectionSize - patternSize;
-
-		if (pStartAddress)
-		{
-			auto* start = pStartAddress.RCast<std::uint8_t*>();
-			if (start < pData || start > pEnd)
-				return DYNLIB_INVALID_MEMORY;
-
-			pData = start;
-		}
-
-#if !DYNLIBUTILS_ARCH_ARM
-		std::array<int, 64> masks = {};// 64*16 = enough masks for 1024 bytes.
-		auto numMasks = static_cast<std::uint8_t>(std::ceil(static_cast<float>(patternSize) / 16.f));
-
-		for (std::uint8_t i = 0; i < numMasks; ++i)
-		{
-			for (std::int8_t j = static_cast<std::int8_t>(std::min<std::size_t>(patternSize - i * 16, 16)) - 1; j >= 0; --j)
-			{
-				if (svMask[static_cast<std::size_t>(i * 16 + j)] == 'x')
-				{
-					masks[i] |= 1 << j;
-				}
-			}
-		}
-
-		const __m128i xmm1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pPattern));
-		__m128i xmm2, xmm3, msks;
-		for (; pData != pEnd; _mm_prefetch(reinterpret_cast<const char*>(++pData + 64), _MM_HINT_NTA))
-		{
-			xmm2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(pData));
-			msks = _mm_cmpeq_epi8(xmm1, xmm2);
-			if ((_mm_movemask_epi8(msks) & masks[0]) == masks[0])
-			{
-				bool found = true;
-				for (uint8_t i = 1; i < numMasks; ++i)
-				{
-					xmm2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>((pData + i * 16)));
-					xmm3 = _mm_loadu_si128(reinterpret_cast<const __m128i*>((pPattern + i * 16)));
-					msks = _mm_cmpeq_epi8(xmm2, xmm3);
-					if ((_mm_movemask_epi8(msks) & masks[i]) != masks[i])
-					{
-						found = false;
-						break;
-					}
-				}
-
-				if (found)
-				{
-					UniqueLock_t lock(m_mutex);
-					m_mapCached[std::move(sKey)] = pData;
-					return pData;
-				}
-			}
-		}
-#else
-		for (; pData != pEnd; ++pData)
-		{
-			bool found = false;
-
-			for (size_t i = 0; i < maskLen; ++i)
-			{
-				if (mask[i] == 'x' || pPattern[i] == *(pData + i))
-				{
-					found = true;
-				}
-				else
-				{
-					found = false;
-					break;
-				}
-			}
-
-			if (found)
-			{
-				UniqueLock_t lock(m_mutex);
-				m_mapCached[std::move(sKey)] = pData;
-				return pData;
-			}
-		}
-#endif // !DYNLIBUTILS_ARCH_ARM
-
-		return DYNLIB_INVALID_MEMORY;
-	}
-
-	template<std::size_t SIZE>
 	[[nodiscard]]
-	inline CMemory FindPattern(const Pattern_t<SIZE>& copyPattern, const CMemory pStartAddress = nullptr, const Section_t* pModuleSection = nullptr) const
+	inline CMemory FindPattern(const CMemoryView<char> memory, const std::string_view svMask, const CMemory pStartAddress, const Section_t* pModuleSection) const
 	{
-		return FindPattern<SIZE>(copyPattern.m_aBytes.data(), std::string_view(copyPattern.m_aMask.data(), copyPattern.m_nSize), pStartAddress, pModuleSection);
+		return FindSignature(
+			std::string_view(memory.RCastView(), svMask.size()),
+			svMask,
+			pStartAddress,
+			pModuleSection
+		);
 	}
 
 	template<std::size_t SIZE>
 	[[nodiscard]]
-	inline CMemory FindPattern(Pattern_t<SIZE>&& movePattern, const CMemory pStartAddress = nullptr, const Section_t* pModuleSection = nullptr) const
+	inline CMemory FindPattern(const Pattern_t<SIZE>& pattern, const CMemory pStartAddress = nullptr, const Section_t* pModuleSection = nullptr) const
 	{
-		return FindPattern<SIZE>(std::move(movePattern.m_aBytes).data(), std::string_view(std::move(movePattern.m_aMask).data(), std::move(movePattern.m_nSize)), pStartAddress, pModuleSection);
+		return FindSignature(
+			std::string_view(pattern.m_aBytes.data(), pattern.m_nSize),
+			std::string_view(pattern.m_aMask.data(), pattern.m_nSize),
+			pStartAddress,
+			pModuleSection
+		);
 	}
 
 	template<std::size_t SIZE, PatternCallback_t FUNC>
 	[[nodiscard]]
 	std::size_t FindAllPatterns(const CSignatureView<SIZE>& sig, const FUNC& callback, CMemory pStartAddress = nullptr, const Section_t* pModuleSection = nullptr) const
 	{
 		const Section_t* pSection = pModuleSection ? pModuleSection : m_pExecutableSection;
-
 		if (!pSection || !pSection->IsValid())
 			return 0;
 
@@ -586,6 +453,15 @@ class CAssemblyModule : public CMemory
 
 protected:
 	void SaveLastError();
+
+	std::string m_sPath;
+	std::string m_sLastError;
+	std::vector<Section_t> m_vecSections;
+
+	const Section_t *m_pExecutableSection;
+
+	mutable std::unordered_map<CCache, CMemory, CHash> m_mapCached;
+	DYNLIB_NUA mutable Mutex m_mutex;
 }; // class CAssemblyModule
 
 using CModule = CAssemblyModule<CNullMutex>;