jitcx86.c

   1 #include "osecpu.h"
   2 #include "jitc.h"
   3
   4 #if (JITC_ARCNUM == 0x0001)
   5 //
   6 // for x86-32bit
   7 //
   8
   9 // F5の場合、decoderが対応するalloc-freeを結びつけるのが簡単で、typやlenを指定必須にしてもフロントエンドコードに影響はない.
  10 int jitCompiler(unsigned char *dst, unsigned char *dst1, const unsigned char *src, const unsigned char *src1, const unsigned char *src0, HOSECPU_LabelListTag *label, int maxLabels, int level, int debugInfo1, int flags)
  11 {
  12         // For IA-32 (x86, 32-bit)
  13         // 本来ならこのレイヤでは文法チェックしない
  14         //
  15         // dst : 現在の書き込みアドレス。
  16         // dst1 : 書き込みアドレスの最大値
  17         // src : 現在の読み込みアドレス(ヘッダ部は飛ばしてある
  18         // src1 : 読み込みアドレスの最大値
  19         // src0 : 読み込みバイナリのアドレス
  20         struct JitCompWork w;
  21         unsigned char *dst00 = dst, *enter0 = NULL, *tmp_ucp;
  22         char *errmsg = "";
  23         const unsigned char *oldsrc;
  24         int timecount = 0, i, j = 0, lastlabel = -1, debugInfo0 = -1;
  25         int reg0, reg1, reg2, cmp0reg = -1, cmp0lev = 0;
  26
  27         w.dst = w.dst0 = dst;
  28         w.err = 0;
  29         w.maxLabels = maxLabels;
  30
  31         if ((flags & JITC_NOSTARTUP) == 0) {
  32                 jitCompPutOp_PUSHAD(w.dst);
  33                 // Load cache
  34                 jitCompA000_loadRegCacheAll(&w);
  35                 jitCompA000_loadPRegCacheAll(&w);
  36         }
  37         if (level <= JITC_LV_SLOWER) {
  38                 // env.debugInfo0 <- 0;
  39                 // env.debugInfo1 <- debugInfo1;
  40                 jitCompPutOp_MOV_EAX_ZERO(w.dst);
  41                 jitCompPutOp_MOV_EBPDisp_GReg(&w, envOffset_DBGINFO0, IA32_REG0_EAX);
  42                 jitCompPutOp_MOV_GReg_Imm32(w.dst, IA32_REG0_EAX, debugInfo1);
  43                 jitCompPutOp_MOV_EBPDisp_GReg(&w, envOffset_DBGINFO1, IA32_REG0_EAX);
  44         }
  45         while (src < src1) {
  46                 w.prefix = 0;   //0x04 CND 命令で変更される
  47                 if (w.dst + 256 > dst1) {
  48                         // 書き込み領域が残り256バイト未満ならエラー
  49                         w.err = JITC_ERR_DST1;
  50                         goto err_w;
  51                 }
  52                 timecount++;
  53                 if (timecount >= 64) {
  54                         timecount -= 64;
  55                         /* 未完成(timeoutチェックコードを入れる) */
  56                 }
  57                 if(*src != 0x00 && *src != 0x01 && *src != 0x34){
  58                         DEBUGCode(&w, *src);
  59                 }
  60         prefix_continue:
  61                 // CND命令コンパイル後ここに戻る
  62                 switch (*src) {
  63                         case 0x00:
  64                                 // NOP
  65                                 if (w.prefix != 0) {
  66                                         // 「条件付きでNOPを実行」するなんて、矛盾している!
  67                                         w.err = JITC_ERR_PREFIX;
  68                                         goto err_w;
  69                                 }
  70                                 break;
  71
  72                         case 0x01:
  73                                 // LB : ラベル設置命令。(6byte)
  74                                 // ・prefex = 1にする
  75                                 // ・timecount++し、timecountのチェックをする。
  76                                 // ・ラベル位置を登録する。
  77                                 // ・割り込みがある場合、このタイミングで割り込みを発生させる。
  78                                 //      Encode:
  79                                 //  0   1       2345
  80                                 //      01      opt     imm32
  81                                 //
  82                                 if (enter0 == NULL && (src[6] == 0x3c /* 多数のレジスタをスタックに退避 */ || (src[6] == 0xfe/* REMARK */ && src[7] == 0x01 && src[9] == 0x3c))) {
  83                                         //beginFunc()中のLB
  84                                         // LB命令の後に0x3C命令・・・beginFunc()
  85                                         enter0 = w.dst;
  86                                         jitCompPutOp_JMPnear(w.dst, 0);
  87                                 }
  88
  89                                 if (src[6] == 0x34) {
  90                                         // 後続命令はDATA
  91                                         // なので、DATA部分をJMPですっとばすコードを生成
  92                                         // DAT_SA0(label, typ32, length) ・・・メモリ確保命令
  93
  94                                         i = jitCompGetImm32(&src[6 + 1]);       // type32 を取得
  95                                         j = 32;
  96
  97                                         if (i != 1) {
  98                                                 i = jitCompA000_convTyp(i);
  99                                                 j = 0;
 100                                                 switch (i >> 1) {
 101                                                         case 1:
 102                                                                 j = 1;
 103                                                                 break;
 104                                                         case 2:
 105                                                                 j = 2;
 106                                                                 break;
 107                                                         case 3:
 108                                                                 j = 4;
 109                                                                 break;
 110                                                 }
 111                                         }
 112                                         // jはデータサイズになる
 113                                         j *= jitCompGetImm32(&src[6 + 5]);      // len32
 114                                         if (j <= 0){
 115                                                 w.err = JITC_ERR_BADTYPE;
 116                                         }
 117                                         // DATA部分を飛び越すジャンプ
 118                                         tmp_ucp = w.dst;
 119                                         jitCompPutOp_JMPnear(w.dst, j);
 120
 121 #if (jitCompA0001_OPTIMIZE_JMP != 0)
 122                                         if (j < 127 - jitCompA0001_OPTIMIZE_ALIGN) {
 123                                                 //飛び先が十分近いので
 124                                                 // 今書いたのはなかったことにして、
 125                                                 w.dst -= 5;
 126                                                 // よりサイズの小さな書き方にする
 127                                                 jitCompPutOp_JMPshort(w.dst, j);
 128                                         }
 129 #endif
 130                                 }
 131 #if (jitCompA0001_OPTIMIZE_ALIGN != 0)
 132                                 // アラインを jitCompA0001_OPTIMIZE_ALIGNにそろえる
 133
 134                                 i = ((int)w.dst + 1) & (jitCompA0001_OPTIMIZE_ALIGN - 1); /* ALIGNで割ったあまりを計算 */
 135                                 i = jitCompA0001_OPTIMIZE_ALIGN - i;
 136                                 if (i == 1) { jitCompPutByte1(w.dst, 0x90); j += i; } /* NOP(); */
 137                                 if (i == 2) { jitCompPutByte2(w.dst, 0x89, 0xc0); j += i; } /* MOV(EAX, EAX); */
 138                                 if (i == 3) { jitCompPutByte3(w.dst, 0x8d, 0x76, 0x00); j += i; } /* LEA(ESI, [ESI+0]); */
 139                                 if (i == 4) { jitCompPutByte4(w.dst, 0x8d, 0x74, 0x26, 0x00); j += i; } /* LEA(ESI, [ESI*1+0]); */
 140                                 if (i == 5) { jitCompPutByte1(w.dst, 0x0d); jitCompPutImm32(w.dst, 0); j += i; } /* OR(EAX, 0); */
 141                                 if (i == 6) { jitCompPutByte2(w.dst, 0x8d, 0xb6); jitCompPutImm32(w.dst, 0); j += i; } /* LEA(ESI, [ESI+0]); */
 142                                 if (i == 7) { jitCompPutByte3(w.dst, 0x8d, 0xb4, 0x26); jitCompPutImm32(w.dst, 0); j += 7; } /* LEA(ESI, [ESI*1+0]); */
 143 #endif
 144                                 if (src[6] == 0x34) {
 145                                         // 後続命令はDATA
 146                                         // パディングに合わせて一個前の相対ジャンプを修正
 147                                         tmp_ucp[1] = j & 0xff;
 148                                         if (*tmp_ucp == 0xe9) {
 149                                                 // Near jump so imm is DWORD
 150                                                 tmp_ucp[2] = (j >> 8) & 0xff;
 151                                                 tmp_ucp[3] = (j >> 16) & 0xff;
 152                                                 tmp_ucp[4] = (j >> 24) & 0xff;
 153                                         }
 154                                 }
 155                                 if ((flags & JITC_PHASE1) == 0) {
 156                                         i = jitCompGetLabelNum(&w, src + 2);
 157                                         if (label[i].opt != 0 && w.err == 0) {
 158                                                 w.err = JITC_ERR_LABELREDEF;
 159                                                 goto err_w;
 160                                         }
 161                                         if (w.prefix != 0) {
 162                                                 w.err = JITC_ERR_PREFIX;
 163                                                 goto err_w;
 164                                         }
 165                                         label[i].opt = src[1] + 1;
 166                                         label[i].typ = 0; /* TYP_CODE */
 167                                         label[i].p = w.dst;
 168                                         label[i].p1 = w.dst + 1;
 169                                         lastlabel = i;
 170                                 }
 171                                 cmp0reg = -1;
 172                                 timecount = 0;
 173                                 /* 未完成(timeoutチェックコードを入れる) */
 174                                 break;
 175
 176                         case 0x02:
 177                                 // LIMM : 定数即値代入命令(6byte)
 178                                 // Encode:
 179                                 // 0    1               2345
 180                                 // 02   reg0R   imm32
 181                                 //
 182                                 // reg3F は条件比較慣用句指定用＆演算命令即値慣用句指定用。よってCND命令の直後では使用できない。
 183
 184                                 if (src[1] == 0x3f && w.prefix != 0){
 185                                         // CND命令の直後でR3Fを書き換えるなんて変だよね
 186                                         w.err = JITC_ERR_PREFIX;
 187                                 }
 188
 189 #if (jitCompA0001_USE_R3F_IMM32 != 0)
 190                                 if (src[1] == 0x3f) {
 191                                         // R3Fへの代入は例外で、 w.r3f を使用
 192                                         w.r3f = jitCompGetImm32(src + 2);
 193                                         break;
 194                                 }
 195 #endif
 196                                 i = jitCompGetImm32(src + 2);   // 与えられた即値(第二引数)を取得
 197                                 /* R00-R02 なら EBX, ECX, EDX 、それ以外なら EAX のレジスタIDを reg0 に代入 */
 198                                 reg0 = jitCompA000_selectRegCache(src[1], IA32_REG0_EAX);
 199
 200 #if (jitCompA0001_OPTIMIZE_MOV != 0)
 201                                 // size optimization
 202                                 // MOV reg, 0 -> XOR reg, reg
 203                                 if (i == 0) {
 204                                         jitCompPutOp_XOR_GReg_GReg(w.dst, reg0, reg0);
 205                                         jitCompA0001_movRxxEax(&w, src[1]);
 206                                         break;
 207                                 }
 208 #endif
 209                                 /* reg0 のレジスタに対応したMOV命令を発行 */
 210                                 jitCompPutOp_MOV_GReg_Imm32(w.dst, reg0, i);
 211
 212                                 if (reg0 == 0){
 213                                         // R03以降の、レジスタの内容をメモリ上に格納してエミュレートする場合
 214                                         jitCompA0001_movRxxEax(&w, src[1]);
 215                                 }
 216
 217                                 break;
 218
 219                         case 0x03: /* 未完成(plsまで対応) */
 220                                  // PLIMM : ラベル番号代入命令(6byte)
 221                                  // Encode:
 222                                  //     0       1       2345
 223                                  //     03      PXX     imm32
 224                                  //
 225                                  // ・P28 はAPI用
 226                                  // ・P30 はリターンアドレス
 227                                  // ・P3F はプログラムカウンタ
 228                                  //
 229
 230                                 i = jitCompGetLabelNum(&w, src + 2);    // Pxxに代入するラベルの番号(第二引数)
 231                                 if ((flags & JITC_PHASE1) != 0 && w.err == 0) {
 232                                         // Phase 1であるならば
 233                                         if (label[i].opt == 0) {
 234                                                 // 指定されたラベル番号は存在しない
 235                                                 w.err = JITC_ERR_LABELNODEF;
 236                                                 goto err_w;
 237                                         }
 238                                         if (src[1] != 0x3f && label[i].opt != 2) {
 239                                                 // ?
 240                                                 w.err = JITC_ERR_LABELTYP;
 241                                                 goto err_w;
 242                                         }
 243                                         if (src[1] == 0x3f && label[i].typ != 0) {
 244                                                 // プログラムカウンタに TYP_CODEでない値は代入できない
 245                                                 w.err = JITC_ERR_LABELTYP;
 246                                                 goto err_w;
 247                                         }
 248                                 }
 249                                 if (src[1] == 0x3f) {
 250                                         // プログラムカウンタへの代入
 251                                         if (w.prefix == 0) {
 252                                                 // CND命令による条件付きでなければ、即座に移動
 253                                                 jitCompPutByte1(w.dst, 0xe9); /* JMP(?); */
 254                                         } else {
 255                                                 // 直前はCND命令。
 256
 257                                                 /*
 258                                                  * CND命令
 259                                                  *      1       2
 260                                                  *      04      reg0R
 261                                                  *
 262                                                  * いま、dstの末端はJZ命令になっている。 0x0F 0x84 cd
 263                                                  */
 264
 265                                                 // Jccの条件変更
 266                                                 // 0F 75
 267                                                 w.dst[-1] = w.dst[-2] ^ 0xf1; /* 74->85, 75->84 */
 268                                                 w.dst[-2] = 0x0f;
 269
 270                                                 w.prefix = 0;
 271                                         }
 272                                         j = 0;
 273                                         if ((flags & JITC_PHASE1) != 0 || (((flags & JITC_PHASE1) == 0) && label[i].opt != 0))  // label番号iが確保されていれば (このif文は意味をなさない)
 274                                                 j = label[i].p - (w.dst + 4);   // j はとび先の相対番地
 275                                         jitCompPutImm32(w.dst, j);      // JMP もしくは JZ 命令のアドレス部を記述
 276 #if (jitCompA0001_OPTIMIZE_JMP != 0)
 277                                         if (-128 - 3 <= j && j < 0) {
 278                                                 if (w.dst[-5] == 0xe9) {
 279                                                         j += 3;
 280                                                         w.dst -= 5;
 281                                                         jitCompPutByte1(w.dst, 0xeb); /* JMP(?); */
 282                                                 } else {
 283                                                         j += 4;
 284                                                         w.dst -= 6;
 285                                                         jitCompPutByte1(w.dst, w.dst[1] ^ 0xf0);
 286                                                 }
 287                                                 jitCompPutByte1(w.dst, j & 0xff);
 288                                         }
 289 #endif
 290                                 } else {        // プログラムカウンタ以外への代入
 291                                         // 代入先が P01, P02なら ESI, EDI,それ以外ならEAXを指定
 292                                         reg0 = jitCompA000_selectPRegCache(src[1], IA32_REG0_EAX);
 293                                         // ラベルのパスを各レジスタに代入
 294                                         jitCompPutOp_MOV_GReg_Imm32(w.dst, reg0, (int)label[i].p);
 295                                         // レジスタへの代入をメモリでエミュレーションする場合は、スタックに書き込む。
 296                                         if (reg0 == 0){
 297                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + 0, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */
 298                                         }
 299
 300                                         if (level < JITC_LV_FASTEST) {
 301                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + 8, reg0);                                /* p0 */
 302                                                 jitCompPutOp_MOV_GReg_Imm32(w.dst, IA32_REG0_EAX, label[i].typ);
 303                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + 4, IA32_REG0_EAX);       /* typ */
 304                                                 jitCompPutOp_MOV_GReg_Imm32(w.dst, IA32_REG0_EAX, (int)label[i].p1);
 305                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + 12, IA32_REG0_EAX);  /* p1 */
 306                                                 jitCompPutOp_MOV_EAX_ZERO(w.dst);
 307                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + 16, IA32_REG0_EAX);      /* liveSign */
 308                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, envOffset_PTRCTRL);
 309                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + 20, IA32_REG0_EAX);      /* pls */
 310                                         }
 311                                 }
 312                                 break;
 313
 314                         case 0x04:
 315                                 // CND (prefix)
 316                                 // 与えられたRxxの最下位ビットが1であれば後続の命令を実行、そうでなければ飛ばす。
 317
 318                                 if (src[1] >= 0x40){
 319                                         // R00-R3F 以外のレジスタは比較対象にできない
 320                                         w.err = JITC_ERR_REGNUM;
 321                                         goto err_w;
 322                                 }
 323
 324                                 // 比較対象のレジスタがメモリ上にあれば-1, それ以外なら適切なレジスタ番号を返す
 325                                 reg0 = jitCompA000_selectRegCache(src[1], -1 /* mem */);
 326
 327                                 /* TEST命令を発行 */
 328                                 if (reg0 < 0) {
 329                                         // 比較対象のレジスタはメモリ上にある
 330                                         jitCompPutByte1(w.dst, 0xf7); /* TEST = 1111 011w : mod 000 r/m : immediate data */
 331                                         jitCompPutModRM_Disp_BaseEBP(&w, src[1] * 4, 0);
 332                                 } else {
 333                                         // 比較対象はキャッシュレジスタ上にある
 334                                         jitCompPutByte2(w.dst, 0xf7, 0xc0 | reg0); /* TEST = 1111 011w : 11 000 reg : immediate data */
 335                                 }
 336                                 jitCompPutImm32(w.dst, 1);
 337
 338                                 /* JZ命令を発行 */
 339                                 jitCompPutByte2(w.dst, 0x74, 0x00);     /* JZ($+2) */
 340                                 cmp0reg = -1;
 341                                 if (w.err != 0){
 342                                         goto err_w;
 343                                 }
 344                                 src += 2;
 345                                 w.prefix = 1;   // プリフィックスをセット
 346                                 w.dst0 = w.dst;
 347                                 goto prefix_continue;
 348
 349                         case 0x08: /* LMEM */   /* 完成 */
 350                                 i = jitCompGetImm32(src + 2);
 351                                 if (i == 0x0001){
 352                                         w.err = JITC_ERR_BADTYPE;
 353                                 }
 354                                 if (level < JITC_LV_FASTER) {
 355                                         jitCompA0001_checkType(&w, src[6], i, 0); // read
 356                                         cmp0reg = -1;
 357                                 }
 358                                 reg0 = jitCompA000_selectRegCache(src[1], IA32_REG0_EAX);
 359                                 reg1 = jitCompA000_selectPRegCache(src[6], IA32_REG2_EDX);
 360                                 if (reg0 != IA32_REG0_EAX && reg1 == IA32_REG2_EDX){
 361                                         reg1 = IA32_REG0_EAX;
 362                                 }
 363                                 if (reg1 == IA32_REG2_EDX){
 364                                         jitCompA000_storeRegCacheEdx(&w);
 365                                 }
 366                                 if (reg1 <= 3 /* EAX, EDX */){
 367                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, reg1, PRegOffset(src[6]));
 368                                 }
 369                                 if (level < JITC_LV_FASTER){
 370                                         jitCompA0001_checkLimit(&w, reg1, src[6]);
 371                                 }
 372                                 i = jitCompA000_convTyp(jitCompGetImm32(src + 2));
 373                                 switch (i) {
 374                                         case 0x0002:
 375                                                 jitCompPutByte3(w.dst, 0x0f, 0xbe, reg0 << 3 | reg1);   /* MOVSX(reg0,BYTE [reg1]); */
 376                                                 break;
 377                                         case 0x0003:
 378                                                 jitCompPutByte3(w.dst, 0x0f, 0xb6, reg0 << 3 | reg1);   /* MOVZX(reg0,BYTE [reg1]); */
 379                                                 break;
 380                                         case 0x0004:
 381                                                 jitCompPutByte3(w.dst, 0x0f, 0xbf, reg0 << 3 | reg1);   /* MOVSX(reg0,WORD [reg1]); */
 382                                                 break;
 383                                         case 0x0005:
 384                                                 jitCompPutByte3(w.dst, 0x0f, 0xb7, reg0 << 3 | reg1);   /* MOVZX(reg0,WORD [reg1]); */
 385                                                 break;
 386                                         case 0x0006:
 387                                         case 0x0007:
 388                                                 jitCompPutByte2(w.dst, 0x8b, reg0 << 3 | reg1); /* MOV(reg0, [reg1]); */
 389                                                 break;
 390                                         default:
 391                                                 w.err = JITC_ERR_BADTYPE;
 392                                 }
 393                                 if (reg0 == IA32_REG0_EAX){
 394                                         jitCompA0001_movRxxEax(&w, src[1]);
 395                                 }
 396                                 if (reg1 == IA32_REG2_EDX){
 397                                         jitCompA000_loadRegCacheEdx(&w);
 398                                 }
 399                                 break;
 400
 401                         case 0x09: /* SMEM */   /* 完成 */
 402                                 i = jitCompGetImm32(src + 2);
 403                                 if (i == 0x0001){
 404                                         w.err = JITC_ERR_BADTYPE;
 405                                 }
 406                                 if (level < JITC_LV_FASTER) {
 407                                         jitCompA0001_checkType(&w, src[6], i, 1); // write
 408                                         cmp0reg = -1;
 409                                 }
 410                                 reg0 = jitCompA000_selectRegCache(src[1], IA32_REG0_EAX);
 411                                 reg1 = jitCompA000_selectPRegCache(src[6], IA32_REG2_EDX);
 412                                 if (reg0 != IA32_REG0_EAX && reg1 == IA32_REG2_EDX){
 413                                         reg1 = IA32_REG0_EAX;
 414                                 }
 415                                 if (reg1 == IA32_REG2_EDX){
 416                                         jitCompA000_storeRegCacheEdx(&w);
 417                                 }
 418                                 if (reg1 <= 3 /* EAX, EDX */){
 419                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, reg1, PRegOffset(src[6]) + 0); /* MOV(reg1, [EBP+?]); */
 420                                 }
 421                                 if (level < JITC_LV_FASTER){
 422                                         jitCompA0001_checkLimit(&w, reg1, src[6]);
 423                                 }
 424                                 if (reg0 == IA32_REG0_EAX){
 425                                         jitCompA0001_movEaxRxx(&w, src[1]);
 426                                 }
 427                                 /* 値の範囲チェック */
 428                                 i = jitCompA000_convTyp(jitCompGetImm32(src + 2));
 429                                 switch (i) {
 430                                         case 0x0002:
 431                                         case 0x0003:
 432                                                 jitCompPutByte2(w.dst, 0x88, reg0 << 3 | reg1); /* MOV([reg1], BYTE(reg0)); */
 433                                                 break;
 434                                         case 0x0004:
 435                                         case 0x0005:
 436                                                 jitCompPutByte3(w.dst, 0x66, 0x89, reg0 << 3 | reg1);   /* MOV([reg1], WORD(reg0)); */
 437                                                 break;
 438                                         case 0x0006:
 439                                         case 0x0007:
 440                                                 jitCompPutByte2(w.dst, 0x89, reg0 << 3 | reg1); /* MOV([reg1], reg0); */
 441                                                 break;
 442                                         default:
 443                                                 w.err = JITC_ERR_BADTYPE;
 444                                 }
 445                                 if (reg1 == IA32_REG2_EDX){
 446                                         jitCompA000_loadRegCacheEdx(&w);
 447                                 }
 448                                 break;
 449
 450                         case 0x0a: /* PLMEM */  /* 完成 */
 451                                 i = jitCompGetImm32(src + 2);
 452                                 if (i != 0x0001){
 453                                         w.err = JITC_ERR_BADTYPE;
 454                                 }
 455                                 if (level < JITC_LV_FASTER) {
 456                                         jitCompA0001_checkType(&w, src[6], i, 0); // read
 457                                         cmp0reg = -1;
 458                                 }
 459                                 reg0 = jitCompA000_selectPRegCache(src[1], IA32_REG0_EAX);
 460                                 reg1 = jitCompA000_selectPRegCache(src[6], IA32_REG2_EDX);
 461                                 //      if (reg0 != 0 /* EAX */ && reg1 == 2 /* EDX */) /* これをやってはいけない！(by K, 2013.08.02) */
 462                                 //              reg1 = 0; /* EAX */
 463                                 if (reg0 == reg1 && reg0 != 0) {
 464                                         // bugfix: hinted by yao, 2013.09.14. thanks!
 465                                         jitCompA000_storePRegCacheAll(&w);
 466                                         reg1 = IA32_REG2_EDX;
 467                                 }
 468                                 if (reg1 == IA32_REG2_EDX){
 469                                         jitCompA000_storeRegCacheEdx(&w);
 470                                 }
 471                                 if (reg1 <= 3 /* EAX, EDX */){
 472                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, reg1, PRegOffset(src[6])); /* MOV(reg1, [EBP+?]); */
 473                                 }
 474                                 if (level < JITC_LV_FASTER){
 475                                         jitCompA0001_checkLimit(&w, reg1, src[6]);
 476                                 }
 477                                 jitCompPutByte2(w.dst, 0x8b, reg0 << 3 | reg1); /* MOV(reg0, [reg1]); */
 478                                 if (reg0 == IA32_REG0_EAX){
 479                                         jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]), IA32_REG0_EAX); /* MOV([EBP+?], EAX); */
 480                                 }
 481                                 for (i = 4; i < 32; i += 4) {
 482                                         jitCompPutByte3(w.dst, 0x8b, 0x40 | reg1, i);   /* MOV(EAX, [reg1+?]); */
 483                                         jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */
 484                                 }
 485                                 if (reg1 == IA32_REG2_EDX){
 486                                         jitCompA000_loadRegCacheEdx(&w);
 487                                 }
 488                                 break;
 489
 490                         case 0x0b: /* PSMEM */  /* 完成 */
 491                                 i = jitCompGetImm32(src + 2);
 492                                 if (i != 0x0001) w.err = JITC_ERR_BADTYPE;
 493                                 if (level < JITC_LV_FASTER) {
 494                                         jitCompA0001_checkType(&w, src[6], i, 1); // write
 495                                         cmp0reg = -1;
 496                                 }
 497                                 reg0 = jitCompA000_selectPRegCache(src[1], IA32_REG0_EAX);
 498                                 reg1 = jitCompA000_selectPRegCache(src[6], IA32_REG2_EDX);
 499                                 /* これをやってはいけない！(by K, 2013.08.02) */
 500                                 //      if (reg0 != 0 /* EAX */ && reg1 == 2 /* EDX */)
 501                                 //              reg1 = 0; /* EAX */
 502                                 if (reg1 == IA32_REG2_EDX){
 503                                         jitCompA000_storeRegCacheEdx(&w);
 504                                 }
 505                                 if (reg1 <= 3 /* EAX, EDX */){
 506                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, reg1, PRegOffset(src[6])); /* MOV(reg1, [EBP+?]); */
 507                                 }
 508                                 if (level < JITC_LV_FASTER){
 509                                         jitCompA0001_checkLimit(&w, reg1, src[6]);
 510                                 }
 511                                 if (reg0 == IA32_REG0_EAX){
 512                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, PRegOffset(src[1])); /* MOV(reg0, [EBP+?]); */
 513                                 }
 514                                 jitCompPutByte2(w.dst, 0x89, reg0 << 3 | reg1); /* MOV([reg1], reg0); */
 515                                 for (i = 4; i < 32; i += 4) {
 516                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(src[1]) + i); /* MOV(EAX, [EBP+?]); */
 517                                         jitCompPutByte3(w.dst, 0x89, 0x40 | reg1, i);   /* MOV([reg1+?], EAX); */
 518                                 }
 519                                 if (reg1 == IA32_REG2_EDX)
 520                                         jitCompA000_loadRegCacheEdx(&w);
 521                                 break;
 522
 523                         case 0x0e: /* PADD */           /* 完成 */
 524                                 if (level < JITC_LV_FASTER) {
 525                                         jitCompA0001_checkType0(&w, src[6], jitCompGetImm32(src + 2), 2); // other, aliveテストはとりあえずしない.
 526                                         cmp0reg = -1;
 527                                 }
 528                                 reg0 = jitCompA000_selectPRegCache(src[1], IA32_REG0_EAX);
 529                                 reg1 = jitCompA000_selectPRegCache(src[6], -1 /* mem */);
 530                                 if (reg1 < 0 /* mem */){
 531                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, PRegOffset(src[6])); /* MOV(reg0, [EBP+?]); */
 532                                 }
 533                                 if (reg1 >= 0 && reg0 != reg1) {
 534                                         jitCompPutByte2(w.dst, 0x89, 0xc0 | reg1 << 3 | reg0); /* MOV(reg0, reg1); */
 535                                 }
 536                                 i = jitCompGetImm32(src + 2);
 537                                 j = -1;
 538                                 if (i == 1){
 539                                         j = 5; /* 32 */
 540                                 } else {
 541                                         i = jitCompA000_convTyp(i);
 542                                         if (0x0002 <= i && i <= 0x0007){
 543                                                 j = (i - 0x0002) >> 1;
 544                                         }
 545                                 }
 546                                 if (j < 0) {
 547                                         w.err = JITC_ERR_BADTYPE;
 548                                         goto err_w;
 549                                 }
 550 #if (jitCompA0001_USE_R3F_IMM32 != 0)
 551                                 if (src[7] == 0x3f) {
 552                                         j = w.r3f << j;
 553 #if (jitCompA0001_USE_R3F_IMM8 != 0)
 554                                         if (-0x80 <= j && j <= 0x7f) {
 555 #if (jitCompA0001_USE_R3F_INCDEC != 0)
 556                                                 if (j == 1) {
 557                                                          /* INC */
 558                                                         jitCompPutByte1(w.dst, 0x40 | reg0);
 559                                                         goto padd1;
 560                                                 }
 561                                                 if (j == -1) {
 562                                                          /* DEC */
 563                                                         jitCompPutByte1(w.dst, 0x48 | reg0);
 564                                                         goto padd1;
 565                                                 }
 566 #endif
 567                                                 /* ADD(reg0, im8); */
 568                                                 jitCompPutByte3(w.dst, 0x83, 0xc0 | reg0, j & 0xff);
 569                                                 goto padd1;
 570                                         }
 571 #endif
 572                                         if (reg0 == 0) {
 573                                                 jitCompPutByte1(w.dst, 0x05);   /* ADD(reg0, ?); */
 574                                         } else {
 575                                                 jitCompPutByte2(w.dst, 0x81, 0xc0 | reg0);      /* ADD(reg0, ?); */
 576                                         }
 577                                         jitCompPutImm32(w.dst, j);
 578                                         goto padd1;
 579                                 }
 580 #endif
 581                                 if (src[7] >= 0x40){
 582                                         w.err = JITC_ERR_REGNUM;
 583                                 }
 584                                 if (j == 0) {
 585                                         reg1 = jitCompA000_selectRegCache(src[7], -1 /* mem */);
 586                                         if (reg1 >= 0) {
 587                                                 jitCompPutByte2(w.dst, 0x01, 0xc0 | reg1 << 3 | reg0);  /* ADD(reg0, reg1); */
 588                                         } else {
 589                                                 jitCompPutByte1(w.dst, 0x03);   /* ADD(reg0, [EBP+?]); */
 590                                                 jitCompPutModRM_Disp_BaseEBP(&w, src[7] * 4, reg0);
 591                                         }
 592                                 }
 593                                 else {
 594                                         reg1 = jitCompA000_selectRegCache(src[7], -1 /* mem */);
 595                                         reg2 = IA32_REG2_EDX;
 596                                         jitCompA000_storeRegCacheEdx(&w);
 597                                         if (reg1 < 0){
 598                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, reg2, src[7] * 4); /* MOV(reg2, [EBP+?]); */
 599                                         }
 600                                         if (reg1 >= 0 && reg1 != reg2) {
 601                                                 jitCompPutByte2(w.dst, 0x89, 0xc0 | reg1 << 3 | reg2); /* MOV(reg2, reg1); */
 602                                         }
 603                                         jitCompPutByte3(w.dst, 0xc1, 0xe0 | reg2, j);   /* SHL(reg2, ?); */
 604                                         jitCompPutByte2(w.dst, 0x01, 0xc0 | reg2 << 3 | reg0);  /* ADD(reg0, reg2); */
 605                                         jitCompA000_loadRegCacheEdx(&w);
 606                                 }
 607 #if (jitCompA0001_USE_R3F_IMM32 != 0)
 608                         padd1:
 609 #endif
 610                                 if (reg0 == IA32_REG0_EAX){
 611                                         jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]), reg0); /* MOV([EBP+?], reg0); */
 612                                 }
 613                                 if (src[1] != src[6]) {
 614                                         for (i = 4; i < 32; i += 4) {
 615                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(src[6]) + i); /* MOV(EAX, [EBP+?]); */
 616                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */
 617                                         }
 618                                 }
 619                                 cmp0reg = -1;
 620                                 break;
 621
 622                         case 0x0f: /* PDIF */   /* 未完成 */
 623                                 reg0 = jitCompA000_selectRegCache(src[1], IA32_REG0_EAX);
 624                                 jitCompA000_storePRegCacheAll(&w); // 手抜き.
 625                                 jitCompA0001_checkCompPtr(&w, src[6], src[7]);
 626                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, PRegOffset(src[6])); /* MOV(reg0, [EBP+?]); */
 627                                 jitCompPutByte1(w.dst, 0x2b);   /* SUB(EAX, [EBP+?]); */
 628                                 jitCompPutModRM_Disp_BaseEBP(&w, PRegOffset(src[7]) + 0, reg0);
 629                                 i = jitCompA000_convTyp(jitCompGetImm32(src + 2));
 630                                 j = -1;
 631                                 if (0x0002 <= i && i <= 0x0007){
 632                                         j = (i - 0x0002) >> 1;
 633                                 }
 634                                 if (j < 0) {
 635                                         w.err = JITC_ERR_BADTYPE;
 636                                         goto err_w;
 637                                 }
 638                                 if (j > 0) {
 639                                         jitCompPutByte3(w.dst, 0xc1, 0xf8 | reg0, j);   /* SAR(reg0,?); */
 640                                 }
 641                                 if (reg0 == IA32_REG0_EAX){
 642                                         jitCompA0001_movRxxEax(&w, src[1]);
 643                                 }
 644                                 cmp0reg = src[1];
 645                                 cmp0lev = 1;
 646                                 break;
 647
 648                         case 0x10:      /* OR */
 649                         case 0x11:      /* XOR */
 650                         case 0x12:      /* AND */
 651                         case 0x14:      /* ADD */
 652                         case 0x15:      /* SUB */
 653                         case 0x16:      /* MUL */
 654                                 if (src[1] >= 0x3f){
 655                                         w.err = JITC_ERR_REGNUM;
 656                                 }
 657                                 reg0 = jitCompA000_selectRegCache(src[1], IA32_REG0_EAX);
 658                                 reg1 = jitCompA000_selectRegCache(src[2], -1 /* mem */);
 659 #if (jitCompA0001_USE_R3F_IMM32 != 0)
 660                                 if (src[2] == 0x3f) {   // SUBのみ該当.
 661                                         if (*src != 0x15){
 662                                                 w.err = JITC_ERR_REGNUM;
 663                                         }
 664                                         reg2 = jitCompA000_selectRegCache(src[3], -1 /* mem */);
 665                                         if (reg2 >= 0){
 666                                                 jitCompA000_storeRegCacheAll(&w);
 667                                         }
 668                                         jitCompPutByte1(w.dst, 0xb8 | reg0);    /* MOV(reg0, ?); */
 669                                         jitCompPutImm32(w.dst, w.r3f);
 670                                         jitCompPutByte1(w.dst, 0x2b);
 671                                         jitCompPutModRM_Disp_BaseEBP(&w, src[3] * 4, reg0);
 672                                         if (reg0 == 0){
 673                                                 jitCompA0001_movRxxEax(&w, src[1]);
 674                                         }
 675                                         break;
 676                                 }
 677 #endif
 678                                 if (reg1 < 0) {
 679                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, src[2] * 4); /* MOV(reg0, [EBP+?]); */
 680                                 }
 681                                 if (reg1 >= 0 && reg0 != reg1) {
 682                                         jitCompPutByte2(w.dst, 0x89, 0xc0 | reg1 << 3 | reg0); /* MOV(reg0, reg1); */
 683                                 }
 684                                 if (!(src[0] == 0x10 && src[3] == 0xff)) {
 685                                         // bugfix: hinted by Iris, 2013.06.26. thanks!
 686                                         cmp0reg = src[1];
 687                                         cmp0lev = 1;
 688                                         if (src[0] < 0x14){
 689                                                 cmp0lev = 2;
 690                                         }
 691                                         if (src[0] == 0x16){
 692                                                 cmp0reg = -1;
 693                                         }
 694                                 }
 695                                 if (!(src[0] == 0x10 && src[3] == 0xff)) {
 696 #if (jitCompA0001_USE_R3F_IMM32 != 0)
 697                                         if (src[3] == 0x3f) {
 698                                                 if (*src == 0x16 && w.r3f == -1) {
 699                                                         jitCompPutByte2(w.dst, 0xf7, 0xd8 | reg0); /* NEG(reg0); */
 700                                                         if (reg0 == 0){
 701                                                                 jitCompA0001_movRxxEax(&w, src[1]);
 702                                                         }
 703                                                         break;
 704                                                 }
 705 #if (jitCompA0001_USE_R3F_INCDEC != 0)
 706                                                 if ((*src == 0x14 && w.r3f == 1) || (*src == 0x15 && w.r3f == -1)) {
 707                                                         jitCompPutByte1(w.dst, 0x40 | reg0);    /* INC(reg0); */
 708                                                         if (reg0 == 0){
 709                                                                 jitCompA0001_movRxxEax(&w, src[1]);
 710                                                         }
 711                                                         break;
 712                                                 }
 713                                                 if ((*src == 0x15 && w.r3f == 1) || (*src == 0x14 && w.r3f == -1)) {
 714                                                         jitCompPutByte1(w.dst, 0x48 | reg0);    /* DEC(reg0); */
 715                                                         if (reg0 == 0){
 716                                                                 jitCompA0001_movRxxEax(&w, src[1]);
 717                                                         }
 718                                                         break;
 719                                                 }
 720 #endif
 721 #if (jitCompA0001_USE_R3F_IMM8 != 0)
 722                                                 if (-0x80 <= w.r3f && w.r3f <= 0x7f) {
 723                                                         if (*src != 0x16) {
 724                                                                 static unsigned char basic_op_table_im8[] = { 0xc8, 0xf0, 0xe0, 0, 0xc0, 0xe8 };
 725                                                                 jitCompPutByte3(w.dst, 0x83, basic_op_table_im8[*src - 0x10] | reg0, w.r3f & 0xff);
 726                                                         } else{
 727                                                                 jitCompPutByte3(w.dst, 0x6b, 0xc0 | reg0 << 3 | reg0, w.r3f & 0xff);
 728                                                         }
 729                                                         if (reg0 == 0){
 730                                                                 jitCompA0001_movRxxEax(&w, src[1]);
 731                                                         }
 732                                                         break;
 733                                                 }
 734 #endif
 735                                                 if (reg0 == IA32_REG0_EAX) {
 736                                                         static unsigned char basic_op_table_im32_eax[] = { 0x0d, 0x35, 0x25, 0, 0x05, 0x2d, 0xc0 };
 737                                                         if (*src == 0x16) {
 738                                                                 jitCompPutByte1(w.dst, 0x69);
 739                                                         }
 740                                                         jitCompPutByte1(w.dst, basic_op_table_im32_eax[*src - 0x10]);
 741                                                 } else{
 742                                                         if (*src != 0x16) {
 743                                                                 static unsigned char basic_op_table_im32_reg[] = { 0xc8, 0xf0, 0xe0, 0, 0xc0, 0xe8 };
 744                                                                 jitCompPutByte2(w.dst, 0x81, basic_op_table_im32_reg[*src - 0x10] | reg0);
 745                                                         }
 746                                                         else {
 747                                                                 jitCompPutByte2(w.dst, 0x69, 0xc0 | reg0 << 3 | reg0);
 748                                                         }
 749                                                 }
 750                                                 jitCompPutImm32(w.dst, w.r3f);
 751                                                 if (reg0 == 0){
 752                                                         jitCompA0001_movRxxEax(&w, src[1]);
 753                                                 }
 754                                                 break;
 755                                         }
 756 #endif
 757                                         reg1 = jitCompA000_selectRegCache(src[3], -1 /* mem */);
 758                                         if (src[3] >= 0x40){
 759                                                 w.err = JITC_ERR_REGNUM;
 760                                         }
 761                                         if (*src != 0x16) {
 762                                                 if (reg1 >= 0) {
 763                                                         static unsigned char basic_op_table_rr[] = { 0x09, 0x31, 0x21, 0, 0x01, 0x29 }; /* op(reg,reg); */
 764                                                         jitCompPutByte2(w.dst, basic_op_table_rr[*src - 0x10], 0xc0 | reg1 << 3 | reg0);
 765                                                 } else{
 766                                                         static unsigned char basic_op_table_rm[] = { 0x0b, 0x33, 0x23, 0, 0x03, 0x2b, 0xaf }; /* op(reg,mem); */
 767                                                         jitCompPutByte1(w.dst, basic_op_table_rm[*src - 0x10]);
 768                                                         jitCompPutModRM_Disp_BaseEBP(&w, src[3] * 4, reg0);
 769                                                 }
 770                                         } else{
 771                                                 if (reg1 >= 0) {
 772                                                         jitCompPutByte3(w.dst, 0x0f, 0xaf, 0xc0 | reg0 << 3 | reg1);
 773                                                 } else{
 774                                                         jitCompPutByte2(w.dst, 0x0f, 0xaf);
 775                                                         jitCompPutModRM_Disp_BaseEBP(&w, src[3] * 4, reg0);
 776                                                 }
 777                                         }
 778                                 }
 779                                 if (reg0 == 0){
 780                                         jitCompA0001_movRxxEax(&w, src[1]);
 781                                 }
 782                                 break;
 783
 784                         case 0x18:      /* SHL */
 785                         case 0x19:      /* SAR */
 786                                 if (src[1] >= 0x3f){
 787                                         w.err = JITC_ERR_REGNUM;
 788                                 }
 789                                 if (src[3] >= 0x40){
 790                                         w.err = JITC_ERR_REGNUM;
 791                                 }
 792 #if (jitCompA0001_USE_R3F_IMM32 != 0)
 793                                 if (src[3] == 0x3f) {
 794                                         reg0 = jitCompA000_selectRegCache(src[1], IA32_REG0_EAX);
 795                                         reg1 = jitCompA000_selectRegCache(src[2], -1 /* mem */);
 796                                         if (src[1] >= 0x3f){
 797                                                 w.err = JITC_ERR_REGNUM;
 798                                         }
 799                                         if (reg1 == -1){
 800                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, src[2] * 4); /* MOV(reg1, [EBP+?]); */
 801                                         } else{
 802                                                 if (reg0 != reg1) {
 803                                                         jitCompPutByte2(w.dst, 0x89, 0xc0 | reg1 << 3 | reg0); /* MOV(reg0, reg1); */
 804                                                 }
 805                                         }
 806                                         if (*src == 0x18) {
 807                                                 /* SHL(reg0, im8); */
 808                                                 jitCompPutByte3(w.dst, 0xc1, 0xe0 | reg0, w.r3f);
 809                                         }
 810                                         if (*src == 0x19) {
 811                                                 /* SAR(reg0, im8); */
 812                                                 jitCompPutByte3(w.dst, 0xc1, 0xf8 | reg0, w.r3f);
 813                                         }
 814                                         if (reg0 == IA32_REG0_EAX){
 815                                                 jitCompA0001_movRxxEax(&w, src[1]);
 816                                         }
 817                                         cmp0reg = src[1];
 818                                         cmp0lev = 1;
 819                                         break;
 820                                 }
 821 #endif
 822                                 jitCompA000_storeRegCacheAll(&w); // 手抜き.
 823                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */
 824 #if (jitCompA0001_USE_R3F_IMM32 != 0)
 825                                 if (src[2] == 0x3f) {
 826                                         jitCompPutByte1(w.dst, 0xb8);   /* MOV(EAX, ?); */
 827                                         jitCompPutImm32(w.dst, w.r3f);
 828                                 } else{
 829                                         jitCompA0001_movEaxRxx(&w, src[2]);
 830                                 }
 831 #else
 832                                 jitCompA0001_movEaxRxx(&w, src[2]);
 833 #endif
 834                                 if (*src == 0x18) {
 835                                          /* SHL(EAX, CL); */
 836                                         jitCompPutByte2(w.dst, 0xd3, 0xe0);
 837                                 }
 838                                 if (*src == 0x19) {
 839                                         /* SAR(EAX, CL); */
 840                                         jitCompPutByte2(w.dst, 0xd3, 0xf8);
 841                                 }
 842                                 jitCompA0001_movRxxEax(&w, src[1]);
 843                                 jitCompA000_loadRegCacheAll(&w); // 手抜き.
 844                                 cmp0reg = src[1];
 845                                 cmp0lev = 1;
 846                                 break;
 847
 848                         case 0x1a:      /* DIV */
 849                         case 0x1b:      /* MOD */
 850                                 if (src[1] >= 0x3f || src[2] >= 0x40 || src[3] >= 0x40){
 851                                         w.err = JITC_ERR_REGNUM;
 852                                 }
 853                                 jitCompA000_storeRegCacheAll(&w); // 手抜き.
 854 #if (jitCompA0001_USE_R3F_IMM32 != 0)
 855                                 if (src[3] == 0x3f) {
 856                                         jitCompPutByte1(w.dst, 0xb8 | 1);       /* MOV(ECX, ?); */
 857                                         jitCompPutImm32(w.dst, w.r3f);
 858                                 } else{
 859                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */
 860                                 }
 861                                 if (src[2] == 0x3f) {
 862                                         jitCompPutByte1(w.dst, 0xb8 | 0);       /* MOV(EAX, ?); */
 863                                         jitCompPutImm32(w.dst, w.r3f);
 864                                 } else{
 865                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, src[2] * 4); /* MOV(EAX, [EBP+?]); */
 866                                 }
 867 #else
 868                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG1_ECX, src[3] * 4); /* MOV(ECX, [EBP+?]); */
 869                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, src[2] * 4); /* MOV(EAX, [EBP+?]); */
 870 #endif
 871                                 jitCompPutByte1(w.dst, 0x99);   /* CDQ(); */
 872                                 /* ECXがゼロではないことを確認すべき */
 873                                 jitCompPutByte2(w.dst, 0xf7, 0xf9);     /* IDIV(ECX); */
 874                                 if (*src == 0x1a) {
 875                                         jitCompPutOp_MOV_EBPDisp_GReg(&w, src[1] * 4, IA32_REG0_EAX);
 876                                 }
 877                                 if (*src == 0x1b) {
 878                                         jitCompPutOp_MOV_EBPDisp_GReg(&w, src[1] * 4, IA32_REG2_EDX);
 879                                 }
 880                                 jitCompA000_loadRegCacheAll(&w); // 手抜き.
 881                                 cmp0reg = -1;
 882                                 break;
 883
 884                         case 0x1c:      /* PLMT0 */
 885                         case 0x1d:      /* PLMT1 */
 886                                 if (src[1] >= 0x40 || src[2] >= 0x40){
 887                                         w.err = JITC_ERR_PREGNUM;
 888                                 }
 889                                 if (level < JITC_LV_FASTEST) {
 890                                         cmp0reg = -1;
 891                                         if (level < JITC_LV_FASTER) {
 892                                                 // typ が一致していることを確認.
 893                                                 // plsとliveSignが一致していることを確認.
 894
 895                                                 // preg1はp0 <= p <= p1 を満たしているか？.
 896                                                 // 新しいp0/p1は古いp0?p1に適合しているか？.
 897
 898                                         }
 899                                 }
 900
 901                         case 0x1e: /* PCP */            /* 未完成(p1まで完成) */
 902                                 if (src[1] >= 0x40 || src[2] >= 0x40){
 903                                         w.err = JITC_ERR_PREGNUM;
 904                                 }
 905                                 if (src[2] == 0x3f){
 906                                         w.err = JITC_ERR_PREGNUM;
 907                                 }
 908                                 if (src[1] != 0x3f) {
 909                                         /* src[2] == 0xff の場合に対応できてない */
 910                                         jitCompA000_storePRegCacheAll(&w); // 手抜き.
 911                                         for (i = 0; i < 32; i += 4) {
 912                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(src[2]) + i); /* MOV(EAX, [EBP+?]); */
 913                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */
 914                                         }
 915                                         jitCompA000_loadPRegCacheAll(&w); // 手抜き.
 916                                 } else {
 917                                         if (level < JITC_LV_FASTER) {
 918                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(src[2]) + 4); /* MOV(EAX, [EBP+?]); */      /* typ */
 919                                                 jitCompPutByte3(w.dst, 0x83, 0xf8, 0);  /* CMP(EAX, 0); */
 920                                                 jitCompPutByte2(w.dst, 0x0f, 0x85); /* JNE */
 921                                                 jitCompPutImm32(w.dst, errfnc - (w.dst + 4));
 922                                                 /* セキュリティチェックが足りてない!(aliveとか) */
 923                                         }
 924                                         reg0 = IA32_REG0_EAX;
 925                                         jitCompA000_storePRegCacheAll(&w); // 手抜き.
 926                                         jitCompPutOp_MOV_GReg_EBPDisp(&w, reg0, PRegOffset(src[2]) + 0); /* MOV(EAX, [EBP+?]); */
 927                                         if (level < JITC_LV_FASTER) {
 928                                                 jitCompPutByte1(w.dst, 0x3b);   /* CMP(reg0, [EBP+?]); */
 929                                                 jitCompPutModRM_Disp_BaseEBP(&w, PRegOffset(src[2]) + 8, reg0); /* p0 */
 930                                                 jitCompPutByte2(w.dst, 0x0f, 0x85); /* JNE */
 931                                                 jitCompPutImm32(w.dst, errfnc - (w.dst + 4));
 932                                         }
 933                                         jitCompPutByte2(w.dst, 0xff, 0xe0);     /* JMP(EAX); */
 934                                 }
 935                                 break;
 936
 937                         case 0x1f: /* PCST */
 938                                 if (jitCompGetImm32(src + 2) == 0) {
 939                                         if (level < JITC_LV_FASTER){
 940                                                 jitCompA0001_checkType0(&w, src[6], jitCompGetImm32(src + 7), 2);
 941                                         }
 942                                         jitCompA000_storePRegCacheAll(&w); // 手抜き.
 943                                         for (i = 0; i < 32 - 4; i += 4) {
 944                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(src[6]) + i); /* MOV(EAX, [EBP+?]); */
 945                                                 if (i == 4) {
 946                                                         jitCompPutByte1(w.dst, 0x0d); /* OR(EAX, ?); */
 947                                                         jitCompPutImm32(w.dst, 0x80000000);
 948                                                 }
 949                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */
 950                                         }
 951                                         jitCompPutOp_MOV_GReg_Imm32(w.dst, IA32_REG0_EAX, debugInfo1);
 952                                         jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + 28, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */
 953                                         jitCompA000_loadPRegCacheAll(&w); // 手抜き.
 954                                         cmp0reg = -1;
 955                                         break;
 956                                 }
 957                                 if (jitCompGetImm32(src + 7) == 0) {
 958                                         jitCompA000_storePRegCacheAll(&w); // 手抜き.
 959                                         for (i = 0; i < 32 - 4; i += 4) {
 960                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(src[6]) + i); /* MOV(EAX, [EBP+?]); */
 961                                                 if (i == 4) {
 962                                                         jitCompPutByte1(w.dst, 0x25); /* AND(EAX, ?); */
 963                                                         jitCompPutImm32(w.dst, 0x7fffffff);
 964                                                 }
 965                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + i, IA32_REG0_EAX); /* MOV([EBP+?], EAX); */
 966                                         }
 967                                         if (level < JITC_LV_FASTER) {
 968                                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(src[6]) + 28); /* MOV(EAX, [EBP+?]); */
 969                                                 jitCompPutByte1(w.dst, 0x3d);   /* CMP(EAX, ?); */
 970                                                 jitCompPutImm32(w.dst, debugInfo1);
 971                                                 jitCompPutByte2(w.dst, 0x74, 8); /* JE */
 972                                                 jitCompPutOp_MOV_EAX_ZERO(w.dst);
 973                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, PRegOffset(src[1]) + 0, IA32_REG0_EAX); /* MOV([EBP+?], EAX); (1+1+4) */
 974                                         }
 975                                         jitCompA000_loadPRegCacheAll(&w); // 手抜き.
 976                                         cmp0reg = -1;
 977                                         break;
 978                                 }
 979                                 w.err = JITC_ERR_OPECODE;
 980                                 goto err_w;
 981
 982                         case 0x20:      /* CMPE */
 983                         case 0x21:      /* CMPNE */
 984                         case 0x22:      /* CMPL */
 985                         case 0x23:      /* CMPGE */
 986                         case 0x24:      /* CMPLE */
 987                         case 0x25:      /* CMPG */
 988                         case 0x26:      /* TSTZ */
 989                         case 0x27:      /* TSTNZ */
 990                                 reg0 = jitCompA000_selectRegCache(src[2], IA32_REG0_EAX);
 991                                 reg1 = jitCompA000_selectRegCache(src[3], -1 /* mem */);
 992                                 if (src[1] == 0x3f) {
 993                                         /* 特殊構文チェック */
 994                                         if (w.prefix != 0) {
 995                                                 w.err = JITC_ERR_PREFIX;
 996                                                 goto err_w;
 997                                         }
 998                                         if (src[4] != 0x04 || src[5] != 0x3f || src[6] != 0x03 || src[7] != 0x3f) {
 999                                                 w.err = JITC_ERR_IDIOM;
1000                                                 goto err_w;
1001                                         }
1002                                 }
1003                                 if (reg0 == 0)
1004                                         jitCompA0001_movEaxRxx(&w, src[2]);
1005 #if (jitCompA0001_USE_R3F_IMM32 != 0)
1006                                 if (src[3] == 0x3f) {
1007 #if (jitCompA0001_OPTIMIZE_CMP != 0)
1008                                         if ((*src <= 0x25 && w.r3f == 0) || (*src >= 0x26 && w.r3f == -1)) {
1009                                                 i = 0;
1010                                                 if (cmp0reg == src[2]) {
1011                                                         if (cmp0lev >= 1 && (src[0] == 0x20 || src[0] == 0x21 || src[0] == 0x26 || src[0] == 0x27)){
1012                                                                 i = 1;
1013                                                         }
1014                                                         if (cmp0lev >= 2 && (src[0] == 0x22 || src[0] == 0x23 || src[0] == 0x24 || src[0] == 0x25)){
1015                                                                 i = 1;
1016                                                         }
1017                                                 }
1018                                                 if (i == 0) {
1019                                                         jitCompPutByte2(w.dst, 0x85, 0xc0 | reg0 << 3 | reg0);  /* TEST(reg0, reg0); */
1020                                                 }
1021                                                 cmp0reg = src[2];
1022                                                 cmp0lev = 2;
1023                                                 goto cmpcc1;
1024                                         }
1025 #endif
1026 #if (jitCompA0001_USE_R3F_IMM8 != 0)
1027                                         if (-0x80 <= w.r3f && w.r3f <= 0x7f && *src <= 0x25) {
1028                                                 jitCompPutByte3(w.dst, 0x83, 0xf8 | reg0, w.r3f);
1029                                                 goto cmpcc1;
1030                                         }
1031 #endif
1032                                         if (reg0 == 0) {
1033                                                 if (*src <= 0x25) {
1034                                                         jitCompPutByte1(w.dst, 0x3d);
1035                                                 }
1036                                                 if (*src >= 0x26) {
1037                                                         jitCompPutByte1(w.dst, 0xa9);
1038                                                 }
1039                                         }
1040                                         else {
1041                                                 if (*src <= 0x25) {
1042                                                         jitCompPutByte2(w.dst, 0x81, 0xf8 | reg0);
1043                                                 }
1044                                                 if (*src >= 0x26) {
1045                                                         jitCompPutByte2(w.dst, 0xf7, 0xc0 | reg0);
1046                                                 }
1047                                         }
1048                                         jitCompPutImm32(w.dst, w.r3f);
1049                                         goto cmpcc1;
1050                                 }
1051 #endif
1052                                 if (src[3] >= 0x40){
1053                                         w.err = JITC_ERR_PREGNUM;
1054                                 }
1055                                 if (reg1 >= 0) {
1056                                         if (*src <= 0x25) {
1057                                                 jitCompPutByte2(w.dst, 0x39, 0xc0 | reg1 << 3 | reg0);
1058                                         }
1059                                         if (*src >= 0x26) {
1060                                                 jitCompPutByte2(w.dst, 0x85, 0xc0 | reg1 << 3 | reg0);
1061                                         }
1062                                 } else{
1063                                         if (*src <= 0x25) {
1064                                                 jitCompPutByte1(w.dst, 0x3b);
1065                                         }
1066                                         if (*src >= 0x26) {
1067                                                 jitCompPutByte1(w.dst, 0x85);
1068                                         }
1069                                         jitCompPutModRM_Disp_BaseEBP(&w, src[3] * 4, reg0);
1070                                 }
1071                         cmpcc1:
1072                                 if (w.err != 0){
1073                                         goto err_w;
1074                                 }
1075                                 static unsigned char cmpcc_table0[] = {
1076                                         0x04, 0x05, 0x0c, 0x0d, 0x0e, 0x0f, 0x04, 0x05, /* CMPcc, TSTcc */
1077                                         0x04, 0x05, 0x02, 0x03, 0x06, 0x07                              /* PCMPcc */
1078                                 };
1079 #if (jitCompA0001_USE_R3F_CMPJMP != 0)
1080                                 if (src[1] == 0x3f) {
1081                                         /* 特殊構文を利用した最適化 */
1082                                         jitCompPutByte2(w.dst, 0x0f, 0x80 | cmpcc_table0[*src - 0x20]);
1083                                         src += 6;
1084                                         i = jitCompGetLabelNum(&w, src + 2);
1085                                         if ((flags & JITC_PHASE1) != 0 && w.err != 0) {
1086                                                 if (label[i].opt == 0) {
1087                                                         w.err = JITC_ERR_LABELNODEF;
1088                                                         goto err_w;
1089                                                 }
1090                                                 //      if (label[i].typ != 1) { w.err = JITC_ERR_LABELTYP; goto err_w; }
1091                                         }
1092                                         j = 0;
1093                                         if ((flags & JITC_PHASE1) != 0 || (((flags & JITC_PHASE1) == 0) && label[i].opt != 0)){
1094                                                 j = label[i].p - (w.dst + 4);
1095                                         }
1096                                         jitCompPutImm32(w.dst, j);
1097 #if (jitCompA0001_OPTIMIZE_JMP != 0)
1098                                         if (-128 - 4 <= j && j < 0) {
1099                                                 j += 4;
1100                                                 w.dst -= 6;
1101                                                 jitCompPutByte2(w.dst, w.dst[1] ^ 0xf0, j & 0xff);
1102                                         }
1103 #endif
1104                                         src += 6;
1105                                         if (w.err != 0){
1106                                                 goto err_w;
1107                                         }
1108                                         continue;
1109                                 }
1110 #endif
1111                                 /* 一般的なJITC */
1112                                 reg0 = jitCompA000_selectRegCache(src[1], IA32_REG0_EAX);
1113                                 jitCompPutByte3(w.dst, 0x0f, 0x90 | cmpcc_table0[*src - 0x20], 0xc0 | reg0);    /* SETcc(BYTE(reg0)); */
1114                                 jitCompPutByte3(w.dst, 0x0f, 0xb6, 0xc0 | reg0 << 3 | reg0);    /* MOVZX(reg0, BYTE(reg0)); */
1115                                 jitCompPutByte2(w.dst, 0xf7, 0xd8 | reg0);      /* NEG(reg0); */
1116                                 if (reg0 == 0){
1117                                         jitCompA0001_movRxxEax(&w, src[1]);
1118                                 }
1119                                 cmp0reg = src[2];
1120                                 cmp0lev = 1;
1121                                 break;
1122
1123                         case 0x28:      /* PCMPE */
1124                         case 0x29:      /* PCMPNE */
1125                         case 0x2a:      /* PCMPL */
1126                         case 0x2b:      /* PCMPGE */
1127                         case 0x2c:      /* PCMPLE */
1128                         case 0x2d:      /* PCMPG */
1129                                 if (src[1] == 0x3f) {
1130                                         /* 特殊構文チェック */
1131                                         if (w.prefix != 0) {
1132                                                 w.err = JITC_ERR_PREFIX;
1133                                                 goto err_w;
1134                                         }
1135                                         if (src[4] != 0x04 || src[5] != 0x3f || src[6] != 0x03 || src[7] != 0x3f) {
1136                                                 w.err = JITC_ERR_IDIOM;
1137                                                 goto err_w;
1138                                         }
1139                                 }
1140                                 if (src[2] >= 0x40) {
1141                                         w.err = JITC_ERR_PREGNUM;
1142                                 }
1143                                 jitCompA000_storePRegCacheAll(&w); // 手抜き.
1144                                 if (src[3] != 0xff){
1145                                         jitCompA0001_checkCompPtr(&w, src[2], src[3]);
1146                                 }
1147                                 jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(src[2]) + 0); /* MOV(EAX, [EBP+?]); */
1148                                 if (src[3] != 0xff) {
1149                                         jitCompPutByte1(w.dst, 0x3b);   /* CMP(EAX, [EBP+?]); */
1150                                         jitCompPutModRM_Disp_BaseEBP(&w, PRegOffset(src[3]) + 0, 0);
1151                                 } else{
1152                                         /* ヌルポインタとの比較はこれでいいのか？たぶんよくない */
1153                                         jitCompPutByte3(w.dst, 0x83, 0xf8, 0x00);       /* CMP(EAX, 0); */
1154                                 }
1155                                 cmp0reg = -1;
1156                                 goto cmpcc1;
1157
1158                         case 0x30:      /* talloc(old:F4) */
1159                         case 0x31:      /* tfree(old:F5) */
1160                         case 0x32:      /* malloc(old:F6) */
1161                         case 0x33:      /* mfree(old:F7) */
1162                                 jitCompA000_storeRegCacheAll(&w); // 手抜き.
1163                                 jitCompA000_storePRegCacheAll(&w); // 手抜き.
1164
1165                                 jitCompPutOp_PUSH_Imm8(w.dst, src[3]);
1166                                 jitCompPutOp_PUSH_Imm8(w.dst, src[2]);
1167                                 jitCompPutOp_PUSH_Imm8(w.dst, src[1]);
1168                                 jitCompPutOp_PUSH_GReg(w.dst, IA32_REG5_EBP);
1169
1170                                 switch (*src) {
1171                                         case 0x30:
1172                                                 j = ((unsigned char *)&funcf4) - (w.dst + 1 + 4);
1173                                                 break;
1174                                         case 0x31:
1175                                                 j = ((unsigned char *)&funcf5) - (w.dst + 1 + 4);
1176                                                 break;
1177                                         case 0x32:
1178                                                 j = ((unsigned char *)&funcf6) - (w.dst + 1 + 4);
1179                                                 break;
1180                                         case 0x33:
1181                                                 j = ((unsigned char *)&funcf7) - (w.dst + 1 + 4);
1182                                                 break;
1183                                 }
1184                                 jitCompPutOp_CALL_Relative(w.dst, j);
1185                                 jitCompPutOp_ADD_GReg_Imm8(w.dst, IA32_REG4_ESP, 16);
1186
1187                                 jitCompA000_loadRegCacheAll(&w); // 手抜き.
1188                                 jitCompA000_loadPRegCacheAll(&w); // 手抜き.
1189                                 cmp0reg = -1;
1190                                 break;
1191
1192                         case 0x34:      /* data (暫定) */
1193                                 // 0    1234    5678            9
1194                                 // 34   typ32   len32   data...
1195                                 // len32 is NOT byte size!
1196
1197                                 cmp0reg = -1;
1198                                 if (w.prefix != 0) {
1199                                         w.err = JITC_ERR_PREFIX;
1200                                         goto err_w;
1201                                 }
1202                                 int k, tmpData, bitCount, dataWidth;
1203                                 // kはtyp32
1204                                 k = jitCompGetImm32(&src[1]);
1205                                 dataWidth = jitCompA000_dataWidth(k);
1206                                 if (lastlabel >= 0 && label[lastlabel].typ == 0){
1207                                         //直前のラベルタイプを設定
1208                                         label[lastlabel].typ = k;
1209                                 }
1210                                 if (k != 1) {
1211                                         i = jitCompA000_convTyp(k);
1212                                         if (i < 2 || i > 7) {
1213                                                 w.err = JITC_ERR_BADTYPE;
1214                                                 goto err_w;
1215                                         }
1216                                 }
1217                                 // jはlen32
1218                                 j = jitCompGetImm32(&src[5]);
1219                                 oldsrc = src;
1220                                 src += 9;
1221
1222                                 // srcはdata本体を指す
1223                                 if (k != 1) {
1224                                         // 一般データ
1225                                         bitCount = 7;
1226                                         while (j > 0) {
1227                                                 if (src >= src1) {
1228                                                         // バイトコードを末端を超えて読もうとした
1229                                                         w.err = JITC_ERR_SRC1;
1230                                                         src = oldsrc;
1231                                                         goto err_w;
1232                                                 }
1233                                                 if (w.dst + 256 > dst1) {
1234                                                         // 書き込み先の残り容量が256Bytesを切った
1235                                                         w.err = JITC_ERR_DST1;
1236                                                         src = oldsrc;
1237                                                         goto err_w;
1238                                                 }
1239                                                 tmpData = 0;
1240                                                 for (k = 0; k < dataWidth; k++) {
1241                                                         // dataWidthビットごとに切り出してtmpDataに入れる
1242                                                         tmpData = tmpData << 1 | ((*src >> bitCount) & 1);
1243                                                         bitCount--;
1244                                                         if (bitCount < 0) {
1245                                                                 bitCount = 7;
1246                                                                 src++;
1247                                                         }
1248                                                 }
1249                                                 if ((i & 1) == 0 && dataWidth <= 31 && (tmpData >> (dataWidth - 1)) != 0) {
1250                                                         // 符号あり型で、かつtmpDataの符号ビットが1なので、マイナスにする
1251                                                         tmpData -= 1 << dataWidth;
1252                                                 }
1253                                                 if (i == 2 || i == 3) {
1254                                                         // BYTE
1255                                                         jitCompPutByte1(w.dst, tmpData & 0xff);
1256                                                 }
1257                                                 if (i == 4 || i == 5) {
1258                                                         // WORD
1259                                                         jitCompPutByte2(w.dst, tmpData & 0xff, (tmpData >> 8) & 0xff);
1260                                                 }
1261                                                 if (i == 6 || i == 7) {
1262                                                         // DWORD
1263                                                         jitCompPutByte4(w.dst, tmpData & 0xff, (tmpData >> 8) & 0xff, (tmpData >> 16) & 0xff, (tmpData >> 24) & 0xff);
1264                                                 }
1265                                                 j--;
1266                                         }
1267                                 } else{
1268                                         // VPtr型
1269                                         while (j > 0) {
1270                                                 if (src >= src1) {
1271                                                         // バイトコードを末端を超えて読もうとした
1272                                                         w.err = JITC_ERR_SRC1;
1273                                                         src = oldsrc;
1274                                                         goto err_w;
1275                                                 }
1276                                                 if (w.dst + 256 > dst1) {
1277                                                         // 書き込み先の残り容量が256Bytesを切った
1278                                                         w.err = JITC_ERR_DST1;
1279                                                         src = oldsrc;
1280                                                         goto err_w;
1281                                                 }
1282                                                 i = jitCompGetImm32(src);
1283                                                 src += 4;
1284                                                 if ((flags & JITC_PHASE1) != 0 && w.err == 0) {
1285                                                         // Only in phase1
1286                                                         if (label[i].opt == 0) {
1287                                                                 // ローカルラベルはだめです...
1288                                                                 w.err = JITC_ERR_LABELNODEF;
1289                                                                 goto err_w;
1290                                                         }
1291                                                 }
1292                                                 jitCompPutImm32(w.dst, (int)label[i].p);
1293                                                 jitCompPutImm32(w.dst, label[i].typ);
1294                                                 jitCompPutImm32(w.dst, (int)label[i].p);
1295                                                 jitCompPutImm32(w.dst, (int)label[i].p1);
1296                                                 jitCompPutImm32(w.dst, 0); /* liveSign */
1297                                                 jitCompPutImm32(w.dst, envOffset_PTRCTRL); /* pls */
1298                                                 jitCompPutImm32(w.dst, 0);
1299                                                 jitCompPutImm32(w.dst, 0);
1300                                                 j--;
1301                                         }
1302                                 }
1303                                 if (lastlabel >= 0 && label[lastlabel].p1 < w.dst){
1304                                         label[lastlabel].p1 = w.dst;
1305                                 }
1306                                 continue;
1307
1308                         case 0x3c:      /* ENTER */
1309                                 jitCompA000_storeRegCacheAll(&w); // 手抜き.
1310                                 jitCompA000_storePRegCacheAll(&w); // 手抜き.
1311                                 jitCompPutOp_PUSH_Imm8(w.dst, src[6]);
1312                                 jitCompPutOp_PUSH_Imm8(w.dst, src[5]);
1313                                 jitCompPutOp_PUSH_Imm8(w.dst, src[4] & 0x0f);
1314                                 jitCompPutOp_PUSH_Imm8(w.dst, (src[4] >> 4) & 0x0f);
1315                                 jitCompPutOp_PUSH_Imm8(w.dst, src[3]);
1316                                 jitCompPutOp_PUSH_Imm8(w.dst, src[2]);
1317                                 jitCompPutOp_PUSH_Imm8(w.dst, src[1]);
1318                                 jitCompPutOp_PUSH_GReg(w.dst, IA32_REG5_EBP);
1319                                 j = ((unsigned char *)&func3c) - (w.dst + 1 + 4);
1320                                 jitCompPutOp_CALL_Relative(w.dst, j)
1321                                 jitCompPutOp_ADD_GReg_Imm8(w.dst, IA32_REG4_ESP, 32);
1322                                 jitCompA000_loadRegCacheAll(&w); // 手抜き.
1323                                 jitCompA000_loadPRegCacheAll(&w); // 手抜き.
1324                                 cmp0reg = -1;
1325                                 break;
1326
1327                         case 0x3d:      /* LEAVE */
1328                                 jitCompA000_storeRegCacheAll(&w); // 手抜き.
1329                                 jitCompA000_storePRegCacheAll(&w); // 手抜き.
1330                                 jitCompPutOp_PUSH_Imm8(w.dst, src[6]);
1331                                 jitCompPutOp_PUSH_Imm8(w.dst, src[5]);
1332                                 jitCompPutOp_PUSH_Imm8(w.dst, src[4] & 0x0f);
1333                                 jitCompPutOp_PUSH_Imm8(w.dst, (src[4] >> 4) & 0x0f);
1334                                 jitCompPutOp_PUSH_Imm8(w.dst, src[3]);
1335                                 jitCompPutOp_PUSH_Imm8(w.dst, src[2]);
1336                                 jitCompPutOp_PUSH_Imm8(w.dst, src[1]);
1337                                 jitCompPutOp_PUSH_GReg(w.dst, IA32_REG5_EBP);
1338                                 j = ((unsigned char *)&func3d) - (w.dst + 1 + 4);
1339                                 jitCompPutOp_CALL_Relative(w.dst, j)
1340                                 jitCompPutOp_ADD_GReg_Imm8(w.dst, IA32_REG4_ESP, 32);
1341                                 jitCompA000_loadRegCacheAll(&w); // 手抜き.
1342                                 jitCompA000_loadPRegCacheAll(&w); // 手抜き.
1343                                 cmp0reg = -1;
1344                                 break;
1345
1346                         case 0xfe:      /* remark */
1347                                 if (src[1] == 0x01 && src[2] == 0x00) {
1348                                         // DBGINFO1
1349                                         if (level <= JITC_LV_SLOWER) {
1350                                                 jitCompPutOp_MOV_GReg_Imm32(w.dst, IA32_REG0_EAX, debugInfo1);
1351                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, envOffset_DBGINFO1, IA32_REG0_EAX);
1352                                         }
1353                                 }
1354                                 if (src[1] == 0x01 && src[2] == 0x03) {
1355                                         // DBGINFO1CLR
1356                                         if (level <= JITC_LV_SLOWER) {
1357                                                 jitCompPutOp_MOV_GReg_Imm32(w.dst, IA32_REG0_EAX, -1);
1358                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, envOffset_DBGINFO1, IA32_REG0_EAX);
1359                                         }
1360                                 }
1361                                 if (src[1] == 0x05 && src[2] == 0x00) {
1362                                         // DBGINFO0
1363                                         if (level <= JITC_LV_SLOWEST) {
1364                                                 debugInfo0 = jitCompGetImm32(src + 3);
1365                                                 jitCompPutOp_MOV_GReg_Imm32(w.dst, IA32_REG0_EAX, debugInfo0);
1366                                                 jitCompPutOp_MOV_EBPDisp_GReg(&w, envOffset_DBGINFO0, IA32_REG0_EAX);
1367                                         }
1368                                 }
1369                                 break;
1370
1371                         default:
1372                                 w.err = JITC_ERR_OPECODE;
1373                                 goto err_w;
1374                 }
1375                 if (w.err != 0){
1376                         goto err_w;
1377                 }
1378                 jitCompA0001_fixPrefix(&w);
1379                 if (w.err != 0) {
1380                         goto err_w;
1381                 }
1382
1383                 if(*src != 0x00 && *src != 0x01 && *src != 0x34){
1384                         DEBUGCode(&w, 315315);
1385                 }
1386
1387                 src += jitCompCmdLen(src);
1388         }
1389         if (enter0 != NULL) {
1390                 j = w.dst - (enter0 + 4);
1391                 enter0[0] = j & 0xff;
1392                 enter0[1] = (j >> 8) & 0xff;
1393                 enter0[2] = (j >> 16) & 0xff;
1394                 enter0[3] = (j >> 24) & 0xff;
1395         }
1396         if ((flags & JITC_NOSTARTUP) == 0) {
1397                 jitCompA000_storeRegCacheAll(&w);
1398                 jitCompA000_storePRegCacheAll(&w);
1399                 jitCompPutOp_POPAD(w.dst);
1400         }
1401         if ((flags & JITC_PHASE1) != 0){
1402                 return w.dst - dst00;
1403         }
1404         return 0;
1405
1406 err_w:
1407         if ((w.err & JITC_ERR_PHASE0ONLY) != 0) {
1408                 if ((flags & JITC_PHASE1) == 0){
1409                         w.err &= ~JITC_ERR_PHASE0ONLY;
1410                 }
1411         }
1412         if (w.err == (JITC_ERR_MASK & JITC_ERR_REGNUM))                 errmsg = "reg-number error";
1413         if (w.err == (JITC_ERR_MASK & JITC_ERR_DST1))                   errmsg = "dst1 error";
1414         if (w.err == (JITC_ERR_MASK & JITC_ERR_OPECODE))                errmsg = "opecode error";
1415         if (w.err == (JITC_ERR_MASK & JITC_ERR_LABELNUM))               errmsg = "label number too large";
1416         if (w.err == (JITC_ERR_MASK & JITC_ERR_LABELREDEF))             errmsg = "label redefine";
1417         if (w.err == (JITC_ERR_MASK & JITC_ERR_PREFIX))                 { errmsg = "prefix redefine"; w.dst -= 2; }
1418         if (w.err == (JITC_ERR_MASK & JITC_ERR_LABELNODEF))             errmsg = "label not defined";
1419         if (w.err == (JITC_ERR_MASK & JITC_ERR_LABELTYP))               errmsg = "label type error";
1420         if (w.err == (JITC_ERR_MASK & JITC_ERR_IDIOM))                  errmsg = "idiom error";
1421         if (w.err == (JITC_ERR_MASK & JITC_ERR_PREGNUM))                errmsg = "preg-number error";
1422         if (w.err == (JITC_ERR_MASK & JITC_ERR_SRC1))                   errmsg = "src1 error";
1423         if (w.err == (JITC_ERR_MASK & JITC_ERR_BADTYPE))                errmsg = "bad type code";
1424         if (w.err == (JITC_ERR_MASK & JITC_ERR_PREFIXFAR))              errmsg = "prefix internal error";
1425         if (w.err == (JITC_ERR_MASK & JITC_ERR_INTERNAL))               errmsg = "general internal error";
1426         if (*errmsg != '\0') {
1427                 fprintf(stderr, "JITC: %s at %06X (debugInfo0=%d)\n    ", errmsg, src - src0, debugInfo0);
1428                 for (i = 0; i < 16; i++)
1429                         fprintf(stderr, "%02X ", src[i]);
1430                 static char *table[0x30] = {
1431                         "NOP", "LB", "LIMM", "PLIMM", "CND", "??", "??", "??",
1432                         "LMEM", "SMEM", "PLMEM", "PSMEM", "LEA", "??", "PADD", "PDIF",
1433                         "CP/OR", "XOR", "AND", "??", "ADD", "SUB", "MUL", "??",
1434                         "SHL", "SAR", "DIV", "MOD", "PLMT0", "PLMT1", "PCP", "PCST",
1435                         "CMPE", "CMPNE", "CMPL", "CMPGE", "CMPLE", "CMPG", "TSTZ", "TSTNZ",
1436                         "PCMPE", "PCMPNE", "PCMPL", "PCMPGE", "PCMPLE", "PCMPG", "??", "EXT" };
1437                 errmsg = "??";
1438                 if (*src < 0x30) errmsg = table[*src];
1439                 fprintf(stderr, "(%s)\n", errmsg);
1440         }
1441         return -1;
1442 }
1443
1444 unsigned char *jitCompCallFunc(unsigned char *dst, void *func)
1445 {
1446         //この関数の中では結局w->dstしか参照していない
1447         struct JitCompWork w;
1448         w.dst = dst;
1449         jitCompA000_storeRegCacheAll(&w);
1450         jitCompA000_storePRegCacheAll(&w);
1451         jitCompPutOp_PUSHAD(w.dst);
1452         jitCompPutOp_PUSH_GReg(w.dst, IA32_REG0_EAX);   /* for 16Byte-align（Mac OSX） */
1453         jitCompPutOp_PUSH_GReg(w.dst, IA32_REG5_EBP);
1454
1455         int j = ((unsigned char *)func) - (w.dst + 1 + 4);
1456         jitCompPutOp_CALL_Relative(w.dst, j);
1457
1458         jitCompPutOp_POP_GReg(w.dst, IA32_REG0_EAX);
1459         jitCompPutOp_POP_GReg(w.dst, IA32_REG0_EAX);            /* for 16Byte-align (Mac OSX) */
1460         jitCompPutOp_POPAD(w.dst);
1461         jitCompA000_loadRegCacheAll(&w);
1462         jitCompA000_loadPRegCacheAll(&w);
1463         jitCompPutOp_MOV_GReg_EBPDisp(&w, IA32_REG0_EAX, PRegOffset(0x30) + 0);
1464
1465         jitCompPutByte2(w.dst, 0xff, 0xe0);     /* JMP(EAX); */
1466         return w.dst;
1467 }
1468
1469 unsigned char *jitCompInit(unsigned char *dst)
1470 {
1471         errfnc = dst;
1472         return jitCompCallFunc(dst, &errHndl);
1473 }
1474
1475 void jitcRunBinary(void (*bin)(char *), HOSECPU_RuntimeEnvironment *env)
1476 {
1477         (*bin)(((char *)env) + jitCompA0001_EBP128); /* サイズを節約するためにEBPをjitCompA0001_EBP128バイトずらす */
1478         return;
1479 }
1480
1481 void func3c(char *ebp, int opt, int r1, int p1, int lenR, int lenP, int r0, int p0)
1482 {
1483         HOSECPU_RuntimeEnvironment *r = (HOSECPU_RuntimeEnvironment *) (ebp - jitCompA0001_EBP128);
1484         int i, *pi;
1485         HOSECPU_PointerRegisterEntry *pp;
1486
1487         if (r->junkStack + 2048 > r->junkStack1) {
1488                 (*(r->errHndl))(r);
1489         }
1490         pi = (void *)r->junkStack;
1491         r->junkStack += r1 * 4;
1492         for (i = 0; i < r1; i++){
1493                 pi[i] = r->ireg[i];
1494         }
1495         pp = (void *)r->junkStack;
1496         r->junkStack += p1 * 32;
1497         for (i = 0; i < p1; i++){
1498                 //pp[i] = r->preg[i];
1499                 PRegCopy(&pp[i], &r->preg[i]);
1500                 //
1501         }
1502         pp = (void *)r->junkStack;
1503         r->junkStack += 32;
1504         //*pp = r->preg[0x30];
1505         PRegCopy(pp, &r->preg[0x30]);
1506         //
1507         pi = (void *)r->junkStack;
1508         r->junkStack += 4;
1509         *pi = opt << 16 | r1 << 8 | p1;
1510         for (i = 0; i < lenR; i++){
1511                 r->ireg[r0 + i] = r->ireg[0x30 + i];
1512         }
1513         for (i = 0; i < lenP; i++){
1514                 r->preg[p0 + i] = r->preg[0x31 + i];
1515         }
1516         return;
1517 }
1518
1519 void func3d(char *ebp, int opt, int r1, int p1, int lenR, int lenP, int r0, int p0)
1520 {
1521         HOSECPU_RuntimeEnvironment *r = (HOSECPU_RuntimeEnvironment *) (ebp - jitCompA0001_EBP128);
1522         int i;
1523         r->junkStack -= 4;
1524         r->junkStack -= 32;
1525         HOSECPU_PointerRegisterEntry *pp = (void *)r->junkStack;
1526
1527         //r->preg[0x30] = *pp;
1528         PRegCopy(&r->preg[0x30], pp);
1529         //
1530         r->junkStack -= p1 * 32; pp = (void *)r->junkStack;
1531         for (i = 0; i < p1; i++){
1532                 //r->preg[i] = pp[i];
1533                 PRegCopy(&r->preg[i], &pp[i]);
1534                 //
1535         }
1536         r->junkStack -= r1 * 4; int *pi = (void *)r->junkStack;
1537         for (i = 0; i < r1; i++){
1538                 r->ireg[i] = pi[i];
1539         }
1540         return;
1541 }
1542
1543 void funcf4(char *ebp, int pxx, int typ, int len)
1544 {
1545         HOSECPU_RuntimeEnvironment *r = (HOSECPU_RuntimeEnvironment *) (ebp - jitCompA0001_EBP128);
1546         int width = jitCompA000_dataWidth(jitCompA000_convTyp(r->ireg[typ])) >> 3;
1547         if (width < 0 || r->ireg[len] < 0){
1548                 (*(r->errHndl))(r);
1549         }
1550         void *p = r->junkStack;
1551         if (r->junkStack + width * r->ireg[len] + 256 > r->junkStack1){
1552                 (*(r->errHndl))(r);
1553         }
1554         r->junkStack += width * r->ireg[len];
1555         r->preg[pxx].p = p;
1556         r->preg[pxx].typ = r->ireg[typ];
1557         r->preg[pxx].p0 = p;
1558         r->preg[pxx].p1 = (void *)r->junkStack;
1559         int *pi = (int *)r->junkStack;
1560         *pi = width * r->ireg[len];
1561         r->junkStack += sizeof (int);
1562         if (r->ireg[typ] == 1) {
1563                 int i, i1 = (width * r->ireg[len]) >> 2;
1564                 pi = p;
1565                 for (i = 0; i < i1; i++){
1566                         pi[i] = 0;
1567                 }
1568         }
1569         return;
1570 }
1571
1572 void funcf5(char *ebp, int pxx, int typ, int len)
1573 {
1574         // pxxはダミーで参照されない
1575         HOSECPU_RuntimeEnvironment *r = (HOSECPU_RuntimeEnvironment *) (ebp - jitCompA0001_EBP128);
1576         r->junkStack -= sizeof (int);
1577         int *pi = (int *)r->junkStack;
1578         r->junkStack -= *pi;
1579 #if 0
1580         int width = jitCompA000_dataWidth(r->ireg[typ]);
1581         void *p = r->junkStack;
1582         r->junkStack -= width * r->ireg[len];
1583 #endif
1584         return;
1585 }
1586
1587 void funcf6(char *ebp, int pxx, int typ, int len)
1588 {
1589         HOSECPU_RuntimeEnvironment *r = (HOSECPU_RuntimeEnvironment *) (ebp - jitCompA0001_EBP128);
1590         int width = jitCompA000_dataWidth(jitCompA000_convTyp(r->ireg[typ])) >> 3;
1591         if (width < 0 || r->ireg[len] < 0){
1592                 (*(r->errHndl))(r);
1593         }
1594         void *p = malloc(width * r->ireg[len]);
1595         r->preg[pxx].p = p;
1596         r->preg[pxx].typ = r->ireg[typ];
1597         r->preg[pxx].p0 = p;
1598         r->preg[pxx].p1 = (unsigned char *)p + width * r->ireg[len];
1599         if (r->ireg[typ] == 1) {
1600                 int i, i1 = (width * r->ireg[len]) >> 2, *pi;
1601                 pi = p;
1602                 for (i = 0; i < i1; i++){
1603                         pi[i] = 0;
1604                 }
1605                 for (i = 1; i < i1; i += 8){
1606                         pi[i] |= -1;
1607                 }
1608         }
1609         return;
1610 }
1611
1612 void funcf7(char *ebp, int pxx, int typ, int len)
1613 {
1614         // typとlenはダミーで参照されない
1615         HOSECPU_RuntimeEnvironment *r = (HOSECPU_RuntimeEnvironment *) (ebp - jitCompA0001_EBP128);
1616         free(r->preg[pxx].p);
1617         return;
1618 }
1619
1620 void errHndl(HOSECPU_RuntimeEnvironment *r)
1621 {
1622         r = (HOSECPU_RuntimeEnvironment *) (((char *)r) - jitCompA0001_EBP128);
1623         (*(r->errHndl))(r);
1624         // ここに帰ってきてはいけない.
1625 }
1626
1627 /*
1628  * jitcの出力コードをひとまとめにする関数を作成しその中身をjitCompile()で生成
1629  *
1630  * qq : 出力バイナリの書き込み位置のアドレスへの参照(書き込み位置を呼び出しに反映させるため参照渡しにする)
1631  * q1 : 出力バイナリの書き込み位置のアドレスの最大値
1632  * p0 : (*.ose)バイナリの読み込み位置のアドレス(ヘッダ部除去済)
1633  * p1 : (*.ose)バイナリの読み込み位置の取りうる最大値
1634  *      (ただし、「確保したメモリ」の最大値なのでこれより手前にゴミデータが入っているかもしれない)
1635  * ret=1 : ヘッダのエラー
1636  * ret=2 : jitコンパイルエラー
1637  */
1638 int jitc0(unsigned char **qq, unsigned char *q1, const unsigned char *p0, const unsigned char *p1, int level, HOSECPU_LabelListTag *label)
1639 {
1640         unsigned char *q = *qq;
1641         int i;
1642
1643         if (p0[0] != 0x05 || p0[1] != SIGN1){
1644                 // OSECPUのヘッダ (05E1) を確認
1645                 return 1;
1646         }
1647
1648         jitCompPutOp_PUSH_GReg(q, IA32_REG5_EBP);
1649
1650         *q++ = 0x8b; *q++ = 0x6c; *q++ = 0x24; *q++ = 0x08; /* MOV(EBP,[ESP+8]); */
1651
1652         for (i = 0; i < JITC_MAXLABELS; i++){
1653                 label[i].opt = 0;
1654         }
1655
1656         // 以下のjitCompile()呼び出しでは第二引数をq1-2にした方がよいのではないか?
1657         i = jitCompiler(q, q1, p0 + 2, p1, p0, label, JITC_MAXLABELS, level, di1_serial, 0);
1658         if (i != 0){
1659                 return 2;
1660         }
1661         i = jitCompiler(q, q1, p0 + 2, p1, p0, label, JITC_MAXLABELS, level, di1_serial, JITC_PHASE1 + 0);
1662         if (i < 0){
1663                 return 2;
1664         }
1665         q += i;
1666
1667         jitCompPutOp_POP_GReg(q, IA32_REG5_EBP);
1668         *q++ = 0xc3; /* RET(); */
1669         *qq = q;
1670         return 0;
1671 }
1672
1673 #if (USE_DEBUGGER != 0)
1674
1675 int dbgrGetRegNum(const char *p)
1676 {
1677         int i, j, r = -1;
1678         if (p[2] <= ' ') {
1679                 i = p[0] - '0';
1680                 j = p[1] - '0';
1681                 if (i > 9){
1682                         i -= 'A' - '0' - 10;
1683                 }
1684                 if (j > 9){
1685                         j -= 'A' - '0' - 10;
1686                 }
1687                 if (0 <= i && i <= 15 && 0 <= j && j <= 15){
1688                         r = i << 4 | j;
1689                 }
1690         }
1691         return r;
1692 }
1693
1694 void dbgrMain(HOSECPU_RuntimeEnvironment *r)
1695 {
1696         if (r->dbgr == 0){
1697                 return;
1698         }
1699         for (;;) {
1700                 char cmd[64], *p;
1701                 int i, j, k;
1702
1703                 printf("\ndbgr>");
1704                 p = fgets(cmd, 64, stdin);
1705                 if (p == NULL){
1706                         break;
1707                 }
1708                 if (cmd[0] == '\0'){
1709                         continue;
1710                 }
1711                 if (cmd[0] == 'q' && cmd[1] <= ' '){
1712                         break;
1713                 }
1714                 if (cmd[0] == 'p' && cmd[1] <= ' ' && cmd[1] != '\0') {
1715                         p = &cmd[2];
1716                         while (*p <= ' ' && *p != '\0'){
1717                                 p++;
1718                         }
1719                         if (*p == 'R') {
1720                                 i = dbgrGetRegNum(p + 1);
1721                                 if (0 <= i && i <= 0x3f) {
1722                                         printf("R%02X = 0x%08X = %d\n", i, r->ireg[i], r->ireg[i]);
1723                                 } else{
1724                                         puts("register name error");
1725                                 }
1726                                 continue;
1727                         }
1728                         if (*p == 'P') {
1729                                 i = dbgrGetRegNum(p + 1);
1730                                 if (0 <= i && i <= 0x3f) {
1731                                         p = "invalid";
1732                                         if (0 <= r->preg[i].typ && r->preg[i].typ <= 0x15) {
1733                                                 static char *typName[] = {
1734                                                         "T_CODE", "T_VPTR", "T_SINT8", "T_UINT8",
1735                                                         "T_SINT16", "T_UINT16", "T_SINT32", "T_UINT32",
1736                                                         "T_SINT4", "T_UINT4", "T_SINT2", "T_UINT2",
1737                                                         "T_SINT1", "T_UINT1", "T_SINT12", "T_UINT12",
1738                                                         "T_SINT20", "T_UINT20", "T_SINT24", "T_UINT24",
1739                                                         "T_SINT28", "T_UINT28"
1740                                                 };
1741                                                 p = typName[r->preg[i].typ];
1742                                         }
1743                                         printf("P%02X:\n  type = %s(%04X),  (origin-ptr) = 0x%08X\n", i, p, r->preg[i].typ, (unsigned int)(r->preg[i].p0));
1744                                         if (r->preg[i].p != NULL && r->preg[i].p0 != NULL) {
1745                                                 j = jitCompA000_dataWidth(jitCompA000_convTyp(r->preg[i].typ)) >> 3;
1746                                                 if (j <= 0){
1747                                                         j = 1;
1748                                                 }
1749                                                 k = (r->preg[i].p1 - r->preg[i].p0) / j;
1750                                                 printf("  size = 0x%08X = %d\n", k, k);
1751                                                 k = (r->preg[i].p - r->preg[i].p0) / j;
1752                                                 printf("  pos  = 0x%08X = %d\n", k, k);
1753                                         }
1754                                         else {
1755                                                 puts("  null pointer");
1756                                         }
1757                                 }
1758                                 else
1759                                         puts("register name error");
1760                                 continue;
1761                         }
1762                 }
1763                 puts("command error");
1764         }
1765         return;
1766 }
1767
1768 #endif
1769
1770
1771 #endif