JITCのModR/M関連部分をわかりやすくした。

diff --git a/jitc.h b/jitc.h
index 3fa9efd..b45308d 100644 (file)
--- a/jitc.h
+++ b/jitc.h
@@ -50,6 +50,15 @@ int jitCompCmdLen(const unsigned char *src);
 #define IA32_REG6_ESI                  6\r
 #define IA32_REG7_EDI                  7\r
 //\r
+#define IA32_MOD_R_M(mod, reg, rm)               ((mod << 6) | reg << 3 | rm)\r
+//\r
+#define IA32_OP_MOD_INDEXONLY          0\r
+#define IA32_OP_MOD_INDEX_AND_DISP_BYTE        1\r
+#define IA32_OP_MOD_INDEX_AND_DISP_FULL        2\r
+#define IA32_OP_MOD_REGISTER           3\r
+//\r
+#define IA32_OP_RM32_MOD00_ADDR_DISP32 5\r
+//\r
 #define envOffset_DBGINFO0             (2304 + 0)\r
 #define envOffset_DBGINFO1             (2304 + 4)\r
 //\r
@@ -92,9 +101,9 @@ struct JitCompWork {
 // @jitcx86a.c\r
 int jitCompGetImm32(const unsigned char *src);\r
 int jitCompGetLabelNum(struct JitCompWork *w, const unsigned char *src);\r
-void jitCompA0001_85DispN(struct JitCompWork *w, int disp, int n);\r
-void jitCompA0001_movEbpDispReg32(struct JitCompWork *w, int disp, int reg32);\r
-void jitCompA0001_movReg32EbpDisp(struct JitCompWork *w, int reg32, int disp);\r
+void jitCompPutModRM_Disp_BaseEBP(struct JitCompWork *w, int disp, int opReg);\r
+void jitCompPutOp_MOV_EBPDisp_GReg(struct JitCompWork *w, int disp, int reg32);\r
+void jitCompPutOp_MOV_GReg_EBPDisp(struct JitCompWork *w, int reg32, int disp);\r
 void jitCompA0001_movEaxRxx(struct JitCompWork *w, int rxx);\r
 void jitCompA0001_movRxxEax(struct JitCompWork *w, int rxx);\r
 void jitCompA0001_fixPrefix(struct JitCompWork *w);\r

diff --git a/jitcx86.c b/jitcx86.c
index c87d77c..b916500 100644 (file)
--- a/jitcx86.c
+++ b/jitcx86.c
@@ -37,10 +37,9 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                // env.debugInfo0 <- 0;\r
                // env.debugInfo1 <- debugInfo1;\r
                jitCompPutOp_MOV_EAX_ZERO(w.dst);\r
-               // MOV(debugInfo0, EAX);\r
-               jitCompA0001_movEbpDispReg32(&w, envOffset_DBGINFO0, IA32_REG0_EAX);\r
+               jitCompPutOp_MOV_EBPDisp_GReg(&w, envOffset_DBGINFO0, IA32_REG0_EAX);\r
                jitCompPutOp_MOV_GReg_Imm32(w.dst, IA32_REG0_EAX, debugInfo1);\r
-               jitCompA0001_movEbpDispReg32(&w, envOffset_DBGINFO1, IA32_REG0_EAX); /* MOV(debugInfo1, EAX); */\r
+               jitCompPutOp_MOV_EBPDisp_GReg(&w, envOffset_DBGINFO1, IA32_REG0_EAX);\r
        }\r
        while (src < src1) {\r
                w.prefix = 0;   //0x04 CND 命令で変更される\r
@@ -282,20 +281,20 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        \r
                                        // レジスタへの代入をメモリでエミュレーションする場合は、スタックに積む。\r
                                        if (reg0 == 0)\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
                                        \r
                                        if (level < JITC_LV_FASTEST) {\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 8, reg0); /* MOV([EBP+?], reg0); */ /* p0 */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 8, reg0); /* MOV([EBP+?], reg0); */ /* p0 */\r
                                                jitCompPutByte1(w.dst, 0xb8); /* MOV(EAX, ?); */\r
                                                jitCompPutImm32(w.dst, label[i].typ);\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 4, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */ /* typ */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 4, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */ /* typ */\r
                                                jitCompPutByte1(w.dst, 0xb8); /* MOV(EAX, ?); */\r
                                                jitCompPutImm32(w.dst, (int)label[i].p1);\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 12, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */ /* p1 */\r
-                                               jitCompPutByte2(w.dst, 0x31, 0xc0);     /* XOR(EAX, EAX); */\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 16, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */ /* liveSign */\r
-                                               jitCompA0001_movReg32EbpDisp(&w, 0, 2320); /* MOV(EAX, ptrCtrl); */\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 20, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */ /* pls */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 12, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */ /* p1 */\r
+                                               jitCompPutOp_MOV_EAX_ZERO(w.dst);\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 16, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */ /* liveSign */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, 0, 2320); /* MOV(EAX, ptrCtrl); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 20, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */ /* pls */\r
                                        }\r
                                }\r
                                break;\r
