Restore comments

Author: qurious-pixel

CMakeLists.txt

@@ -287,7 +287,7 @@ endif()
 if(CEMU_ARCHITECTURE MATCHES "(aarch64)|(AARCH64)|(arm64)|(ARM64)")
 	add_subdirectory("dependencies/xbyak_aarch64" EXCLUDE_FROM_ALL)
 	if(MSVC)
-        set_target_properties(xbyak_aarch64 PROPERTIES COMPILE_FLAGS "/wd4245 /wd4458")
+		target_compile_options(xbyak_aarch64 PRIVATE "/wd4245" "/wd4458")
     endif()
 endif()
 

src/CMakeLists.txt

@@ -73,8 +73,9 @@ cemu_use_precompiled_header(CemuBin)
 if(MSVC)
     set(CEMU_LINKER_FLAGS "/NODEFAULTLIB:MSVCRT")
 
-    # Check for the specific VS 17.10 version
     if(MSVC_VERSION EQUAL 1940)
+	# workaround for an msvc issue on VS 17.10 where generated ILK files are too large
+	# see https://developercommunity.visualstudio.com/t/After-updating-to-VS-1710-the-size-of-/10665511
         string(APPEND CEMU_LINKER_FLAGS " /INCREMENTAL:NO")
     endif()
 

src/Cafe/CMakeLists.txt

@@ -664,10 +664,6 @@ target_link_libraries(CemuCafe PRIVATE
   OpenSSL::SSL
 )
 
-if(MSVC AND CMAKE_SYSTEM_PROCESSOR STREQUAL "ARM64")
-    target_link_libraries(CemuCafe PRIVATE ntdll.lib)
-endif()
-
 if (ENABLE_WAYLAND)
 	# PUBLIC because wayland-client.h is included in VulkanAPI.h
   target_link_libraries(CemuCafe PUBLIC Wayland::Client)
@@ -676,9 +672,7 @@ endif()
 if (ENABLE_LIBUSB)
   if (ENABLE_VCPKG)
     if(WIN32)
-		if(DEFINED VCPKG_TARGET_TRIPLET)
-		    set(PKG_CONFIG_EXECUTABLE "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/tools/pkgconf/pkgconf.exe")
-		endif()
+		set(PKG_CONFIG_EXECUTABLE "${VCPKG_INSTALLED_DIR}/${VCPKG_TARGET_TRIPLET}/tools/pkgconf/pkgconf.exe")
     endif()
     find_package(PkgConfig REQUIRED)
     pkg_check_modules(libusb REQUIRED IMPORTED_TARGET libusb-1.0)

src/Cafe/HW/Espresso/PPCTimer.cpp

@@ -3,19 +3,14 @@
 #include "util/helpers/fspinlock.h"
 #include "util/highresolutiontimer/HighResolutionTimer.h"
 #include "Common/cpu_features.h"
+
 #include "Common/Intrinsics.h"
 
+#include <chrono>
+#include <thread>
+
 uint64 _rdtscLastMeasure = 0;
 uint64 _rdtscFrequency = 0;
-uint64 _tickSummary = 0;
-
-struct uint128_t
-{
-	uint64 low;
-	uint64 high;
-};
-
-static_assert(sizeof(uint128_t) == 16);
 
 uint128_t _rdtscAcc{};
 
@@ -30,32 +25,42 @@ uint64 muldiv64(uint64 a, uint64 b, uint64 d)
 
 uint64 PPCTimer_estimateRDTSCFrequency()
 {
-#if defined(ARCH_X86_64)
+    #if defined(ARCH_X86_64) || defined(__x86_64__) || defined(_M_X64)
 	if (!g_CPUFeatures.x86.invariant_tsc)
 		cemuLog_log(LogType::Force, "Invariant TSC not supported");
-#endif
+    #endif
 
 	BARRIER_FENCE();
 	uint64 tscStart = READ_TSC();
-	unsigned int startTime = GetTickCount();
+	auto startTime = std::chrono::steady_clock::now();
 	HRTick startTick = HighResolutionTimer::now().getTick();
-	
+	// wait roughly 3 seconds
 	while (true)
 	{
-		if ((GetTickCount() - startTime) >= 3000)
+		auto elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(
+			std::chrono::steady_clock::now() - startTime).count();
+		if (elapsed >= 3000)
 			break;
 		std::this_thread::sleep_for(std::chrono::milliseconds(10));
 	}
 
 	BARRIER_FENCE();
 	HRTick stopTick = HighResolutionTimer::now().getTick();
 	uint64 tscEnd = READ_TSC();
-	
+	// derive frequency approximation from measured time difference
 	uint64 tsc_diff = tscEnd - tscStart;
 	uint64 hrtFreq = 0;
 	uint64 hrtDiff = HighResolutionTimer::getTimeDiffEx(startTick, stopTick, hrtFreq);
 	uint64 tsc_freq = muldiv64(tsc_diff, hrtFreq, hrtDiff);
 
+	// uint64 freqMultiplier = tsc_freq / hrtFreq;
+	//cemuLog_log(LogType::Force, "RDTSC measurement test:");
+	//cemuLog_log(LogType::Force, "TSC-diff:   0x{:016x}", tsc_diff);
+	//cemuLog_log(LogType::Force, "TSC-freq:   0x{:016x}", tsc_freq);
+	//cemuLog_log(LogType::Force, "HPC-diff:   0x{:016x}", qpc_diff);
+	//cemuLog_log(LogType::Force, "HPC-freq:   0x{:016x}", (uint64)qpc_freq.QuadPart);
+	//cemuLog_log(LogType::Force, "Multiplier: 0x{:016x}", freqMultiplier);
+	
 	return tsc_freq;
 }
 
