Merge branch 'timing'

We do this to improve timing information before entering a supervior
function. We also do this to try and stay within JITted code as much
as possible, by updating the cycles we have remaining.

src/backend_x64/block_of_code.cpp

@@ -76,13 +76,13 @@ size_t BlockOfCode::SpaceRemaining() const {
     return std::min(TOTAL_CODE_SIZE - far_code_offset, FAR_CODE_OFFSET - near_code_offset);
 }
 
-size_t BlockOfCode::RunCode(JitState* jit_state, size_t cycles_to_run) const {
+void BlockOfCode::RunCode(JitState* jit_state, size_t cycles_to_run) const {
     constexpr size_t max_cycles_to_run = static_cast<size_t>(std::numeric_limits<decltype(jit_state->cycles_remaining)>::max());
     ASSERT(cycles_to_run <= max_cycles_to_run);
 
+    jit_state->cycles_to_run = cycles_to_run;
     jit_state->cycles_remaining = cycles_to_run;
     run_code(jit_state);
-    return cycles_to_run - jit_state->cycles_remaining; // Return number of cycles actually run.
 }
 
 void BlockOfCode::ReturnFromRunCode(bool MXCSR_switch) {
@@ -137,6 +137,10 @@ void BlockOfCode::GenRunCode() {
             jg(loop);
         }
 
+        mov(ABI_PARAM1, qword[r15 + offsetof(JitState, cycles_to_run)]);
+        sub(ABI_PARAM1, qword[r15 + offsetof(JitState, cycles_remaining)]);
+        CallFunction(cb.AddTicks);
+
         ABI_PopCalleeSaveRegistersAndAdjustStack(this);
         ret();
     };

src/backend_x64/block_of_code.h

@@ -32,7 +32,7 @@ public:
     size_t SpaceRemaining() const;
 
     /// Runs emulated code for approximately `cycles_to_run` cycles.
-    size_t RunCode(JitState* jit_state, size_t cycles_to_run) const;
+    void RunCode(JitState* jit_state, size_t cycles_to_run) const;
     /// Code emitter: Returns to dispatcher
     void ReturnFromRunCode(bool MXCSR_switch = true);
     /// Code emitter: Returns to dispatcher, forces return to host

src/backend_x64/emit_x64.cpp

@@ -421,11 +421,21 @@ void EmitX64::EmitBXWritePC(RegAlloc& reg_alloc, IR::Block&, IR::Inst* inst) {
 }
 
 void EmitX64::EmitCallSupervisor(RegAlloc& reg_alloc, IR::Block&, IR::Inst* inst) {
-    auto args = reg_alloc.GetArgumentInfo(inst);
-    reg_alloc.HostCall(nullptr, args[0]);
+    using namespace Xbyak::util;
+
+    reg_alloc.HostCall(nullptr);
 
     code->SwitchMxcsrOnExit();
+    code->mov(code->ABI_PARAM1, qword[r15 + offsetof(JitState, cycles_to_run)]);
+    code->sub(code->ABI_PARAM1, qword[r15 + offsetof(JitState, cycles_remaining)]);
+    code->CallFunction(cb.AddTicks);
+    reg_alloc.EndOfAllocScope();
+    auto args = reg_alloc.GetArgumentInfo(inst);
+    reg_alloc.HostCall(nullptr, args[0]);
     code->CallFunction(cb.CallSVC);
+    code->CallFunction(cb.GetTicksRemaining);
+    code->mov(qword[r15 + offsetof(JitState, cycles_to_run)], code->ABI_RETURN);
+    code->mov(qword[r15 + offsetof(JitState, cycles_remaining)], code->ABI_RETURN);
     code->SwitchMxcsrOnEntry();
 }
 

src/backend_x64/interface_x64.cpp

@@ -48,8 +48,8 @@ struct Jit::Impl {
     std::deque<Common::AddressRange> invalid_cache_ranges;
     bool invalidate_entire_cache = false;
 
-    size_t Execute(size_t cycle_count) {
-        return block_of_code.RunCode(&jit_state, cycle_count);
+    void Execute(size_t cycle_count) {
+        block_of_code.RunCode(&jit_state, cycle_count);
     }
 
     std::string Disassemble(const IR::LocationDescriptor& descriptor) {
@@ -161,18 +161,16 @@ Jit::Jit(UserCallbacks callbacks) : impl(std::make_unique<Impl>(this, callbacks)
 
 Jit::~Jit() {}
 
-size_t Jit::Run(size_t cycle_count) {
+void Jit::Run(size_t cycle_count) {
     ASSERT(!is_executing);
     is_executing = true;
     SCOPE_EXIT({ this->is_executing = false; });
 
     impl->jit_state.halt_requested = false;
 
-    size_t cycles_executed = impl->Execute(cycle_count);
+    impl->Execute(cycle_count);
 
     impl->PerformCacheInvalidation();
-
-    return cycles_executed;
 }
 
 void Jit::ClearCache() {

src/backend_x64/jitstate.h

@@ -36,6 +36,7 @@ struct JitState {
     // For internal use (See: BlockOfCode::RunCode)
     u32 guest_MXCSR = 0x00001f80;
     u32 save_host_MXCSR = 0;
+    s64 cycles_to_run = 0;
     s64 cycles_remaining = 0;
     bool halt_requested = false;