@@ -316,7 +315,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                /* TEST命令を発行 */\r
                                if (reg0 < 0) { //比較対象のレジスタはメモリ上にある\r
                                        jitCompPutByte1(w.dst, 0xf7); /* TEST([EBP+?],1); */\r
-                                       jitCompA0001_85DispN(&w, src[1] * 4, 0);\r
+                                       jitCompPutModRM_Disp_BaseEBP(&w, src[1] * 4, 0);\r
                                }\r
                                else {\r
                                        jitCompPutByte2(w.dst, 0xf7, 0xc0 | reg0); /* TEST(reg0,1); */\r
@@ -346,7 +345,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                if (reg1 == IA32_REG2_EDX)\r
                                        jitCompA000_storeRegCacheEdx(&w);\r
                                if (reg1 <= 3 /* EAX, EDX */)\r
-                                       jitCompA0001_movReg32EbpDisp(&w, reg1, 256 + src[6] * 32 + 0); /* MOV(reg1, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, reg1, 256 + src[6] * 32 + 0); /* MOV(reg1, [EBP+?]); */\r
                                if (level < JITC_LV_FASTER)\r
                                        jitCompA0001_checkLimit(&w, reg1, src[6]);\r
                                i = jitCompA000_convTyp(jitCompGetImm32(src + 2));\r
@@ -390,7 +389,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                if (reg1 == IA32_REG2_EDX)\r
                                        jitCompA000_storeRegCacheEdx(&w);\r
                                if (reg1 <= 3 /* EAX, EDX */)\r
-                                       jitCompA0001_movReg32EbpDisp(&w, reg1, 256 + src[6] * 32 + 0); /* MOV(reg1, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, reg1, 256 + src[6] * 32 + 0); /* MOV(reg1, [EBP+?]); */\r
                                if (level < JITC_LV_FASTER)\r
                                        jitCompA0001_checkLimit(&w, reg1, src[6]);\r
                                if (reg0 == 0 /* EAX */)\r
@@ -436,15 +435,15 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                if (reg1 == IA32_REG2_EDX)\r
                                        jitCompA000_storeRegCacheEdx(&w);\r
                                if (reg1 <= 3 /* EAX, EDX */)\r
-                                       jitCompA0001_movReg32EbpDisp(&w, reg1, 256 + src[6] * 32 + 0); /* MOV(reg1, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, reg1, 256 + src[6] * 32 + 0); /* MOV(reg1, [EBP+?]); */\r
                                if (level < JITC_LV_FASTER)\r
                                        jitCompA0001_checkLimit(&w, reg1, src[6]);\r
                                jitCompPutByte2(w.dst, 0x8b, reg0 << 3 | reg1); /* MOV(reg0, [reg1]); */\r
                                if (reg0 == IA32_REG0_EAX)\r
-                                       jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 0, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
+                                       jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 0, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
                                for (i = 4; i < 32; i += 4) {\r
                                        jitCompPutByte3(w.dst, 0x8b, 0x40 | reg1, i);   /* MOV(EAX, [reg1+?]); */\r
-                                       jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
+                                       jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
                                }\r
                                if (reg1 == IA32_REG2_EDX)\r
                                        jitCompA000_loadRegCacheEdx(&w);\r
@@ -465,14 +464,14 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                if (reg1 == IA32_REG2_EDX)\r
                                        jitCompA000_storeRegCacheEdx(&w);\r
                                if (reg1 <= 3 /* EAX, EDX */)\r
-                                       jitCompA0001_movReg32EbpDisp(&w, reg1, 256 + src[6] * 32 + 0); /* MOV(reg1, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, reg1, 256 + src[6] * 32 + 0); /* MOV(reg1, [EBP+?]); */\r
                                if (level < JITC_LV_FASTER)\r
                                        jitCompA0001_checkLimit(&w, reg1, src[6]);\r
                                if (reg0 == IA32_REG0_EAX)\r
-                                       jitCompA0001_movReg32EbpDisp(&w, reg0, 256 + src[1] * 32 + 0); /* MOV(reg0, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, 256 + src[1] * 32 + 0); /* MOV(reg0, [EBP+?]); */\r
                                jitCompPutByte2(w.dst, 0x89, reg0 << 3 | reg1); /* MOV([reg1], reg0); */\r
                                for (i = 4; i < 32; i += 4) {\r
-                                       jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, 256 + src[1] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, 256 + src[1] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
                                        jitCompPutByte3(w.dst, 0x89, 0x40 | reg1, i);   /* MOV([reg1+?], EAX); */\r
                                }\r
                                if (reg1 == IA32_REG2_EDX)\r
@@ -487,7 +486,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                reg0 = jitCompA000_selectPRegCache(src[1], IA32_REG0_EAX);\r
                                reg1 = jitCompA000_selectPRegCache(src[6], -1 /* mem */);\r
                                if (reg1 < 0 /* mem */)\r
-                                       jitCompA0001_movReg32EbpDisp(&w, reg0, 256 + src[6] * 32 + 0); /* MOV(reg0, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, 256 + src[6] * 32 + 0); /* MOV(reg0, [EBP+?]); */\r
                                if (reg1 >= 0 && reg0 != reg1) {\r
                                        jitCompPutByte2(w.dst, 0x89, 0xc0 | reg1 << 3 | reg0); /* MOV(reg0, reg1); */\r
                                }\r
@@ -532,7 +531,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        }\r
                                        else {\r
                                                jitCompPutByte1(w.dst, 0x03);   /* ADD(reg0, [EBP+?]); */\r
-                                               jitCompA0001_85DispN(&w, src[7] * 4, reg0);\r
+                                               jitCompPutModRM_Disp_BaseEBP(&w, src[7] * 4, reg0);\r
                                        }\r
                                }\r
                                else {\r
@@ -540,7 +539,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        reg2 = 2; /* EDX */\r
                                        jitCompA000_storeRegCacheEdx(&w);\r
                                        if (reg1 < 0)\r
-                                               jitCompA0001_movReg32EbpDisp(&w, reg2, src[7] * 4); /* MOV(reg2, [EBP+?]); */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, reg2, src[7] * 4); /* MOV(reg2, [EBP+?]); */\r
                                        if (reg1 >= 0 && reg1 != reg2) {\r
                                                jitCompPutByte2(w.dst, 0x89, 0xc0 | reg1 << 3 | reg2); /* MOV(reg2, reg1); */\r
                                        }\r
