[Memory Observer] Fix build outside x86, cache CPUID result for AVX2, fix styling,

Author: wheremyfoodat

src/gui/widgets/memory_observer.cc

@@ -19,14 +19,23 @@
 
 #include "gui/widgets/memory_observer.h"
 
+#ifdef MEMORY_OBSERVER_X86
 #include <xbyak_util.h>
+#endif
 
 #include <magic_enum/include/magic_enum.hpp>
 
 #include "core/psxemulator.h"
 #include "core/psxmem.h"
 #include "core/system.h"
 
+PCSX::Widgets::MemoryObserver::MemoryObserver() {
+#ifdef MEMORY_OBSERVER_X86
+    const auto cpu = Xbyak::util::Cpu();
+    m_useSIMD = cpu.has(Xbyak::util::Cpu::tAVX2);
+#endif
+}
+
 void PCSX::Widgets::MemoryObserver::draw(const char* title) {
     if (!ImGui::Begin(title, &m_show)) {
         ImGui::End();
@@ -204,10 +213,7 @@ void PCSX::Widgets::MemoryObserver::draw(const char* title) {
         }
 
         if (ImGui::BeginTabItem(_("Pattern search"))) {
-            const auto cpu = Xbyak::util::Cpu();
-            const bool bHasAvx2 = cpu.has(Xbyak::util::Cpu::tAVX2);
-
-            if (bHasAvx2) {
+            if (m_useSIMD) {
                 ImGui::Text(_("Sequence size: "));
                 ImGui::SameLine();
                 ImGui::RadioButton(_("8 bytes (fast)"), &m_sequenceSize, 8);
@@ -222,10 +228,10 @@ void PCSX::Widgets::MemoryObserver::draw(const char* title) {
             ImGui::InputInt(_("Step"), &m_step);
 
             if (ImGui::Button(_("Search"))) {
-                if (bHasAvx2 && m_sequenceSize == 8) {
-                    avx2_populateAddressList<8>(memData, memBase, memSize);
-                } else if (bHasAvx2 && m_sequenceSize == 16) {
-                    avx2_populateAddressList<16>(memData, memBase, memSize);
+                if (m_useSIMD && m_sequenceSize == 8) {
+                    simd_populateAddressList<8>(memData, memBase, memSize);
+                } else if (m_useSIMD && m_sequenceSize == 16) {
+                    simd_populateAddressList<16>(memData, memBase, memSize);
                 } else {
                     populateAddressList(memData, memBase, memSize);
                 }
@@ -282,6 +288,7 @@ int PCSX::Widgets::MemoryObserver::getMemValue(uint32_t absoluteAddress, const u
     return memValue;
 }
 
+#ifdef MEMORY_OBSERVER_X86
 bool PCSX::Widgets::MemoryObserver::all_equal(__m256i input) {
     const auto lane0 = _mm256_castsi256_si128(input);
     const auto tmp = _mm_shuffle_epi8(lane0, _mm_setzero_si128());
@@ -290,6 +297,7 @@ bool PCSX::Widgets::MemoryObserver::all_equal(__m256i input) {
 
     return (static_cast<uint32_t>(_mm256_movemask_epi8(eq)) == 0xffffffff);
 }
+#endif // MEMORY_OBSERVER_X86
 
 std::vector<uint8_t> PCSX::Widgets::MemoryObserver::getShuffleResultsFor(const std::vector<uint8_t>& buffer) {
     const size_t bufferSize = buffer.size();

src/gui/widgets/memory_observer.h

@@ -22,10 +22,14 @@
 #include <stdint.h>
 
 #include <array>
+#include <stdexcept>
 #include <vector>
 
 #include "imgui.h"
+#if defined(__i386__) || defined(_M_IX86) || defined(__x86_64) || defined(_M_AMD64)
+#define MEMORY_OBSERVER_X86 // Do not include immintrin/xbyak or use avx intrinsics unless we're compiling for x86
 #include "immintrin.h"
+#endif
 
 namespace PCSX {
 
@@ -35,6 +39,7 @@ class MemoryObserver {
   public:
     void draw(const char* title);
     bool m_show = false;
+    MemoryObserver();
 
   private:
     static int getMemValue(uint32_t absoluteAddress, const uint8_t* memData, uint32_t memSize, uint32_t memBase,
@@ -66,12 +71,14 @@ class MemoryObserver {
     ScanAlignment m_scanAlignment = ScanAlignment::OneByte;
     std::vector<AddressValuePair> m_addressValuePairs;
     bool m_hex = false;
+    bool m_useSIMD = false;
     int m_value = 0;
 
     /**
      * Pattern search.
      */
 
+    #ifdef MEMORY_OBSERVER_X86
     template <int bufferSize>
     static __m256i avx2_getShuffleResultsFor(const std::array<uint8_t, bufferSize>& buffer,
                                              std::array<uint8_t, 32>& extendedBuffer, int mask) {
@@ -116,7 +123,7 @@ class MemoryObserver {
     }
 
     template <int bufferSize>
-    void avx2_populateAddressList(const uint8_t* memData, uint32_t memBase, uint32_t memSize) {
+    void simd_populateAddressList(const uint8_t* memData, uint32_t memBase, uint32_t memSize) {
         static_assert(bufferSize == 8 || bufferSize == 16);
 
         alignas(32) auto buffer = std::array<uint8_t, bufferSize>{};
@@ -150,8 +157,14 @@ class MemoryObserver {
             }
         }
     }
-
     static bool all_equal(__m256i input);
+    #else
+    template <int bufferSize>
+    void simd_populateAddressList(const uint8_t* memData, uint32_t memBase, uint32_t memSize) {
+        throw std::runtime_error("SIMD pattern searching is not supported on this platform! This shouldn't have been called!");
+    }
+    #endif // MEMORY_OBSERVER_X86
+
     static std::vector<uint8_t> getShuffleResultsFor(const std::vector<uint8_t>& buffer);
     static bool matchesPattern(const std::vector<uint8_t>& buffer, const std::vector<uint8_t>& patternShuffleResults);
     void populateAddressList(const uint8_t* memData, uint32_t memBase, uint32_t memSize);