diff --git a/FEXCore/Source/Interface/Core/OpcodeDispatcher.cpp b/FEXCore/Source/Interface/Core/OpcodeDispatcher.cpp
index 807dee63a..6f8ebb363 100644
--- a/FEXCore/Source/Interface/Core/OpcodeDispatcher.cpp
+++ b/FEXCore/Source/Interface/Core/OpcodeDispatcher.cpp
@@ -113,7 +113,7 @@ void OpDispatchBuilder::SyscallOp(OpcodeArgs) {
     StoreGPRRegister(X86State::REG_RCX, RIPAfterInst, 8);
   }
 
-  CalculateDeferredFlags();
+  FlushRegisterCache();
   auto SyscallOp = _Syscall(Arguments[0], Arguments[1], Arguments[2], Arguments[3], Arguments[4], Arguments[5], Arguments[6], DefaultSyscallFlags);
 
   if (OSABI != FEXCore::HLE::SyscallOSABI::OS_HANGOVER &&
@@ -395,7 +395,7 @@ void OpDispatchBuilder::PUSHOp(OpcodeArgs) {
 
   // Store the new stack pointer
   StoreGPRRegister(X86State::REG_RSP, NewSP);
-  CalculateDeferredFlags();
+  FlushRegisterCache();
 }
 
 void OpDispatchBuilder::PUSHREGOp(OpcodeArgs) {
@@ -408,7 +408,7 @@ void OpDispatchBuilder::PUSHREGOp(OpcodeArgs) {
   auto NewSP = _Push(GPRSize, Size, Src, OldSP);
   // Store the new stack pointer
   StoreGPRRegister(X86State::REG_RSP, NewSP);
-  CalculateDeferredFlags();
+  FlushRegisterCache();
 }
 
 void OpDispatchBuilder::PUSHAOp(OpcodeArgs) {
@@ -458,7 +458,7 @@ void OpDispatchBuilder::PUSHAOp(OpcodeArgs) {
 
   // Store the new stack pointer
   StoreGPRRegister(X86State::REG_RSP, NewSP, 4);
-  CalculateDeferredFlags();
+  FlushRegisterCache();
 }
 
 template<uint32_t SegmentReg>
@@ -843,7 +843,7 @@ void OpDispatchBuilder::CondJUMPOp(OpcodeArgs) {
     Target &= 0xFFFFFFFFU;
   }
 
-  CalculateDeferredFlags();
+  FlushRegisterCache();
   auto TrueBlock = JumpTargets.find(Target);
   auto FalseBlock = JumpTargets.find(Op->PC + Op->InstSize);
 
@@ -4007,7 +4007,7 @@ void OpDispatchBuilder::BeginFunction(uint64_t RIP, const fextl::vector<FEXCore:
 
 void OpDispatchBuilder::Finalize() {
   // This usually doesn't emit any IR but in the case of hitting the block instruction limit it will
-  CalculateDeferredFlags();
+  FlushRegisterCache();
   const uint8_t GPRSize = CTX->GetGPRSize();
 
   // Node 0 is invalid node
@@ -4716,7 +4716,7 @@ void OpDispatchBuilder::INTOp(OpcodeArgs) {
   }
 
   // Calculate flags early.
-  CalculateDeferredFlags();
+  FlushRegisterCache();
 
   const uint8_t GPRSize = CTX->GetGPRSize();
 
diff --git a/FEXCore/Source/Interface/Core/OpcodeDispatcher.h b/FEXCore/Source/Interface/Core/OpcodeDispatcher.h
index c01213911..01d5bfc19 100644
--- a/FEXCore/Source/Interface/Core/OpcodeDispatcher.h
+++ b/FEXCore/Source/Interface/Core/OpcodeDispatcher.h
@@ -115,7 +115,7 @@ public:
     // Changes get stored out by CalculateDeferredFlags.
     CachedNZCV = nullptr;
     PossiblySetNZCVBits = ~0U;
-    CalculateDeferredFlags();
+    FlushRegisterCache();
 
     // New block needs to reset segment telemetry.
     SegmentsNeedReadCheck = ~0U;
@@ -125,28 +125,28 @@ public:
   }
 
   IRPair<IROp_Jump> Jump() {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
     return _Jump();
   }
   IRPair<IROp_Jump> Jump(Ref _TargetBlock) {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
     return _Jump(_TargetBlock);
   }
   IRPair<IROp_CondJump>
   CondJump(Ref _Cmp1, Ref _Cmp2, Ref _TrueBlock, Ref _FalseBlock, CondClassType _Cond = {COND_NEQ}, uint8_t _CompareSize = 0) {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
     return _CondJump(_Cmp1, _Cmp2, _TrueBlock, _FalseBlock, _Cond, _CompareSize);
   }
   IRPair<IROp_CondJump> CondJump(Ref ssa0, CondClassType cond = {COND_NEQ}) {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
     return _CondJump(ssa0, cond);
   }
   IRPair<IROp_CondJump> CondJump(Ref ssa0, Ref ssa1, Ref ssa2, CondClassType cond = {COND_NEQ}) {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
     return _CondJump(ssa0, ssa1, ssa2, cond);
   }
   IRPair<IROp_CondJump> CondJumpNZCV(CondClassType Cond) {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
 
     // The jump will ignore the sources, so it doesn't matter what we put here.
     // Put an inline constant so RA+codegen will ignore altogether.
@@ -154,15 +154,15 @@ public:
     return _CondJump(Placeholder, Placeholder, InvalidNode, InvalidNode, Cond, 0, true);
   }
   IRPair<IROp_ExitFunction> ExitFunction(Ref NewRIP) {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
     return _ExitFunction(NewRIP);
   }
   IRPair<IROp_Break> Break(BreakDefinition Reason) {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
     return _Break(Reason);
   }
   IRPair<IROp_Thunk> Thunk(Ref ArgPtr, SHA256Sum ThunkNameHash) {
-    CalculateDeferredFlags();
+    FlushRegisterCache();
     return _Thunk(ArgPtr, ThunkNameHash);
   }
 
@@ -1267,6 +1267,10 @@ public:
     }
   }
 
+  void FlushRegisterCache(bool SRAOnly = false) {
+    CalculateDeferredFlags();
+  }
+
 protected:
   void SaveNZCV(IROps Op = OP_DUMMY) override {
     /* Some opcodes are conservatively marked as clobbering flags, but in fact