@@ -552,11 +551,11 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                        padd1:\r
 #endif\r
                                if (reg0 == IA32_REG0_EAX)\r
-                                       jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 0, reg0); /* MOV([EBP+?], reg0); */\r
+                                       jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 0, reg0); /* MOV([EBP+?], reg0); */\r
                                if (src[1] != src[6]) {\r
                                        for (i = 4; i < 32; i += 4) {\r
-                                               jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, 256 + src[6] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + i, 0 /* EAX */); /* MOV([EBP+?], EAX); */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, 256 + src[6] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + i, 0 /* EAX */); /* MOV([EBP+?], EAX); */\r
                                        }\r
                                }\r
                                cmp0reg = -1;\r
@@ -566,9 +565,9 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                reg0 = jitCompA000_selectRegCache(src[1], IA32_REG0_EAX);\r
                                jitCompA000_storePRegCacheAll(&w); // 手抜き.\r
                                jitCompA0001_checkCompPtr(&w, src[6], src[7]);\r
-                               jitCompA0001_movReg32EbpDisp(&w, reg0, 256 + src[6] * 32 + 0); /* MOV(reg0, [EBP+?]); */\r
+                               jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, 256 + src[6] * 32 + 0); /* MOV(reg0, [EBP+?]); */\r
                                jitCompPutByte1(w.dst, 0x2b);   /* SUB(EAX, [EBP+?]); */\r
-                               jitCompA0001_85DispN(&w, 256 + src[7] * 32 + 0, reg0);\r
+                               jitCompPutModRM_Disp_BaseEBP(&w, 256 + src[7] * 32 + 0, reg0);\r
                                i = jitCompA000_convTyp(jitCompGetImm32(src + 2));\r
                                j = -1;\r
                                if (0x0002 <= i && i <= 0x0007)\r
@@ -600,14 +599,14 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        jitCompPutByte1(w.dst, 0xb8 | reg0);    /* MOV(reg0, ?); */\r
                                        jitCompPutImm32(w.dst, w.r3f);\r
                                        jitCompPutByte1(w.dst, 0x2b);\r
-                                       jitCompA0001_85DispN(&w, src[3] * 4, reg0);\r
+                                       jitCompPutModRM_Disp_BaseEBP(&w, src[3] * 4, reg0);\r
                                        if (reg0 == 0)\r
                                                jitCompA0001_movRxxEax(&w, src[1]);\r
                                        break;\r
                                }\r
 #endif\r
                                if (reg1 < 0) {\r
-                                       jitCompA0001_movReg32EbpDisp(&w, reg0, src[2] * 4); /* MOV(reg0, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, src[2] * 4); /* MOV(reg0, [EBP+?]); */\r
                                }\r
                                if (reg1 >= 0 && reg0 != reg1) {\r
                                        jitCompPutByte2(w.dst, 0x89, 0xc0 | reg1 << 3 | reg0); /* MOV(reg0, reg1); */\r
@@ -688,7 +687,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                                else {\r
                                                        static unsigned char basic_op_table_rm[] = { 0x0b, 0x33, 0x23, 0, 0x03, 0x2b, 0xaf }; /* op(reg,mem); */\r
                                                        jitCompPutByte1(w.dst, basic_op_table_rm[*src - 0x10]);\r
-                                                       jitCompA0001_85DispN(&w, src[3] * 4, reg0);\r
+                                                       jitCompPutModRM_Disp_BaseEBP(&w, src[3] * 4, reg0);\r
                                                }\r
                                        }\r
                                        else {\r
@@ -697,7 +696,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                                }\r
                                                else {\r
                                                        jitCompPutByte2(w.dst, 0x0f, 0xaf);\r
-                                                       jitCompA0001_85DispN(&w, src[3] * 4, reg0);\r
+                                                       jitCompPutModRM_Disp_BaseEBP(&w, src[3] * 4, reg0);\r
                                                }\r
                                        }\r
                                }\r
