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
decoder fix for cut/paste bug in rm decoding
[palacios.git] / palacios / include / palacios / vmm_instr_decoder.h
diff --git a/palacios/include/palacios/vmm_instr_decoder.h b/palacios/include/palacios/vmm_instr_decoder.h
index 1cce578..ce494e7 100644 (file)
--- a/palacios/include/palacios/vmm_instr_decoder.h
+++ b/palacios/include/palacios/vmm_instr_decoder.h
@@ -28,6 +28,7 @@ typedef enum {
     SMSW,
     CLTS,
     INVLPG,
+    INT, 
 
     MOV_CR2,
     MOV_2CR,
@@ -190,6 +191,7 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
        case XOR_MEM2_8:
        case XOR_IMM2_8:
        case INC_8:
+       case INT:
        case DEC_8:
        case NEG_8:
        case NOT_8:
@@ -220,8 +222,7 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
        case MOV_MEM2:
        case MOV_2MEM:
        case MOV_MEM2AX:
-       case MOV_AX2MEM:
-       case MOV_IMM2:      
+       case MOV_AX2MEM: 
        case MOVS:
        case MOVSX:
        case MOVZX:
@@ -255,6 +256,7 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
        case OR_IMM2SX_8:
        case SUB_IMM2SX_8:
        case XOR_IMM2SX_8:
+       case MOV_IMM2:
            switch (v3_get_vm_cpu_mode(info)) {
                case REAL:
                    return (instr->prefixes.op_size) ? 4 : 2;
@@ -262,7 +264,7 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
                    if (instr->prefixes.rex_op_size) {
                        return 8;
                    } else {
-                       return 4;
+                       return (instr->prefixes.op_size) ? 2 : 4;
                    }
                case PROTECTED:
                case PROTECTED_PAE:
@@ -277,7 +279,6 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
                    PrintError("Unsupported CPU mode: %d\n", info->cpu_mode);
                    return -1;
            }
-           
        case INVLPG:
            switch (v3_get_vm_cpu_mode(info)) {
                case REAL:
@@ -310,6 +311,7 @@ static int get_operand_width(struct guest_info * info, struct x86_instr * instr,
                    return -1;
            }
 
+       //case INT:
        case MOV_DR2:
        case MOV_2DR:
        case MOV_CR2:
@@ -476,24 +478,6 @@ static inline int decode_cr(struct guest_info * core,
     return 0;
 }
 
-// This converts the displacement into the appropriate masked value
-/* 
-   QUESTION: Are the register Values signed ?????
- */
-#define MASK_DISPLACEMENT(reg, mode) ({                                        \
-           sint64_t val = 0;                                           \
-           if (mode == DISP8) {                                        \
-               val = (sint8_t)(reg & 0xff);                            \
-           } else if (mode == DISP16) {                                \
-               val = (sint16_t)(reg & 0xffff);                         \
-           } else if (mode == DISP32) {                                \
-               val = (sint32_t)(reg & 0xffffffff);                     \
-           } else {                                                    \
-               PrintError("Error invalid displacement size (%d)\n", mode); \
-               /*V3_ASSERT(0);*/                                       \
-           }                                                           \
-           val;                                                        \
-       })
 
 
 #define ADDR_MASK(val, length) ({                            \
