Merge pull request #6190 from JosJuice/is-trivially-copyable-vs

Remove IsTriviallyCopyable hack for VS

4 files changed, 36 insertions, 9 deletions

diff --git a/Source/Core/Common/BitField.h b/Source/Core/Common/BitField.h
index c8a81a092a..6866282298 100644
--- a/Source/Core/Common/BitField.h
+++ b/Source/Core/Common/BitField.h
@@ -124,15 +124,18 @@ public:
   // so that we can use this within unions
   constexpr BitField() = default;
 
+// Visual Studio (as of VS2017) considers BitField to not be trivially
+// copyable if we delete this copy assignment operator.
+// https://developercommunity.visualstudio.com/content/problem/101208/c-compiler-is-overly-strict-regarding-whether-a-cl.html
+#ifndef _MSC_VER
   // We explicitly delete the copy assignment operator here, because the
   // default copy assignment would copy the full storage value, rather than
   // just the bits relevant to this particular bit field.
   // Ideally, we would just implement the copy assignment to copy only the
-  // relevant bits, but this requires compiler support for unrestricted
-  // unions.
-  // TODO: Implement this operator properly once all target compilers
-  // support unrestricted unions.
+  // relevant bits, but we're prevented from doing that because the savestate
+  // code expects that this class is trivially copyable.
   BitField& operator=(const BitField&) = delete;
+#endif
 
   __forceinline BitField& operator=(T val)
   {
diff --git a/Source/Core/Common/ChunkFile.h b/Source/Core/Common/ChunkFile.h
index fdae41102b..ea4bb2cd54 100644
--- a/Source/Core/Common/ChunkFile.h
+++ b/Source/Core/Common/ChunkFile.h
@@ -41,14 +41,11 @@
 
 #if (__has_feature(is_trivially_copyable) &&                                                       \
      (defined(_LIBCPP_VERSION) || defined(__GLIBCXX__))) ||                                        \
-    (defined(__GNUC__) && __GNUC__ >= 5)
+    (defined(__GNUC__) && __GNUC__ >= 5) || defined(_MSC_VER)
 #define IsTriviallyCopyable(T)                                                                     \
   std::is_trivially_copyable<typename std::remove_volatile<T>::type>::value
 #elif __GNUC__
 #define IsTriviallyCopyable(T) std::has_trivial_copy_constructor<T>::value
-#elif _MSC_VER
-// (shuffle2) see https://github.com/dolphin-emu/dolphin/pull/2218
-#define IsTriviallyCopyable(T) 1
 #else
 #error No version of is_trivially_copyable
 #endif
diff --git a/Source/Core/VideoCommon/CommandProcessor.cpp b/Source/Core/VideoCommon/CommandProcessor.cpp
index 04ede7c412..424435a178 100644
--- a/Source/Core/VideoCommon/CommandProcessor.cpp
+++ b/Source/Core/VideoCommon/CommandProcessor.cpp
@@ -50,6 +50,31 @@ static void UpdateInterrupts_Wrapper(u64 userdata, s64 cyclesLate)
   UpdateInterrupts(userdata);
 }
 
+void SCPFifoStruct::DoState(PointerWrap& p)
+{
+  p.Do(CPBase);
+  p.Do(CPEnd);
+  p.Do(CPHiWatermark);
+  p.Do(CPLoWatermark);
+  p.Do(CPReadWriteDistance);
+  p.Do(CPWritePointer);
+  p.Do(CPReadPointer);
+  p.Do(CPBreakpoint);
+  p.Do(SafeCPReadPointer);
+
+  p.Do(bFF_GPLinkEnable);
+  p.Do(bFF_GPReadEnable);
+  p.Do(bFF_BPEnable);
+  p.Do(bFF_BPInt);
+  p.Do(bFF_Breakpoint);
+
+  p.Do(bFF_LoWatermarkInt);
+  p.Do(bFF_HiWatermarkInt);
+
+  p.Do(bFF_LoWatermark);
+  p.Do(bFF_HiWatermark);
+}
+
 void DoState(PointerWrap& p)
 {
   p.DoPOD(m_CPStatusReg);
@@ -60,7 +85,7 @@ void DoState(PointerWrap& p)
   p.Do(m_bboxright);
   p.Do(m_bboxbottom);
   p.Do(m_tokenReg);
-  p.Do(fifo);
+  fifo.DoState(p);
 
   p.Do(s_interrupt_set);
   p.Do(s_interrupt_waiting);
diff --git a/Source/Core/VideoCommon/CommandProcessor.h b/Source/Core/VideoCommon/CommandProcessor.h
index 7257d3e861..77623357d9 100644
--- a/Source/Core/VideoCommon/CommandProcessor.h
+++ b/Source/Core/VideoCommon/CommandProcessor.h
@@ -38,6 +38,8 @@ struct SCPFifoStruct
 
   volatile u32 bFF_LoWatermark;
   volatile u32 bFF_HiWatermark;
+
+  void DoState(PointerWrap& p);
 };
 
 // This one is shared between gfx thread and emulator thread.