Palacios Public Git Repository

To checkout Palacios execute 

  git clone http://v3vee.org/palacios/palacios.web/palacios.git
This will give you the master branch. You probably want the devel branch or one of the release branches. To switch to the devel branch, simply execute 
  cd palacios
  git checkout --track -b devel origin/devel
The other branches are similar.

projects / palacios.git / blobdiff
? search: re
summary | shortlog | log | commit | commitdiff | tree
raw
added movsx/movzx decoding to internal decoder
[palacios.git] / palacios / src / palacios / vmm_v3dec.c
diff --git a/palacios/src/palacios/vmm_v3dec.c b/palacios/src/palacios/vmm_v3dec.c
index 0b0d7a4..ac9eb69 100644 (file)
--- a/palacios/src/palacios/vmm_v3dec.c
+++ b/palacios/src/palacios/vmm_v3dec.c
@@ -20,9 +20,14 @@
 #include <palacios/vmm_decoder.h>
 #include <palacios/vmm_instr_decoder.h>
 
+#ifndef CONFIG_DEBUG_DECODER
+#undef PrintDebug
+#define PrintDebug(fmt, args...)
+#endif
+
 
 #define MASK(val, length) ({                                           \
-            ullong_t mask = 0x0LL;                                     \
+            uint64_t mask = 0x0LL;                                     \
             switch (length) {                                          \
                case 1:                                                 \
                    mask = 0x00000000000000ffLL;                        \
@@ -78,18 +83,25 @@ int v3_decode(struct guest_info * core, addr_t instr_ptr, struct x86_instr * ins
     length = v3_get_prefixes((uint8_t *)instr_ptr, &(instr->prefixes));
 
 
-       // REX prefix
-       if (v3_get_vm_cpu_mode(core) == LONG) {
-           if ((*(uint8_t *)(instr_ptr + length) & 0xf0) == 0x40) {
-                       *(uint8_t *)&(instr->prefixes.rex) = *(uint8_t *)(instr_ptr + length);
-                       length += 1;
-               }
+    // REX prefix
+    if (v3_get_vm_cpu_mode(core) == LONG) {
+       uint8_t prefix = *(uint8_t *)(instr_ptr + length);
+
+       if ((prefix & 0xf0) == 0x40) {
+           instr->prefixes.rex = 1;
+
+           instr->prefixes.rex_rm = (prefix & 0x01);
+           instr->prefixes.rex_sib_idx = ((prefix & 0x02) >> 1);
+           instr->prefixes.rex_reg = ((prefix & 0x04) >> 2);
+           instr->prefixes.rex_op_size = ((prefix & 0x08) >> 3);
+
+           length += 1;
        }
+    }
 
 
     form = op_code_to_form((uint8_t *)(instr_ptr + length), &length);
 
-
     V3_Print("\t decoded as (%s)\n", op_form_to_str(form));
 
     if (form == INVALID_INSTR) {
@@ -106,11 +118,9 @@ int v3_decode(struct guest_info * core, addr_t instr_ptr, struct x86_instr * ins
        return -1;
     }
     length += ret;
-    
 
     instr->instr_length += length;
 
-
     v3_print_instr(instr);
 
     return 0;
@@ -145,9 +155,7 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
        case MOV_IMM2:{
            uint8_t reg_code = 0;
 
-           instr->dst_operand.size = operand_width;
-
-           ret = decode_rm_operand(core, instr_ptr, instr, &(instr->dst_operand), &reg_code);
+           ret = decode_rm_operand(core, instr_ptr, form, instr, &(instr->dst_operand), &reg_code);
 
            if (ret == -1) {
                PrintError("Error decoding operand\n");
@@ -159,6 +167,7 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
            instr->src_operand.type = IMM_OPERAND;
            instr->src_operand.size = operand_width;
 
+
            if (operand_width == 1) {
                instr->src_operand.operand = *(uint8_t *)instr_ptr;
            } else if (operand_width == 2) {
@@ -170,6 +179,9 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
                return -1;
            }
 
+           instr->src_operand.read = 1;
+           instr->dst_operand.write = 1;
+
            instr_ptr += operand_width;
 
            instr->num_operands = 2;
@@ -183,18 +195,20 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
        case SUB_2MEM_8:
        case XOR_2MEM_8:
        case MOV_2MEM_8:
+       case MOVSX_8:
+       case MOVZX_8:
        case ADC_2MEM:
        case ADD_2MEM:
        case AND_2MEM:
        case OR_2MEM:
        case SUB_2MEM:
        case XOR_2MEM:
-       case MOV_2MEM: {
+       case MOV_2MEM:
+       case MOVSX:
+       case MOVZX: {
            uint8_t reg_code = 0;
 
-           instr->dst_operand.size = operand_width;
-
-           ret = decode_rm_operand(core, instr_ptr, instr, &(instr->dst_operand), &reg_code);
+           ret = decode_rm_operand(core, instr_ptr, form, instr, &(instr->dst_operand), &reg_code);
 
            if (ret == -1) {
                PrintError("Error decoding operand\n");
@@ -206,6 +220,10 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
            instr->src_operand.type = REG_OPERAND;
            instr->src_operand.size = operand_width;
 
+           instr->src_operand.read = 1;
+           instr->dst_operand.write = 1;
+
+
            decode_gpr(core, reg_code, &(instr->src_operand));
 
            instr->num_operands = 2;
@@ -226,9 +244,8 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
        case XOR_MEM2:
        case MOV_MEM2: {
            uint8_t reg_code = 0;
-           instr->src_operand.size = operand_width;
 
-           ret = decode_rm_operand(core, instr_ptr, instr, &(instr->src_operand), &reg_code);
+           ret = decode_rm_operand(core, instr_ptr, form, instr, &(instr->src_operand), &reg_code);
 
            if (ret == -1) {
                PrintError("Error decoding operand\n");
@@ -241,6 +258,9 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
            instr->dst_operand.type = REG_OPERAND;
            decode_gpr(core, reg_code, &(instr->dst_operand));
 
+           instr->src_operand.read = 1;
+           instr->dst_operand.write = 1;
+
            instr->num_operands = 2;
 
            break;
@@ -252,9 +272,8 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
        case SUB_IMM2SX_8:
        case XOR_IMM2SX_8: {
            uint8_t reg_code = 0;
-           instr->src_operand.size = operand_width;
 
-           ret = decode_rm_operand(core, instr_ptr, instr, &(instr->src_operand), &reg_code);
+           ret = decode_rm_operand(core, instr_ptr, form, instr, &(instr->dst_operand), &reg_code);
 
            if (ret == -1) {
                PrintError("Error decoding operand\n");
@@ -265,7 +284,10 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
 
            instr->src_operand.type = IMM_OPERAND;
            instr->src_operand.size = operand_width;
-           instr->src_operand.operand = *(sint8_t *)instr_ptr;  // sign extend.
+           instr->src_operand.operand = (addr_t)MASK((sint64_t)*(sint8_t *)instr_ptr, operand_width);  // sign extend.
+
+           instr->src_operand.read = 1;
+           instr->dst_operand.write = 1;
 
            instr_ptr += 1;
 
@@ -290,104 +312,110 @@ static int parse_operands(struct guest_info * core, uint8_t * instr_ptr,
            instr->src_operand.size = operand_width;
            instr->src_operand.operand = get_addr_linear(core,  MASK(core->vm_regs.rsi, addr_width), &(core->segments.ds));
 
+
            instr->dst_operand.type = MEM_OPERAND;
            instr->dst_operand.size = operand_width;
            instr->dst_operand.operand = get_addr_linear(core, MASK(core->vm_regs.rdi, addr_width), &(core->segments.es));
 
-           instr->num_operands = 2;
-
-           break;
-
-           case MOV_2CR: {
-               uint8_t reg_code = 0;
 
-               instr->src_operand.size = operand_width;
+           instr->src_operand.read = 1;
+           instr->dst_operand.write = 1;
 
-               ret = decode_rm_operand(core, instr_ptr, instr, &(instr->src_operand),
-                                       &reg_code);
-
-               if (ret == -1) {
-                   PrintError("Error decoding operand for (%s)\n", op_form_to_str(form));
-                   return -1;
-               }
-               
-               instr_ptr += ret;
+           instr->num_operands = 2;
 
-               instr->dst_operand.type = REG_OPERAND;
-               instr->dst_operand.size = operand_width;
-               decode_cr(core, reg_code, &(instr->dst_operand));
+           break;
+       }
+       case MOV_2CR: {
+           uint8_t reg_code = 0;
+           
+           ret = decode_rm_operand(core, instr_ptr, form, instr, &(instr->src_operand),
+                                   &reg_code);
 
-               instr->num_operands = 2;
-               break;
+           if (ret == -1) {
+               PrintError("Error decoding operand for (%s)\n", op_form_to_str(form));
+               return -1;
            }
-           case MOV_CR2: {
-               uint8_t reg_code = 0;
-
-               instr->dst_operand.size = operand_width;
-
-               ret = decode_rm_operand(core, instr_ptr, instr, &(instr->dst_operand),
-                                       &reg_code);
+               
+           instr_ptr += ret;
 
-               if (ret == -1) {
-                   PrintError("Error decoding operand for (%s)\n", op_form_to_str(form));
-                   return -1;
-               }
+           instr->dst_operand.type = REG_OPERAND;
+           instr->dst_operand.size = operand_width;
+           decode_cr(core, reg_code, &(instr->dst_operand));
+           
+           instr->src_operand.read = 1;
+           instr->dst_operand.write = 1;
 
-               instr_ptr += ret;
-               
-               instr->src_operand.type = REG_OPERAND;
-               instr->src_operand.size = operand_width;
-               decode_cr(core, reg_code, &(instr->src_operand));
+           instr->num_operands = 2;
+           break;
+       }
+       case MOV_CR2: {
+           uint8_t reg_code = 0;
+           
+           ret = decode_rm_operand(core, instr_ptr, form, instr, &(instr->dst_operand),
+                                   &reg_code);
+           
 
-               instr->num_operands = 2;
-               break;
+           if (ret == -1) {
+               PrintError("Error decoding operand for (%s)\n", op_form_to_str(form));
+               return -1;
            }
-           case STOS:
-           case STOS_8: {
-               instr->is_str_op = 1;
-               
-               if (instr->prefixes.rep == 1) {
-                   instr->str_op_length = MASK(core->vm_regs.rcx, operand_width);
-               } else {
-                   instr->str_op_length = 1;
-               }
+
+           instr_ptr += ret;
                
-               instr->src_operand.size = operand_width;
-               instr->src_operand.type = REG_OPERAND;
-               instr->src_operand.operand = (addr_t)&(core->vm_regs.rax);
+           instr->src_operand.type = REG_OPERAND;
+           instr->src_operand.size = operand_width;
+           decode_cr(core, reg_code, &(instr->src_operand));
 
-               instr->dst_operand.type = MEM_OPERAND;
-               instr->dst_operand.size = operand_width;
-               instr->dst_operand.operand = get_addr_linear(core, MASK(core->vm_regs.rdi, addr_width), &(core->segments.es));
+           instr->src_operand.read = 1;
+           instr->dst_operand.write = 1;
 
-               instr->num_operands = 2;
+           instr->num_operands = 2;
+           break;
+       }
+       case STOS:
+       case STOS_8: {
+           instr->is_str_op = 1;
 
-               break;
+           if (instr->prefixes.rep == 1) {
+               instr->str_op_length = MASK(core->vm_regs.rcx, operand_width);
+           } else {
+               instr->str_op_length = 1;
            }
-           case INVLPG: {
-               uint8_t reg_code = 0;
-
-               // We use the dst operand here to maintain bug-for-bug compatibility with XED
 
-               instr->dst_operand.size = operand_width;
-
-               ret = decode_rm_operand(core, instr_ptr, instr, &(instr->dst_operand), &reg_code);
+           instr->src_operand.size = operand_width;
+           instr->src_operand.type = REG_OPERAND;
+           instr->src_operand.operand = (addr_t)&(core->vm_regs.rax);
 
-               if (ret == -1) {
-                   PrintError("Error decoding operand for (%s)\n", op_form_to_str(form));
-                   return -1;
-               }
+           instr->dst_operand.type = MEM_OPERAND;
+           instr->dst_operand.size = operand_width;
+           instr->dst_operand.operand = get_addr_linear(core, MASK(core->vm_regs.rdi, addr_width), &(core->segments.es));
 
-               instr_ptr += ret;
+           instr->src_operand.read = 1;
+           instr->dst_operand.write = 1;
 
-               instr->num_operands = 1;
-               break;
-           }
-           case CLTS: {
-               // no operands. 
-               break;
+           instr->num_operands = 2;
 
+           break;
+       }
+       case INVLPG: {
+           uint8_t reg_code = 0;
+           
+           ret = decode_rm_operand(core, instr_ptr, form, instr, &(instr->dst_operand), &reg_code);
+           
+           if (ret == -1) {
+               PrintError("Error decoding operand for (%s)\n", op_form_to_str(form));
+               return -1;
            }
+           
+           instr_ptr += ret;
+           
+           instr->num_operands = 1;
+           break;
+       }
+       case CLTS: {
+           // no operands. 
+           break;
+           
        }
        default:
            PrintError("Invalid Instruction form: %s\n", op_form_to_str(form));
Public Palacios Development Repository for the V3VEE Project