Optimization: Cached RSP/RFLAGS reads

Signed-off-by: Alexandro Sanchez Bach <asanchez@kryptoslogic.com>

Author: AlexAltea

core/cpu.c

@@ -382,8 +382,6 @@ int cpu_vmx_execute(struct vcpu_t *vcpu, struct hax_tunnel *htun)
         vmx(vcpu, interruptibility_state).raw = vmread(
                 vcpu, GUEST_INTERRUPTIBILITY);
 
-        state->_rflags = vmread(vcpu, GUEST_RFLAGS);
-        state->_rsp = vmread(vcpu, GUEST_RSP);
         vmread_cr(vcpu);
 
         if (vcpu->nr_pending_intrs > 0 || hax_intr_is_blocked(vcpu))

core/include/vcpu.h

@@ -256,6 +256,8 @@ void hax_panic_vcpu(struct vcpu_t *v, char *fmt, ...);
 
 // Extension-specific operations
 
+mword vcpu_get_rflags(struct vcpu_t *vcpu);
+mword vcpu_get_rsp(struct vcpu_t *vcpu);
 mword vcpu_get_rip(struct vcpu_t *vcpu);
 uint16_t vcpu_get_seg_selector(struct vcpu_t *vcpu, int seg);
 mword vcpu_get_seg_base(struct vcpu_t *vcpu, int seg);

core/include/vmx.h

@@ -339,8 +339,8 @@ typedef enum component_index_t component_index_t;
     COMP(0, 0, W_UL, HOST_SYSENTER_ESP)                      \
     COMP(0, 0, W_UL, HOST_SYSENTER_EIP)                      \
     COMP(1, 0, W_UL, GUEST_RIP)                              \
-    COMP(0, 0, W_UL, GUEST_RFLAGS)                           \
-    COMP(0, 0, W_UL, GUEST_RSP)                              \
+    COMP(1, 0, W_UL, GUEST_RFLAGS)                           \
+    COMP(1, 0, W_UL, GUEST_RSP)                              \
     COMP(0, 0, W_UL, GUEST_CR0)                              \
     COMP(0, 0, W_UL, GUEST_CR3)                              \
     COMP(0, 0, W_UL, GUEST_CR4)                              \

core/intr_exc.c