@@ -715,7 +714,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        reg1 = jitCompA000_selectRegCache(src[2], -1 /* mem */);\r
                                        if (src[1] >= 0x3f) w.err = JITC_ERR_REGNUM;\r
                                        if (reg1 == -1)\r
-                                               jitCompA0001_movReg32EbpDisp(&w, reg0, src[2] * 4); /* MOV(reg1, [EBP+?]); */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, src[2] * 4); /* MOV(reg1, [EBP+?]); */\r
                                        else {\r
                                                if (reg0 != reg1) {\r
                                                        jitCompPutByte2(w.dst, 0x89, 0xc0 | reg1 << 3 | reg0); /* MOV(reg0, reg1); */\r
@@ -731,7 +730,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                }\r
 #endif\r
                                jitCompA000_storeRegCacheAll(&w); // 手抜き.\r
-                               jitCompA0001_movReg32EbpDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */\r
+                               jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */\r
 #if (jitCompA0001_USE_R3F_IMM32 != 0)\r
                                if (src[2] == 0x3f) {\r
                                        jitCompPutByte1(w.dst, 0xb8);   /* MOV(EAX, ?); */\r
@@ -763,24 +762,24 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        jitCompPutImm32(w.dst, w.r3f);\r
                                }\r
                                else {\r
-                                       jitCompA0001_movReg32EbpDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */\r
                                }\r
                                if (src[2] == 0x3f) {\r
                                        jitCompPutByte1(w.dst, 0xb8 | 0);       /* MOV(EAX, ?); */\r
                                        jitCompPutImm32(w.dst, w.r3f);\r
                                }\r
                                else {\r
-                                       jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, src[2] * 4); /* MOV(EAX, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, src[2] * 4); /* MOV(EAX, [EBP+?]); */\r
                                }\r
 #else\r
-                               jitCompA0001_movReg32EbpDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */\r
-                               jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, src[2] * 4); /* MOV(EAX, [EBP+?]); */\r
+                               jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */\r
+                               jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, src[2] * 4); /* MOV(EAX, [EBP+?]); */\r
 #endif\r
                                jitCompPutByte1(w.dst, 0x99);   /* CDQ(); */\r
                                /* ECXがゼロではないことを確認すべき */\r
                                jitCompPutByte2(w.dst, 0xf7, 0xf9);     /* IDIV(ECX); */\r
-                               if (*src == 0x1a) { jitCompA0001_movEbpDispReg32(&w, src[1] * 4, IA32_REG0_EAX); }\r
-                               if (*src == 0x1b) { jitCompA0001_movEbpDispReg32(&w, src[1] * 4, IA32_REG2_EDX); }\r
+                               if (*src == 0x1a) { jitCompPutOp_MOV_EBPDisp_GReg(&w, src[1] * 4, IA32_REG0_EAX); }\r
+                               if (*src == 0x1b) { jitCompPutOp_MOV_EBPDisp_GReg(&w, src[1] * 4, IA32_REG2_EDX); }\r
                                jitCompA000_loadRegCacheAll(&w); // 手抜き.\r
                                cmp0reg = -1;\r
                                break;\r
@@ -807,14 +806,14 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        /* src[2] == 0xff の場合に対応できてない */\r
                                        jitCompA000_storePRegCacheAll(&w); // 手抜き.\r
                                        for (i = 0; i < 32; i += 4) {\r
-                                               jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, 256 + src[2] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, 256 + src[2] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
                                        }\r
                                        jitCompA000_loadPRegCacheAll(&w); // 手抜き.\r
                                }\r
                                else {\r
                                        if (level < JITC_LV_FASTER) {\r
-                                               jitCompA0001_movReg32EbpDisp(&w, 0 /* EAX */, 256 + src[2] * 32 + 4); /* MOV(EAX, [EBP+?]); */  /* typ */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, 0 /* EAX */, 256 + src[2] * 32 + 4); /* MOV(EAX, [EBP+?]); */ /* typ */\r
                                                jitCompPutByte3(w.dst, 0x83, 0xf8, 0);  /* CMP(EAX, 0); */\r
                                                jitCompPutByte2(w.dst, 0x0f, 0x85); /* JNE */\r
                                                jitCompPutImm32(w.dst, errfnc - (w.dst + 4));\r
@@ -822,10 +821,10 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        }\r
                                        reg0 = IA32_REG0_EAX;\r
                                        jitCompA000_storePRegCacheAll(&w); // 手抜き.\r
-                                       jitCompA0001_movReg32EbpDisp(&w, reg0, 256 + src[2] * 32 + 0); /* MOV(EAX, [EBP+?]); */\r
+                                       jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, 256 + src[2] * 32 + 0); /* MOV(EAX, [EBP+?]); */\r
                                        if (level < JITC_LV_FASTER) {\r
                                                jitCompPutByte1(w.dst, 0x3b);   /* CMP(reg0, [EBP+?]); */\r
-                                               jitCompA0001_85DispN(&w, 256 + src[2] * 32 + 8, reg0);  /* p0 */\r
+                                               jitCompPutModRM_Disp_BaseEBP(&w, 256 + src[2] * 32 + 8, reg0);  /* p0 */\r
                                                jitCompPutByte2(w.dst, 0x0f, 0x85); /* JNE */\r
                                                jitCompPutImm32(w.dst, errfnc - (w.dst + 4));\r
                                        }\r