@@ -72,6 +77,8 @@ void PPCTimer_init()
 	_rdtscLastMeasure = READ_TSC();
 }
 
+uint64 _tickSummary = 0;
+
 void PPCTimer_start()
 {
 	_rdtscLastMeasure = READ_TSC();
@@ -91,12 +98,10 @@ uint64 PPCTimer_microsecondsToTsc(uint64 us)
 uint64 PPCTimer_tscToMicroseconds(uint64 us)
 {
 	uint128_t r{};
-    // Changed: Using Multiply64to128 wrapper
-	r.low = Multiply64to128(us, 1000000ULL, &r.high);
+	r.low = portable_umul128(us, 1000000ULL, &r.high);
 
 	uint64 remainder;
-    // Changed: Using Divide128by64 wrapper
-	const uint64 microseconds = Divide128by64(r.high, r.low, _rdtscFrequency, &remainder);
+	const uint64 microseconds = portable_udiv128(r.high, r.low, _rdtscFrequency, &remainder);
 
 	return microseconds;
 }
@@ -113,37 +118,35 @@ void PPCTimer_waitForInit()
 
 FSpinlock sTimerSpinlock;
 
+// thread safe
 uint64 PPCTimer_getFromRDTSC()
 {
 	sTimerSpinlock.lock();
 	BARRIER_FENCE();
 	uint64 rdtscCurrentMeasure = READ_TSC();
 	uint64 rdtscDif = rdtscCurrentMeasure - _rdtscLastMeasure;
-	
+	// optimized max(rdtscDif, 0) without conditionals
 	rdtscDif = rdtscDif & ~(uint64)((sint64)rdtscDif >> 63);
 
 	uint128_t diff{};
-	diff.low = Multiply64to128(rdtscDif, Espresso::CORE_CLOCK, &diff.high);
+	diff.low = portable_umul128(rdtscDif, Espresso::CORE_CLOCK, &diff.high);
 
 	if(rdtscCurrentMeasure > _rdtscLastMeasure)
-		_rdtscLastMeasure = rdtscCurrentMeasure; 
+		_rdtscLastMeasure = rdtscCurrentMeasure; // only travel forward in time
 
-	uint8 c = 0;
-	#if defined(_MSC_VER)
-	c = _addcarry_u64(c, _rdtscAcc.low, diff.low, &_rdtscAcc.low);
-	_addcarry_u64(c, _rdtscAcc.high, diff.high, &_rdtscAcc.high);
-	#else
-	c = _addcarry_u64(c, _rdtscAcc.low, diff.low, (unsigned long long*)&_rdtscAcc.low);
-	_addcarry_u64(c, _rdtscAcc.high, diff.high, (unsigned long long*)&_rdtscAcc.high);
-	#endif
+	uint64 old_low = _rdtscAcc.low;
+	_rdtscAcc.low += diff.low;
+	uint64 carry = (_rdtscAcc.low < old_low) ? 1 : 0;
+	_rdtscAcc.high += diff.high + carry;
 
 	uint64 remainder;
-	uint64 elapsedTick = Divide128by64(_rdtscAcc.high, _rdtscAcc.low, _rdtscFrequency, &remainder);
+	uint64 elapsedTick = portable_udiv128(_rdtscAcc.high, _rdtscAcc.low, _rdtscFrequency, &remainder);
 
 	_rdtscAcc.low = remainder;
 	_rdtscAcc.high = 0;
 
-	elapsedTick <<= 3ull; 
+	// timer scaling
+	elapsedTick <<= 3ull; // *8
 	uint8 timerShiftFactor = ActiveSettings::GetTimerShiftFactor();
 	elapsedTick >>= timerShiftFactor;
 

src/Cafe/HW/Espresso/Recompiler/IML/IMLInstruction.h

@@ -758,7 +758,7 @@ struct IMLInstruction
 	void make_fpr_compare(IMLReg regA, IMLReg regB, IMLReg regR, IMLCondition cond)
 	{
 		this->type = PPCREC_IML_TYPE_FPR_COMPARE;
-		this->operation = 255;
+		this->operation = -999;
 		this->op_fpr_compare.regR = regR;
 		this->op_fpr_compare.regA = regA;
 		this->op_fpr_compare.regB = regB;
@@ -807,7 +807,7 @@ struct IMLInstruction
 	void make_x86_eflags_jcc(IMLCondition cond, bool invertedCondition)
 	{
 		this->type = PPCREC_IML_TYPE_X86_EFLAGS_JCC;
-		this->operation = 255;
+		this->operation = -999;
 		this->op_x86_eflags_jcc.cond = cond;
 		this->op_x86_eflags_jcc.invertedCondition = invertedCondition;
 	}

src/Common/Intrinsics.h

@@ -1,88 +1,101 @@
 #pragma once
+
 #include <cstdint>
 
-#if defined(_MSC_VER)
-    #include <intrin.h>
-    #if defined(_M_ARM64)
-        #include <arm64intr.h>
-        #define BARRIER_FENCE() __dmb(_ARM64_BARRIER_ISH)
-        #define READ_TSC()      _ReadStatusReg(ARM64_CNTVCT_EL0)
-    #else
+using uint64 = uint64_t;
+using sint64 = int64_t;
+using uint8  = uint8_t;
+
+#if defined(_M_X64) || defined(__x86_64__)
+    #if defined(_MSC_VER)
         #include <immintrin.h>
+        #pragma intrinsic(__rdtsc)
         #define BARRIER_FENCE() _mm_mfence()
         #define READ_TSC()      __rdtsc()
-    #endif
-#else 
-    #if defined(__aarch64__)
-        #define BARRIER_FENCE() __asm__ __volatile__ ("dmb ish" : : : "memory")
-        static inline uint64_t READ_TSC() {
-            uint64_t val;
-            __asm__ __volatile__("mrs %0, cntvct_el0" : "=r" (val));
-            return val;
-        }
-    #else
+    #else 
         #include <x86intrin.h>
-        #define BARRIER_FENCE() __asm__ __volatile__ ("mfence" : : : "memory")
+        #define BARRIER_FENCE() __builtin_ia32_mfence()
         #define READ_TSC()      __rdtsc()
     #endif
+#elif defined(_M_ARM64) || defined(__aarch64__)
+    #if defined(_MSC_VER)
+        #include <intrin.h>
+        #define BARRIER_FENCE() __dmb(_ARM64_BARRIER_SY)
+        #define READ_TSC()      _ReadStatusReg(ARM64_CNTVCT_EL0)
+    #else 
+        #define BARRIER_FENCE() __asm__ __volatile__("dmb sy" : : : "memory")
+        inline uint64 READ_TSC() {
+            uint64 virtual_timer;
+            __asm__ __volatile__("mrs %0, cntvct_el0" : "=r" (virtual_timer));
+            return virtual_timer;
+        }
+    #endif
 #endif
 
-static inline uint64_t Multiply64to128(uint64_t a, uint64_t b, uint64_t* high) {
-#if defined(__SIZEOF_INT128__)
-    unsigned __int128 res = (unsigned __int128)a * b;
-    *high = (uint64_t)(res >> 64);
-    return (uint64_t)res;
-#elif defined(_MSC_VER) && defined(_M_X64)
-    return _umul128(a, b, high);
-#elif defined(_MSC_VER) && defined(_M_ARM64)
-    *high = __umulh(a, b);
-    return a * b;
+struct uint128_t {
+    uint64 low;
+    uint64 high;
+};
+
+inline uint64 portable_umul128(uint64 multiplier, uint64 multiplicand, uint64* high) {
+#if defined(_MSC_VER)
+    #if defined(_M_X64)
+        return _umul128(multiplier, multiplicand, high);
+    #elif defined(_M_ARM64)
+        *high = __umulh(multiplier, multiplicand);
+        return multiplier * multiplicand;
+    #endif
 #else
-    // Generic fallback for other compilers/archs
-    uint64_t a_lo = (uint32_t)a, a_hi = a >> 32;
-    uint64_t b_lo = (uint32_t)b, b_hi = b >> 32;
-    uint64_t p0 = a_lo * b_lo;
-    uint64_t p1 = a_lo * b_hi;
-    uint64_t p2 = a_hi * b_lo;
-    uint64_t p3 = a_hi * b_hi;
-    uint64_t cy = (uint32_t)(p0 >> 32) + (uint32_t)p1 + (uint32_t)p2;
-    *high = p3 + (p1 >> 32) + (p2 >> 32) + (cy >> 32);
-    return (p0 & 0xFFFFFFFF) | (cy << 32);
+    unsigned __int128 res = (unsigned __int128)multiplier * multiplicand;
+    *high = (uint64)(res >> 64);
+    return (uint64)res;
 #endif
 }
 
-static inline uint64_t Divide128by64(uint64_t high, uint64_t low, uint64_t divisor, uint64_t* remainder) {
-#if defined(__SIZEOF_INT128__)
-    unsigned __int128 dividend = ((unsigned __int128)high << 64) | low;
-    *remainder = (uint64_t)(dividend % divisor);
-    return (uint64_t)(dividend / divisor);
-#elif defined(_MSC_VER) && defined(_M_X64)
-    return _udiv128(high, low, divisor, remainder);
-#else
-    // Software fallback for MSVC ARM64 and others
-    // This implements long division for 128-bit / 64-bit
-    if (high < divisor) {
-        // Common case for many emulators: quotient fits in 64 bits
-        uint64_t q, r;
-        // Schoolbook division: split 128-bit into 4x32-bit if necessary, 
-        // but here we use a binary long division for simplicity and correctness.
-        uint64_t rem = high;
-        uint64_t quot = 0;
+inline uint64 portable_udiv128(uint64 high, uint64 low, uint64 denominator, uint64* remainder) {
+#if defined(_MSC_VER)
+    #if defined(_M_X64)
+        return _udiv128(high, low, denominator, remainder);
+    #else
+        if (high == 0) {
+            if (remainder) *remainder = low % denominator;
+            return low / denominator;
+        }
+        
+        uint64 rem = 0;
+        uint64 quot = 0;
+        for (int i = 63; i >= 0; i--) {
+            rem = (rem << 1) | (high >> 63);
+            high <<= 1;
+            if (rem >= denominator) {
+                rem -= denominator;
+                quot |= (1ULL << i);
+            }
+        }
         for (int i = 63; i >= 0; i--) {
-            rem = (rem << 1) | ((low >> i) & 1);
-            if (rem >= divisor) {
-                rem -= divisor;
+            rem = (rem << 1) | (low >> 63);
+            low <<= 1;
+            if (rem >= denominator) {
+                rem -= denominator;
                 quot |= (1ULL << i);
             }
         }
-        *remainder = rem;
-        return quot;
-    } else {
-        // Quotient overflow: high >= divisor means result > 64 bits.
-        // If your code expects a 64-bit return, this is technically an error state.
-        // Return max value as a sentinel or handle as needed.
-        *remainder = 0; 
-        return 0xFFFFFFFFFFFFFFFFULL;
-    }
+        // Secure native software fallback block
+        uint64_t q = 0;
+        uint64_t r = 0;
+        for (int i = 127; i >= 0; i--) {
+            r = (r << 1) | ((i >= 64 ? high >> (i - 64) : low >> i) & 1);
+            if (r >= denominator) {
+                r -= denominator;
+                q |= (1ULL << (i % 64)); 
+            }
+        }
+        if (remainder) *remainder = r;
+        return q;
+    #endif
+#else
+    unsigned __int128 dividend = ((unsigned __int128)high << 64) | low;
+    if (remainder) *remainder = (uint64)(dividend % denominator);
+    return (uint64)(dividend / denominator);
 #endif
 }

src/Common/precompiled.h

@@ -394,12 +394,15 @@ inline void _mm_mfence()
 
 inline unsigned char _addcarry_u64(unsigned char carry, unsigned long long a, unsigned long long b, unsigned long long *result)
 {
+#if !defined(_MSC_VER)
     unsigned __int128 res = (unsigned __int128)a + b + carry;
     *result = (unsigned long long)res;
     return (res >> 64) ? 1 : 0;
-}
-
+#else
+    *result = a + b + carry;
+    return (*result < a || (*result == a && carry > 0)) ? 1 : 0;
 #endif
+}
 
 // asserts