@@ -119,10 +119,11 @@ static void hax_enable_intr_window(struct vcpu_t *vcpu)
  */
 uint hax_intr_is_blocked(struct vcpu_t *vcpu)
 {
-    struct vcpu_state_t *state = vcpu->state;
     uint32_t intr_status;
+    uint64_t rflags;
 
-    if (!(state->_eflags & EFLAGS_IF))
+    rflags = vcpu_get_rflags(vcpu);
+    if (!(rflags & EFLAGS_IF))
         return 1;
 
     intr_status = vmx(vcpu, interruptibility_state).raw;

core/vcpu.c

@@ -1062,6 +1062,7 @@ static void load_dirty_vmcs_fields(struct vcpu_t *vcpu)
     // rflags
     if (vcpu->debug_control_dirty) {
         // Single-stepping
+        state->_rflags = vcpu_get_rflags(vcpu);
         if (vcpu->debug_control & HAX_DEBUG_STEP) {
             state->_rflags |= EFLAGS_TF;
         } else {
@@ -2173,12 +2174,20 @@ static int vcpu_emulate_insn(struct vcpu_t *vcpu)
 static uint64_t vcpu_read_gpr(void *obj, uint32_t reg_index, uint32_t size)
 {
     struct vcpu_t *vcpu = obj;
+    uint64_t value;
+
     if (reg_index >= 16) {
         hax_panic_vcpu(vcpu, "vcpu_read_gpr: Invalid register index\n");
         return 0;
     }
-    uint64_t value = 0;
-    memcpy(&value, &vcpu->state->_regs[reg_index], size);
+    switch (reg_index) {
+    case REG_RSP:
+        value = vcpu_get_rsp(vcpu);
+        break;
+    default:
+        value = 0;
+        memcpy(&value, &vcpu->state->_regs[reg_index], size);
+    }
     return value;
 }
 
@@ -2196,7 +2205,7 @@ static void vcpu_write_gpr(void *obj, uint32_t reg_index, uint64_t value,
 uint64_t vcpu_read_rflags(void *obj)
 {
     struct vcpu_t *vcpu = obj;
-    return vcpu->state->_rflags;
+    return vcpu_get_rflags(vcpu);
 }
 
 void vcpu_write_rflags(void *obj, uint64_t value)
@@ -3042,6 +3051,7 @@ static int handle_string_io(struct vcpu_t *vcpu, exit_qualification_t *qual,
 {
     struct vcpu_state_t *state = vcpu->state;
     uint64_t count, total_size;
+    uint64_t rflags;
     uint elem_size, n, copy_size;
     hax_vaddr_t gla, start_gva;
 
@@ -3065,7 +3075,8 @@ static int handle_string_io(struct vcpu_t *vcpu, exit_qualification_t *qual,
     // attribute of the instruction, or to check the presence of a segment
     // override prefix that can make OUTS read from ES:ESI instead of DS:ESI).
     gla = vmread(vcpu, VM_EXIT_INFO_GUEST_LINEAR_ADDRESS);
-    if (state->_rflags & EFLAGS_DF) {
+    rflags = vcpu_get_rflags(vcpu);
+    if (rflags & EFLAGS_DF) {
         start_gva = gla - (n - 1) * elem_size;
         htun->io._df = 1;
     } else {
@@ -3091,7 +3102,7 @@ static int handle_string_io(struct vcpu_t *vcpu, exit_qualification_t *qual,
         advance_rip(vcpu);
     }
 
-    if (state->_rflags & EFLAGS_DF) {
+    if (rflags & EFLAGS_DF) {
         if (qual->io.direction == HAX_IO_OUT) {
             state->_rsi -= copy_size;
         } else {
@@ -3843,13 +3854,8 @@ int vcpu_set_regs(struct vcpu_t *vcpu, struct vcpu_state_t *ustate)
     int i;
     int cr_dirty = 0, dr_dirty = 0;
     preempt_flag flags;
-    int rsp_dirty = 0;
     uint32_t vmcs_err = 0;
 
-    if (state->_rsp != ustate->_rsp) {
-        rsp_dirty = 1;
-    }
-
     for (i = 0; i < 16; i++) {
         state->_regs[i] = ustate->_regs[i];
     }
@@ -3865,11 +3871,11 @@ int vcpu_set_regs(struct vcpu_t *vcpu, struct vcpu_state_t *ustate)
         state->_rip = ustate->_rip;
         vcpu->rip_dirty = 1;
     }
-    if (state->_rflags != ustate->_rflags) {
+    if (vcpu_get_rflags(vcpu) != ustate->_rflags) {
         state->_rflags = ustate->_rflags;
         vcpu->rflags_dirty = 1;
     }
-    if (rsp_dirty) {
+    if (vcpu_get_rsp(vcpu) != ustate->_rsp) {
         state->_rsp = ustate->_rsp;
         vmwrite(vcpu, GUEST_RSP, state->_rsp);
     }

core/vmx.c

@@ -327,6 +327,16 @@ void vcpu_vmcs_flush_cache_w(struct vcpu_t *vcpu)
     vcpu->vmx.vmcs_cache_w.dirty = 0;
 }
 
+mword vcpu_get_rflags(struct vcpu_t *vcpu)
+{
+    return vmcs_read(vcpu, GUEST_RFLAGS);
+}
+
+mword vcpu_get_rsp(struct vcpu_t *vcpu)
+{
+    return vmcs_read(vcpu, GUEST_RSP);
+}
+
 mword vcpu_get_rip(struct vcpu_t *vcpu)
 {
     return vmcs_read(vcpu, GUEST_RIP);