@@ -839,16 +838,16 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                                jitCompA0001_checkType0(&w, src[6], jitCompGetImm32(src + 7), 2);\r
                                        jitCompA000_storePRegCacheAll(&w); // 手抜き.\r
                                        for (i = 0; i < 32 - 4; i += 4) {\r
-                                               jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, 256 + src[6] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, 256 + src[6] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
                                                if (i == 4) {\r
                                                        jitCompPutByte1(w.dst, 0x0d); /* OR(EAX, ?); */\r
                                                        jitCompPutImm32(w.dst, 0x80000000);\r
                                                }\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
                                        }\r
                                        jitCompPutByte1(w.dst, 0xb8);   /* MOV(EAX, ?); */\r
                                        jitCompPutImm32(w.dst, debugInfo1);\r
-                                       jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 28, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
+                                       jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 28, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
                                        jitCompA000_loadPRegCacheAll(&w); // 手抜き.\r
                                        cmp0reg = -1;\r
                                        break;\r
@@ -856,20 +855,20 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                if (jitCompGetImm32(src + 7) == 0) {\r
                                        jitCompA000_storePRegCacheAll(&w); // 手抜き.\r
                                        for (i = 0; i < 32 - 4; i += 4) {\r
-                                               jitCompA0001_movReg32EbpDisp(&w, 0 /* EAX */, 256 + src[6] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, 0 /* EAX */, 256 + src[6] * 32 + i); /* MOV(EAX, [EBP+?]); */\r
                                                if (i == 4) {\r
                                                        jitCompPutByte1(w.dst, 0x25); /* AND(EAX, ?); */\r
                                                        jitCompPutImm32(w.dst, 0x7fffffff);\r
                                                }\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
                                        }\r
                                        if (level < JITC_LV_FASTER) {\r
-                                               jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, 256 + src[6] * 32 + 28); /* MOV(EAX, [EBP+?]); */\r
+                                               jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, 256 + src[6] * 32 + 28); /* MOV(EAX, [EBP+?]); */\r
                                                jitCompPutByte1(w.dst, 0x3d);   /* CMP(EAX, ?); */\r
                                                jitCompPutImm32(w.dst, debugInfo1);\r
                                                jitCompPutByte2(w.dst, 0x74, 8); /* JE */\r
                                                jitCompPutByte2(w.dst, 0x31, 0xc0);     /* XOR(EAX, EAX); (2) */\r
-                                               jitCompA0001_movEbpDispReg32(&w, 256 + src[1] * 32 + 0, IA32_REG0_EAX); /* MOV([EBP+?], EAX); (1+1+4) */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 256 + src[1] * 32 + 0, IA32_REG0_EAX); /* MOV([EBP+?], EAX); (1+1+4) */\r
                                        }\r
                                        jitCompA000_loadPRegCacheAll(&w); // 手抜き.\r
                                        cmp0reg = -1;\r
@@ -942,7 +941,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                else {\r
                                        if (*src <= 0x25) { jitCompPutByte1(w.dst, 0x3b); }\r
                                        if (*src >= 0x26) { jitCompPutByte1(w.dst, 0x85); }\r
-                                       jitCompA0001_85DispN(&w, src[3] * 4, reg0);\r
+                                       jitCompPutModRM_Disp_BaseEBP(&w, src[3] * 4, reg0);\r
                                }\r
                        cmpcc1:\r
                                if (w.err != 0) goto err_w;\r
@@ -1004,10 +1003,10 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                jitCompA000_storePRegCacheAll(&w); // 手抜き.\r
                                if (src[3] != 0xff)\r
                                        jitCompA0001_checkCompPtr(&w, src[2], src[3]);\r
-                               jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, 256 + src[2] * 32 + 0); /* MOV(EAX, [EBP+?]); */\r
+                               jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, 256 + src[2] * 32 + 0); /* MOV(EAX, [EBP+?]); */\r
                                if (src[3] != 0xff) {\r
                                        jitCompPutByte1(w.dst, 0x3b);   /* CMP(EAX, [EBP+?]); */\r
-                                       jitCompA0001_85DispN(&w, 256 + src[3] * 32 + 0, 0);\r
+                                       jitCompPutModRM_Disp_BaseEBP(&w, 256 + src[3] * 32 + 0, 0);\r
                                }\r
                                else {\r
                                        /* ヌルポインタとの比較はこれでいいのか？たぶんよくない */\r
@@ -1153,14 +1152,14 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                        if (level <= JITC_LV_SLOWER) {\r
                                                jitCompPutByte1(w.dst, 0xb8);   /* MOV(EAX, ?); */\r
                                                jitCompPutImm32(w.dst, debugInfo1);\r
-                                               jitCompA0001_movEbpDispReg32(&w, 2304 + 4, IA32_REG0_EAX); /* MOV(debugInfo1, EAX); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 2304 + 4, IA32_REG0_EAX); /* MOV(debugInfo1, EAX); */\r
                                        }\r
                                }\r
                                if (src[1] == 0x01 && src[2] == 0x03) { // DBGINFO1CLR\r
                                        if (level <= JITC_LV_SLOWER) {\r
                                                jitCompPutByte1(w.dst, 0xb8);   /* MOV(EAX, ?); */\r
                                                jitCompPutImm32(w.dst, -1);\r
-                                               jitCompA0001_movEbpDispReg32(&w, 2304 + 4, IA32_REG0_EAX); /* MOV(debugInfo1, EAX); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 2304 + 4, IA32_REG0_EAX); /* MOV(debugInfo1, EAX); */\r
                                        }\r
                                }\r
                                if (src[1] == 0x05 && src[2] == 0x00) { // DBGINFO0\r
@@ -1170,7 +1169,7 @@ int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *sr
                                                //      jitCompPutImm32(&w, debugInfo0);\r
                                                jitCompPutByte1(w.dst, 0xb8);   /* MOV(EAX, ?); */\r
                                                jitCompPutImm32(w.dst, debugInfo0);\r
-                                               jitCompA0001_movEbpDispReg32(&w, 2304 + 0, IA32_REG0_EAX); /* MOV(debugInfo0, EAX); */\r
+                                               jitCompPutOp_MOV_EBPDisp_GReg(&w, 2304 + 0, IA32_REG0_EAX); /* MOV(debugInfo0, EAX); */\r
                                        }\r
                                }\r
                                break;\r