@@ -697,7 +681,6 @@ static int decode_rm_operand32(struct guest_info * core,
        }
 
        if (has_sib_byte) {
-           instr_cursor += 1;
            struct sib_byte * sib = (struct sib_byte *)(instr_cursor);
            int scale = 0x1 << sib->scale;
 
@@ -735,30 +718,33 @@ static int decode_rm_operand32(struct guest_info * core,
 
            switch (sib->base) {
                case 0:
-                   base_addr += MASK_DISPLACEMENT(gprs->rax, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rax, 4);
                    break;
                case 1:
-                   base_addr += MASK_DISPLACEMENT(gprs->rcx, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rcx, 4);
                    break;
                case 2:
-                   base_addr += MASK_DISPLACEMENT(gprs->rdx, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rdx, 4);
                    break;
                case 3:
-                   base_addr += MASK_DISPLACEMENT(gprs->rbx, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rbx, 4);
                    break;
                case 4:
-                   base_addr += MASK_DISPLACEMENT(gprs->rsp, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rsp, 4);
                    break;
                case 5:
                    if (modrm->mod != 0) {
-                       base_addr += MASK_DISPLACEMENT(gprs->rbp, mod_mode);
+                       base_addr += ADDR_MASK(gprs->rbp, 4);
+                   } else {
+                       mod_mode = DISP32;
+                       base_addr = 0;
                    }
                    break;
                case 6:
-                   base_addr += MASK_DISPLACEMENT(gprs->rsi, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rsi, 4);
                    break;
                case 7:
-                   base_addr += MASK_DISPLACEMENT(gprs->rdi, mod_mode);
+                   base_addr += ADDR_MASK(gprs->rdi, 4);
                    break;
            }
 
@@ -904,7 +890,6 @@ int decode_rm_operand64(struct guest_info * core, uint8_t * modrm_instr,
        }
 
        if (has_sib_byte) {
-           instr_cursor += 1;
            struct sib_byte * sib = (struct sib_byte *)(instr_cursor);
            int scale = 0x1 << sib->scale;
            uint8_t index_val = sib->index;
@@ -971,54 +956,57 @@ int decode_rm_operand64(struct guest_info * core, uint8_t * modrm_instr,
 
            switch (base_val) {
                case 0:
-                   base_addr += MASK_DISPLACEMENT(gprs->rax, mod_mode);
+                   base_addr += gprs->rax;
                    break;
                case 1:
-                   base_addr += MASK_DISPLACEMENT(gprs->rcx, mod_mode);
+                   base_addr += gprs->rcx;
                    break;
                case 2:
-                   base_addr += MASK_DISPLACEMENT(gprs->rdx, mod_mode);
+                   base_addr += gprs->rdx;
                    break;
                case 3:
-                   base_addr += MASK_DISPLACEMENT(gprs->rbx, mod_mode);
+                   base_addr += gprs->rbx;
                    break;
                case 4:
-                   base_addr += MASK_DISPLACEMENT(gprs->rsp, mod_mode);
+                   base_addr += gprs->rsp;
                    break;
                case 5:
                    if (modrm->mod != 0) {
-                       base_addr += MASK_DISPLACEMENT(gprs->rbp, mod_mode);
+                       base_addr += gprs->rbp;
+                   } else {
+                       mod_mode = DISP32;
+                       base_addr = 0;
                    }
                    break;
                case 6:
-                   base_addr += MASK_DISPLACEMENT(gprs->rsi, mod_mode);
+                   base_addr += gprs->rsi;
                    break;
                case 7:
-                   base_addr += MASK_DISPLACEMENT(gprs->rdi, mod_mode);
+                   base_addr += gprs->rdi;
                    break;
                case 8:
-                   base_addr += MASK_DISPLACEMENT(gprs->r8, mod_mode);
+                   base_addr += gprs->r8;
                    break;
                case 9:
-                   base_addr += MASK_DISPLACEMENT(gprs->r9, mod_mode);
+                   base_addr += gprs->r9;
                    break;
                case 10:
-                   base_addr += MASK_DISPLACEMENT(gprs->r10, mod_mode);
+                   base_addr += gprs->r10;
                    break;
                case 11:
-                   base_addr += MASK_DISPLACEMENT(gprs->r11, mod_mode);
+                   base_addr += gprs->r11;
                    break;
                case 12:
-                   base_addr += MASK_DISPLACEMENT(gprs->r12, mod_mode);
+                   base_addr += gprs->r12;
                    break;
                case 13:
-                   base_addr += MASK_DISPLACEMENT(gprs->r13, mod_mode);
+                   base_addr += gprs->r13;
                    break;
                case 14:
-                   base_addr += MASK_DISPLACEMENT(gprs->r14, mod_mode);
+                   base_addr += gprs->r14;
                    break;
                case 15:
-                   base_addr += MASK_DISPLACEMENT(gprs->r15, mod_mode);
+                   base_addr += gprs->r15;
                    break;
            }
 
@@ -1034,23 +1022,24 @@ int decode_rm_operand64(struct guest_info * core, uint8_t * modrm_instr,
        }
     
 
-       /* 
-          Segments should be ignored 
-          // get appropriate segment
-          if (instr->prefixes.cs_override) {
-          seg = &(core->segments.cs);
-          } else if (instr->prefixes.es_override) {
-          seg = &(core->segments.es);
-          } else if (instr->prefixes.ss_override) {
-          seg = &(core->segments.ss);
-          } else if (instr->prefixes.fs_override) {
-          seg = &(core->segments.fs);
-          } else if (instr->prefixes.gs_override) {
-          seg = &(core->segments.gs);
-          } else {
-          seg = &(core->segments.ds);
-          }
-       */
+       
+       //Segments should be ignored 
+       // get appropriate segment
+
+       if (instr->prefixes.cs_override) {
+           seg = &(core->segments.cs);
+       } else if (instr->prefixes.es_override) {
+           seg = &(core->segments.es);
+       } else if (instr->prefixes.ss_override) {
+           seg = &(core->segments.ss);
+       } else if (instr->prefixes.fs_override) {
+           seg = &(core->segments.fs);
+       } else if (instr->prefixes.gs_override) {
+           seg = &(core->segments.gs);
+       } else {
+           seg = &(core->segments.ds);
+       }
+       
 
        operand->operand = ADDR_MASK(get_addr_linear(core, base_addr, seg), 
                                     get_addr_width(core, instr));
@@ -1078,7 +1067,7 @@ static int decode_rm_operand(struct guest_info * core,
        case REAL:
            return decode_rm_operand16(core, instr_ptr, instr, operand, reg_code);
        case LONG:
-           if (instr->prefixes.rex_op_size) {
+           if (instr->prefixes.rex) {
                return decode_rm_operand64(core, instr_ptr, instr, operand, reg_code);
            }
        case PROTECTED:
@@ -1349,6 +1338,8 @@ static op_form_t op_code_to_form(uint8_t * instr, int * length) {
        case 0xf4:
            return HLT;
 
+       case 0xcd:
+               return INT;
 
        case 0xf6: {
            struct modrm_byte * modrm = (struct modrm_byte *)&(instr[1]);
@@ -1511,6 +1502,7 @@ static char * op_form_to_str(op_form_t form) {
        case SETO: return "SETO";
        case STOS_8: return "STOS_8";
        case STOS: return "STOS";
+       case INT: return "INT";
 
        case INVALID_INSTR:
        default:
Public Palacios Development Repository for the V3VEE Project