Update GetVirtualMethodIndex method with AM way

Author: Wend4r

include/dynlibutils/virtual.hpp

@@ -14,44 +14,105 @@
 #include <bit>
 #include <type_traits>
 
-#define DYNLIB_INVALID_VMETHOD_INDEX -1
+#define DYNLIB_INVALID_VCALL -1
 
 namespace DynLibUtils {
 
-template<auto METHOD, class T>
-inline std::ptrdiff_t GetVirtualMethodIndex(T *pClass) noexcept
+template<auto METHOD>
+constexpr std::ptrdiff_t GetVirtualMethodIndex() noexcept
 {
 	static_assert(std::is_member_function_pointer_v<decltype(METHOD)>, "Templated method must be a pointer-to-member-function");
 
-#if defined(_MSC_VER)
-	// --- MSVC ABI: runtime scan vtable (no constexpr!) ---
-	struct MSVCPMF { void* ptr; std::ptrdiff_t adj; };
-	union { decltype(METHOD) m; MSVCPMF pmf; } u{ METHOD };
-	void* target = u.pmf.ptr;
-
-	void** vtbl = *reinterpret_cast<void***>(pClass);
-
-	constexpr std::size_t header = 2; // [RTTI][offset-to-top]
-
-	for (std::size_t n = header; ; ++n)
-		if (vtbl[n] == target)
-			return n - header;
-
-#elif defined(__GNUG__) || defined(__clang__)
 	// --- Itanium C++ ABI: PMF.ptr = 1 + offset_in_bytes for virtual ones ---
-	struct ItaniumPMF { void* ptr; std::ptrdiff_t adj; };
-	union { decltype(METHOD) m; ItaniumPMF pmf; } u{ METHOD };
-
-	constexpr auto raw = reinterpret_cast<std::uintptr_t>(u.pmf.ptr);
+	struct ItaniumPMF
+	{
+		union
+		{
+			std::ptrdiff_t addr;
+			void* ptr;
+		};
+
+		std::ptrdiff_t adj;
+	};
+	constexpr union { decltype(METHOD) m; ItaniumPMF pmf; } u{ METHOD };
 
-	static_assert((raw & 1u) != 0, "Not a virtual member function");
+#if defined(_MSC_VER)
+	auto *pAddr = reinterpret_cast<unsigned char *>(u.pmf.ptr);
+
+	// Skip JMP-thunk
+	if (*pAddr == 0xE9)
+	{
+		// May or may not be!
+		// Check where it'd jump
+		pAddr += 5 /*size of the instruction*/ + *(unsigned long*)(pAddr + 1);
+	}
+
+	// Check whether it's a virtual function call
+	// They look like this:
+	// 004125A0 8B 01            mov         eax,dword ptr [ecx]
+	// 004125A2 FF 60 04         jmp         dword ptr [eax+4]
+	//		==OR==
+	// 00411B80 8B 01            mov         eax,dword ptr [ecx]
+	// 00411B82 FF A0 18 03 00 00 jmp         dword ptr [eax+318h]
+
+	// However, for vararg functions, they look like this:
+	// 0048F0B0 8B 44 24 04      mov         eax,dword ptr [esp+4]
+	// 0048F0B4 8B 00            mov         eax,dword ptr [eax]
+	// 0048F0B6 FF 60 08         jmp         dword ptr [eax+8]
+	//		==OR==
+	// 0048F0B0 8B 44 24 04      mov         eax,dword ptr [esp+4]
+	// 0048F0B4 8B 00            mov         eax,dword ptr [eax]
+	// 00411B82 FF A0 18 03 00 00 jmp         dword ptr [eax+318h]
+
+	// With varargs, the this pointer is passed as if it was the first argument
+
+	bool ok = false;
+
+	if (pAddr[0] == 0x8B && pAddr[1] == 0x44 && pAddr[2] == 0x24 && pAddr[3] == 0x04 &&
+	    pAddr[4] == 0x8B && pAddr[5] == 0x00)
+	{
+		pAddr += 6; ok = true;
+	}
+	else if (pAddr[0] == 0x8B && pAddr[1] == 0x01)
+	{
+		pAddr += 2; ok = true;
+	}
+	else if (pAddr[0] == 0x48 && pAddr[1] == 0x8B && pAddr[2] == 0x01)
+	{
+		pAddr += 3; ok = true;
+	}
+
+	if (!ok)
+		return DYNLIB_INVALID_VCALL;
+
+	// FF /60 /A0 /20
+	if (*pAddr++ == 0xFF)
+	{
+		if (*pAddr == 0x60)
+		{
+			return static_cast<std::ptrdiff_t>(*++pAddr) / sizeof(void *);
+		}
+		else if (*pAddr == 0xA0)
+		{
+			return static_cast<std::ptrdiff_t>(*reinterpret_cast<unsigned int*>(++pAddr)) / sizeof(void *);
+		}
+		else if (*pAddr == 0x20)
+		{
+			return 0;
+		}
+		else
+		{
+			return DYNLIB_INVALID_VCALL;
+		}
+	}
 
-	return (raw - 1u) / sizeof(void*);
+#elif defined(__GNUG__) || defined(__clang__)
+	return (u.pmf.addr - 1u) / sizeof(void*);
 #else
 	static_assert(false, "Unsupported compiler");
 #endif
 
-	return DYNLIB_INVALID_VMETHOD_INDEX;
+	return DYNLIB_INVALID_VCALL;
 }
 
 class CVirtualTable : public CMemoryView<void *>