@@ -1256,7 +1255,7 @@ unsigned char *jitCompCallFunc(unsigned char *dst, void *func)
        jitCompPutOp_POPAD(w.dst);\r
        jitCompA000_loadRegCacheAll(&w);\r
        jitCompA000_loadPRegCacheAll(&w);\r
-       jitCompA0001_movReg32EbpDisp(&w, IA32_REG0_EAX, 256 + 0x30 * 32 + 0); /* MOV(EAX, [EBP+?]); */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, 256 + 0x30 * 32 + 0); /* MOV(EAX, [EBP+?]); */\r
        jitCompPutByte2(w.dst, 0xff, 0xe0);     /* JMP(EAX); */\r
        return w.dst;\r
 }\r

diff --git a/jitcx86a.c b/jitcx86a.c
index c33131c..4044493 100644 (file)
--- a/jitcx86a.c
+++ b/jitcx86a.c
@@ -20,32 +20,39 @@ int jitCompGetLabelNum(struct JitCompWork *w, const unsigned char *src)
        return i;\r
 }\r
 \r
-void jitCompA0001_85DispN(struct JitCompWork *w, int disp, int n)\r
+void jitCompPutModRM_Disp_BaseEBP(struct JitCompWork *w, int disp, int opReg)\r
 {\r
+       // EBPをベースとするアドレスオペランドとレジスタオペランドを出力する\r
        disp -= jitCompA0001_EBP128;\r
        if (-128 <= disp && disp <= 127) {\r
-               jitCompPutByte2(w->dst, 0x45 | (n << 3), disp & 0xff);\r
+               // [EBP + Disp08]\r
+               jitCompPutByte1(w->dst, IA32_MOD_R_M(IA32_OP_MOD_INDEX_AND_DISP_BYTE, opReg, IA32_REG5_EBP));\r
+               jitCompPutByte1(w->dst, disp & 0xff);\r
        } else {\r
-               // 10 + reg + 101 + disp\r
-               jitCompPutByte1(w->dst, 0x85 | (n << 3));\r
+               // [EBP + Disp32]\r
+               jitCompPutByte1(w->dst, IA32_MOD_R_M(IA32_OP_MOD_INDEX_AND_DISP_FULL, opReg, IA32_REG5_EBP));\r
                jitCompPutImm32(w->dst, disp);\r
        }\r
        return;\r
 }\r
 \r
-void jitCompA0001_movEbpDispReg32(struct JitCompWork *w, int disp, int reg32)\r
+void jitCompPutOp_MOV_EBPDisp_GReg(struct JitCompWork *w, int disp, int reg32)\r
 {\r
+       // MOV([EBP + disp] <- reg32);\r
        // MOV Ev, Gv\r
-       // MOV + ModR/M(2Mod + 3Reg + 3R/M)\r
-       jitCompPutByte1(w->dst, 0x89); /* 1000 1001 MOV(mem, reg32); */\r
-       jitCompA0001_85DispN(w, disp, reg32);\r
+       // [1000 100 1] [mod reg r/m]\r
+       jitCompPutByte1(w->dst, 0x89);\r
+       jitCompPutModRM_Disp_BaseEBP(w, disp, reg32);\r
        return;\r
 }\r
 \r
-void jitCompA0001_movReg32EbpDisp(struct JitCompWork *w, int reg32, int disp)\r
+void jitCompPutOp_MOV_GReg_EBPDisp(struct JitCompWork *w, int reg32, int disp)\r
 {\r
-       jitCompPutByte1(w->dst, 0x8b); /* MOV(reg32, mem); */\r
-       jitCompA0001_85DispN(w, disp, reg32);\r
+       // MOV (reg32 <- [EBP + disp])\r
+       // MOV Gv, Ev\r
+       // [1000 101 1] [mod reg r/m]\r
+       jitCompPutByte1(w->dst, 0x8b);\r
+       jitCompPutModRM_Disp_BaseEBP(w, disp, reg32);\r
        return;\r
 }\r
 \r
@@ -61,7 +68,7 @@ void jitCompA0001_movEaxRxx(struct JitCompWork *w, int rxx)
        if (rxx >= 0x40 || rxx < 0){\r
                w->err = JITC_ERR_REGNUM;\r
        }\r
-       jitCompA0001_movReg32EbpDisp(w, IA32_REG0_EAX, rxx * 4); /* MOV(EAX, [EBP+?]); */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG0_EAX, rxx * 4);\r
        return;\r
 }\r
 \r
@@ -70,7 +77,7 @@ void jitCompA0001_movRxxEax(struct JitCompWork *w, int rxx)
        if (rxx >= 0x40 || rxx < 0){\r
                w->err = JITC_ERR_REGNUM;\r
        }\r
-       jitCompA0001_movEbpDispReg32(w, rxx * 4, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */\r
+       jitCompPutOp_MOV_EBPDisp_GReg(w, rxx * 4, IA32_REG0_EAX);\r
        return;\r
 }\r
 \r
@@ -99,58 +106,59 @@ void jitCompA0001_checkCompPtr(struct JitCompWork *w, int p0, int p1)
 \r
 void jitCompA000_loadRegCacheAll(struct JitCompWork *w)\r
 {\r
-       jitCompA0001_movReg32EbpDisp(w, 3 /* EBX */, 0 * 4); /* EBX = R00; */\r
-       jitCompA0001_movReg32EbpDisp(w, 1 /* ECX */, 1 * 4); /* ECX = R01; */\r
-       jitCompA0001_movReg32EbpDisp(w, 2 /* EDX */, 2 * 4); /* EDX = R02; */\r
+       //保存されたレジスタキャッシュをメモリからロード\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG3_EBX, 4 * 0); /* EBX = R00; */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG1_ECX, 4 * 1); /* ECX = R01; */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG2_EDX, 4 * 2); /* EDX = R02; */\r
        return;\r
 }\r
 \r
 void jitCompA000_storeRegCacheAll(struct JitCompWork *w)\r
 {\r
-       jitCompA0001_movEbpDispReg32(w, 0 * 4, 3 /* EBX */); /* R00 = EBX; */\r
-       jitCompA0001_movEbpDispReg32(w, 1 * 4, 1 /* ECX */); /* R01 = ECX; */\r
-       jitCompA0001_movEbpDispReg32(w, 2 * 4, 2 /* EDX */); /* R02 = EDX; */\r
+       //レジスタキャッシュをメモリに退避\r
+       jitCompPutOp_MOV_EBPDisp_GReg(w, 0 * 4, IA32_REG3_EBX); /* R00 = EBX; */\r
+       jitCompPutOp_MOV_EBPDisp_GReg(w, 1 * 4, IA32_REG1_ECX); /* R01 = ECX; */\r
+       jitCompPutOp_MOV_EBPDisp_GReg(w, 2 * 4, IA32_REG2_EDX); /* R02 = EDX; */\r
        return;\r
 }\r
 \r
 void jitCompA000_loadRegCacheEcx(struct JitCompWork *w)\r
 {\r
-       jitCompA0001_movReg32EbpDisp(w, 1 /* ECX */, 1 * 4); /* ECX = R01; */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG1_ECX, 1 * 4); /* ECX = R01; */\r
        return;\r
 }\r
 \r
 void jitCompA000_storeRegCacheEcx(struct JitCompWork *w)\r
 {\r
-       jitCompA0001_movEbpDispReg32(w, 1 * 4, 1 /* ECX */); /* R01 = ECX; */\r
+       jitCompPutOp_MOV_EBPDisp_GReg(w, 1 * 4, IA32_REG1_ECX); /* R01 = ECX; */\r
        return;\r
 }\r
 \r
 void jitCompA000_loadRegCacheEdx(struct JitCompWork *w)\r
 {\r
-       jitCompA0001_movReg32EbpDisp(w, 2 /* EDX */, 2 * 4); /* EDX = R02; */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG2_EDX, 2 * 4); /* EDX = R02; */\r
        return;\r
 }\r
 \r
 void jitCompA000_storeRegCacheEdx(struct JitCompWork *w)\r
 {\r
-       jitCompA0001_movEbpDispReg32(w, 2 * 4, 2 /* EDX */); /* R02 = EDX; */\r
+       jitCompPutOp_MOV_EBPDisp_GReg(w, 2 * 4, IA32_REG2_EDX); /* R02 = EDX; */\r
        return;\r
 }\r
 \r
 int jitCompA000_selectRegCache(int rxx, int reg)\r
 {\r
+       // OSECPUレジスタ番号をIA32レジスタ番号へ変換\r
+       // 対応するキャッシュレジスタがない場合regが返る\r
        switch (rxx) {\r
                case 0:\r
-                       //EBX\r
-                       reg = 3;\r
+                       reg = IA32_REG3_EBX;\r
                        break;\r
                case 1:\r
-                       //ECX\r
-                       reg = 1;\r
+                       reg = IA32_REG1_ECX;\r
                        break;\r
                case 2:\r
-                       //EDX\r
-                       reg = 2;\r
+                       reg = IA32_REG2_EDX;\r
                        break;\r
        }\r
        return reg;\r
@@ -158,17 +166,17 @@ int jitCompA000_selectRegCache(int rxx, int reg)
 \r
 void jitCompA000_loadPRegCacheAll(struct JitCompWork *w)\r
 {\r
-       //      jitCompA0001_movReg32EbpDisp(w, 5 /* EBP */, 256 + 0 * 32 + 0); /* EBP = P00; */\r
-       jitCompA0001_movReg32EbpDisp(w, 6 /* ESI */, 256 + 1 * 32 + 0); /* ESI = P01; */\r
-       jitCompA0001_movReg32EbpDisp(w, 7 /* EDI */, 256 + 2 * 32 + 0); /* EDI = P02; */\r
+       //      jitCompPutOp_MOV_GReg_EBPDisp(w, 5 /* EBP */, 256 + 0 * 32 + 0); /* EBP = P00; */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG6_ESI, 256 + 1 * 32 + 0); /* ESI = P01; */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG7_EDI, 256 + 2 * 32 + 0); /* EDI = P02; */\r
        return;\r
 }\r
 \r
 void jitCompA000_storePRegCacheAll(struct JitCompWork *w)\r
 {\r
-       //      jitCompA0001_movEbpDispReg32(w, 256 + 0 * 32 + 0, 5 /* EBP */); /* P00 = EBP; */\r
-       jitCompA0001_movEbpDispReg32(w, 256 + 1 * 32 + 0, 6 /* ESI */); /* P01 = ESI; */\r
-       jitCompA0001_movEbpDispReg32(w, 256 + 2 * 32 + 0, 7 /* EDI */); /* P02 = EDI; */\r
+       //      jitCompPutOp_MOV_EBPDisp_GReg(w, 256 + 0 * 32 + 0, 5 /* EBP */); /* P00 = EBP; */\r
+       jitCompPutOp_MOV_EBPDisp_GReg(w, 256 + 1 * 32 + 0, IA32_REG6_ESI); /* P01 = ESI; */\r
+       jitCompPutOp_MOV_EBPDisp_GReg(w, 256 + 2 * 32 + 0, IA32_REG7_EDI); /* P02 = EDI; */\r
        return;\r
 }\r
 \r
@@ -229,7 +237,7 @@ void jitCompA0001_checkType0(struct JitCompWork *w, int pxx, int typ, int ac)
 {\r
        if (typ <= 0) { w->err = JITC_ERR_BADTYPE; }\r
        if (typ > 0x7f) { w->err = JITC_ERR_INTERNAL; }\r
-       jitCompA0001_movReg32EbpDisp(w, 0 /* EAX */, 256 + pxx * 32 + 4); /* MOV(EAX, [EBP+?]); */      /* typ */\r
+       jitCompPutOp_MOV_GReg_EBPDisp(w, IA32_REG0_EAX, 256 + pxx * 32 + 4); /* MOV(EAX, [EBP+?]); */   /* typ */\r
        jitCompPutByte3(w->dst, 0x83, 0xf8, typ & 0x7f);        /* CMP(EAX, ?); */\r
        jitCompPutByte2(w->dst, 0x0f, 0x85); /* JNE */\r
        jitCompPutImm32(w->dst, errfnc - (w->dst + 4));\r
@@ -237,9 +245,9 @@ void jitCompA0001_checkType0(struct JitCompWork *w, int pxx, int typ, int ac)
 }\r
 \r
 void jitCompA0001_checkType(struct JitCompWork *w, int pxx, int typ, int ac)\r
-// data用.\r
-// 将来的にはaliveやアクセス権チェックも入れる\r
 {\r
+       // data用.\r
+       // 将来的にはaliveやアクセス権チェックも入れる\r
        jitCompA0001_checkType0(w, pxx, typ, ac);\r
        return;\r
 }\r
@@ -247,11 +255,11 @@ void jitCompA0001_checkType(struct JitCompWork *w, int pxx, int typ, int ac)
 void jitCompA0001_checkLimit(struct JitCompWork *w, int reg, int pxx)\r
 {\r
        jitCompPutByte1(w->dst, 0x3b);  /* CMP(reg, [EBP+?]); */\r
-       jitCompA0001_85DispN(w, 256 + pxx * 32 + 8, reg);       /* p0 */\r
+       jitCompPutModRM_Disp_BaseEBP(w, 256 + pxx * 32 + 8, reg);       /* p0 */\r
        jitCompPutByte2(w->dst, 0x0f, 0x82); /* JB */\r
        jitCompPutImm32(w->dst, errfnc - (w->dst + 4));\r
        jitCompPutByte1(w->dst, 0x3b);  /* CMP(reg, [EBP+?]); */\r
-       jitCompA0001_85DispN(w, 256 + pxx * 32 + 12, reg);      /* p1 */\r
+       jitCompPutModRM_Disp_BaseEBP(w, 256 + pxx * 32 + 12, reg);      /* p1 */\r
        jitCompPutByte2(w->dst, 0x0f, 0x83); /* JAE */\r
        jitCompPutImm32(w->dst, errfnc - (w->dst + 4));\r
        return;\r