00001 #define sign_extend(N,SIZE) (((int)((N) << (sizeof(unsigned)*8-(SIZE)))) >> (sizeof(unsigned)*8-(SIZE)))
00002 #include <assert.h>
00003
00004 #line 1 "frontend/machine/pentium/decoder.m"
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032 #include <assert.h>
00033 #if defined(_MSC_VER) && _MSC_VER <= 1100
00034 #include "signature.h"
00035 #endif
00036
00037 #include "rtl.h"
00038 #include "decoder.h"
00039 #include "pentiumdecoder.h"
00040 #include "prog.h"
00041 #include "exp.h"
00042 #include "proc.h"
00043 #include "boomerang.h"
00044 #include "statement.h"
00045
00046 #define DIS_R8 (dis_Reg(r8+8))
00047 #define DIS_R16 (dis_Reg(r16+0))
00048 #define DIS_R32 (dis_Reg(r32+24))
00049 #define DIS_REG8 (dis_Reg(reg+8))
00050 #define DIS_REG16 (dis_Reg(reg+0))
00051 #define DIS_REG32 (dis_Reg(reg+24))
00052 #define DIS_SR16 (dis_Reg(sr16+16))
00053 #define DIS_IDX (dis_Reg(idx+32))
00054 #define DIS_IDXP1 (dis_Reg((idx+1)%7+32))
00055
00056 #define DIS_EADDR32 (dis_Eaddr(Eaddr, 32))
00057 #define DIS_EADDR16 (dis_Eaddr(Eaddr, 16))
00058 #define DIS_EADDR8 (dis_Eaddr(Eaddr, 8))
00059 #define DIS_MEM (dis_Mem(Mem))
00060 #define DIS_MEM16 (dis_Mem(Mem16)) // Probably needs changing
00061 #define DIS_MEM32 (dis_Mem(Mem32)) // Probably needs changing
00062 #define DIS_MEM64 (dis_Mem(Mem64)) // Probably needs changing
00063 #define DIS_MEM80 (dis_Mem(Mem80)) // Probably needs changing
00064
00065 #define DIS_I32 (addReloc(new Const(i32)))
00066 #define DIS_I16 (new Const(i16))
00067 #define DIS_I8 (new Const(i8))
00068 #define DIS_COUNT (new Const(count))
00069 #define DIS_OFF (addReloc(new Const(off)))
00070
00071
00072
00073
00074 void genBSFR(ADDRESS pc, Exp* reg, Exp* modrm, int init, int size, OPER incdec,
00075 int numBytes);
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087 void PentiumDecoder::unused(int x)
00088 {}
00089
00090
00091
00092
00093
00094
00095
00096
00097
00098
00099
00100
00101
00102
00103
00104 static DecodeResult result;
00105 DecodeResult& PentiumDecoder::decodeInstruction (ADDRESS pc, int delta)
00106 {
00107 ADDRESS hostPC = pc + delta;
00108
00109
00110 result.reset();
00111
00112
00113 std::list<Statement*>* stmts = NULL;
00114
00115
00116 ADDRESS nextPC = NO_ADDRESS;
00117
00118
00119 #line 112 "frontend/machine/pentium/decoder.m"
00120 {
00121 dword MATCH_p =
00122
00123 #line 112 "frontend/machine/pentium/decoder.m"
00124 hostPC
00125 ;
00126 char *MATCH_name;
00127 char *MATCH_name_page_0[] = {"REPNE.MOVSB", "JMP.Jvow", };
00128 char *MATCH_name_page_1[] = {"REPNE.MOVSvow", "REPNE.STOSvow", };
00129 char *MATCH_name_page_2[] = {"REPNE.CMPSvow", "REPNE.LODSvow", };
00130 char *MATCH_name_page_3[] = {"REP.MOVSvow", "REPNE.SCASvow", };
00131 char *MATCH_name_page_4[] = {"REPNE.MOVSvod", "REPNE.STOSB", };
00132 char *MATCH_name_page_5[] = {"REPNE.CMPSB", "REPNE.STOSvod", };
00133 char *MATCH_name_page_6[] = {"REPNE.CMPSvod", "REPNE.LODSB", };
00134 char *MATCH_name_page_7[] = {"REP.MOVSB", "REPNE.LODSvod", };
00135 char *MATCH_name_page_8[] = {"REP.MOVSvod", "REPNE.SCASB", };
00136 char *MATCH_name_page_9[] = {"REP.CMPSB", "REPNE.SCASvod", };
00137 char *MATCH_name_page_10[] = {"REP.CMPSvow", "REP.STOSvow", };
00138 char *MATCH_name_page_13[] = {"REP.CMPSvod", "REP.STOSB", };
00139 char *MATCH_name_col_59[] = {(char *)0, "JMP.Jvod", (char *)0, "JMP.Jb", };
00140 unsigned MATCH_w_8_0;
00141 unsigned MATCH_w_8_8;
00142 unsigned MATCH_w_16_8;
00143 unsigned MATCH_w_32_8;
00144 unsigned MATCH_w_8_16;
00145 unsigned MATCH_w_16_16;
00146 unsigned MATCH_w_32_16;
00147 unsigned MATCH_w_8_24;
00148 unsigned MATCH_w_16_24;
00149 unsigned MATCH_w_32_24;
00150 unsigned MATCH_w_8_32;
00151 unsigned MATCH_w_16_32;
00152 unsigned MATCH_w_32_32;
00153 unsigned MATCH_w_8_40;
00154 unsigned MATCH_w_16_40;
00155 unsigned MATCH_w_8_48;
00156 unsigned MATCH_w_32_48;
00157 unsigned MATCH_w_8_56;
00158 unsigned MATCH_w_16_56;
00159 unsigned MATCH_w_32_56;
00160 unsigned MATCH_w_8_64;
00161 unsigned MATCH_w_16_64;
00162 unsigned MATCH_w_8_72;
00163 {
00164 MATCH_w_8_0 = getByte(MATCH_p);
00165 if ((MATCH_w_8_0 >> 3 & 0x1) == 1)
00166
00167 switch((MATCH_w_8_0 >> 4 & 0xf) ) {
00168 case 0:
00169
00170 switch((MATCH_w_8_0 & 0x7) ) {
00171 case 0:
00172 MATCH_w_8_8 = getByte(1 + MATCH_p);
00173
00174 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
00175 case 0:
00176
00177 switch((MATCH_w_8_8 & 0x7) ) {
00178 case 0: case 1: case 2: case 3: case 6: case 7:
00179 goto MATCH_label_c786; break;
00180 case 4:
00181 MATCH_w_8_16 = getByte(2 + MATCH_p);
00182 if ((MATCH_w_8_16 & 0x7)
00183 == 5 &&
00184 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00185 &&
00186 (MATCH_w_8_16 >> 3 & 0x7)
00187 < 8))
00188 goto MATCH_label_c788;
00189 else
00190 goto MATCH_label_c787;
00191
00192 break;
00193 case 5:
00194 goto MATCH_label_c789; break;
00195 default: assert(0);
00196 }
00197 break;
00198 case 1:
00199 MATCH_w_8_16 = getByte(2 + MATCH_p);
00200 if ((MATCH_w_8_8 & 0x7) == 4 &&
00201 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00202 &&
00203 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
00204 unsigned Eaddr = 1 + addressToPC(MATCH_p);
00205 unsigned r8 =
00206 (MATCH_w_8_8 >> 3 & 0x7) ;
00207 nextPC = 4 + MATCH_p;
00208
00209 #line 1543 "frontend/machine/pentium/decoder.m"
00210
00211
00212 stmts = instantiate(pc, "ORmrb", DIS_EADDR8, DIS_R8);
00213
00214
00215
00216
00217
00218
00219 }
00220 else
00221 goto MATCH_label_c787;
00222
00223 break;
00224 case 2:
00225 MATCH_w_8_16 = getByte(2 + MATCH_p);
00226 if ((MATCH_w_8_8 & 0x7) == 4 &&
00227 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00228 &&
00229 (MATCH_w_8_16 >> 3 & 0x7) < 8))
00230 goto MATCH_label_c788;
00231 else
00232 goto MATCH_label_c789;
00233
00234 break;
00235 case 3:
00236 goto MATCH_label_c786; break;
00237 default: assert(0);
00238 }
00239
00240 break;
00241 case 1:
00242 MATCH_w_8_8 = getByte(1 + MATCH_p);
00243
00244 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
00245 case 0:
00246
00247 switch((MATCH_w_8_8 & 0x7) ) {
00248 case 0: case 1: case 2: case 3: case 6: case 7:
00249 goto MATCH_label_c790; break;
00250 case 4:
00251 MATCH_w_8_16 = getByte(2 + MATCH_p);
00252 if ((MATCH_w_8_16 & 0x7)
00253 == 5 &&
00254 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00255 &&
00256 (MATCH_w_8_16 >> 3 & 0x7)
00257 < 8))
00258 goto MATCH_label_c792;
00259 else
00260 goto MATCH_label_c791;
00261
00262 break;
00263 case 5:
00264 goto MATCH_label_c793; break;
00265 default: assert(0);
00266 }
00267 break;
00268 case 1:
00269 MATCH_w_8_16 = getByte(2 + MATCH_p);
00270 if ((MATCH_w_8_8 & 0x7) == 4 &&
00271 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00272 &&
00273 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
00274 unsigned Eaddr = 1 + addressToPC(MATCH_p);
00275 unsigned reg =
00276 (MATCH_w_8_8 >> 3 & 0x7) ;
00277 nextPC = 4 + MATCH_p;
00278
00279 #line 1513 "frontend/machine/pentium/decoder.m"
00280
00281
00282 stmts = instantiate(pc, "ORmrod", DIS_EADDR32, DIS_REG32);
00283
00284
00285
00286
00287
00288
00289 }
00290 else
00291 goto MATCH_label_c791;
00292
00293 break;
00294 case 2:
00295 MATCH_w_8_16 = getByte(2 + MATCH_p);
00296 if ((MATCH_w_8_8 & 0x7) == 4 &&
00297 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00298 &&
00299 (MATCH_w_8_16 >> 3 & 0x7) < 8))
00300 goto MATCH_label_c792;
00301 else
00302 goto MATCH_label_c793;
00303
00304 break;
00305 case 3:
00306 goto MATCH_label_c790; break;
00307 default: assert(0);
00308 }
00309
00310 break;
00311 case 2:
00312 MATCH_w_8_8 = getByte(1 + MATCH_p);
00313
00314 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
00315 case 0:
00316
00317 switch((MATCH_w_8_8 & 0x7) ) {
00318 case 0: case 1: case 2: case 3: case 6: case 7:
00319 goto MATCH_label_c794; break;
00320 case 4:
00321 MATCH_w_8_16 = getByte(2 + MATCH_p);
00322 if ((MATCH_w_8_16 & 0x7)
00323 == 5 &&
00324 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00325 &&
00326 (MATCH_w_8_16 >> 3 & 0x7)
00327 < 8))
00328 goto MATCH_label_c796;
00329 else
00330 goto MATCH_label_c795;
00331
00332 break;
00333 case 5:
00334 goto MATCH_label_c797; break;
00335 default: assert(0);
00336 }
00337 break;
00338 case 1:
00339 MATCH_w_8_16 = getByte(2 + MATCH_p);
00340 if ((MATCH_w_8_8 & 0x7) == 4 &&
00341 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00342 &&
00343 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
00344 unsigned Eaddr = 1 + addressToPC(MATCH_p);
00345 unsigned r8 =
00346 (MATCH_w_8_8 >> 3 & 0x7) ;
00347 nextPC = 4 + MATCH_p;
00348
00349 #line 1471 "frontend/machine/pentium/decoder.m"
00350
00351
00352 stmts = instantiate(pc, "ORrmb", DIS_R8, DIS_EADDR8);
00353
00354
00355
00356
00357
00358
00359 }
00360 else
00361 goto MATCH_label_c795;
00362
00363 break;
00364 case 2:
00365 MATCH_w_8_16 = getByte(2 + MATCH_p);
00366 if ((MATCH_w_8_8 & 0x7) == 4 &&
00367 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00368 &&
00369 (MATCH_w_8_16 >> 3 & 0x7) < 8))
00370 goto MATCH_label_c796;
00371 else
00372 goto MATCH_label_c797;
00373
00374 break;
00375 case 3:
00376 goto MATCH_label_c794; break;
00377 default: assert(0);
00378 }
00379
00380 break;
00381 case 3:
00382 MATCH_w_8_8 = getByte(1 + MATCH_p);
00383
00384 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
00385 case 0:
00386
00387 switch((MATCH_w_8_8 & 0x7) ) {
00388 case 0: case 1: case 2: case 3: case 6: case 7:
00389 goto MATCH_label_c798; break;
00390 case 4:
00391 MATCH_w_8_16 = getByte(2 + MATCH_p);
00392 if ((MATCH_w_8_16 & 0x7)
00393 == 5 &&
00394 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00395 &&
00396 (MATCH_w_8_16 >> 3 & 0x7)
00397 < 8))
00398 goto MATCH_label_c800;
00399 else
00400 goto MATCH_label_c799;
00401
00402 break;
00403 case 5:
00404 goto MATCH_label_c801; break;
00405 default: assert(0);
00406 }
00407 break;
00408 case 1:
00409 MATCH_w_8_16 = getByte(2 + MATCH_p);
00410 if ((MATCH_w_8_8 & 0x7) == 4 &&
00411 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00412 &&
00413 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
00414 unsigned Eaddr = 1 + addressToPC(MATCH_p);
00415 unsigned reg =
00416 (MATCH_w_8_8 >> 3 & 0x7) ;
00417 nextPC = 4 + MATCH_p;
00418
00419 #line 1441 "frontend/machine/pentium/decoder.m"
00420
00421
00422 stmts = instantiate(pc, "ORrmod", DIS_REG32, DIS_EADDR32);
00423
00424
00425
00426
00427
00428
00429 }
00430 else
00431 goto MATCH_label_c799;
00432
00433 break;
00434 case 2:
00435 MATCH_w_8_16 = getByte(2 + MATCH_p);
00436 if ((MATCH_w_8_8 & 0x7) == 4 &&
00437 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
00438 &&
00439 (MATCH_w_8_16 >> 3 & 0x7) < 8))
00440 goto MATCH_label_c800;
00441 else
00442 goto MATCH_label_c801;
00443
00444 break;
00445 case 3:
00446 goto MATCH_label_c798; break;
00447 default: assert(0);
00448 }
00449
00450 break;
00451 case 4:
00452 MATCH_w_8_8 = getByte(1 + MATCH_p);
00453 {
00454 int i8 =
00455 sign_extend((MATCH_w_8_8 & 0xff) , 8);
00456 nextPC = 2 + MATCH_p;
00457
00458 #line 1738 "frontend/machine/pentium/decoder.m"
00459
00460
00461 stmts = instantiate(pc, "ORiAL", DIS_I8);
00462
00463
00464
00465
00466
00467
00468 }
00469
00470 break;
00471 case 5:
00472 MATCH_w_32_8 = getDword(1 + MATCH_p);
00473 {
00474 unsigned i32 = MATCH_w_32_8 ;
00475 nextPC = 5 + MATCH_p;
00476
00477 #line 1690 "frontend/machine/pentium/decoder.m"
00478
00479
00480 stmts = instantiate(pc, "ORiEAX", DIS_I32);
00481
00482
00483
00484
00485
00486
00487 }
00488
00489 break;
00490 case 6:
00491 nextPC = 1 + MATCH_p;
00492
00493 #line 817 "frontend/machine/pentium/decoder.m"
00494
00495
00496 stmts = instantiate(pc, "PUSH.CS");
00497
00498
00499
00500
00501
00502
00503
00504 break;
00505 case 7:
00506 MATCH_w_8_8 = getByte(1 + MATCH_p);
00507
00508 switch((MATCH_w_8_8 >> 4 & 0xf) ) {
00509 case 0:
00510
00511 switch((MATCH_w_8_8 & 0x7) ) {
00512 case 0:
00513 if ((MATCH_w_8_8 >> 3 & 0x1)
00514 == 1) {
00515 nextPC = 2 + MATCH_p;
00516
00517 #line 1098 "frontend/machine/pentium/decoder.m"
00518
00519
00520 stmts = instantiate(pc, "INVD");
00521
00522
00523
00524
00525
00526
00527 }
00528 else {
00529 MATCH_w_8_16 = getByte(2 + MATCH_p);
00530
00531 switch((MATCH_w_8_16 >> 3 & 0x7)
00532 ) {
00533 case 0:
00534
00535 switch((MATCH_w_8_16 >> 6 & 0x3)
00536 ) {
00537 case 0:
00538
00539 switch((MATCH_w_8_16 & 0x7)
00540 ) {
00541 case 0: case 1: case 2:
00542 case 3: case 6: case 7:
00543 goto MATCH_label_c802;
00544
00545 break;
00546 case 4:
00547 MATCH_w_8_24 =
00548 getByte(3 + MATCH_p);
00549 if ((MATCH_w_8_24 & 0x7)
00550 == 5 &&
00551 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00552 &&
00553 (MATCH_w_8_24 >> 3 & 0x7)
00554 < 8))
00555 goto MATCH_label_c804;
00556 else
00557 goto MATCH_label_c803;
00558
00559 break;
00560 case 5:
00561 goto MATCH_label_c805;
00562
00563 break;
00564 default: assert(0);
00565 }
00566
00567 break;
00568 case 1:
00569 MATCH_w_8_24 =
00570 getByte(3 + MATCH_p);
00571 if ((MATCH_w_8_16 & 0x7)
00572 == 4 &&
00573 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00574 &&
00575 (MATCH_w_8_24 >> 3 & 0x7)
00576 < 8)) {
00577 unsigned Eaddr =
00578 2 + addressToPC(MATCH_p);
00579 nextPC = 5 + MATCH_p;
00580
00581 #line 429 "frontend/machine/pentium/decoder.m"
00582
00583
00584 stmts = instantiate(pc, "SLDT", DIS_EADDR32);
00585
00586
00587
00588
00589
00590
00591 }
00592 else
00593 goto MATCH_label_c803;
00594
00595 break;
00596 case 2:
00597 MATCH_w_8_24 =
00598 getByte(3 + MATCH_p);
00599 if ((MATCH_w_8_16 & 0x7)
00600 == 4 &&
00601 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00602 &&
00603 (MATCH_w_8_24 >> 3 & 0x7)
00604 < 8))
00605 goto MATCH_label_c804;
00606 else
00607 goto MATCH_label_c805;
00608
00609 break;
00610 case 3:
00611 goto MATCH_label_c802; break;
00612 default: assert(0);
00613 }
00614
00615 break;
00616 case 1:
00617
00618 switch((MATCH_w_8_16 >> 6 & 0x3)
00619 ) {
00620 case 0:
00621
00622 switch((MATCH_w_8_16 & 0x7)
00623 ) {
00624 case 0: case 1: case 2:
00625 case 3: case 6: case 7:
00626 {
00627 unsigned Mem =
00628 2 +
00629 addressToPC(MATCH_p);
00630 nextPC = 3 + MATCH_p;
00631
00632 #line 405 "frontend/machine/pentium/decoder.m"
00633
00634
00635 stmts = instantiate(pc, "STR", DIS_MEM);
00636
00637
00638
00639
00640
00641
00642 }
00643
00644 break;
00645 case 4:
00646 MATCH_w_8_24 =
00647 getByte(3 + MATCH_p);
00648 if ((MATCH_w_8_24 & 0x7)
00649 == 5 &&
00650 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00651 &&
00652 (MATCH_w_8_24 >> 3 & 0x7)
00653 < 8))
00654 goto MATCH_label_c807;
00655 else
00656 goto MATCH_label_c806;
00657
00658 break;
00659 case 5:
00660 goto MATCH_label_c808;
00661
00662 break;
00663 default: assert(0);
00664 }
00665
00666 break;
00667 case 1:
00668 MATCH_w_8_24 =
00669 getByte(3 + MATCH_p);
00670 if ((MATCH_w_8_16 & 0x7)
00671 == 4 &&
00672 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00673 &&
00674 (MATCH_w_8_24 >> 3 & 0x7)
00675 < 8)) {
00676 unsigned Mem =
00677 2 + addressToPC(MATCH_p);
00678 nextPC = 5 + MATCH_p;
00679
00680 #line 405 "frontend/machine/pentium/decoder.m"
00681
00682
00683 stmts = instantiate(pc, "STR", DIS_MEM);
00684
00685
00686
00687
00688
00689
00690 }
00691 else
00692 goto MATCH_label_c806;
00693
00694 break;
00695 case 2:
00696 MATCH_w_8_24 =
00697 getByte(3 + MATCH_p);
00698 if ((MATCH_w_8_16 & 0x7)
00699 == 4 &&
00700 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00701 &&
00702 (MATCH_w_8_24 >> 3 & 0x7)
00703 < 8))
00704 goto MATCH_label_c807;
00705 else
00706 goto MATCH_label_c808;
00707
00708 break;
00709 case 3:
00710 goto MATCH_label_c64; break;
00711 default: assert(0);
00712 }
00713
00714 break;
00715 case 2: case 6: case 7:
00716 goto MATCH_label_c64; break;
00717 case 3:
00718
00719 switch((MATCH_w_8_16 >> 6 & 0x3)
00720 ) {
00721 case 0:
00722
00723 switch((MATCH_w_8_16 & 0x7)
00724 ) {
00725 case 0: case 1: case 2:
00726 case 3: case 6: case 7:
00727 goto MATCH_label_c809;
00728
00729 break;
00730 case 4:
00731 MATCH_w_8_24 =
00732 getByte(3 + MATCH_p);
00733 if ((MATCH_w_8_24 & 0x7)
00734 == 5 &&
00735 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00736 &&
00737 (MATCH_w_8_24 >> 3 & 0x7)
00738 < 8))
00739 goto MATCH_label_c811;
00740 else
00741 goto MATCH_label_c810;
00742
00743 break;
00744 case 5:
00745 goto MATCH_label_c812;
00746
00747 break;
00748 default: assert(0);
00749 }
00750
00751 break;
00752 case 1:
00753 MATCH_w_8_24 =
00754 getByte(3 + MATCH_p);
00755 if ((MATCH_w_8_16 & 0x7)
00756 == 4 &&
00757 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00758 &&
00759 (MATCH_w_8_24 >> 3 & 0x7)
00760 < 8)) {
00761 unsigned Eaddr =
00762 2 + addressToPC(MATCH_p);
00763 nextPC = 5 + MATCH_p;
00764
00765 #line 1040 "frontend/machine/pentium/decoder.m"
00766
00767
00768 stmts = instantiate(pc, "LTR", DIS_EADDR32);
00769
00770
00771
00772
00773
00774
00775 }
00776 else
00777 goto MATCH_label_c810;
00778
00779 break;
00780 case 2:
00781 MATCH_w_8_24 =
00782 getByte(3 + MATCH_p);
00783 if ((MATCH_w_8_16 & 0x7)
00784 == 4 &&
00785 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00786 &&
00787 (MATCH_w_8_24 >> 3 & 0x7)
00788 < 8))
00789 goto MATCH_label_c811;
00790 else
00791 goto MATCH_label_c812;
00792
00793 break;
00794 case 3:
00795 goto MATCH_label_c809; break;
00796 default: assert(0);
00797 }
00798
00799 break;
00800 case 4:
00801
00802 switch((MATCH_w_8_16 >> 6 & 0x3)
00803 ) {
00804 case 0:
00805
00806 switch((MATCH_w_8_16 & 0x7)
00807 ) {
00808 case 0: case 1: case 2:
00809 case 3: case 6: case 7:
00810 goto MATCH_label_c813;
00811
00812 break;
00813 case 4:
00814 MATCH_w_8_24 =
00815 getByte(3 + MATCH_p);
00816 if ((MATCH_w_8_24 & 0x7)
00817 == 5 &&
00818 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00819 &&
00820 (MATCH_w_8_24 >> 3 & 0x7)
00821 < 8))
00822 goto MATCH_label_c815;
00823 else
00824 goto MATCH_label_c814;
00825
00826 break;
00827 case 5:
00828 goto MATCH_label_c816;
00829
00830 break;
00831 default: assert(0);
00832 }
00833
00834 break;
00835 case 1:
00836 MATCH_w_8_24 =
00837 getByte(3 + MATCH_p);
00838 if ((MATCH_w_8_16 & 0x7)
00839 == 4 &&
00840 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00841 &&
00842 (MATCH_w_8_24 >> 3 & 0x7)
00843 < 8)) {
00844 unsigned Eaddr =
00845 2 + addressToPC(MATCH_p);
00846 nextPC = 5 + MATCH_p;
00847
00848 #line 375 "frontend/machine/pentium/decoder.m"
00849
00850
00851 stmts = instantiate(pc, "VERR", DIS_EADDR32);
00852
00853
00854
00855
00856
00857
00858 }
00859 else
00860 goto MATCH_label_c814;
00861
00862 break;
00863 case 2:
00864 MATCH_w_8_24 =
00865 getByte(3 + MATCH_p);
00866 if ((MATCH_w_8_16 & 0x7)
00867 == 4 &&
00868 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00869 &&
00870 (MATCH_w_8_24 >> 3 & 0x7)
00871 < 8))
00872 goto MATCH_label_c815;
00873 else
00874 goto MATCH_label_c816;
00875
00876 break;
00877 case 3:
00878 goto MATCH_label_c813; break;
00879 default: assert(0);
00880 }
00881
00882 break;
00883 case 5:
00884
00885 switch((MATCH_w_8_16 >> 6 & 0x3)
00886 ) {
00887 case 0:
00888
00889 switch((MATCH_w_8_16 & 0x7)
00890 ) {
00891 case 0: case 1: case 2:
00892 case 3: case 6: case 7:
00893 goto MATCH_label_c817;
00894
00895 break;
00896 case 4:
00897 MATCH_w_8_24 =
00898 getByte(3 + MATCH_p);
00899 if ((MATCH_w_8_24 & 0x7)
00900 == 5 &&
00901 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00902 &&
00903 (MATCH_w_8_24 >> 3 & 0x7)
00904 < 8))
00905 goto MATCH_label_c819;
00906 else
00907 goto MATCH_label_c818;
00908
00909 break;
00910 case 5:
00911 goto MATCH_label_c820;
00912
00913 break;
00914 default: assert(0);
00915 }
00916
00917 break;
00918 case 1:
00919 MATCH_w_8_24 =
00920 getByte(3 + MATCH_p);
00921 if ((MATCH_w_8_16 & 0x7)
00922 == 4 &&
00923 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00924 &&
00925 (MATCH_w_8_24 >> 3 & 0x7)
00926 < 8)) {
00927 unsigned Eaddr =
00928 2 + addressToPC(MATCH_p);
00929 nextPC = 5 + MATCH_p;
00930
00931 #line 372 "frontend/machine/pentium/decoder.m"
00932
00933
00934 stmts = instantiate(pc, "VERW", DIS_EADDR32);
00935
00936
00937
00938
00939
00940
00941 }
00942 else
00943 goto MATCH_label_c818;
00944
00945 break;
00946 case 2:
00947 MATCH_w_8_24 =
00948 getByte(3 + MATCH_p);
00949 if ((MATCH_w_8_16 & 0x7)
00950 == 4 &&
00951 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
00952 &&
00953 (MATCH_w_8_24 >> 3 & 0x7)
00954 < 8))
00955 goto MATCH_label_c819;
00956 else
00957 goto MATCH_label_c820;
00958
00959 break;
00960 case 3:
00961 goto MATCH_label_c817; break;
00962 default: assert(0);
00963 }
00964
00965 break;
00966 default: assert(0);
00967 }
00968
00969
00970 }
00971 break;
00972 case 1:
00973 if ((MATCH_w_8_8 >> 3 & 0x1)
00974 == 1) {
00975 nextPC = 2 + MATCH_p;
00976
00977 #line 366 "frontend/machine/pentium/decoder.m"
00978
00979
00980 stmts = instantiate(pc, "WBINVD");
00981
00982
00983
00984
00985
00986
00987 }
00988 else {
00989 MATCH_w_8_16 = getByte(2 + MATCH_p);
00990
00991 switch((MATCH_w_8_16 >> 3 & 0x7)
00992 ) {
00993 case 0:
00994
00995 switch((MATCH_w_8_16 >> 6 & 0x3)
00996 ) {
00997 case 0:
00998
00999 switch((MATCH_w_8_16 & 0x7)
01000 ) {
01001 case 0: case 1: case 2:
01002 case 3: case 6: case 7:
01003 {
01004 unsigned Mem =
01005 2 +
01006 addressToPC(MATCH_p);
01007 nextPC = 3 + MATCH_p;
01008
01009 #line 459 "frontend/machine/pentium/decoder.m"
01010
01011
01012 stmts = instantiate(pc, "SGDT", DIS_MEM);
01013
01014
01015
01016
01017
01018
01019
01020
01021 }
01022
01023 break;
01024 case 4:
01025 MATCH_w_8_24 =
01026 getByte(3 + MATCH_p);
01027 if ((MATCH_w_8_24 & 0x7)
01028 == 5 &&
01029 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01030 &&
01031 (MATCH_w_8_24 >> 3 & 0x7)
01032 < 8))
01033 goto MATCH_label_c822;
01034 else
01035 goto MATCH_label_c821;
01036
01037 break;
01038 case 5:
01039 goto MATCH_label_c823;
01040
01041 break;
01042 default: assert(0);
01043 }
01044
01045 break;
01046 case 1:
01047 MATCH_w_8_24 =
01048 getByte(3 + MATCH_p);
01049 if ((MATCH_w_8_16 & 0x7)
01050 == 4 &&
01051 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01052 &&
01053 (MATCH_w_8_24 >> 3 & 0x7)
01054 < 8)) {
01055 unsigned Mem =
01056 2 + addressToPC(MATCH_p);
01057 nextPC = 5 + MATCH_p;
01058
01059 #line 459 "frontend/machine/pentium/decoder.m"
01060
01061
01062 stmts = instantiate(pc, "SGDT", DIS_MEM);
01063
01064
01065
01066
01067
01068
01069
01070
01071 }
01072 else
01073 goto MATCH_label_c821;
01074
01075 break;
01076 case 2:
01077 MATCH_w_8_24 =
01078 getByte(3 + MATCH_p);
01079 if ((MATCH_w_8_16 & 0x7)
01080 == 4 &&
01081 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01082 &&
01083 (MATCH_w_8_24 >> 3 & 0x7)
01084 < 8))
01085 goto MATCH_label_c822;
01086 else
01087 goto MATCH_label_c823;
01088
01089 break;
01090 case 3:
01091 goto MATCH_label_c64; break;
01092 default: assert(0);
01093 }
01094
01095 break;
01096 case 1:
01097
01098 switch((MATCH_w_8_16 >> 6 & 0x3)
01099 ) {
01100 case 0:
01101
01102 switch((MATCH_w_8_16 & 0x7)
01103 ) {
01104 case 0: case 1: case 2:
01105 case 3: case 6: case 7:
01106 {
01107 unsigned Mem =
01108 2 +
01109 addressToPC(MATCH_p);
01110 nextPC = 3 + MATCH_p;
01111
01112 #line 456 "frontend/machine/pentium/decoder.m"
01113
01114
01115 stmts = instantiate(pc, "SIDT", DIS_MEM);
01116
01117
01118
01119
01120
01121
01122 }
01123
01124 break;
01125 case 4:
01126 MATCH_w_8_24 =
01127 getByte(3 + MATCH_p);
01128 if ((MATCH_w_8_24 & 0x7)
01129 == 5 &&
01130 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01131 &&
01132 (MATCH_w_8_24 >> 3 & 0x7)
01133 < 8))
01134 goto MATCH_label_c825;
01135 else
01136 goto MATCH_label_c824;
01137
01138 break;
01139 case 5:
01140 goto MATCH_label_c826;
01141
01142 break;
01143 default: assert(0);
01144 }
01145
01146 break;
01147 case 1:
01148 MATCH_w_8_24 =
01149 getByte(3 + MATCH_p);
01150 if ((MATCH_w_8_16 & 0x7)
01151 == 4 &&
01152 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01153 &&
01154 (MATCH_w_8_24 >> 3 & 0x7)
01155 < 8)) {
01156 unsigned Mem =
01157 2 + addressToPC(MATCH_p);
01158 nextPC = 5 + MATCH_p;
01159
01160 #line 456 "frontend/machine/pentium/decoder.m"
01161
01162
01163 stmts = instantiate(pc, "SIDT", DIS_MEM);
01164
01165
01166
01167
01168
01169
01170 }
01171 else
01172 goto MATCH_label_c824;
01173
01174 break;
01175 case 2:
01176 MATCH_w_8_24 =
01177 getByte(3 + MATCH_p);
01178 if ((MATCH_w_8_16 & 0x7)
01179 == 4 &&
01180 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01181 &&
01182 (MATCH_w_8_24 >> 3 & 0x7)
01183 < 8))
01184 goto MATCH_label_c825;
01185 else
01186 goto MATCH_label_c826;
01187
01188 break;
01189 case 3:
01190 goto MATCH_label_c64; break;
01191 default: assert(0);
01192 }
01193
01194 break;
01195 case 2: case 3: case 5: case 6:
01196 goto MATCH_label_c64; break;
01197 case 4:
01198
01199 switch((MATCH_w_8_16 >> 6 & 0x3)
01200 ) {
01201 case 0:
01202
01203 switch((MATCH_w_8_16 & 0x7)
01204 ) {
01205 case 0: case 1: case 2:
01206 case 3: case 6: case 7:
01207 goto MATCH_label_c827;
01208
01209 break;
01210 case 4:
01211 MATCH_w_8_24 =
01212 getByte(3 + MATCH_p);
01213 if ((MATCH_w_8_24 & 0x7)
01214 == 5 &&
01215 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01216 &&
01217 (MATCH_w_8_24 >> 3 & 0x7)
01218 < 8))
01219 goto MATCH_label_c829;
01220 else
01221 goto MATCH_label_c828;
01222
01223 break;
01224 case 5:
01225 goto MATCH_label_c830;
01226
01227 break;
01228 default: assert(0);
01229 }
01230
01231 break;
01232 case 1:
01233 MATCH_w_8_24 =
01234 getByte(3 + MATCH_p);
01235 if ((MATCH_w_8_16 & 0x7)
01236 == 4 &&
01237 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01238 &&
01239 (MATCH_w_8_24 >> 3 & 0x7)
01240 < 8)) {
01241 unsigned Eaddr =
01242 2 + addressToPC(MATCH_p);
01243 nextPC = 5 + MATCH_p;
01244
01245 #line 426 "frontend/machine/pentium/decoder.m"
01246
01247
01248 stmts = instantiate(pc, "SMSW", DIS_EADDR32);
01249
01250
01251
01252
01253
01254
01255 }
01256 else
01257 goto MATCH_label_c828;
01258
01259 break;
01260 case 2:
01261 MATCH_w_8_24 =
01262 getByte(3 + MATCH_p);
01263 if ((MATCH_w_8_16 & 0x7)
01264 == 4 &&
01265 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01266 &&
01267 (MATCH_w_8_24 >> 3 & 0x7)
01268 < 8))
01269 goto MATCH_label_c829;
01270 else
01271 goto MATCH_label_c830;
01272
01273 break;
01274 case 3:
01275 goto MATCH_label_c827; break;
01276 default: assert(0);
01277 }
01278
01279 break;
01280 case 7:
01281
01282 switch((MATCH_w_8_16 >> 6 & 0x3)
01283 ) {
01284 case 0:
01285
01286 switch((MATCH_w_8_16 & 0x7)
01287 ) {
01288 case 0: case 1: case 2:
01289 case 3: case 6: case 7:
01290 {
01291 unsigned Mem =
01292 2 +
01293 addressToPC(MATCH_p);
01294 nextPC = 3 + MATCH_p;
01295
01296 #line 1095 "frontend/machine/pentium/decoder.m"
01297
01298
01299 stmts = instantiate(pc, "INVLPG", DIS_MEM);
01300
01301
01302
01303
01304
01305
01306 }
01307
01308 break;
01309 case 4:
01310 MATCH_w_8_24 =
01311 getByte(3 + MATCH_p);
01312 if ((MATCH_w_8_24 & 0x7)
01313 == 5 &&
01314 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01315 &&
01316 (MATCH_w_8_24 >> 3 & 0x7)
01317 < 8))
01318 goto MATCH_label_c832;
01319 else
01320 goto MATCH_label_c831;
01321
01322 break;
01323 case 5:
01324 goto MATCH_label_c833;
01325
01326 break;
01327 default: assert(0);
01328 }
01329
01330 break;
01331 case 1:
01332 MATCH_w_8_24 =
01333 getByte(3 + MATCH_p);
01334 if ((MATCH_w_8_16 & 0x7)
01335 == 4 &&
01336 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01337 &&
01338 (MATCH_w_8_24 >> 3 & 0x7)
01339 < 8)) {
01340 unsigned Mem =
01341 2 + addressToPC(MATCH_p);
01342 nextPC = 5 + MATCH_p;
01343
01344 #line 1095 "frontend/machine/pentium/decoder.m"
01345
01346
01347 stmts = instantiate(pc, "INVLPG", DIS_MEM);
01348
01349
01350
01351
01352
01353
01354 }
01355 else
01356 goto MATCH_label_c831;
01357
01358 break;
01359 case 2:
01360 MATCH_w_8_24 =
01361 getByte(3 + MATCH_p);
01362 if ((MATCH_w_8_16 & 0x7)
01363 == 4 &&
01364 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01365 &&
01366 (MATCH_w_8_24 >> 3 & 0x7)
01367 < 8))
01368 goto MATCH_label_c832;
01369 else
01370 goto MATCH_label_c833;
01371
01372 break;
01373 case 3:
01374 goto MATCH_label_c64; break;
01375 default: assert(0);
01376 }
01377
01378 break;
01379 default: assert(0);
01380 }
01381
01382
01383 }
01384 break;
01385 case 2:
01386 if ((MATCH_w_8_8 >> 3 & 0x1)
01387 == 1)
01388 goto MATCH_label_c64;
01389 else {
01390 MATCH_w_8_16 = getByte(2 + MATCH_p);
01391
01392 switch((MATCH_w_8_16 >> 6 & 0x3)
01393 ) {
01394 case 0:
01395
01396 switch((MATCH_w_8_16 & 0x7)
01397 ) {
01398 case 0: case 1: case 2: case 3:
01399 case 6: case 7:
01400 goto MATCH_label_c834; break;
01401 case 4:
01402 MATCH_w_8_24 =
01403 getByte(3 + MATCH_p);
01404 if ((MATCH_w_8_24 & 0x7)
01405 == 5 &&
01406 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01407 &&
01408 (MATCH_w_8_24 >> 3 & 0x7)
01409 < 8))
01410 goto MATCH_label_c836;
01411 else
01412 goto MATCH_label_c835;
01413
01414 break;
01415 case 5:
01416 goto MATCH_label_c837; break;
01417 default: assert(0);
01418 }
01419
01420 break;
01421 case 1:
01422 MATCH_w_8_24 = getByte(3 + MATCH_p);
01423 if ((MATCH_w_8_16 & 0x7)
01424 == 4 &&
01425 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01426 &&
01427 (MATCH_w_8_24 >> 3 & 0x7)
01428 < 8)) {
01429 unsigned Eaddr =
01430 2 + addressToPC(MATCH_p);
01431 unsigned reg =
01432 (MATCH_w_8_16 >> 3 & 0x7)
01433 ;
01434 nextPC = 5 + MATCH_p;
01435
01436 #line 1082 "frontend/machine/pentium/decoder.m"
01437
01438
01439 stmts = instantiate(pc, "LAR.od", DIS_REG32, DIS_EADDR32);
01440
01441
01442
01443
01444
01445
01446 }
01447 else
01448 goto MATCH_label_c835;
01449
01450 break;
01451 case 2:
01452 MATCH_w_8_24 = getByte(3 + MATCH_p);
01453 if ((MATCH_w_8_16 & 0x7)
01454 == 4 &&
01455 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01456 &&
01457 (MATCH_w_8_24 >> 3 & 0x7)
01458 < 8))
01459 goto MATCH_label_c836;
01460 else
01461 goto MATCH_label_c837;
01462
01463 break;
01464 case 3:
01465 goto MATCH_label_c834; break;
01466 default: assert(0);
01467 }
01468
01469
01470 }
01471 break;
01472 case 3:
01473 if ((MATCH_w_8_8 >> 3 & 0x1)
01474 == 1)
01475 goto MATCH_label_c64;
01476 else {
01477 MATCH_w_8_16 = getByte(2 + MATCH_p);
01478
01479 switch((MATCH_w_8_16 >> 6 & 0x3)
01480 ) {
01481 case 0:
01482
01483 switch((MATCH_w_8_16 & 0x7)
01484 ) {
01485 case 0: case 1: case 2: case 3:
01486 case 6: case 7:
01487 goto MATCH_label_c838; break;
01488 case 4:
01489 MATCH_w_8_24 =
01490 getByte(3 + MATCH_p);
01491 if ((MATCH_w_8_24 & 0x7)
01492 == 5 &&
01493 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01494 &&
01495 (MATCH_w_8_24 >> 3 & 0x7)
01496 < 8))
01497 goto MATCH_label_c840;
01498 else
01499 goto MATCH_label_c839;
01500
01501 break;
01502 case 5:
01503 goto MATCH_label_c841; break;
01504 default: assert(0);
01505 }
01506
01507 break;
01508 case 1:
01509 MATCH_w_8_24 = getByte(3 + MATCH_p);
01510 if ((MATCH_w_8_16 & 0x7)
01511 == 4 &&
01512 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01513 &&
01514 (MATCH_w_8_24 >> 3 & 0x7)
01515 < 8)) {
01516 unsigned Eaddr =
01517 2 + addressToPC(MATCH_p);
01518 unsigned reg =
01519 (MATCH_w_8_16 >> 3 & 0x7)
01520 ;
01521 nextPC = 5 + MATCH_p;
01522
01523 #line 1046 "frontend/machine/pentium/decoder.m"
01524
01525
01526 stmts = instantiate(pc, "LSLod", DIS_REG32, DIS_EADDR32);
01527
01528
01529
01530
01531
01532
01533 }
01534 else
01535 goto MATCH_label_c839;
01536
01537 break;
01538 case 2:
01539 MATCH_w_8_24 = getByte(3 + MATCH_p);
01540 if ((MATCH_w_8_16 & 0x7)
01541 == 4 &&
01542 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01543 &&
01544 (MATCH_w_8_24 >> 3 & 0x7)
01545 < 8))
01546 goto MATCH_label_c840;
01547 else
01548 goto MATCH_label_c841;
01549
01550 break;
01551 case 3:
01552 goto MATCH_label_c838; break;
01553 default: assert(0);
01554 }
01555
01556
01557 }
01558 break;
01559 case 4: case 5: case 7:
01560 goto MATCH_label_c64; break;
01561 case 6:
01562 if ((MATCH_w_8_8 >> 3 & 0x1)
01563 == 0) {
01564 nextPC = 2 + MATCH_p;
01565
01566 #line 1259 "frontend/machine/pentium/decoder.m"
01567
01568
01569 stmts = instantiate(pc, "CLTS");
01570
01571
01572
01573
01574
01575
01576 }
01577 else
01578 goto MATCH_label_c64;
01579
01580 break;
01581 default: assert(0);
01582 }
01583 break;
01584 case 1: case 2: case 4: case 5: case 6: case 7:
01585 case 13: case 14: case 15:
01586 goto MATCH_label_c64; break;
01587 case 3:
01588
01589 switch((MATCH_w_8_8 & 0x7) ) {
01590 case 0:
01591 if ((MATCH_w_8_8 >> 3 & 0x1)
01592 == 0) {
01593 nextPC = 2 + MATCH_p;
01594
01595 #line 363 "frontend/machine/pentium/decoder.m"
01596
01597
01598 stmts = instantiate(pc, "WRMSR");
01599
01600
01601
01602
01603
01604
01605 }
01606 else
01607 goto MATCH_label_c64;
01608
01609 break;
01610 case 1: case 3: case 4: case 5: case 6: case 7:
01611 goto MATCH_label_c64; break;
01612 case 2:
01613 if ((MATCH_w_8_8 >> 3 & 0x1)
01614 == 0) {
01615 nextPC = 2 + MATCH_p;
01616
01617 #line 596 "frontend/machine/pentium/decoder.m"
01618
01619
01620 stmts = instantiate(pc, "RDMSR");
01621
01622
01623
01624
01625
01626
01627 }
01628 else
01629 goto MATCH_label_c64;
01630
01631 break;
01632 default: assert(0);
01633 }
01634 break;
01635 case 8:
01636 if ((MATCH_w_8_8 >> 3 & 0x1) == 1)
01637
01638 switch((MATCH_w_8_8 & 0x7) ) {
01639 case 0:
01640 MATCH_w_32_16 = getDword(2 + MATCH_p);
01641 {
01642 unsigned relocd =
01643 6 + MATCH_w_32_16 +
01644 addressToPC(MATCH_p);
01645 nextPC = 6 + MATCH_p;
01646
01647 #line 246 "frontend/machine/pentium/decoder.m"
01648
01649
01650 COND_JUMP("Jv.Sod", 6, relocd, BRANCH_JMI)
01651
01652
01653
01654
01655 }
01656
01657 break;
01658 case 1:
01659 MATCH_w_32_16 = getDword(2 + MATCH_p);
01660 {
01661 unsigned relocd =
01662 6 + MATCH_w_32_16 +
01663 addressToPC(MATCH_p);
01664 nextPC = 6 + MATCH_p;
01665
01666 #line 244 "frontend/machine/pentium/decoder.m"
01667
01668
01669 COND_JUMP("Jv.NSod", 6, relocd, BRANCH_JPOS)
01670
01671
01672
01673
01674 }
01675
01676 break;
01677 case 2:
01678 MATCH_w_32_16 = getDword(2 + MATCH_p);
01679 {
01680 unsigned relocd =
01681 6 + MATCH_w_32_16 +
01682 addressToPC(MATCH_p);
01683 nextPC = 6 + MATCH_p;
01684
01685 #line 242 "frontend/machine/pentium/decoder.m"
01686
01687
01688 COND_JUMP("Jv.Pod", 6, relocd, BRANCH_JPAR)
01689
01690
01691
01692
01693 }
01694
01695 break;
01696 case 3:
01697 MATCH_w_32_16 = getDword(2 + MATCH_p);
01698 {
01699 unsigned relocd =
01700 6 + MATCH_w_32_16 +
01701 addressToPC(MATCH_p);
01702 nextPC = 6 + MATCH_p;
01703
01704 #line 240 "frontend/machine/pentium/decoder.m"
01705
01706
01707 COND_JUMP("Jv.NPod", 6, relocd, (BRANCH_TYPE)0)
01708
01709
01710
01711
01712 }
01713
01714 break;
01715 case 4:
01716 MATCH_w_32_16 = getDword(2 + MATCH_p);
01717 {
01718 unsigned relocd =
01719 6 + MATCH_w_32_16 +
01720 addressToPC(MATCH_p);
01721 nextPC = 6 + MATCH_p;
01722
01723 #line 238 "frontend/machine/pentium/decoder.m"
01724
01725
01726 COND_JUMP("Jv.Lod", 6, relocd, BRANCH_JSL)
01727
01728
01729
01730
01731 }
01732
01733 break;
01734 case 5:
01735 MATCH_w_32_16 = getDword(2 + MATCH_p);
01736 {
01737 unsigned relocd =
01738 6 + MATCH_w_32_16 +
01739 addressToPC(MATCH_p);
01740 nextPC = 6 + MATCH_p;
01741
01742 #line 236 "frontend/machine/pentium/decoder.m"
01743
01744
01745 COND_JUMP("Jv.NLod", 6, relocd, BRANCH_JSGE)
01746
01747
01748
01749
01750 }
01751
01752 break;
01753 case 6:
01754 MATCH_w_32_16 = getDword(2 + MATCH_p);
01755 {
01756 unsigned relocd =
01757 6 + MATCH_w_32_16 +
01758 addressToPC(MATCH_p);
01759 nextPC = 6 + MATCH_p;
01760
01761 #line 234 "frontend/machine/pentium/decoder.m"
01762
01763
01764 COND_JUMP("Jv.LEod", 6, relocd, BRANCH_JSLE)
01765
01766
01767
01768
01769 }
01770
01771 break;
01772 case 7:
01773 MATCH_w_32_16 = getDword(2 + MATCH_p);
01774 {
01775 unsigned relocd =
01776 6 + MATCH_w_32_16 +
01777 addressToPC(MATCH_p);
01778 nextPC = 6 + MATCH_p;
01779
01780 #line 232 "frontend/machine/pentium/decoder.m"
01781
01782
01783 COND_JUMP("Jv.NLEod", 6, relocd, BRANCH_JSG)
01784
01785
01786
01787
01788 }
01789
01790 break;
01791 default: assert(0);
01792 }
01793 else
01794
01795 switch((MATCH_w_8_8 & 0x7) ) {
01796 case 0:
01797 MATCH_w_32_16 = getDword(2 + MATCH_p);
01798 {
01799 unsigned relocd =
01800 6 + MATCH_w_32_16 +
01801 addressToPC(MATCH_p);
01802 nextPC = 6 + MATCH_p;
01803
01804 #line 263 "frontend/machine/pentium/decoder.m"
01805
01806
01807 COND_JUMP("Jv.Ood", 6, relocd, (BRANCH_TYPE)0)
01808
01809
01810
01811
01812
01813
01814 }
01815
01816 break;
01817 case 1:
01818 MATCH_w_32_16 = getDword(2 + MATCH_p);
01819 {
01820 unsigned relocd =
01821 6 + MATCH_w_32_16 +
01822 addressToPC(MATCH_p);
01823 nextPC = 6 + MATCH_p;
01824
01825 #line 260 "frontend/machine/pentium/decoder.m"
01826
01827
01828 COND_JUMP("Jv.NOod", 6, relocd, (BRANCH_TYPE)0)
01829
01830
01831
01832
01833 }
01834
01835 break;
01836 case 2:
01837 MATCH_w_32_16 = getDword(2 + MATCH_p);
01838 {
01839 unsigned relocd =
01840 6 + MATCH_w_32_16 +
01841 addressToPC(MATCH_p);
01842 nextPC = 6 + MATCH_p;
01843
01844 #line 258 "frontend/machine/pentium/decoder.m"
01845
01846
01847 COND_JUMP("Jv.Bod", 6, relocd, BRANCH_JUL)
01848
01849
01850
01851
01852 }
01853
01854 break;
01855 case 3:
01856 MATCH_w_32_16 = getDword(2 + MATCH_p);
01857 {
01858 unsigned relocd =
01859 6 + MATCH_w_32_16 +
01860 addressToPC(MATCH_p);
01861 nextPC = 6 + MATCH_p;
01862
01863 #line 256 "frontend/machine/pentium/decoder.m"
01864
01865
01866 COND_JUMP("Jv.NBod", 6, relocd, BRANCH_JUGE)
01867
01868
01869
01870
01871 }
01872
01873 break;
01874 case 4:
01875 MATCH_w_32_16 = getDword(2 + MATCH_p);
01876 {
01877 unsigned relocd =
01878 6 + MATCH_w_32_16 +
01879 addressToPC(MATCH_p);
01880 nextPC = 6 + MATCH_p;
01881
01882 #line 254 "frontend/machine/pentium/decoder.m"
01883
01884
01885 COND_JUMP("Jv.Zod", 6, relocd, BRANCH_JE)
01886
01887
01888
01889
01890 }
01891
01892 break;
01893 case 5:
01894 MATCH_w_32_16 = getDword(2 + MATCH_p);
01895 {
01896 unsigned relocd =
01897 6 + MATCH_w_32_16 +
01898 addressToPC(MATCH_p);
01899 nextPC = 6 + MATCH_p;
01900
01901 #line 252 "frontend/machine/pentium/decoder.m"
01902
01903
01904 COND_JUMP("Jv.NZod", 6, relocd, BRANCH_JNE)
01905
01906
01907
01908
01909 }
01910
01911 break;
01912 case 6:
01913 MATCH_w_32_16 = getDword(2 + MATCH_p);
01914 {
01915 unsigned relocd =
01916 6 + MATCH_w_32_16 +
01917 addressToPC(MATCH_p);
01918 nextPC = 6 + MATCH_p;
01919
01920 #line 250 "frontend/machine/pentium/decoder.m"
01921
01922
01923 COND_JUMP("Jv.BEod", 6, relocd, BRANCH_JULE)
01924
01925
01926
01927
01928 }
01929
01930 break;
01931 case 7:
01932 MATCH_w_32_16 = getDword(2 + MATCH_p);
01933 {
01934 unsigned relocd =
01935 6 + MATCH_w_32_16 +
01936 addressToPC(MATCH_p);
01937 nextPC = 6 + MATCH_p;
01938
01939 #line 248 "frontend/machine/pentium/decoder.m"
01940
01941
01942 COND_JUMP("Jv.NBEod", 6, relocd, BRANCH_JUG)
01943
01944
01945
01946
01947 }
01948
01949 break;
01950 default: assert(0);
01951 }
01952 break;
01953 case 9:
01954 if ((MATCH_w_8_8 >> 3 & 0x1) == 1)
01955
01956 switch((MATCH_w_8_8 & 0x7) ) {
01957 case 0:
01958 MATCH_w_8_16 = getByte(2 + MATCH_p);
01959
01960 switch((MATCH_w_8_16 >> 6 & 0x3)
01961 ) {
01962 case 0:
01963
01964 switch((MATCH_w_8_16 & 0x7)
01965 ) {
01966 case 0: case 1: case 2: case 3:
01967 case 6: case 7:
01968 MATCH_name = "SETb.S";
01969 goto MATCH_label_c866;
01970
01971 break;
01972 case 4:
01973 MATCH_w_8_24 =
01974 getByte(3 + MATCH_p);
01975 if ((MATCH_w_8_24 & 0x7)
01976 == 5 &&
01977 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
01978 &&
01979 (MATCH_w_8_24 >> 3 & 0x7)
01980 < 8)) {
01981 MATCH_name = "SETb.S";
01982 goto MATCH_label_c868;
01983
01984 }
01985 else {
01986 MATCH_name = "SETb.S";
01987 goto MATCH_label_c867;
01988
01989 }
01990
01991 break;
01992 case 5:
01993 MATCH_name = "SETb.S";
01994 goto MATCH_label_c869;
01995
01996 break;
01997 default: assert(0);
01998 }
01999
02000 break;
02001 case 1:
02002 MATCH_w_8_24 = getByte(3 + MATCH_p);
02003 if ((MATCH_w_8_16 & 0x7)
02004 == 4 &&
02005 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02006 &&
02007 (MATCH_w_8_24 >> 3 & 0x7)
02008 < 8)) {
02009 MATCH_name = "SETb.S";
02010 {
02011 char *name = MATCH_name;
02012 unsigned Eaddr =
02013 2 + addressToPC(MATCH_p);
02014 nextPC = 5 + MATCH_p;
02015
02016 #line 287 "frontend/machine/pentium/decoder.m"
02017
02018
02019 stmts = instantiate(pc, name, DIS_EADDR8);
02020
02021 SETS(name, DIS_EADDR8, BRANCH_JMI)
02022
02023
02024
02025
02026 }
02027
02028 }
02029 else {
02030 MATCH_name = "SETb.S";
02031 goto MATCH_label_c867;
02032
02033 }
02034
02035 break;
02036 case 2:
02037 MATCH_w_8_24 = getByte(3 + MATCH_p);
02038 if ((MATCH_w_8_16 & 0x7)
02039 == 4 &&
02040 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02041 &&
02042 (MATCH_w_8_24 >> 3 & 0x7)
02043 < 8)) {
02044 MATCH_name = "SETb.S";
02045 goto MATCH_label_c868;
02046
02047 }
02048 else {
02049 MATCH_name = "SETb.S";
02050 goto MATCH_label_c869;
02051
02052 }
02053
02054 break;
02055 case 3:
02056 MATCH_name = "SETb.S";
02057 goto MATCH_label_c866;
02058
02059 break;
02060 default: assert(0);
02061 }
02062
02063
02064 break;
02065 case 1:
02066 MATCH_w_8_16 = getByte(2 + MATCH_p);
02067
02068 switch((MATCH_w_8_16 >> 6 & 0x3)
02069 ) {
02070 case 0:
02071
02072 switch((MATCH_w_8_16 & 0x7)
02073 ) {
02074 case 0: case 1: case 2: case 3:
02075 case 6: case 7:
02076 MATCH_name = "SETb.NS";
02077 goto MATCH_label_c870;
02078
02079 break;
02080 case 4:
02081 MATCH_w_8_24 =
02082 getByte(3 + MATCH_p);
02083 if ((MATCH_w_8_24 & 0x7)
02084 == 5 &&
02085 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02086 &&
02087 (MATCH_w_8_24 >> 3 & 0x7)
02088 < 8)) {
02089 MATCH_name = "SETb.NS";
02090 goto MATCH_label_c872;
02091
02092 }
02093 else {
02094 MATCH_name = "SETb.NS";
02095 goto MATCH_label_c871;
02096
02097 }
02098
02099 break;
02100 case 5:
02101 MATCH_name = "SETb.NS";
02102 goto MATCH_label_c873;
02103
02104 break;
02105 default: assert(0);
02106 }
02107
02108 break;
02109 case 1:
02110 MATCH_w_8_24 = getByte(3 + MATCH_p);
02111 if ((MATCH_w_8_16 & 0x7)
02112 == 4 &&
02113 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02114 &&
02115 (MATCH_w_8_24 >> 3 & 0x7)
02116 < 8)) {
02117 MATCH_name = "SETb.NS";
02118 {
02119 char *name = MATCH_name;
02120 unsigned Eaddr =
02121 2 + addressToPC(MATCH_p);
02122 nextPC = 5 + MATCH_p;
02123
02124 #line 284 "frontend/machine/pentium/decoder.m"
02125
02126
02127 stmts = instantiate(pc, name, DIS_EADDR8);
02128
02129 SETS(name, DIS_EADDR8, BRANCH_JPOS)
02130
02131
02132
02133
02134 }
02135
02136 }
02137 else {
02138 MATCH_name = "SETb.NS";
02139 goto MATCH_label_c871;
02140
02141 }
02142
02143 break;
02144 case 2:
02145 MATCH_w_8_24 = getByte(3 + MATCH_p);
02146 if ((MATCH_w_8_16 & 0x7)
02147 == 4 &&
02148 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02149 &&
02150 (MATCH_w_8_24 >> 3 & 0x7)
02151 < 8)) {
02152 MATCH_name = "SETb.NS";
02153 goto MATCH_label_c872;
02154
02155 }
02156 else {
02157 MATCH_name = "SETb.NS";
02158 goto MATCH_label_c873;
02159
02160 }
02161
02162 break;
02163 case 3:
02164 MATCH_name = "SETb.NS";
02165 goto MATCH_label_c870;
02166
02167 break;
02168 default: assert(0);
02169 }
02170
02171
02172 break;
02173 case 2: case 3:
02174 goto MATCH_label_c64; break;
02175 case 4:
02176 MATCH_w_8_16 = getByte(2 + MATCH_p);
02177
02178 switch((MATCH_w_8_16 >> 6 & 0x3)
02179 ) {
02180 case 0:
02181
02182 switch((MATCH_w_8_16 & 0x7)
02183 ) {
02184 case 0: case 1: case 2: case 3:
02185 case 6: case 7:
02186 MATCH_name = "SETb.L";
02187 goto MATCH_label_c874;
02188
02189 break;
02190 case 4:
02191 MATCH_w_8_24 =
02192 getByte(3 + MATCH_p);
02193 if ((MATCH_w_8_24 & 0x7)
02194 == 5 &&
02195 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02196 &&
02197 (MATCH_w_8_24 >> 3 & 0x7)
02198 < 8)) {
02199 MATCH_name = "SETb.L";
02200 goto MATCH_label_c876;
02201
02202 }
02203 else {
02204 MATCH_name = "SETb.L";
02205 goto MATCH_label_c875;
02206
02207 }
02208
02209 break;
02210 case 5:
02211 MATCH_name = "SETb.L";
02212 goto MATCH_label_c877;
02213
02214 break;
02215 default: assert(0);
02216 }
02217
02218 break;
02219 case 1:
02220 MATCH_w_8_24 = getByte(3 + MATCH_p);
02221 if ((MATCH_w_8_16 & 0x7)
02222 == 4 &&
02223 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02224 &&
02225 (MATCH_w_8_24 >> 3 & 0x7)
02226 < 8)) {
02227 MATCH_name = "SETb.L";
02228 {
02229 char *name = MATCH_name;
02230 unsigned Eaddr =
02231 2 + addressToPC(MATCH_p);
02232 nextPC = 5 + MATCH_p;
02233
02234 #line 275 "frontend/machine/pentium/decoder.m"
02235
02236
02237 stmts = instantiate(pc, name, DIS_EADDR8);
02238
02239 SETS(name, DIS_EADDR8, BRANCH_JSL)
02240
02241
02242
02243
02244
02245
02246
02247
02248
02249
02250
02251
02252
02253
02254
02255
02256 }
02257
02258 }
02259 else {
02260 MATCH_name = "SETb.L";
02261 goto MATCH_label_c875;
02262
02263 }
02264
02265 break;
02266 case 2:
02267 MATCH_w_8_24 = getByte(3 + MATCH_p);
02268 if ((MATCH_w_8_16 & 0x7)
02269 == 4 &&
02270 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02271 &&
02272 (MATCH_w_8_24 >> 3 & 0x7)
02273 < 8)) {
02274 MATCH_name = "SETb.L";
02275 goto MATCH_label_c876;
02276
02277 }
02278 else {
02279 MATCH_name = "SETb.L";
02280 goto MATCH_label_c877;
02281
02282 }
02283
02284 break;
02285 case 3:
02286 MATCH_name = "SETb.L";
02287 goto MATCH_label_c874;
02288
02289 break;
02290 default: assert(0);
02291 }
02292
02293
02294 break;
02295 case 5:
02296 MATCH_w_8_16 = getByte(2 + MATCH_p);
02297
02298 switch((MATCH_w_8_16 >> 6 & 0x3)
02299 ) {
02300 case 0:
02301
02302 switch((MATCH_w_8_16 & 0x7)
02303 ) {
02304 case 0: case 1: case 2: case 3:
02305 case 6: case 7:
02306 MATCH_name = "SETb.NL";
02307 goto MATCH_label_c878;
02308
02309 break;
02310 case 4:
02311 MATCH_w_8_24 =
02312 getByte(3 + MATCH_p);
02313 if ((MATCH_w_8_24 & 0x7)
02314 == 5 &&
02315 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02316 &&
02317 (MATCH_w_8_24 >> 3 & 0x7)
02318 < 8)) {
02319 MATCH_name = "SETb.NL";
02320 goto MATCH_label_c880;
02321
02322 }
02323 else {
02324 MATCH_name = "SETb.NL";
02325 goto MATCH_label_c879;
02326
02327 }
02328
02329 break;
02330 case 5:
02331 MATCH_name = "SETb.NL";
02332 goto MATCH_label_c881;
02333
02334 break;
02335 default: assert(0);
02336 }
02337
02338 break;
02339 case 1:
02340 MATCH_w_8_24 = getByte(3 + MATCH_p);
02341 if ((MATCH_w_8_16 & 0x7)
02342 == 4 &&
02343 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02344 &&
02345 (MATCH_w_8_24 >> 3 & 0x7)
02346 < 8)) {
02347 MATCH_name = "SETb.NL";
02348 {
02349 char *name = MATCH_name;
02350 unsigned Eaddr =
02351 2 + addressToPC(MATCH_p);
02352 nextPC = 5 + MATCH_p;
02353
02354 #line 272 "frontend/machine/pentium/decoder.m"
02355
02356
02357 stmts = instantiate(pc, name, DIS_EADDR8);
02358
02359 SETS(name, DIS_EADDR8, BRANCH_JSGE)
02360
02361
02362
02363
02364 }
02365
02366 }
02367 else {
02368 MATCH_name = "SETb.NL";
02369 goto MATCH_label_c879;
02370
02371 }
02372
02373 break;
02374 case 2:
02375 MATCH_w_8_24 = getByte(3 + MATCH_p);
02376 if ((MATCH_w_8_16 & 0x7)
02377 == 4 &&
02378 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02379 &&
02380 (MATCH_w_8_24 >> 3 & 0x7)
02381 < 8)) {
02382 MATCH_name = "SETb.NL";
02383 goto MATCH_label_c880;
02384
02385 }
02386 else {
02387 MATCH_name = "SETb.NL";
02388 goto MATCH_label_c881;
02389
02390 }
02391
02392 break;
02393 case 3:
02394 MATCH_name = "SETb.NL";
02395 goto MATCH_label_c878;
02396
02397 break;
02398 default: assert(0);
02399 }
02400
02401
02402 break;
02403 case 6:
02404 MATCH_w_8_16 = getByte(2 + MATCH_p);
02405
02406 switch((MATCH_w_8_16 >> 6 & 0x3)
02407 ) {
02408 case 0:
02409
02410 switch((MATCH_w_8_16 & 0x7)
02411 ) {
02412 case 0: case 1: case 2: case 3:
02413 case 6: case 7:
02414 MATCH_name = "SETb.LE";
02415 goto MATCH_label_c882;
02416
02417 break;
02418 case 4:
02419 MATCH_w_8_24 =
02420 getByte(3 + MATCH_p);
02421 if ((MATCH_w_8_24 & 0x7)
02422 == 5 &&
02423 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02424 &&
02425 (MATCH_w_8_24 >> 3 & 0x7)
02426 < 8)) {
02427 MATCH_name = "SETb.LE";
02428 goto MATCH_label_c884;
02429
02430 }
02431 else {
02432 MATCH_name = "SETb.LE";
02433 goto MATCH_label_c883;
02434
02435 }
02436
02437 break;
02438 case 5:
02439 MATCH_name = "SETb.LE";
02440 goto MATCH_label_c885;
02441
02442 break;
02443 default: assert(0);
02444 }
02445
02446 break;
02447 case 1:
02448 MATCH_w_8_24 = getByte(3 + MATCH_p);
02449 if ((MATCH_w_8_16 & 0x7)
02450 == 4 &&
02451 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02452 &&
02453 (MATCH_w_8_24 >> 3 & 0x7)
02454 < 8)) {
02455 MATCH_name = "SETb.LE";
02456 {
02457 char *name = MATCH_name;
02458 unsigned Eaddr =
02459 2 + addressToPC(MATCH_p);
02460 nextPC = 5 + MATCH_p;
02461
02462 #line 269 "frontend/machine/pentium/decoder.m"
02463
02464
02465 stmts = instantiate(pc, name, DIS_EADDR8);
02466
02467 SETS(name, DIS_EADDR8, BRANCH_JSLE)
02468
02469
02470
02471
02472 }
02473
02474 }
02475 else {
02476 MATCH_name = "SETb.LE";
02477 goto MATCH_label_c883;
02478
02479 }
02480
02481 break;
02482 case 2:
02483 MATCH_w_8_24 = getByte(3 + MATCH_p);
02484 if ((MATCH_w_8_16 & 0x7)
02485 == 4 &&
02486 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02487 &&
02488 (MATCH_w_8_24 >> 3 & 0x7)
02489 < 8)) {
02490 MATCH_name = "SETb.LE";
02491 goto MATCH_label_c884;
02492
02493 }
02494 else {
02495 MATCH_name = "SETb.LE";
02496 goto MATCH_label_c885;
02497
02498 }
02499
02500 break;
02501 case 3:
02502 MATCH_name = "SETb.LE";
02503 goto MATCH_label_c882;
02504
02505 break;
02506 default: assert(0);
02507 }
02508
02509
02510 break;
02511 case 7:
02512 MATCH_w_8_16 = getByte(2 + MATCH_p);
02513
02514 switch((MATCH_w_8_16 >> 6 & 0x3)
02515 ) {
02516 case 0:
02517
02518 switch((MATCH_w_8_16 & 0x7)
02519 ) {
02520 case 0: case 1: case 2: case 3:
02521 case 6: case 7:
02522 MATCH_name = "SETb.NLE";
02523 goto MATCH_label_c886;
02524
02525 break;
02526 case 4:
02527 MATCH_w_8_24 =
02528 getByte(3 + MATCH_p);
02529 if ((MATCH_w_8_24 & 0x7)
02530 == 5 &&
02531 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02532 &&
02533 (MATCH_w_8_24 >> 3 & 0x7)
02534 < 8)) {
02535 MATCH_name = "SETb.NLE";
02536 goto MATCH_label_c888;
02537
02538 }
02539 else {
02540 MATCH_name = "SETb.NLE";
02541 goto MATCH_label_c887;
02542
02543 }
02544
02545 break;
02546 case 5:
02547 MATCH_name = "SETb.NLE";
02548 goto MATCH_label_c889;
02549
02550 break;
02551 default: assert(0);
02552 }
02553
02554 break;
02555 case 1:
02556 MATCH_w_8_24 = getByte(3 + MATCH_p);
02557 if ((MATCH_w_8_16 & 0x7)
02558 == 4 &&
02559 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02560 &&
02561 (MATCH_w_8_24 >> 3 & 0x7)
02562 < 8)) {
02563 MATCH_name = "SETb.NLE";
02564 {
02565 char *name = MATCH_name;
02566 unsigned Eaddr =
02567 2 + addressToPC(MATCH_p);
02568 nextPC = 5 + MATCH_p;
02569
02570 #line 266 "frontend/machine/pentium/decoder.m"
02571
02572
02573 stmts = instantiate(pc, name, DIS_EADDR8);
02574
02575 SETS(name, DIS_EADDR8, BRANCH_JSG)
02576
02577
02578
02579
02580 }
02581
02582 }
02583 else {
02584 MATCH_name = "SETb.NLE";
02585 goto MATCH_label_c887;
02586
02587 }
02588
02589 break;
02590 case 2:
02591 MATCH_w_8_24 = getByte(3 + MATCH_p);
02592 if ((MATCH_w_8_16 & 0x7)
02593 == 4 &&
02594 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02595 &&
02596 (MATCH_w_8_24 >> 3 & 0x7)
02597 < 8)) {
02598 MATCH_name = "SETb.NLE";
02599 goto MATCH_label_c888;
02600
02601 }
02602 else {
02603 MATCH_name = "SETb.NLE";
02604 goto MATCH_label_c889;
02605
02606 }
02607
02608 break;
02609 case 3:
02610 MATCH_name = "SETb.NLE";
02611 goto MATCH_label_c886;
02612
02613 break;
02614 default: assert(0);
02615 }
02616
02617
02618 break;
02619 default: assert(0);
02620 }
02621 else
02622
02623 switch((MATCH_w_8_8 & 0x7) ) {
02624 case 0: case 1:
02625 goto MATCH_label_c64; break;
02626 case 2:
02627 MATCH_w_8_16 = getByte(2 + MATCH_p);
02628
02629 switch((MATCH_w_8_16 >> 6 & 0x3)
02630 ) {
02631 case 0:
02632
02633 switch((MATCH_w_8_16 & 0x7)
02634 ) {
02635 case 0: case 1: case 2: case 3:
02636 case 6: case 7:
02637 MATCH_name = "SETb.B";
02638 goto MATCH_label_c842;
02639
02640 break;
02641 case 4:
02642 MATCH_w_8_24 =
02643 getByte(3 + MATCH_p);
02644 if ((MATCH_w_8_24 & 0x7)
02645 == 5 &&
02646 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02647 &&
02648 (MATCH_w_8_24 >> 3 & 0x7)
02649 < 8)) {
02650 MATCH_name = "SETb.B";
02651 goto MATCH_label_c844;
02652
02653 }
02654 else {
02655 MATCH_name = "SETb.B";
02656 goto MATCH_label_c843;
02657
02658 }
02659
02660 break;
02661 case 5:
02662 MATCH_name = "SETb.B";
02663 goto MATCH_label_c845;
02664
02665 break;
02666 default: assert(0);
02667 }
02668
02669 break;
02670 case 1:
02671 MATCH_w_8_24 = getByte(3 + MATCH_p);
02672 if ((MATCH_w_8_16 & 0x7)
02673 == 4 &&
02674 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02675 &&
02676 (MATCH_w_8_24 >> 3 & 0x7)
02677 < 8)) {
02678 MATCH_name = "SETb.B";
02679 {
02680 char *name = MATCH_name;
02681 unsigned Eaddr =
02682 2 + addressToPC(MATCH_p);
02683 nextPC = 5 + MATCH_p;
02684
02685 #line 305 "frontend/machine/pentium/decoder.m"
02686
02687
02688 stmts = instantiate(pc, name, DIS_EADDR8);
02689
02690 SETS(name, DIS_EADDR8, BRANCH_JUL)
02691
02692
02693
02694
02695
02696
02697
02698
02699
02700
02701
02702
02703
02704
02705
02706
02707
02708
02709 }
02710
02711 }
02712 else {
02713 MATCH_name = "SETb.B";
02714 goto MATCH_label_c843;
02715
02716 }
02717
02718 break;
02719 case 2:
02720 MATCH_w_8_24 = getByte(3 + MATCH_p);
02721 if ((MATCH_w_8_16 & 0x7)
02722 == 4 &&
02723 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02724 &&
02725 (MATCH_w_8_24 >> 3 & 0x7)
02726 < 8)) {
02727 MATCH_name = "SETb.B";
02728 goto MATCH_label_c844;
02729
02730 }
02731 else {
02732 MATCH_name = "SETb.B";
02733 goto MATCH_label_c845;
02734
02735 }
02736
02737 break;
02738 case 3:
02739 MATCH_name = "SETb.B";
02740 goto MATCH_label_c842;
02741
02742 break;
02743 default: assert(0);
02744 }
02745
02746
02747 break;
02748 case 3:
02749 MATCH_w_8_16 = getByte(2 + MATCH_p);
02750
02751 switch((MATCH_w_8_16 >> 6 & 0x3)
02752 ) {
02753 case 0:
02754
02755 switch((MATCH_w_8_16 & 0x7)
02756 ) {
02757 case 0: case 1: case 2: case 3:
02758 case 6: case 7:
02759 MATCH_name = "SETb.NB";
02760 goto MATCH_label_c846;
02761
02762 break;
02763 case 4:
02764 MATCH_w_8_24 =
02765 getByte(3 + MATCH_p);
02766 if ((MATCH_w_8_24 & 0x7)
02767 == 5 &&
02768 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02769 &&
02770 (MATCH_w_8_24 >> 3 & 0x7)
02771 < 8)) {
02772 MATCH_name = "SETb.NB";
02773 goto MATCH_label_c848;
02774
02775 }
02776 else {
02777 MATCH_name = "SETb.NB";
02778 goto MATCH_label_c847;
02779
02780 }
02781
02782 break;
02783 case 5:
02784 MATCH_name = "SETb.NB";
02785 goto MATCH_label_c849;
02786
02787 break;
02788 default: assert(0);
02789 }
02790
02791 break;
02792 case 1:
02793 MATCH_w_8_24 = getByte(3 + MATCH_p);
02794 if ((MATCH_w_8_16 & 0x7)
02795 == 4 &&
02796 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02797 &&
02798 (MATCH_w_8_24 >> 3 & 0x7)
02799 < 8)) {
02800 MATCH_name = "SETb.NB";
02801 {
02802 char *name = MATCH_name;
02803 unsigned Eaddr =
02804 2 + addressToPC(MATCH_p);
02805 nextPC = 5 + MATCH_p;
02806
02807 #line 302 "frontend/machine/pentium/decoder.m"
02808
02809
02810 stmts = instantiate(pc, name, DIS_EADDR8);
02811
02812 SETS(name, DIS_EADDR8, BRANCH_JUGE)
02813
02814
02815
02816
02817 }
02818
02819 }
02820 else {
02821 MATCH_name = "SETb.NB";
02822 goto MATCH_label_c847;
02823
02824 }
02825
02826 break;
02827 case 2:
02828 MATCH_w_8_24 = getByte(3 + MATCH_p);
02829 if ((MATCH_w_8_16 & 0x7)
02830 == 4 &&
02831 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02832 &&
02833 (MATCH_w_8_24 >> 3 & 0x7)
02834 < 8)) {
02835 MATCH_name = "SETb.NB";
02836 goto MATCH_label_c848;
02837
02838 }
02839 else {
02840 MATCH_name = "SETb.NB";
02841 goto MATCH_label_c849;
02842
02843 }
02844
02845 break;
02846 case 3:
02847 MATCH_name = "SETb.NB";
02848 goto MATCH_label_c846;
02849
02850 break;
02851 default: assert(0);
02852 }
02853
02854
02855 break;
02856 case 4:
02857 MATCH_w_8_16 = getByte(2 + MATCH_p);
02858
02859 switch((MATCH_w_8_16 >> 6 & 0x3)
02860 ) {
02861 case 0:
02862
02863 switch((MATCH_w_8_16 & 0x7)
02864 ) {
02865 case 0: case 1: case 2: case 3:
02866 case 6: case 7:
02867 MATCH_name = "SETb.Z";
02868 goto MATCH_label_c850;
02869
02870 break;
02871 case 4:
02872 MATCH_w_8_24 =
02873 getByte(3 + MATCH_p);
02874 if ((MATCH_w_8_24 & 0x7)
02875 == 5 &&
02876 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02877 &&
02878 (MATCH_w_8_24 >> 3 & 0x7)
02879 < 8)) {
02880 MATCH_name = "SETb.Z";
02881 goto MATCH_label_c852;
02882
02883 }
02884 else {
02885 MATCH_name = "SETb.Z";
02886 goto MATCH_label_c851;
02887
02888 }
02889
02890 break;
02891 case 5:
02892 MATCH_name = "SETb.Z";
02893 goto MATCH_label_c853;
02894
02895 break;
02896 default: assert(0);
02897 }
02898
02899 break;
02900 case 1:
02901 MATCH_w_8_24 = getByte(3 + MATCH_p);
02902 if ((MATCH_w_8_16 & 0x7)
02903 == 4 &&
02904 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02905 &&
02906 (MATCH_w_8_24 >> 3 & 0x7)
02907 < 8)) {
02908 MATCH_name = "SETb.Z";
02909 {
02910 char *name = MATCH_name;
02911 unsigned Eaddr =
02912 2 + addressToPC(MATCH_p);
02913 nextPC = 5 + MATCH_p;
02914
02915 #line 299 "frontend/machine/pentium/decoder.m"
02916
02917
02918 stmts = instantiate(pc, name, DIS_EADDR8);
02919
02920 SETS(name, DIS_EADDR8, BRANCH_JE)
02921
02922
02923
02924
02925 }
02926
02927 }
02928 else {
02929 MATCH_name = "SETb.Z";
02930 goto MATCH_label_c851;
02931
02932 }
02933
02934 break;
02935 case 2:
02936 MATCH_w_8_24 = getByte(3 + MATCH_p);
02937 if ((MATCH_w_8_16 & 0x7)
02938 == 4 &&
02939 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02940 &&
02941 (MATCH_w_8_24 >> 3 & 0x7)
02942 < 8)) {
02943 MATCH_name = "SETb.Z";
02944 goto MATCH_label_c852;
02945
02946 }
02947 else {
02948 MATCH_name = "SETb.Z";
02949 goto MATCH_label_c853;
02950
02951 }
02952
02953 break;
02954 case 3:
02955 MATCH_name = "SETb.Z";
02956 goto MATCH_label_c850;
02957
02958 break;
02959 default: assert(0);
02960 }
02961
02962
02963 break;
02964 case 5:
02965 MATCH_w_8_16 = getByte(2 + MATCH_p);
02966
02967 switch((MATCH_w_8_16 >> 6 & 0x3)
02968 ) {
02969 case 0:
02970
02971 switch((MATCH_w_8_16 & 0x7)
02972 ) {
02973 case 0: case 1: case 2: case 3:
02974 case 6: case 7:
02975 MATCH_name = "SETb.NZ";
02976 goto MATCH_label_c854;
02977
02978 break;
02979 case 4:
02980 MATCH_w_8_24 =
02981 getByte(3 + MATCH_p);
02982 if ((MATCH_w_8_24 & 0x7)
02983 == 5 &&
02984 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
02985 &&
02986 (MATCH_w_8_24 >> 3 & 0x7)
02987 < 8)) {
02988 MATCH_name = "SETb.NZ";
02989 goto MATCH_label_c856;
02990
02991 }
02992 else {
02993 MATCH_name = "SETb.NZ";
02994 goto MATCH_label_c855;
02995
02996 }
02997
02998 break;
02999 case 5:
03000 MATCH_name = "SETb.NZ";
03001 goto MATCH_label_c857;
03002
03003 break;
03004 default: assert(0);
03005 }
03006
03007 break;
03008 case 1:
03009 MATCH_w_8_24 = getByte(3 + MATCH_p);
03010 if ((MATCH_w_8_16 & 0x7)
03011 == 4 &&
03012 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03013 &&
03014 (MATCH_w_8_24 >> 3 & 0x7)
03015 < 8)) {
03016 MATCH_name = "SETb.NZ";
03017 {
03018 char *name = MATCH_name;
03019 unsigned Eaddr =
03020 2 + addressToPC(MATCH_p);
03021 nextPC = 5 + MATCH_p;
03022
03023 #line 296 "frontend/machine/pentium/decoder.m"
03024
03025
03026 stmts = instantiate(pc, name, DIS_EADDR8);
03027
03028 SETS(name, DIS_EADDR8, BRANCH_JNE)
03029
03030
03031
03032
03033 }
03034
03035 }
03036 else {
03037 MATCH_name = "SETb.NZ";
03038 goto MATCH_label_c855;
03039
03040 }
03041
03042 break;
03043 case 2:
03044 MATCH_w_8_24 = getByte(3 + MATCH_p);
03045 if ((MATCH_w_8_16 & 0x7)
03046 == 4 &&
03047 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03048 &&
03049 (MATCH_w_8_24 >> 3 & 0x7)
03050 < 8)) {
03051 MATCH_name = "SETb.NZ";
03052 goto MATCH_label_c856;
03053
03054 }
03055 else {
03056 MATCH_name = "SETb.NZ";
03057 goto MATCH_label_c857;
03058
03059 }
03060
03061 break;
03062 case 3:
03063 MATCH_name = "SETb.NZ";
03064 goto MATCH_label_c854;
03065
03066 break;
03067 default: assert(0);
03068 }
03069
03070
03071 break;
03072 case 6:
03073 MATCH_w_8_16 = getByte(2 + MATCH_p);
03074
03075 switch((MATCH_w_8_16 >> 6 & 0x3)
03076 ) {
03077 case 0:
03078
03079 switch((MATCH_w_8_16 & 0x7)
03080 ) {
03081 case 0: case 1: case 2: case 3:
03082 case 6: case 7:
03083 MATCH_name = "SETb.BE";
03084 goto MATCH_label_c858;
03085
03086 break;
03087 case 4:
03088 MATCH_w_8_24 =
03089 getByte(3 + MATCH_p);
03090 if ((MATCH_w_8_24 & 0x7)
03091 == 5 &&
03092 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03093 &&
03094 (MATCH_w_8_24 >> 3 & 0x7)
03095 < 8)) {
03096 MATCH_name = "SETb.BE";
03097 goto MATCH_label_c860;
03098
03099 }
03100 else {
03101 MATCH_name = "SETb.BE";
03102 goto MATCH_label_c859;
03103
03104 }
03105
03106 break;
03107 case 5:
03108 MATCH_name = "SETb.BE";
03109 goto MATCH_label_c861;
03110
03111 break;
03112 default: assert(0);
03113 }
03114
03115 break;
03116 case 1:
03117 MATCH_w_8_24 = getByte(3 + MATCH_p);
03118 if ((MATCH_w_8_16 & 0x7)
03119 == 4 &&
03120 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03121 &&
03122 (MATCH_w_8_24 >> 3 & 0x7)
03123 < 8)) {
03124 MATCH_name = "SETb.BE";
03125 {
03126 char *name = MATCH_name;
03127 unsigned Eaddr =
03128 2 + addressToPC(MATCH_p);
03129 nextPC = 5 + MATCH_p;
03130
03131 #line 293 "frontend/machine/pentium/decoder.m"
03132
03133
03134 stmts = instantiate(pc, name, DIS_EADDR8);
03135
03136 SETS(name, DIS_EADDR8, BRANCH_JULE)
03137
03138
03139
03140
03141 }
03142
03143 }
03144 else {
03145 MATCH_name = "SETb.BE";
03146 goto MATCH_label_c859;
03147
03148 }
03149
03150 break;
03151 case 2:
03152 MATCH_w_8_24 = getByte(3 + MATCH_p);
03153 if ((MATCH_w_8_16 & 0x7)
03154 == 4 &&
03155 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03156 &&
03157 (MATCH_w_8_24 >> 3 & 0x7)
03158 < 8)) {
03159 MATCH_name = "SETb.BE";
03160 goto MATCH_label_c860;
03161
03162 }
03163 else {
03164 MATCH_name = "SETb.BE";
03165 goto MATCH_label_c861;
03166
03167 }
03168
03169 break;
03170 case 3:
03171 MATCH_name = "SETb.BE";
03172 goto MATCH_label_c858;
03173
03174 break;
03175 default: assert(0);
03176 }
03177
03178
03179 break;
03180 case 7:
03181 MATCH_w_8_16 = getByte(2 + MATCH_p);
03182
03183 switch((MATCH_w_8_16 >> 6 & 0x3)
03184 ) {
03185 case 0:
03186
03187 switch((MATCH_w_8_16 & 0x7)
03188 ) {
03189 case 0: case 1: case 2: case 3:
03190 case 6: case 7:
03191 MATCH_name = "SETb.NBE";
03192 goto MATCH_label_c862;
03193
03194 break;
03195 case 4:
03196 MATCH_w_8_24 =
03197 getByte(3 + MATCH_p);
03198 if ((MATCH_w_8_24 & 0x7)
03199 == 5 &&
03200 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03201 &&
03202 (MATCH_w_8_24 >> 3 & 0x7)
03203 < 8)) {
03204 MATCH_name = "SETb.NBE";
03205 goto MATCH_label_c864;
03206
03207 }
03208 else {
03209 MATCH_name = "SETb.NBE";
03210 goto MATCH_label_c863;
03211
03212 }
03213
03214 break;
03215 case 5:
03216 MATCH_name = "SETb.NBE";
03217 goto MATCH_label_c865;
03218
03219 break;
03220 default: assert(0);
03221 }
03222
03223 break;
03224 case 1:
03225 MATCH_w_8_24 = getByte(3 + MATCH_p);
03226 if ((MATCH_w_8_16 & 0x7)
03227 == 4 &&
03228 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03229 &&
03230 (MATCH_w_8_24 >> 3 & 0x7)
03231 < 8)) {
03232 MATCH_name = "SETb.NBE";
03233 {
03234 char *name = MATCH_name;
03235 unsigned Eaddr =
03236 2 + addressToPC(MATCH_p);
03237 nextPC = 5 + MATCH_p;
03238
03239 #line 290 "frontend/machine/pentium/decoder.m"
03240
03241
03242 stmts = instantiate(pc, name, DIS_EADDR8);
03243
03244 SETS(name, DIS_EADDR8, BRANCH_JUG)
03245
03246
03247
03248
03249 }
03250
03251 }
03252 else {
03253 MATCH_name = "SETb.NBE";
03254 goto MATCH_label_c863;
03255
03256 }
03257
03258 break;
03259 case 2:
03260 MATCH_w_8_24 = getByte(3 + MATCH_p);
03261 if ((MATCH_w_8_16 & 0x7)
03262 == 4 &&
03263 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03264 &&
03265 (MATCH_w_8_24 >> 3 & 0x7)
03266 < 8)) {
03267 MATCH_name = "SETb.NBE";
03268 goto MATCH_label_c864;
03269
03270 }
03271 else {
03272 MATCH_name = "SETb.NBE";
03273 goto MATCH_label_c865;
03274
03275 }
03276
03277 break;
03278 case 3:
03279 MATCH_name = "SETb.NBE";
03280 goto MATCH_label_c862;
03281
03282 break;
03283 default: assert(0);
03284 }
03285
03286
03287 break;
03288 default: assert(0);
03289 }
03290 break;
03291 case 10:
03292
03293 switch((MATCH_w_8_8 & 0x7) ) {
03294 case 0:
03295 if ((MATCH_w_8_8 >> 3 & 0x1)
03296 == 1) {
03297 nextPC = 2 + MATCH_p;
03298
03299 #line 802 "frontend/machine/pentium/decoder.m"
03300
03301
03302 stmts = instantiate(pc, "PUSH.GS");
03303
03304
03305
03306
03307
03308
03309 }
03310 else {
03311 nextPC = 2 + MATCH_p;
03312
03313 #line 805 "frontend/machine/pentium/decoder.m"
03314
03315
03316 stmts = instantiate(pc, "PUSH.FS");
03317
03318
03319
03320
03321
03322
03323 }
03324
03325 break;
03326 case 1:
03327 if ((MATCH_w_8_8 >> 3 & 0x1)
03328 == 1) {
03329 nextPC = 2 + MATCH_p;
03330
03331 #line 856 "frontend/machine/pentium/decoder.m"
03332
03333
03334 stmts = instantiate(pc, "POP.GS");
03335
03336
03337
03338
03339
03340
03341 }
03342 else {
03343 nextPC = 2 + MATCH_p;
03344
03345 #line 859 "frontend/machine/pentium/decoder.m"
03346
03347
03348 stmts = instantiate(pc, "POP.FS");
03349
03350
03351
03352
03353
03354
03355 }
03356
03357 break;
03358 case 2:
03359 if ((MATCH_w_8_8 >> 3 & 0x1)
03360 == 1) {
03361 nextPC = 2 + MATCH_p;
03362
03363 #line 475 "frontend/machine/pentium/decoder.m"
03364
03365
03366 stmts = instantiate(pc, "RSM");
03367
03368
03369
03370
03371
03372
03373 }
03374 else {
03375 nextPC = 2 + MATCH_p;
03376
03377 #line 1232 "frontend/machine/pentium/decoder.m"
03378
03379
03380 stmts = instantiate(pc, "CPUID");
03381
03382
03383
03384
03385
03386
03387 }
03388
03389 break;
03390 case 3:
03391 if ((MATCH_w_8_8 >> 3 & 0x1)
03392 == 1) {
03393 MATCH_w_8_16 = getByte(2 + MATCH_p);
03394
03395 switch((MATCH_w_8_16 >> 6 & 0x3)
03396 ) {
03397 case 0:
03398
03399 switch((MATCH_w_8_16 & 0x7)
03400 ) {
03401 case 0: case 1: case 2: case 3:
03402 case 6: case 7:
03403 goto MATCH_label_c894; break;
03404 case 4:
03405 MATCH_w_8_24 =
03406 getByte(3 + MATCH_p);
03407 if ((MATCH_w_8_24 & 0x7)
03408 == 5 &&
03409 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03410 &&
03411 (MATCH_w_8_24 >> 3 & 0x7)
03412 < 8))
03413 goto MATCH_label_c896;
03414 else
03415 goto MATCH_label_c895;
03416
03417 break;
03418 case 5:
03419 goto MATCH_label_c897; break;
03420 default: assert(0);
03421 }
03422
03423 break;
03424 case 1:
03425 MATCH_w_8_24 = getByte(3 + MATCH_p);
03426 if ((MATCH_w_8_16 & 0x7)
03427 == 4 &&
03428 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03429 &&
03430 (MATCH_w_8_24 >> 3 & 0x7)
03431 < 8)) {
03432 unsigned Eaddr =
03433 2 + addressToPC(MATCH_p);
03434 unsigned reg =
03435 (MATCH_w_8_16 >> 3 & 0x7)
03436 ;
03437 nextPC = 5 + MATCH_p;
03438
03439 #line 1316 "frontend/machine/pentium/decoder.m"
03440
03441
03442 stmts = instantiate(pc, "BTSod", DIS_EADDR32, DIS_REG32);
03443
03444
03445
03446
03447
03448
03449 }
03450 else
03451 goto MATCH_label_c895;
03452
03453 break;
03454 case 2:
03455 MATCH_w_8_24 = getByte(3 + MATCH_p);
03456 if ((MATCH_w_8_16 & 0x7)
03457 == 4 &&
03458 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03459 &&
03460 (MATCH_w_8_24 >> 3 & 0x7)
03461 < 8))
03462 goto MATCH_label_c896;
03463 else
03464 goto MATCH_label_c897;
03465
03466 break;
03467 case 3:
03468 goto MATCH_label_c894; break;
03469 default: assert(0);
03470 }
03471
03472
03473 }
03474 else {
03475 MATCH_w_8_16 = getByte(2 + MATCH_p);
03476
03477 switch((MATCH_w_8_16 >> 6 & 0x3)
03478 ) {
03479 case 0:
03480
03481 switch((MATCH_w_8_16 & 0x7)
03482 ) {
03483 case 0: case 1: case 2: case 3:
03484 case 6: case 7:
03485 goto MATCH_label_c890; break;
03486 case 4:
03487 MATCH_w_8_24 =
03488 getByte(3 + MATCH_p);
03489 if ((MATCH_w_8_24 & 0x7)
03490 == 5 &&
03491 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03492 &&
03493 (MATCH_w_8_24 >> 3 & 0x7)
03494 < 8))
03495 goto MATCH_label_c892;
03496 else
03497 goto MATCH_label_c891;
03498
03499 break;
03500 case 5:
03501 goto MATCH_label_c893; break;
03502 default: assert(0);
03503 }
03504
03505 break;
03506 case 1:
03507 MATCH_w_8_24 = getByte(3 + MATCH_p);
03508 if ((MATCH_w_8_16 & 0x7)
03509 == 4 &&
03510 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03511 &&
03512 (MATCH_w_8_24 >> 3 & 0x7)
03513 < 8)) {
03514 unsigned Eaddr =
03515 2 + addressToPC(MATCH_p);
03516 unsigned reg =
03517 (MATCH_w_8_16 >> 3 & 0x7)
03518 ;
03519 nextPC = 5 + MATCH_p;
03520
03521 #line 1352 "frontend/machine/pentium/decoder.m"
03522
03523
03524 stmts = instantiate(pc, "BTod", DIS_EADDR32, DIS_REG32);
03525
03526
03527
03528
03529
03530
03531 }
03532 else
03533 goto MATCH_label_c891;
03534
03535 break;
03536 case 2:
03537 MATCH_w_8_24 = getByte(3 + MATCH_p);
03538 if ((MATCH_w_8_16 & 0x7)
03539 == 4 &&
03540 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03541 &&
03542 (MATCH_w_8_24 >> 3 & 0x7)
03543 < 8))
03544 goto MATCH_label_c892;
03545 else
03546 goto MATCH_label_c893;
03547
03548 break;
03549 case 3:
03550 goto MATCH_label_c890; break;
03551 default: assert(0);
03552 }
03553
03554
03555 }
03556 break;
03557 case 4:
03558 if ((MATCH_w_8_8 >> 3 & 0x1)
03559 == 1) {
03560 MATCH_w_8_16 = getByte(2 + MATCH_p);
03561
03562 switch((MATCH_w_8_16 >> 6 & 0x3)
03563 ) {
03564 case 0:
03565
03566 switch((MATCH_w_8_16 & 0x7)
03567 ) {
03568 case 0: case 1: case 2: case 3:
03569 case 6: case 7:
03570 MATCH_w_8_24 =
03571 getByte(3 + MATCH_p);
03572 goto MATCH_label_c902;
03573
03574 break;
03575 case 4:
03576 MATCH_w_8_24 =
03577 getByte(3 + MATCH_p);
03578 if ((MATCH_w_8_24 & 0x7)
03579 == 5 &&
03580 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03581 &&
03582 (MATCH_w_8_24 >> 3 & 0x7)
03583 < 8)) {
03584 MATCH_w_8_64 =
03585 getByte(8 + MATCH_p);
03586 goto MATCH_label_c904;
03587
03588 }
03589 else {
03590 MATCH_w_8_32 =
03591 getByte(4 + MATCH_p);
03592 goto MATCH_label_c903;
03593
03594 }
03595
03596 break;
03597 case 5:
03598 MATCH_w_8_56 =
03599 getByte(7 + MATCH_p);
03600 goto MATCH_label_c905;
03601
03602 break;
03603 default: assert(0);
03604 }
03605
03606 break;
03607 case 1:
03608 MATCH_w_8_24 = getByte(3 + MATCH_p);
03609 if ((MATCH_w_8_16 & 0x7)
03610 == 4 &&
03611 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03612 &&
03613 (MATCH_w_8_24 >> 3 & 0x7)
03614 < 8)) {
03615 MATCH_w_8_40 = getByte(5 + MATCH_p);
03616 {
03617 unsigned Eaddr =
03618 2 + addressToPC(MATCH_p);
03619 unsigned count =
03620 (MATCH_w_8_40 & 0xff)
03621 ;
03622 unsigned reg =
03623 (MATCH_w_8_16 >> 3 & 0x7)
03624 ;
03625 nextPC = 6 + MATCH_p;
03626
03627 #line 450 "frontend/machine/pentium/decoder.m"
03628
03629
03630 stmts = instantiate(pc, "SHRD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
03631
03632
03633
03634
03635
03636
03637 }
03638
03639 }
03640 else {
03641 MATCH_w_8_32 = getByte(4 + MATCH_p);
03642 goto MATCH_label_c903;
03643
03644 }
03645
03646 break;
03647 case 2:
03648 MATCH_w_8_24 = getByte(3 + MATCH_p);
03649 if ((MATCH_w_8_16 & 0x7)
03650 == 4 &&
03651 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03652 &&
03653 (MATCH_w_8_24 >> 3 & 0x7)
03654 < 8)) {
03655 MATCH_w_8_64 = getByte(8 + MATCH_p);
03656 goto MATCH_label_c904;
03657
03658 }
03659 else {
03660 MATCH_w_8_56 = getByte(7 + MATCH_p);
03661 goto MATCH_label_c905;
03662
03663 }
03664
03665 break;
03666 case 3:
03667 MATCH_w_8_24 = getByte(3 + MATCH_p);
03668 goto MATCH_label_c902;
03669
03670 break;
03671 default: assert(0);
03672 }
03673
03674
03675 }
03676 else {
03677 MATCH_w_8_16 = getByte(2 + MATCH_p);
03678
03679 switch((MATCH_w_8_16 >> 6 & 0x3)
03680 ) {
03681 case 0:
03682
03683 switch((MATCH_w_8_16 & 0x7)
03684 ) {
03685 case 0: case 1: case 2: case 3:
03686 case 6: case 7:
03687 MATCH_w_8_24 =
03688 getByte(3 + MATCH_p);
03689 goto MATCH_label_c898;
03690
03691 break;
03692 case 4:
03693 MATCH_w_8_24 =
03694 getByte(3 + MATCH_p);
03695 if ((MATCH_w_8_24 & 0x7)
03696 == 5 &&
03697 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03698 &&
03699 (MATCH_w_8_24 >> 3 & 0x7)
03700 < 8)) {
03701 MATCH_w_8_64 =
03702 getByte(8 + MATCH_p);
03703 goto MATCH_label_c900;
03704
03705 }
03706 else {
03707 MATCH_w_8_32 =
03708 getByte(4 + MATCH_p);
03709 goto MATCH_label_c899;
03710
03711 }
03712
03713 break;
03714 case 5:
03715 MATCH_w_8_56 =
03716 getByte(7 + MATCH_p);
03717 goto MATCH_label_c901;
03718
03719 break;
03720 default: assert(0);
03721 }
03722
03723 break;
03724 case 1:
03725 MATCH_w_8_24 = getByte(3 + MATCH_p);
03726 if ((MATCH_w_8_16 & 0x7)
03727 == 4 &&
03728 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03729 &&
03730 (MATCH_w_8_24 >> 3 & 0x7)
03731 < 8)) {
03732 MATCH_w_8_40 = getByte(5 + MATCH_p);
03733 {
03734 unsigned Eaddr =
03735 2 + addressToPC(MATCH_p);
03736 unsigned count =
03737 (MATCH_w_8_40 & 0xff)
03738 ;
03739 unsigned reg =
03740 (MATCH_w_8_16 >> 3 & 0x7)
03741 ;
03742 nextPC = 6 + MATCH_p;
03743
03744 #line 444 "frontend/machine/pentium/decoder.m"
03745
03746
03747 stmts = instantiate(pc, "SHLD.Ibod", DIS_EADDR32, DIS_REG32, DIS_COUNT);
03748
03749
03750
03751
03752
03753
03754 }
03755
03756 }
03757 else {
03758 MATCH_w_8_32 = getByte(4 + MATCH_p);
03759 goto MATCH_label_c899;
03760
03761 }
03762
03763 break;
03764 case 2:
03765 MATCH_w_8_24 = getByte(3 + MATCH_p);
03766 if ((MATCH_w_8_16 & 0x7)
03767 == 4 &&
03768 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03769 &&
03770 (MATCH_w_8_24 >> 3 & 0x7)
03771 < 8)) {
03772 MATCH_w_8_64 = getByte(8 + MATCH_p);
03773 goto MATCH_label_c900;
03774
03775 }
03776 else {
03777 MATCH_w_8_56 = getByte(7 + MATCH_p);
03778 goto MATCH_label_c901;
03779
03780 }
03781
03782 break;
03783 case 3:
03784 MATCH_w_8_24 = getByte(3 + MATCH_p);
03785 goto MATCH_label_c898;
03786
03787 break;
03788 default: assert(0);
03789 }
03790
03791
03792 }
03793 break;
03794 case 5:
03795 if ((MATCH_w_8_8 >> 3 & 0x1)
03796 == 1) {
03797 MATCH_w_8_16 = getByte(2 + MATCH_p);
03798
03799 switch((MATCH_w_8_16 >> 6 & 0x3)
03800 ) {
03801 case 0:
03802
03803 switch((MATCH_w_8_16 & 0x7)
03804 ) {
03805 case 0: case 1: case 2: case 3:
03806 case 6: case 7:
03807 goto MATCH_label_c910; break;
03808 case 4:
03809 MATCH_w_8_24 =
03810 getByte(3 + MATCH_p);
03811 if ((MATCH_w_8_24 & 0x7)
03812 == 5 &&
03813 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03814 &&
03815 (MATCH_w_8_24 >> 3 & 0x7)
03816 < 8))
03817 goto MATCH_label_c912;
03818 else
03819 goto MATCH_label_c911;
03820
03821 break;
03822 case 5:
03823 goto MATCH_label_c913; break;
03824 default: assert(0);
03825 }
03826
03827 break;
03828 case 1:
03829 MATCH_w_8_24 = getByte(3 + MATCH_p);
03830 if ((MATCH_w_8_16 & 0x7)
03831 == 4 &&
03832 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03833 &&
03834 (MATCH_w_8_24 >> 3 & 0x7)
03835 < 8)) {
03836 unsigned Eaddr =
03837 2 + addressToPC(MATCH_p);
03838 unsigned reg =
03839 (MATCH_w_8_16 >> 3 & 0x7)
03840 ;
03841 nextPC = 5 + MATCH_p;
03842
03843 #line 438 "frontend/machine/pentium/decoder.m"
03844
03845
03846 stmts = instantiate(pc, "SHRD.CLod", DIS_EADDR32, DIS_REG32);
03847
03848
03849
03850
03851
03852
03853 }
03854 else
03855 goto MATCH_label_c911;
03856
03857 break;
03858 case 2:
03859 MATCH_w_8_24 = getByte(3 + MATCH_p);
03860 if ((MATCH_w_8_16 & 0x7)
03861 == 4 &&
03862 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03863 &&
03864 (MATCH_w_8_24 >> 3 & 0x7)
03865 < 8))
03866 goto MATCH_label_c912;
03867 else
03868 goto MATCH_label_c913;
03869
03870 break;
03871 case 3:
03872 goto MATCH_label_c910; break;
03873 default: assert(0);
03874 }
03875
03876
03877 }
03878 else {
03879 MATCH_w_8_16 = getByte(2 + MATCH_p);
03880
03881 switch((MATCH_w_8_16 >> 6 & 0x3)
03882 ) {
03883 case 0:
03884
03885 switch((MATCH_w_8_16 & 0x7)
03886 ) {
03887 case 0: case 1: case 2: case 3:
03888 case 6: case 7:
03889 goto MATCH_label_c906; break;
03890 case 4:
03891 MATCH_w_8_24 =
03892 getByte(3 + MATCH_p);
03893 if ((MATCH_w_8_24 & 0x7)
03894 == 5 &&
03895 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03896 &&
03897 (MATCH_w_8_24 >> 3 & 0x7)
03898 < 8))
03899 goto MATCH_label_c908;
03900 else
03901 goto MATCH_label_c907;
03902
03903 break;
03904 case 5:
03905 goto MATCH_label_c909; break;
03906 default: assert(0);
03907 }
03908
03909 break;
03910 case 1:
03911 MATCH_w_8_24 = getByte(3 + MATCH_p);
03912 if ((MATCH_w_8_16 & 0x7)
03913 == 4 &&
03914 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03915 &&
03916 (MATCH_w_8_24 >> 3 & 0x7)
03917 < 8)) {
03918 unsigned Eaddr =
03919 2 + addressToPC(MATCH_p);
03920 unsigned reg =
03921 (MATCH_w_8_16 >> 3 & 0x7)
03922 ;
03923 nextPC = 5 + MATCH_p;
03924
03925 #line 432 "frontend/machine/pentium/decoder.m"
03926
03927
03928 stmts = instantiate(pc, "SHLD.CLod", DIS_EADDR32, DIS_REG32);
03929
03930
03931
03932
03933
03934
03935 }
03936 else
03937 goto MATCH_label_c907;
03938
03939 break;
03940 case 2:
03941 MATCH_w_8_24 = getByte(3 + MATCH_p);
03942 if ((MATCH_w_8_16 & 0x7)
03943 == 4 &&
03944 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03945 &&
03946 (MATCH_w_8_24 >> 3 & 0x7)
03947 < 8))
03948 goto MATCH_label_c908;
03949 else
03950 goto MATCH_label_c909;
03951
03952 break;
03953 case 3:
03954 goto MATCH_label_c906; break;
03955 default: assert(0);
03956 }
03957
03958
03959 }
03960 break;
03961 case 6:
03962 goto MATCH_label_c64; break;
03963 case 7:
03964 if ((MATCH_w_8_8 >> 3 & 0x1)
03965 == 1) {
03966 MATCH_w_8_16 = getByte(2 + MATCH_p);
03967
03968 switch((MATCH_w_8_16 >> 6 & 0x3)
03969 ) {
03970 case 0:
03971
03972 switch((MATCH_w_8_16 & 0x7)
03973 ) {
03974 case 0: case 1: case 2: case 3:
03975 case 6: case 7:
03976 goto MATCH_label_c914; break;
03977 case 4:
03978 MATCH_w_8_24 =
03979 getByte(3 + MATCH_p);
03980 if ((MATCH_w_8_24 & 0x7)
03981 == 5 &&
03982 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
03983 &&
03984 (MATCH_w_8_24 >> 3 & 0x7)
03985 < 8))
03986 goto MATCH_label_c916;
03987 else
03988 goto MATCH_label_c915;
03989
03990 break;
03991 case 5:
03992 goto MATCH_label_c917; break;
03993 default: assert(0);
03994 }
03995
03996 break;
03997 case 1:
03998 MATCH_w_8_24 = getByte(3 + MATCH_p);
03999 if ((MATCH_w_8_16 & 0x7)
04000 == 4 &&
04001 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04002 &&
04003 (MATCH_w_8_24 >> 3 & 0x7)
04004 < 8)) {
04005 unsigned Eaddr =
04006 2 + addressToPC(MATCH_p);
04007 unsigned reg =
04008 (MATCH_w_8_16 >> 3 & 0x7)
04009 ;
04010 nextPC = 5 + MATCH_p;
04011
04012 #line 1166 "frontend/machine/pentium/decoder.m"
04013
04014
04015 stmts = instantiate(pc, "IMULrmod", DIS_REG32, DIS_EADDR32);
04016
04017
04018
04019
04020
04021
04022 }
04023 else
04024 goto MATCH_label_c915;
04025
04026 break;
04027 case 2:
04028 MATCH_w_8_24 = getByte(3 + MATCH_p);
04029 if ((MATCH_w_8_16 & 0x7)
04030 == 4 &&
04031 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04032 &&
04033 (MATCH_w_8_24 >> 3 & 0x7)
04034 < 8))
04035 goto MATCH_label_c916;
04036 else
04037 goto MATCH_label_c917;
04038
04039 break;
04040 case 3:
04041 goto MATCH_label_c914; break;
04042 default: assert(0);
04043 }
04044
04045
04046 }
04047 else
04048 goto MATCH_label_c64;
04049 break;
04050 default: assert(0);
04051 }
04052 break;
04053 case 11:
04054 if ((MATCH_w_8_8 >> 3 & 0x1) == 1)
04055
04056 switch((MATCH_w_8_8 & 0x7) ) {
04057 case 0: case 1:
04058 goto MATCH_label_c64; break;
04059 case 2:
04060 MATCH_w_8_16 = getByte(2 + MATCH_p);
04061
04062 switch((MATCH_w_8_16 >> 3 & 0x7)
04063 ) {
04064 case 0: case 1: case 2: case 3:
04065 goto MATCH_label_c64; break;
04066 case 4:
04067
04068 switch((MATCH_w_8_16 >> 6 & 0x3)
04069 ) {
04070 case 0:
04071
04072 switch((MATCH_w_8_16 & 0x7)
04073 ) {
04074 case 0: case 1: case 2:
04075 case 3: case 6: case 7:
04076 MATCH_w_8_24 =
04077 getByte(3 + MATCH_p);
04078 goto MATCH_label_c947;
04079
04080 break;
04081 case 4:
04082 MATCH_w_8_24 =
04083 getByte(3 + MATCH_p);
04084 if ((MATCH_w_8_24 & 0x7)
04085 == 5 &&
04086 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04087 &&
04088 (MATCH_w_8_24 >> 3 & 0x7)
04089 < 8)) {
04090 MATCH_w_8_64 =
04091 getByte(8 + MATCH_p);
04092 goto MATCH_label_c949;
04093
04094 }
04095 else {
04096 MATCH_w_8_32 =
04097 getByte(4 + MATCH_p);
04098 goto MATCH_label_c948;
04099
04100 }
04101
04102 break;
04103 case 5:
04104 MATCH_w_8_56 =
04105 getByte(7 + MATCH_p);
04106 goto MATCH_label_c950;
04107
04108 break;
04109 default: assert(0);
04110 }
04111
04112 break;
04113 case 1:
04114 MATCH_w_8_24 =
04115 getByte(3 + MATCH_p);
04116 if ((MATCH_w_8_16 & 0x7)
04117 == 4 &&
04118 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04119 &&
04120 (MATCH_w_8_24 >> 3 & 0x7)
04121 < 8)) {
04122 MATCH_w_8_40 =
04123 getByte(5 + MATCH_p);
04124 {
04125 unsigned Eaddr =
04126 2 + addressToPC(MATCH_p);
04127 int i8 =
04128 sign_extend((MATCH_w_8_40 & 0xff)
04129 ,
04130 8);
04131 nextPC = 6 + MATCH_p;
04132
04133 #line 1346 "frontend/machine/pentium/decoder.m"
04134
04135
04136 stmts = instantiate(pc, "BTiod", DIS_EADDR32, DIS_I8);
04137
04138
04139
04140
04141
04142
04143 }
04144
04145 }
04146 else {
04147 MATCH_w_8_32 =
04148 getByte(4 + MATCH_p);
04149 goto MATCH_label_c948;
04150
04151 }
04152
04153 break;
04154 case 2:
04155 MATCH_w_8_24 =
04156 getByte(3 + MATCH_p);
04157 if ((MATCH_w_8_16 & 0x7)
04158 == 4 &&
04159 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04160 &&
04161 (MATCH_w_8_24 >> 3 & 0x7)
04162 < 8)) {
04163 MATCH_w_8_64 =
04164 getByte(8 + MATCH_p);
04165 goto MATCH_label_c949;
04166
04167 }
04168 else {
04169 MATCH_w_8_56 =
04170 getByte(7 + MATCH_p);
04171 goto MATCH_label_c950;
04172
04173 }
04174
04175 break;
04176 case 3:
04177 MATCH_w_8_24 =
04178 getByte(3 + MATCH_p);
04179 goto MATCH_label_c947;
04180
04181 break;
04182 default: assert(0);
04183 }
04184
04185 break;
04186 case 5:
04187
04188 switch((MATCH_w_8_16 >> 6 & 0x3)
04189 ) {
04190 case 0:
04191
04192 switch((MATCH_w_8_16 & 0x7)
04193 ) {
04194 case 0: case 1: case 2:
04195 case 3: case 6: case 7:
04196 MATCH_w_8_24 =
04197 getByte(3 + MATCH_p);
04198 goto MATCH_label_c951;
04199
04200 break;
04201 case 4:
04202 MATCH_w_8_24 =
04203 getByte(3 + MATCH_p);
04204 if ((MATCH_w_8_24 & 0x7)
04205 == 5 &&
04206 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04207 &&
04208 (MATCH_w_8_24 >> 3 & 0x7)
04209 < 8)) {
04210 MATCH_w_8_64 =
04211 getByte(8 + MATCH_p);
04212 goto MATCH_label_c953;
04213
04214 }
04215 else {
04216 MATCH_w_8_32 =
04217 getByte(4 + MATCH_p);
04218 goto MATCH_label_c952;
04219
04220 }
04221
04222 break;
04223 case 5:
04224 MATCH_w_8_56 =
04225 getByte(7 + MATCH_p);
04226 goto MATCH_label_c954;
04227
04228 break;
04229 default: assert(0);
04230 }
04231
04232 break;
04233 case 1:
04234 MATCH_w_8_24 =
04235 getByte(3 + MATCH_p);
04236 if ((MATCH_w_8_16 & 0x7)
04237 == 4 &&
04238 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04239 &&
04240 (MATCH_w_8_24 >> 3 & 0x7)
04241 < 8)) {
04242 MATCH_w_8_40 =
04243 getByte(5 + MATCH_p);
04244 {
04245 unsigned Eaddr =
04246 2 + addressToPC(MATCH_p);
04247 int i8 =
04248 sign_extend((MATCH_w_8_40 & 0xff)
04249 ,
04250 8);
04251 nextPC = 6 + MATCH_p;
04252
04253 #line 1310 "frontend/machine/pentium/decoder.m"
04254
04255
04256 stmts = instantiate(pc, "BTSiod", DIS_I8, DIS_EADDR32);
04257
04258
04259
04260
04261
04262
04263 }
04264
04265 }
04266 else {
04267 MATCH_w_8_32 =
04268 getByte(4 + MATCH_p);
04269 goto MATCH_label_c952;
04270
04271 }
04272
04273 break;
04274 case 2:
04275 MATCH_w_8_24 =
04276 getByte(3 + MATCH_p);
04277 if ((MATCH_w_8_16 & 0x7)
04278 == 4 &&
04279 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04280 &&
04281 (MATCH_w_8_24 >> 3 & 0x7)
04282 < 8)) {
04283 MATCH_w_8_64 =
04284 getByte(8 + MATCH_p);
04285 goto MATCH_label_c953;
04286
04287 }
04288 else {
04289 MATCH_w_8_56 =
04290 getByte(7 + MATCH_p);
04291 goto MATCH_label_c954;
04292
04293 }
04294
04295 break;
04296 case 3:
04297 MATCH_w_8_24 =
04298 getByte(3 + MATCH_p);
04299 goto MATCH_label_c951;
04300
04301 break;
04302 default: assert(0);
04303 }
04304
04305 break;
04306 case 6:
04307
04308 switch((MATCH_w_8_16 >> 6 & 0x3)
04309 ) {
04310 case 0:
04311
04312 switch((MATCH_w_8_16 & 0x7)
04313 ) {
04314 case 0: case 1: case 2:
04315 case 3: case 6: case 7:
04316 MATCH_w_8_24 =
04317 getByte(3 + MATCH_p);
04318 goto MATCH_label_c955;
04319
04320 break;
04321 case 4:
04322 MATCH_w_8_24 =
04323 getByte(3 + MATCH_p);
04324 if ((MATCH_w_8_24 & 0x7)
04325 == 5 &&
04326 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04327 &&
04328 (MATCH_w_8_24 >> 3 & 0x7)
04329 < 8)) {
04330 MATCH_w_8_64 =
04331 getByte(8 + MATCH_p);
04332 goto MATCH_label_c957;
04333
04334 }
04335 else {
04336 MATCH_w_8_32 =
04337 getByte(4 + MATCH_p);
04338 goto MATCH_label_c956;
04339
04340 }
04341
04342 break;
04343 case 5:
04344 MATCH_w_8_56 =
04345 getByte(7 + MATCH_p);
04346 goto MATCH_label_c958;
04347
04348 break;
04349 default: assert(0);
04350 }
04351
04352 break;
04353 case 1:
04354 MATCH_w_8_24 =
04355 getByte(3 + MATCH_p);
04356 if ((MATCH_w_8_16 & 0x7)
04357 == 4 &&
04358 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04359 &&
04360 (MATCH_w_8_24 >> 3 & 0x7)
04361 < 8)) {
04362 MATCH_w_8_40 =
04363 getByte(5 + MATCH_p);
04364 {
04365 unsigned Eaddr =
04366 2 + addressToPC(MATCH_p);
04367 int i8 =
04368 sign_extend((MATCH_w_8_40 & 0xff)
04369 ,
04370 8);
04371 nextPC = 6 + MATCH_p;
04372
04373 #line 1322 "frontend/machine/pentium/decoder.m"
04374
04375
04376 stmts = instantiate(pc, "BTRiod", DIS_EADDR32, DIS_I8);
04377
04378
04379
04380
04381
04382
04383 }
04384
04385 }
04386 else {
04387 MATCH_w_8_32 =
04388 getByte(4 + MATCH_p);
04389 goto MATCH_label_c956;
04390
04391 }
04392
04393 break;
04394 case 2:
04395 MATCH_w_8_24 =
04396 getByte(3 + MATCH_p);
04397 if ((MATCH_w_8_16 & 0x7)
04398 == 4 &&
04399 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04400 &&
04401 (MATCH_w_8_24 >> 3 & 0x7)
04402 < 8)) {
04403 MATCH_w_8_64 =
04404 getByte(8 + MATCH_p);
04405 goto MATCH_label_c957;
04406
04407 }
04408 else {
04409 MATCH_w_8_56 =
04410 getByte(7 + MATCH_p);
04411 goto MATCH_label_c958;
04412
04413 }
04414
04415 break;
04416 case 3:
04417 MATCH_w_8_24 =
04418 getByte(3 + MATCH_p);
04419 goto MATCH_label_c955;
04420
04421 break;
04422 default: assert(0);
04423 }
04424
04425 break;
04426 case 7:
04427
04428 switch((MATCH_w_8_16 >> 6 & 0x3)
04429 ) {
04430 case 0:
04431
04432 switch((MATCH_w_8_16 & 0x7)
04433 ) {
04434 case 0: case 1: case 2:
04435 case 3: case 6: case 7:
04436 MATCH_w_8_24 =
04437 getByte(3 + MATCH_p);
04438 goto MATCH_label_c959;
04439
04440 break;
04441 case 4:
04442 MATCH_w_8_24 =
04443 getByte(3 + MATCH_p);
04444 if ((MATCH_w_8_24 & 0x7)
04445 == 5 &&
04446 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04447 &&
04448 (MATCH_w_8_24 >> 3 & 0x7)
04449 < 8)) {
04450 MATCH_w_8_64 =
04451 getByte(8 + MATCH_p);
04452 goto MATCH_label_c961;
04453
04454 }
04455 else {
04456 MATCH_w_8_32 =
04457 getByte(4 + MATCH_p);
04458 goto MATCH_label_c960;
04459
04460 }
04461
04462 break;
04463 case 5:
04464 MATCH_w_8_56 =
04465 getByte(7 + MATCH_p);
04466 goto MATCH_label_c962;
04467
04468 break;
04469 default: assert(0);
04470 }
04471
04472 break;
04473 case 1:
04474 MATCH_w_8_24 =
04475 getByte(3 + MATCH_p);
04476 if ((MATCH_w_8_16 & 0x7)
04477 == 4 &&
04478 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04479 &&
04480 (MATCH_w_8_24 >> 3 & 0x7)
04481 < 8)) {
04482 MATCH_w_8_40 =
04483 getByte(5 + MATCH_p);
04484 {
04485 unsigned Eaddr =
04486 2 + addressToPC(MATCH_p);
04487 int i8 =
04488 sign_extend((MATCH_w_8_40 & 0xff)
04489 ,
04490 8);
04491 nextPC = 6 + MATCH_p;
04492
04493 #line 1334 "frontend/machine/pentium/decoder.m"
04494
04495
04496 stmts = instantiate(pc, "BTCiod", DIS_EADDR32, DIS_I8);
04497
04498
04499
04500
04501
04502
04503 }
04504
04505 }
04506 else {
04507 MATCH_w_8_32 =
04508 getByte(4 + MATCH_p);
04509 goto MATCH_label_c960;
04510
04511 }
04512
04513 break;
04514 case 2:
04515 MATCH_w_8_24 =
04516 getByte(3 + MATCH_p);
04517 if ((MATCH_w_8_16 & 0x7)
04518 == 4 &&
04519 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04520 &&
04521 (MATCH_w_8_24 >> 3 & 0x7)
04522 < 8)) {
04523 MATCH_w_8_64 =
04524 getByte(8 + MATCH_p);
04525 goto MATCH_label_c961;
04526
04527 }
04528 else {
04529 MATCH_w_8_56 =
04530 getByte(7 + MATCH_p);
04531 goto MATCH_label_c962;
04532
04533 }
04534
04535 break;
04536 case 3:
04537 MATCH_w_8_24 =
04538 getByte(3 + MATCH_p);
04539 goto MATCH_label_c959;
04540
04541 break;
04542 default: assert(0);
04543 }
04544
04545 break;
04546 default: assert(0);
04547 }
04548
04549
04550 break;
04551 case 3:
04552 MATCH_w_8_16 = getByte(2 + MATCH_p);
04553
04554 switch((MATCH_w_8_16 >> 6 & 0x3)
04555 ) {
04556 case 0:
04557
04558 switch((MATCH_w_8_16 & 0x7)
04559 ) {
04560 case 0: case 1: case 2: case 3:
04561 case 6: case 7:
04562 goto MATCH_label_c963; break;
04563 case 4:
04564 MATCH_w_8_24 =
04565 getByte(3 + MATCH_p);
04566 if ((MATCH_w_8_24 & 0x7)
04567 == 5 &&
04568 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04569 &&
04570 (MATCH_w_8_24 >> 3 & 0x7)
04571 < 8))
04572 goto MATCH_label_c965;
04573 else
04574 goto MATCH_label_c964;
04575
04576 break;
04577 case 5:
04578 goto MATCH_label_c966; break;
04579 default: assert(0);
04580 }
04581
04582 break;
04583 case 1:
04584 MATCH_w_8_24 = getByte(3 + MATCH_p);
04585 if ((MATCH_w_8_16 & 0x7)
04586 == 4 &&
04587 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04588 &&
04589 (MATCH_w_8_24 >> 3 & 0x7)
04590 < 8)) {
04591 unsigned Eaddr =
04592 2 + addressToPC(MATCH_p);
04593 unsigned reg =
04594 (MATCH_w_8_16 >> 3 & 0x7)
04595 ;
04596 nextPC = 5 + MATCH_p;
04597
04598 #line 1340 "frontend/machine/pentium/decoder.m"
04599
04600
04601 stmts = instantiate(pc, "BTCod", DIS_EADDR32, DIS_REG32);
04602
04603
04604
04605
04606
04607
04608 }
04609 else
04610 goto MATCH_label_c964;
04611
04612 break;
04613 case 2:
04614 MATCH_w_8_24 = getByte(3 + MATCH_p);
04615 if ((MATCH_w_8_16 & 0x7)
04616 == 4 &&
04617 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04618 &&
04619 (MATCH_w_8_24 >> 3 & 0x7)
04620 < 8))
04621 goto MATCH_label_c965;
04622 else
04623 goto MATCH_label_c966;
04624
04625 break;
04626 case 3:
04627 goto MATCH_label_c963; break;
04628 default: assert(0);
04629 }
04630
04631
04632 break;
04633 case 4:
04634 MATCH_w_8_16 = getByte(2 + MATCH_p);
04635
04636 switch((MATCH_w_8_16 >> 6 & 0x3)
04637 ) {
04638 case 0:
04639
04640 switch((MATCH_w_8_16 & 0x7)
04641 ) {
04642 case 0: case 1: case 2: case 3:
04643 case 6: case 7:
04644 goto MATCH_label_c967; break;
04645 case 4:
04646 MATCH_w_8_24 =
04647 getByte(3 + MATCH_p);
04648 if ((MATCH_w_8_24 & 0x7)
04649 == 5 &&
04650 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04651 &&
04652 (MATCH_w_8_24 >> 3 & 0x7)
04653 < 8))
04654 goto MATCH_label_c969;
04655 else
04656 goto MATCH_label_c968;
04657
04658 break;
04659 case 5:
04660 goto MATCH_label_c970; break;
04661 default: assert(0);
04662 }
04663
04664 break;
04665 case 1:
04666 MATCH_w_8_24 = getByte(3 + MATCH_p);
04667 if ((MATCH_w_8_16 & 0x7)
04668 == 4 &&
04669 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04670 &&
04671 (MATCH_w_8_24 >> 3 & 0x7)
04672 < 8)) {
04673 unsigned Eaddr =
04674 2 + addressToPC(MATCH_p);
04675 unsigned reg =
04676 (MATCH_w_8_16 >> 3 & 0x7)
04677 ;
04678 nextPC = 5 + MATCH_p;
04679
04680 #line 1372 "frontend/machine/pentium/decoder.m"
04681
04682
04683
04684
04685 genBSFR(pc, DIS_REG32, DIS_EADDR32, -1, 32, opPlus, nextPC-hostPC);
04686
04687 return result;
04688
04689
04690
04691
04692
04693
04694 }
04695 else
04696 goto MATCH_label_c968;
04697
04698 break;
04699 case 2:
04700 MATCH_w_8_24 = getByte(3 + MATCH_p);
04701 if ((MATCH_w_8_16 & 0x7)
04702 == 4 &&
04703 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04704 &&
04705 (MATCH_w_8_24 >> 3 & 0x7)
04706 < 8))
04707 goto MATCH_label_c969;
04708 else
04709 goto MATCH_label_c970;
04710
04711 break;
04712 case 3:
04713 goto MATCH_label_c967; break;
04714 default: assert(0);
04715 }
04716
04717
04718 break;
04719 case 5:
04720 MATCH_w_8_16 = getByte(2 + MATCH_p);
04721
04722 switch((MATCH_w_8_16 >> 6 & 0x3)
04723 ) {
04724 case 0:
04725
04726 switch((MATCH_w_8_16 & 0x7)
04727 ) {
04728 case 0: case 1: case 2: case 3:
04729 case 6: case 7:
04730 goto MATCH_label_c971; break;
04731 case 4:
04732 MATCH_w_8_24 =
04733 getByte(3 + MATCH_p);
04734 if ((MATCH_w_8_24 & 0x7)
04735 == 5 &&
04736 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04737 &&
04738 (MATCH_w_8_24 >> 3 & 0x7)
04739 < 8))
04740 goto MATCH_label_c973;
04741 else
04742 goto MATCH_label_c972;
04743
04744 break;
04745 case 5:
04746 goto MATCH_label_c974; break;
04747 default: assert(0);
04748 }
04749
04750 break;
04751 case 1:
04752 MATCH_w_8_24 = getByte(3 + MATCH_p);
04753 if ((MATCH_w_8_16 & 0x7)
04754 == 4 &&
04755 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04756 &&
04757 (MATCH_w_8_24 >> 3 & 0x7)
04758 < 8)) {
04759 unsigned Eaddr =
04760 2 + addressToPC(MATCH_p);
04761 unsigned reg =
04762 (MATCH_w_8_16 >> 3 & 0x7)
04763 ;
04764 nextPC = 5 + MATCH_p;
04765
04766 #line 1361 "frontend/machine/pentium/decoder.m"
04767
04768
04769
04770
04771
04772
04773 genBSFR(pc, DIS_REG32, DIS_EADDR32, 32, 32, opMinus, nextPC-hostPC);
04774
04775 return result;
04776
04777
04778
04779
04780
04781
04782 }
04783 else
04784 goto MATCH_label_c972;
04785
04786 break;
04787 case 2:
04788 MATCH_w_8_24 = getByte(3 + MATCH_p);
04789 if ((MATCH_w_8_16 & 0x7)
04790 == 4 &&
04791 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04792 &&
04793 (MATCH_w_8_24 >> 3 & 0x7)
04794 < 8))
04795 goto MATCH_label_c973;
04796 else
04797 goto MATCH_label_c974;
04798
04799 break;
04800 case 3:
04801 goto MATCH_label_c971; break;
04802 default: assert(0);
04803 }
04804
04805
04806 break;
04807 case 6:
04808 MATCH_w_8_16 = getByte(2 + MATCH_p);
04809
04810 switch((MATCH_w_8_16 >> 6 & 0x3)
04811 ) {
04812 case 0:
04813
04814 switch((MATCH_w_8_16 & 0x7)
04815 ) {
04816 case 0: case 1: case 2: case 3:
04817 case 6: case 7:
04818 goto MATCH_label_c975; break;
04819 case 4:
04820 MATCH_w_8_24 =
04821 getByte(3 + MATCH_p);
04822 if ((MATCH_w_8_24 & 0x7)
04823 == 5 &&
04824 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04825 &&
04826 (MATCH_w_8_24 >> 3 & 0x7)
04827 < 8))
04828 goto MATCH_label_c977;
04829 else
04830 goto MATCH_label_c976;
04831
04832 break;
04833 case 5:
04834 goto MATCH_label_c978; break;
04835 default: assert(0);
04836 }
04837
04838 break;
04839 case 1:
04840 MATCH_w_8_24 = getByte(3 + MATCH_p);
04841 if ((MATCH_w_8_16 & 0x7)
04842 == 4 &&
04843 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04844 &&
04845 (MATCH_w_8_24 >> 3 & 0x7)
04846 < 8)) {
04847 unsigned Eaddr =
04848 2 + addressToPC(MATCH_p);
04849 unsigned r32 =
04850 (MATCH_w_8_16 >> 3 & 0x7)
04851 ;
04852 nextPC = 5 + MATCH_p;
04853
04854 #line 949 "frontend/machine/pentium/decoder.m"
04855
04856
04857 stmts = instantiate(pc, "MOVSX.Gv.Ebod", DIS_R32, DIS_EADDR8);
04858
04859
04860
04861
04862
04863
04864 }
04865 else
04866 goto MATCH_label_c976;
04867
04868 break;
04869 case 2:
04870 MATCH_w_8_24 = getByte(3 + MATCH_p);
04871 if ((MATCH_w_8_16 & 0x7)
04872 == 4 &&
04873 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04874 &&
04875 (MATCH_w_8_24 >> 3 & 0x7)
04876 < 8))
04877 goto MATCH_label_c977;
04878 else
04879 goto MATCH_label_c978;
04880
04881 break;
04882 case 3:
04883 goto MATCH_label_c975; break;
04884 default: assert(0);
04885 }
04886
04887
04888 break;
04889 case 7:
04890 MATCH_w_8_16 = getByte(2 + MATCH_p);
04891
04892 switch((MATCH_w_8_16 >> 6 & 0x3)
04893 ) {
04894 case 0:
04895
04896 switch((MATCH_w_8_16 & 0x7)
04897 ) {
04898 case 0: case 1: case 2: case 3:
04899 case 6: case 7:
04900 goto MATCH_label_c979; break;
04901 case 4:
04902 MATCH_w_8_24 =
04903 getByte(3 + MATCH_p);
04904 if ((MATCH_w_8_24 & 0x7)
04905 == 5 &&
04906 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04907 &&
04908 (MATCH_w_8_24 >> 3 & 0x7)
04909 < 8))
04910 goto MATCH_label_c981;
04911 else
04912 goto MATCH_label_c980;
04913
04914 break;
04915 case 5:
04916 goto MATCH_label_c982; break;
04917 default: assert(0);
04918 }
04919
04920 break;
04921 case 1:
04922 MATCH_w_8_24 = getByte(3 + MATCH_p);
04923 if ((MATCH_w_8_16 & 0x7)
04924 == 4 &&
04925 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04926 &&
04927 (MATCH_w_8_24 >> 3 & 0x7)
04928 < 8)) {
04929 unsigned Eaddr =
04930 2 + addressToPC(MATCH_p);
04931 unsigned r32 =
04932 (MATCH_w_8_16 >> 3 & 0x7)
04933 ;
04934 nextPC = 5 + MATCH_p;
04935
04936 #line 946 "frontend/machine/pentium/decoder.m"
04937
04938
04939 stmts = instantiate(pc, "MOVSX.Gv.Ew", DIS_R32, DIS_EADDR16);
04940
04941
04942
04943
04944
04945
04946 }
04947 else
04948 goto MATCH_label_c980;
04949
04950 break;
04951 case 2:
04952 MATCH_w_8_24 = getByte(3 + MATCH_p);
04953 if ((MATCH_w_8_16 & 0x7)
04954 == 4 &&
04955 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04956 &&
04957 (MATCH_w_8_24 >> 3 & 0x7)
04958 < 8))
04959 goto MATCH_label_c981;
04960 else
04961 goto MATCH_label_c982;
04962
04963 break;
04964 case 3:
04965 goto MATCH_label_c979; break;
04966 default: assert(0);
04967 }
04968
04969
04970 break;
04971 default: assert(0);
04972 }
04973 else
04974
04975 switch((MATCH_w_8_8 & 0x7) ) {
04976 case 0:
04977 MATCH_w_8_16 = getByte(2 + MATCH_p);
04978
04979 switch((MATCH_w_8_16 >> 6 & 0x3)
04980 ) {
04981 case 0:
04982
04983 switch((MATCH_w_8_16 & 0x7)
04984 ) {
04985 case 0: case 1: case 2: case 3:
04986 case 6: case 7:
04987 goto MATCH_label_c918; break;
04988 case 4:
04989 MATCH_w_8_24 =
04990 getByte(3 + MATCH_p);
04991 if ((MATCH_w_8_24 & 0x7)
04992 == 5 &&
04993 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
04994 &&
04995 (MATCH_w_8_24 >> 3 & 0x7)
04996 < 8))
04997 goto MATCH_label_c920;
04998 else
04999 goto MATCH_label_c919;
05000
05001 break;
05002 case 5:
05003 goto MATCH_label_c921; break;
05004 default: assert(0);
05005 }
05006
05007 break;
05008 case 1:
05009 MATCH_w_8_24 = getByte(3 + MATCH_p);
05010 if ((MATCH_w_8_16 & 0x7)
05011 == 4 &&
05012 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05013 &&
05014 (MATCH_w_8_24 >> 3 & 0x7)
05015 < 8)) {
05016 unsigned Eaddr =
05017 2 + addressToPC(MATCH_p);
05018 unsigned reg =
05019 (MATCH_w_8_16 >> 3 & 0x7)
05020 ;
05021 nextPC = 5 + MATCH_p;
05022
05023 #line 1244 "frontend/machine/pentium/decoder.m"
05024
05025
05026 stmts = instantiate(pc, "CMPXCHG.Eb.Gb", DIS_EADDR8, DIS_REG8);
05027
05028
05029
05030
05031
05032
05033 }
05034 else
05035 goto MATCH_label_c919;
05036
05037 break;
05038 case 2:
05039 MATCH_w_8_24 = getByte(3 + MATCH_p);
05040 if ((MATCH_w_8_16 & 0x7)
05041 == 4 &&
05042 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05043 &&
05044 (MATCH_w_8_24 >> 3 & 0x7)
05045 < 8))
05046 goto MATCH_label_c920;
05047 else
05048 goto MATCH_label_c921;
05049
05050 break;
05051 case 3:
05052 goto MATCH_label_c918; break;
05053 default: assert(0);
05054 }
05055
05056
05057 break;
05058 case 1:
05059 MATCH_w_8_16 = getByte(2 + MATCH_p);
05060
05061 switch((MATCH_w_8_16 >> 6 & 0x3)
05062 ) {
05063 case 0:
05064
05065 switch((MATCH_w_8_16 & 0x7)
05066 ) {
05067 case 0: case 1: case 2: case 3:
05068 case 6: case 7:
05069 goto MATCH_label_c922; break;
05070 case 4:
05071 MATCH_w_8_24 =
05072 getByte(3 + MATCH_p);
05073 if ((MATCH_w_8_24 & 0x7)
05074 == 5 &&
05075 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05076 &&
05077 (MATCH_w_8_24 >> 3 & 0x7)
05078 < 8))
05079 goto MATCH_label_c924;
05080 else
05081 goto MATCH_label_c923;
05082
05083 break;
05084 case 5:
05085 goto MATCH_label_c925; break;
05086 default: assert(0);
05087 }
05088
05089 break;
05090 case 1:
05091 MATCH_w_8_24 = getByte(3 + MATCH_p);
05092 if ((MATCH_w_8_16 & 0x7)
05093 == 4 &&
05094 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05095 &&
05096 (MATCH_w_8_24 >> 3 & 0x7)
05097 < 8)) {
05098 unsigned Eaddr =
05099 2 + addressToPC(MATCH_p);
05100 unsigned reg =
05101 (MATCH_w_8_16 >> 3 & 0x7)
05102 ;
05103 nextPC = 5 + MATCH_p;
05104
05105 #line 1238 "frontend/machine/pentium/decoder.m"
05106
05107
05108 stmts = instantiate(pc, "CMPXCHG.Ev.Gvod", DIS_EADDR32, DIS_REG32);
05109
05110
05111
05112
05113
05114
05115 }
05116 else
05117 goto MATCH_label_c923;
05118
05119 break;
05120 case 2:
05121 MATCH_w_8_24 = getByte(3 + MATCH_p);
05122 if ((MATCH_w_8_16 & 0x7)
05123 == 4 &&
05124 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05125 &&
05126 (MATCH_w_8_24 >> 3 & 0x7)
05127 < 8))
05128 goto MATCH_label_c924;
05129 else
05130 goto MATCH_label_c925;
05131
05132 break;
05133 case 3:
05134 goto MATCH_label_c922; break;
05135 default: assert(0);
05136 }
05137
05138
05139 break;
05140 case 2:
05141 MATCH_w_8_16 = getByte(2 + MATCH_p);
05142
05143 switch((MATCH_w_8_16 >> 6 & 0x3)
05144 ) {
05145 case 0:
05146
05147 switch((MATCH_w_8_16 & 0x7)
05148 ) {
05149 case 0: case 1: case 2: case 3:
05150 case 6: case 7:
05151 {
05152 unsigned Mem =
05153 2 + addressToPC(MATCH_p);
05154 unsigned reg =
05155 (MATCH_w_8_16 >> 3 & 0x7)
05156 ;
05157 nextPC = 3 + MATCH_p;
05158
05159 #line 1043 "frontend/machine/pentium/decoder.m"
05160
05161
05162 stmts = instantiate(pc, "LSS", DIS_REG32, DIS_MEM);
05163
05164
05165
05166
05167
05168
05169 }
05170
05171 break;
05172 case 4:
05173 MATCH_w_8_24 =
05174 getByte(3 + MATCH_p);
05175 if ((MATCH_w_8_24 & 0x7)
05176 == 5 &&
05177 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05178 &&
05179 (MATCH_w_8_24 >> 3 & 0x7)
05180 < 8))
05181 goto MATCH_label_c927;
05182 else
05183 goto MATCH_label_c926;
05184
05185 break;
05186 case 5:
05187 goto MATCH_label_c928; break;
05188 default: assert(0);
05189 }
05190
05191 break;
05192 case 1:
05193 MATCH_w_8_24 = getByte(3 + MATCH_p);
05194 if ((MATCH_w_8_16 & 0x7)
05195 == 4 &&
05196 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05197 &&
05198 (MATCH_w_8_24 >> 3 & 0x7)
05199 < 8)) {
05200 unsigned Mem =
05201 2 + addressToPC(MATCH_p);
05202 unsigned reg =
05203 (MATCH_w_8_16 >> 3 & 0x7)
05204 ;
05205 nextPC = 5 + MATCH_p;
05206
05207 #line 1043 "frontend/machine/pentium/decoder.m"
05208
05209
05210 stmts = instantiate(pc, "LSS", DIS_REG32, DIS_MEM);
05211
05212
05213
05214
05215
05216
05217 }
05218 else
05219 goto MATCH_label_c926;
05220
05221 break;
05222 case 2:
05223 MATCH_w_8_24 = getByte(3 + MATCH_p);
05224 if ((MATCH_w_8_16 & 0x7)
05225 == 4 &&
05226 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05227 &&
05228 (MATCH_w_8_24 >> 3 & 0x7)
05229 < 8))
05230 goto MATCH_label_c927;
05231 else
05232 goto MATCH_label_c928;
05233
05234 break;
05235 case 3:
05236 goto MATCH_label_c64; break;
05237 default: assert(0);
05238 }
05239
05240
05241 break;
05242 case 3:
05243 MATCH_w_8_16 = getByte(2 + MATCH_p);
05244
05245 switch((MATCH_w_8_16 >> 6 & 0x3)
05246 ) {
05247 case 0:
05248
05249 switch((MATCH_w_8_16 & 0x7)
05250 ) {
05251 case 0: case 1: case 2: case 3:
05252 case 6: case 7:
05253 goto MATCH_label_c929; break;
05254 case 4:
05255 MATCH_w_8_24 =
05256 getByte(3 + MATCH_p);
05257 if ((MATCH_w_8_24 & 0x7)
05258 == 5 &&
05259 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05260 &&
05261 (MATCH_w_8_24 >> 3 & 0x7)
05262 < 8))
05263 goto MATCH_label_c931;
05264 else
05265 goto MATCH_label_c930;
05266
05267 break;
05268 case 5:
05269 goto MATCH_label_c932; break;
05270 default: assert(0);
05271 }
05272
05273 break;
05274 case 1:
05275 MATCH_w_8_24 = getByte(3 + MATCH_p);
05276 if ((MATCH_w_8_16 & 0x7)
05277 == 4 &&
05278 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05279 &&
05280 (MATCH_w_8_24 >> 3 & 0x7)
05281 < 8)) {
05282 unsigned Eaddr =
05283 2 + addressToPC(MATCH_p);
05284 unsigned reg =
05285 (MATCH_w_8_16 >> 3 & 0x7)
05286 ;
05287 nextPC = 5 + MATCH_p;
05288
05289 #line 1328 "frontend/machine/pentium/decoder.m"
05290
05291
05292 stmts = instantiate(pc, "BTRod", DIS_EADDR32, DIS_REG32);
05293
05294
05295
05296
05297
05298
05299 }
05300 else
05301 goto MATCH_label_c930;
05302
05303 break;
05304 case 2:
05305 MATCH_w_8_24 = getByte(3 + MATCH_p);
05306 if ((MATCH_w_8_16 & 0x7)
05307 == 4 &&
05308 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05309 &&
05310 (MATCH_w_8_24 >> 3 & 0x7)
05311 < 8))
05312 goto MATCH_label_c931;
05313 else
05314 goto MATCH_label_c932;
05315
05316 break;
05317 case 3:
05318 goto MATCH_label_c929; break;
05319 default: assert(0);
05320 }
05321
05322
05323 break;
05324 case 4:
05325 MATCH_w_8_16 = getByte(2 + MATCH_p);
05326
05327 switch((MATCH_w_8_16 >> 6 & 0x3)
05328 ) {
05329 case 0:
05330
05331 switch((MATCH_w_8_16 & 0x7)
05332 ) {
05333 case 0: case 1: case 2: case 3:
05334 case 6: case 7:
05335 {
05336 unsigned Mem =
05337 2 + addressToPC(MATCH_p);
05338 unsigned reg =
05339 (MATCH_w_8_16 >> 3 & 0x7)
05340 ;
05341 nextPC = 3 + MATCH_p;
05342
05343 #line 1064 "frontend/machine/pentium/decoder.m"
05344
05345
05346 stmts = instantiate(pc, "LFS", DIS_REG32, DIS_MEM);
05347
05348
05349
05350
05351
05352
05353 }
05354
05355 break;
05356 case 4:
05357 MATCH_w_8_24 =
05358 getByte(3 + MATCH_p);
05359 if ((MATCH_w_8_24 & 0x7)
05360 == 5 &&
05361 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05362 &&
05363 (MATCH_w_8_24 >> 3 & 0x7)
05364 < 8))
05365 goto MATCH_label_c934;
05366 else
05367 goto MATCH_label_c933;
05368
05369 break;
05370 case 5:
05371 goto MATCH_label_c935; break;
05372 default: assert(0);
05373 }
05374
05375 break;
05376 case 1:
05377 MATCH_w_8_24 = getByte(3 + MATCH_p);
05378 if ((MATCH_w_8_16 & 0x7)
05379 == 4 &&
05380 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05381 &&
05382 (MATCH_w_8_24 >> 3 & 0x7)
05383 < 8)) {
05384 unsigned Mem =
05385 2 + addressToPC(MATCH_p);
05386 unsigned reg =
05387 (MATCH_w_8_16 >> 3 & 0x7)
05388 ;
05389 nextPC = 5 + MATCH_p;
05390
05391 #line 1064 "frontend/machine/pentium/decoder.m"
05392
05393
05394 stmts = instantiate(pc, "LFS", DIS_REG32, DIS_MEM);
05395
05396
05397
05398
05399
05400
05401 }
05402 else
05403 goto MATCH_label_c933;
05404
05405 break;
05406 case 2:
05407 MATCH_w_8_24 = getByte(3 + MATCH_p);
05408 if ((MATCH_w_8_16 & 0x7)
05409 == 4 &&
05410 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05411 &&
05412 (MATCH_w_8_24 >> 3 & 0x7)
05413 < 8))
05414 goto MATCH_label_c934;
05415 else
05416 goto MATCH_label_c935;
05417
05418 break;
05419 case 3:
05420 goto MATCH_label_c64; break;
05421 default: assert(0);
05422 }
05423
05424
05425 break;
05426 case 5:
05427 MATCH_w_8_16 = getByte(2 + MATCH_p);
05428
05429 switch((MATCH_w_8_16 >> 6 & 0x3)
05430 ) {
05431 case 0:
05432
05433 switch((MATCH_w_8_16 & 0x7)
05434 ) {
05435 case 0: case 1: case 2: case 3:
05436 case 6: case 7:
05437 {
05438 unsigned Mem =
05439 2 + addressToPC(MATCH_p);
05440 unsigned reg =
05441 (MATCH_w_8_16 >> 3 & 0x7)
05442 ;
05443 nextPC = 3 + MATCH_p;
05444
05445 #line 1061 "frontend/machine/pentium/decoder.m"
05446
05447
05448 stmts = instantiate(pc, "LGS", DIS_REG32, DIS_MEM);
05449
05450
05451
05452
05453
05454
05455 }
05456
05457 break;
05458 case 4:
05459 MATCH_w_8_24 =
05460 getByte(3 + MATCH_p);
05461 if ((MATCH_w_8_24 & 0x7)
05462 == 5 &&
05463 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05464 &&
05465 (MATCH_w_8_24 >> 3 & 0x7)
05466 < 8))
05467 goto MATCH_label_c937;
05468 else
05469 goto MATCH_label_c936;
05470
05471 break;
05472 case 5:
05473 goto MATCH_label_c938; break;
05474 default: assert(0);
05475 }
05476
05477 break;
05478 case 1:
05479 MATCH_w_8_24 = getByte(3 + MATCH_p);
05480 if ((MATCH_w_8_16 & 0x7)
05481 == 4 &&
05482 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05483 &&
05484 (MATCH_w_8_24 >> 3 & 0x7)
05485 < 8)) {
05486 unsigned Mem =
05487 2 + addressToPC(MATCH_p);
05488 unsigned reg =
05489 (MATCH_w_8_16 >> 3 & 0x7)
05490 ;
05491 nextPC = 5 + MATCH_p;
05492
05493 #line 1061 "frontend/machine/pentium/decoder.m"
05494
05495
05496 stmts = instantiate(pc, "LGS", DIS_REG32, DIS_MEM);
05497
05498
05499
05500
05501
05502
05503 }
05504 else
05505 goto MATCH_label_c936;
05506
05507 break;
05508 case 2:
05509 MATCH_w_8_24 = getByte(3 + MATCH_p);
05510 if ((MATCH_w_8_16 & 0x7)
05511 == 4 &&
05512 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05513 &&
05514 (MATCH_w_8_24 >> 3 & 0x7)
05515 < 8))
05516 goto MATCH_label_c937;
05517 else
05518 goto MATCH_label_c938;
05519
05520 break;
05521 case 3:
05522 goto MATCH_label_c64; break;
05523 default: assert(0);
05524 }
05525
05526
05527 break;
05528 case 6:
05529 MATCH_w_8_16 = getByte(2 + MATCH_p);
05530
05531 switch((MATCH_w_8_16 >> 6 & 0x3)
05532 ) {
05533 case 0:
05534
05535 switch((MATCH_w_8_16 & 0x7)
05536 ) {
05537 case 0: case 1: case 2: case 3:
05538 case 6: case 7:
05539 goto MATCH_label_c939; break;
05540 case 4:
05541 MATCH_w_8_24 =
05542 getByte(3 + MATCH_p);
05543 if ((MATCH_w_8_24 & 0x7)
05544 == 5 &&
05545 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05546 &&
05547 (MATCH_w_8_24 >> 3 & 0x7)
05548 < 8))
05549 goto MATCH_label_c941;
05550 else
05551 goto MATCH_label_c940;
05552
05553 break;
05554 case 5:
05555 goto MATCH_label_c942; break;
05556 default: assert(0);
05557 }
05558
05559 break;
05560 case 1:
05561 MATCH_w_8_24 = getByte(3 + MATCH_p);
05562 if ((MATCH_w_8_16 & 0x7)
05563 == 4 &&
05564 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05565 &&
05566 (MATCH_w_8_24 >> 3 & 0x7)
05567 < 8)) {
05568 unsigned Eaddr =
05569 2 + addressToPC(MATCH_p);
05570 unsigned r32 =
05571 (MATCH_w_8_16 >> 3 & 0x7)
05572 ;
05573 nextPC = 5 + MATCH_p;
05574
05575 #line 940 "frontend/machine/pentium/decoder.m"
05576
05577
05578 stmts = instantiate(pc, "MOVZX.Gv.Ebod", DIS_R32, DIS_EADDR8);
05579
05580
05581
05582
05583
05584
05585 }
05586 else
05587 goto MATCH_label_c940;
05588
05589 break;
05590 case 2:
05591 MATCH_w_8_24 = getByte(3 + MATCH_p);
05592 if ((MATCH_w_8_16 & 0x7)
05593 == 4 &&
05594 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05595 &&
05596 (MATCH_w_8_24 >> 3 & 0x7)
05597 < 8))
05598 goto MATCH_label_c941;
05599 else
05600 goto MATCH_label_c942;
05601
05602 break;
05603 case 3:
05604 goto MATCH_label_c939; break;
05605 default: assert(0);
05606 }
05607
05608
05609 break;
05610 case 7:
05611 MATCH_w_8_16 = getByte(2 + MATCH_p);
05612
05613 switch((MATCH_w_8_16 >> 6 & 0x3)
05614 ) {
05615 case 0:
05616
05617 switch((MATCH_w_8_16 & 0x7)
05618 ) {
05619 case 0: case 1: case 2: case 3:
05620 case 6: case 7:
05621 goto MATCH_label_c943; break;
05622 case 4:
05623 MATCH_w_8_24 =
05624 getByte(3 + MATCH_p);
05625 if ((MATCH_w_8_24 & 0x7)
05626 == 5 &&
05627 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05628 &&
05629 (MATCH_w_8_24 >> 3 & 0x7)
05630 < 8))
05631 goto MATCH_label_c945;
05632 else
05633 goto MATCH_label_c944;
05634
05635 break;
05636 case 5:
05637 goto MATCH_label_c946; break;
05638 default: assert(0);
05639 }
05640
05641 break;
05642 case 1:
05643 MATCH_w_8_24 = getByte(3 + MATCH_p);
05644 if ((MATCH_w_8_16 & 0x7)
05645 == 4 &&
05646 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05647 &&
05648 (MATCH_w_8_24 >> 3 & 0x7)
05649 < 8)) {
05650 unsigned Eaddr =
05651 2 + addressToPC(MATCH_p);
05652 unsigned r32 =
05653 (MATCH_w_8_16 >> 3 & 0x7)
05654 ;
05655 nextPC = 5 + MATCH_p;
05656
05657 #line 937 "frontend/machine/pentium/decoder.m"
05658
05659
05660 stmts = instantiate(pc, "MOVZX.Gv.Ew", DIS_R32, DIS_EADDR16);
05661
05662
05663
05664
05665
05666
05667 }
05668 else
05669 goto MATCH_label_c944;
05670
05671 break;
05672 case 2:
05673 MATCH_w_8_24 = getByte(3 + MATCH_p);
05674 if ((MATCH_w_8_16 & 0x7)
05675 == 4 &&
05676 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05677 &&
05678 (MATCH_w_8_24 >> 3 & 0x7)
05679 < 8))
05680 goto MATCH_label_c945;
05681 else
05682 goto MATCH_label_c946;
05683
05684 break;
05685 case 3:
05686 goto MATCH_label_c943; break;
05687 default: assert(0);
05688 }
05689
05690
05691 break;
05692 default: assert(0);
05693 }
05694 break;
05695 case 12:
05696 if ((MATCH_w_8_8 >> 3 & 0x1) == 1) {
05697 unsigned r32 = (MATCH_w_8_8 & 0x7) ;
05698 nextPC = 2 + MATCH_p;
05699
05700 #line 1358 "frontend/machine/pentium/decoder.m"
05701
05702
05703 stmts = instantiate(pc, "BSWAP", DIS_R32);
05704
05705
05706
05707
05708
05709
05710 }
05711 else
05712
05713 switch((MATCH_w_8_8 & 0x7) ) {
05714 case 0:
05715 MATCH_w_8_16 = getByte(2 + MATCH_p);
05716
05717 switch((MATCH_w_8_16 >> 6 & 0x3)
05718 ) {
05719 case 0:
05720
05721 switch((MATCH_w_8_16 & 0x7)
05722 ) {
05723 case 0: case 1: case 2: case 3:
05724 case 6: case 7:
05725 goto MATCH_label_c983; break;
05726 case 4:
05727 MATCH_w_8_24 =
05728 getByte(3 + MATCH_p);
05729 if ((MATCH_w_8_24 & 0x7)
05730 == 5 &&
05731 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05732 &&
05733 (MATCH_w_8_24 >> 3 & 0x7)
05734 < 8))
05735 goto MATCH_label_c985;
05736 else
05737 goto MATCH_label_c984;
05738
05739 break;
05740 case 5:
05741 goto MATCH_label_c986; break;
05742 default: assert(0);
05743 }
05744
05745 break;
05746 case 1:
05747 MATCH_w_8_24 = getByte(3 + MATCH_p);
05748 if ((MATCH_w_8_16 & 0x7)
05749 == 4 &&
05750 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05751 &&
05752 (MATCH_w_8_24 >> 3 & 0x7)
05753 < 8)) {
05754 unsigned Eaddr =
05755 2 + addressToPC(MATCH_p);
05756 unsigned reg =
05757 (MATCH_w_8_16 >> 3 & 0x7)
05758 ;
05759 nextPC = 5 + MATCH_p;
05760
05761 #line 360 "frontend/machine/pentium/decoder.m"
05762
05763
05764 stmts = instantiate(pc, "XADD.Eb.Gb", DIS_EADDR8, DIS_REG8);
05765
05766
05767
05768
05769
05770
05771 }
05772 else
05773 goto MATCH_label_c984;
05774
05775 break;
05776 case 2:
05777 MATCH_w_8_24 = getByte(3 + MATCH_p);
05778 if ((MATCH_w_8_16 & 0x7)
05779 == 4 &&
05780 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05781 &&
05782 (MATCH_w_8_24 >> 3 & 0x7)
05783 < 8))
05784 goto MATCH_label_c985;
05785 else
05786 goto MATCH_label_c986;
05787
05788 break;
05789 case 3:
05790 goto MATCH_label_c983; break;
05791 default: assert(0);
05792 }
05793
05794
05795 break;
05796 case 1:
05797 MATCH_w_8_16 = getByte(2 + MATCH_p);
05798
05799 switch((MATCH_w_8_16 >> 6 & 0x3)
05800 ) {
05801 case 0:
05802
05803 switch((MATCH_w_8_16 & 0x7)
05804 ) {
05805 case 0: case 1: case 2: case 3:
05806 case 6: case 7:
05807 goto MATCH_label_c987; break;
05808 case 4:
05809 MATCH_w_8_24 =
05810 getByte(3 + MATCH_p);
05811 if ((MATCH_w_8_24 & 0x7)
05812 == 5 &&
05813 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05814 &&
05815 (MATCH_w_8_24 >> 3 & 0x7)
05816 < 8))
05817 goto MATCH_label_c989;
05818 else
05819 goto MATCH_label_c988;
05820
05821 break;
05822 case 5:
05823 goto MATCH_label_c990; break;
05824 default: assert(0);
05825 }
05826
05827 break;
05828 case 1:
05829 MATCH_w_8_24 = getByte(3 + MATCH_p);
05830 if ((MATCH_w_8_16 & 0x7)
05831 == 4 &&
05832 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05833 &&
05834 (MATCH_w_8_24 >> 3 & 0x7)
05835 < 8)) {
05836 unsigned Eaddr =
05837 2 + addressToPC(MATCH_p);
05838 unsigned reg =
05839 (MATCH_w_8_16 >> 3 & 0x7)
05840 ;
05841 nextPC = 5 + MATCH_p;
05842
05843 #line 354 "frontend/machine/pentium/decoder.m"
05844
05845
05846 stmts = instantiate(pc, "XADD.Ev.Gvod", DIS_EADDR32, DIS_REG32);
05847
05848
05849
05850
05851
05852
05853 }
05854 else
05855 goto MATCH_label_c988;
05856
05857 break;
05858 case 2:
05859 MATCH_w_8_24 = getByte(3 + MATCH_p);
05860 if ((MATCH_w_8_16 & 0x7)
05861 == 4 &&
05862 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05863 &&
05864 (MATCH_w_8_24 >> 3 & 0x7)
05865 < 8))
05866 goto MATCH_label_c989;
05867 else
05868 goto MATCH_label_c990;
05869
05870 break;
05871 case 3:
05872 goto MATCH_label_c987; break;
05873 default: assert(0);
05874 }
05875
05876
05877 break;
05878 case 2: case 3: case 4: case 5: case 6:
05879 goto MATCH_label_c64; break;
05880 case 7:
05881 MATCH_w_8_16 = getByte(2 + MATCH_p);
05882 if ((MATCH_w_8_16 >> 3 & 0x7)
05883 == 1)
05884
05885 switch((MATCH_w_8_16 >> 6 & 0x3)
05886 ) {
05887 case 0:
05888
05889 switch((MATCH_w_8_16 & 0x7)
05890 ) {
05891 case 0: case 1: case 2: case 3:
05892 case 6: case 7:
05893 {
05894 unsigned Mem =
05895 2 + addressToPC(MATCH_p);
05896 nextPC = 3 + MATCH_p;
05897
05898 #line 1235 "frontend/machine/pentium/decoder.m"
05899
05900
05901 stmts = instantiate(pc, "CMPXCHG8B", DIS_MEM);
05902
05903
05904
05905
05906
05907
05908 }
05909
05910 break;
05911 case 4:
05912 MATCH_w_8_24 =
05913 getByte(3 + MATCH_p);
05914 if ((MATCH_w_8_24 & 0x7)
05915 == 5 &&
05916 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05917 &&
05918 (MATCH_w_8_24 >> 3 & 0x7)
05919 < 8))
05920 goto MATCH_label_c992;
05921 else
05922 goto MATCH_label_c991;
05923
05924 break;
05925 case 5:
05926 goto MATCH_label_c993; break;
05927 default: assert(0);
05928 }
05929
05930 break;
05931 case 1:
05932 MATCH_w_8_24 = getByte(3 + MATCH_p);
05933 if ((MATCH_w_8_16 & 0x7)
05934 == 4 &&
05935 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05936 &&
05937 (MATCH_w_8_24 >> 3 & 0x7)
05938 < 8)) {
05939 unsigned Mem =
05940 2 + addressToPC(MATCH_p);
05941 nextPC = 5 + MATCH_p;
05942
05943 #line 1235 "frontend/machine/pentium/decoder.m"
05944
05945
05946 stmts = instantiate(pc, "CMPXCHG8B", DIS_MEM);
05947
05948
05949
05950
05951
05952
05953 }
05954 else
05955 goto MATCH_label_c991;
05956
05957 break;
05958 case 2:
05959 MATCH_w_8_24 = getByte(3 + MATCH_p);
05960 if ((MATCH_w_8_16 & 0x7)
05961 == 4 &&
05962 (0 <= (MATCH_w_8_24 >> 3 & 0x7)
05963 &&
05964 (MATCH_w_8_24 >> 3 & 0x7)
05965 < 8))
05966 goto MATCH_label_c992;
05967 else
05968 goto MATCH_label_c993;
05969
05970 break;
05971 case 3:
05972 goto MATCH_label_c64; break;
05973 default: assert(0);
05974 }
05975
05976 else
05977 goto MATCH_label_c64;
05978
05979 break;
05980 default: assert(0);
05981 }
05982 break;
05983 default: assert(0);
05984 }
05985
05986 break;
05987 default: assert(0);
05988 }
05989 break;
05990 case 1:
05991
05992 switch((MATCH_w_8_0 & 0x7) ) {
05993 case 0:
05994 MATCH_w_8_8 = getByte(1 + MATCH_p);
05995
05996 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
05997 case 0:
05998
05999 switch((MATCH_w_8_8 & 0x7) ) {
06000 case 0: case 1: case 2: case 3: case 6: case 7:
06001 goto MATCH_label_c994; break;
06002 case 4:
06003 MATCH_w_8_16 = getByte(2 + MATCH_p);
06004 if ((MATCH_w_8_16 & 0x7)
06005 == 5 &&
06006 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06007 &&
06008 (MATCH_w_8_16 >> 3 & 0x7)
06009 < 8))
06010 goto MATCH_label_c996;
06011 else
06012 goto MATCH_label_c995;
06013
06014 break;
06015 case 5:
06016 goto MATCH_label_c997; break;
06017 default: assert(0);
06018 }
06019 break;
06020 case 1:
06021 MATCH_w_8_16 = getByte(2 + MATCH_p);
06022 if ((MATCH_w_8_8 & 0x7) == 4 &&
06023 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06024 &&
06025 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06026 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06027 unsigned r8 =
06028 (MATCH_w_8_8 >> 3 & 0x7) ;
06029 nextPC = 4 + MATCH_p;
06030
06031 #line 1537 "frontend/machine/pentium/decoder.m"
06032
06033
06034 stmts = instantiate(pc, "SBBmrb", DIS_EADDR8, DIS_R8);
06035
06036
06037
06038
06039
06040
06041 }
06042 else
06043 goto MATCH_label_c995;
06044
06045 break;
06046 case 2:
06047 MATCH_w_8_16 = getByte(2 + MATCH_p);
06048 if ((MATCH_w_8_8 & 0x7) == 4 &&
06049 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06050 &&
06051 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06052 goto MATCH_label_c996;
06053 else
06054 goto MATCH_label_c997;
06055
06056 break;
06057 case 3:
06058 goto MATCH_label_c994; break;
06059 default: assert(0);
06060 }
06061
06062 break;
06063 case 1:
06064 MATCH_w_8_8 = getByte(1 + MATCH_p);
06065
06066 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06067 case 0:
06068
06069 switch((MATCH_w_8_8 & 0x7) ) {
06070 case 0: case 1: case 2: case 3: case 6: case 7:
06071 goto MATCH_label_c998; break;
06072 case 4:
06073 MATCH_w_8_16 = getByte(2 + MATCH_p);
06074 if ((MATCH_w_8_16 & 0x7)
06075 == 5 &&
06076 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06077 &&
06078 (MATCH_w_8_16 >> 3 & 0x7)
06079 < 8))
06080 goto MATCH_label_c1000;
06081 else
06082 goto MATCH_label_c999;
06083
06084 break;
06085 case 5:
06086 goto MATCH_label_c1001; break;
06087 default: assert(0);
06088 }
06089 break;
06090 case 1:
06091 MATCH_w_8_16 = getByte(2 + MATCH_p);
06092 if ((MATCH_w_8_8 & 0x7) == 4 &&
06093 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06094 &&
06095 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06096 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06097 unsigned reg =
06098 (MATCH_w_8_8 >> 3 & 0x7) ;
06099 nextPC = 4 + MATCH_p;
06100
06101 #line 1501 "frontend/machine/pentium/decoder.m"
06102
06103
06104 stmts = instantiate(pc, "SBBmrod", DIS_EADDR32, DIS_REG32);
06105
06106
06107
06108
06109
06110
06111 }
06112 else
06113 goto MATCH_label_c999;
06114
06115 break;
06116 case 2:
06117 MATCH_w_8_16 = getByte(2 + MATCH_p);
06118 if ((MATCH_w_8_8 & 0x7) == 4 &&
06119 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06120 &&
06121 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06122 goto MATCH_label_c1000;
06123 else
06124 goto MATCH_label_c1001;
06125
06126 break;
06127 case 3:
06128 goto MATCH_label_c998; break;
06129 default: assert(0);
06130 }
06131
06132 break;
06133 case 2:
06134 MATCH_w_8_8 = getByte(1 + MATCH_p);
06135
06136 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06137 case 0:
06138
06139 switch((MATCH_w_8_8 & 0x7) ) {
06140 case 0: case 1: case 2: case 3: case 6: case 7:
06141 goto MATCH_label_c1002; break;
06142 case 4:
06143 MATCH_w_8_16 = getByte(2 + MATCH_p);
06144 if ((MATCH_w_8_16 & 0x7)
06145 == 5 &&
06146 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06147 &&
06148 (MATCH_w_8_16 >> 3 & 0x7)
06149 < 8))
06150 goto MATCH_label_c1004;
06151 else
06152 goto MATCH_label_c1003;
06153
06154 break;
06155 case 5:
06156 goto MATCH_label_c1005; break;
06157 default: assert(0);
06158 }
06159 break;
06160 case 1:
06161 MATCH_w_8_16 = getByte(2 + MATCH_p);
06162 if ((MATCH_w_8_8 & 0x7) == 4 &&
06163 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06164 &&
06165 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06166 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06167 unsigned r8 =
06168 (MATCH_w_8_8 >> 3 & 0x7) ;
06169 nextPC = 4 + MATCH_p;
06170
06171 #line 1465 "frontend/machine/pentium/decoder.m"
06172
06173
06174 stmts = instantiate(pc, "SBBrmb", DIS_R8, DIS_EADDR8);
06175
06176
06177
06178
06179
06180
06181 }
06182 else
06183 goto MATCH_label_c1003;
06184
06185 break;
06186 case 2:
06187 MATCH_w_8_16 = getByte(2 + MATCH_p);
06188 if ((MATCH_w_8_8 & 0x7) == 4 &&
06189 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06190 &&
06191 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06192 goto MATCH_label_c1004;
06193 else
06194 goto MATCH_label_c1005;
06195
06196 break;
06197 case 3:
06198 goto MATCH_label_c1002; break;
06199 default: assert(0);
06200 }
06201
06202 break;
06203 case 3:
06204 MATCH_w_8_8 = getByte(1 + MATCH_p);
06205
06206 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06207 case 0:
06208
06209 switch((MATCH_w_8_8 & 0x7) ) {
06210 case 0: case 1: case 2: case 3: case 6: case 7:
06211 goto MATCH_label_c1006; break;
06212 case 4:
06213 MATCH_w_8_16 = getByte(2 + MATCH_p);
06214 if ((MATCH_w_8_16 & 0x7)
06215 == 5 &&
06216 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06217 &&
06218 (MATCH_w_8_16 >> 3 & 0x7)
06219 < 8))
06220 goto MATCH_label_c1008;
06221 else
06222 goto MATCH_label_c1007;
06223
06224 break;
06225 case 5:
06226 goto MATCH_label_c1009; break;
06227 default: assert(0);
06228 }
06229 break;
06230 case 1:
06231 MATCH_w_8_16 = getByte(2 + MATCH_p);
06232 if ((MATCH_w_8_8 & 0x7) == 4 &&
06233 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06234 &&
06235 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06236 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06237 unsigned reg =
06238 (MATCH_w_8_8 >> 3 & 0x7) ;
06239 nextPC = 4 + MATCH_p;
06240
06241 #line 1429 "frontend/machine/pentium/decoder.m"
06242
06243
06244 stmts = instantiate(pc, "SBBrmod", DIS_REG32, DIS_EADDR32);
06245
06246
06247
06248
06249
06250
06251 }
06252 else
06253 goto MATCH_label_c1007;
06254
06255 break;
06256 case 2:
06257 MATCH_w_8_16 = getByte(2 + MATCH_p);
06258 if ((MATCH_w_8_8 & 0x7) == 4 &&
06259 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06260 &&
06261 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06262 goto MATCH_label_c1008;
06263 else
06264 goto MATCH_label_c1009;
06265
06266 break;
06267 case 3:
06268 goto MATCH_label_c1006; break;
06269 default: assert(0);
06270 }
06271
06272 break;
06273 case 4:
06274 MATCH_w_8_8 = getByte(1 + MATCH_p);
06275 {
06276 int i8 =
06277 sign_extend((MATCH_w_8_8 & 0xff) , 8);
06278 nextPC = 2 + MATCH_p;
06279
06280 #line 1732 "frontend/machine/pentium/decoder.m"
06281
06282
06283 stmts = instantiate(pc, "SBBiAL", DIS_I8);
06284
06285
06286
06287
06288
06289
06290 }
06291
06292 break;
06293 case 5:
06294 MATCH_w_32_8 = getDword(1 + MATCH_p);
06295 {
06296 unsigned i32 = MATCH_w_32_8 ;
06297 nextPC = 5 + MATCH_p;
06298
06299 #line 1684 "frontend/machine/pentium/decoder.m"
06300
06301
06302 stmts = instantiate(pc, "SBBiEAX", DIS_I32);
06303
06304
06305
06306
06307
06308
06309 }
06310
06311 break;
06312 case 6:
06313 nextPC = 1 + MATCH_p;
06314
06315 #line 811 "frontend/machine/pentium/decoder.m"
06316
06317
06318 stmts = instantiate(pc, "PUSH.DS");
06319
06320
06321
06322
06323
06324
06325
06326 break;
06327 case 7:
06328 nextPC = 1 + MATCH_p;
06329
06330 #line 862 "frontend/machine/pentium/decoder.m"
06331
06332
06333 stmts = instantiate(pc, "POP.DS");
06334
06335
06336
06337
06338
06339
06340
06341 break;
06342 default: assert(0);
06343 }
06344 break;
06345 case 2:
06346
06347 switch((MATCH_w_8_0 & 0x7) ) {
06348 case 0:
06349 MATCH_w_8_8 = getByte(1 + MATCH_p);
06350
06351 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06352 case 0:
06353
06354 switch((MATCH_w_8_8 & 0x7) ) {
06355 case 0: case 1: case 2: case 3: case 6: case 7:
06356 goto MATCH_label_c1010; break;
06357 case 4:
06358 MATCH_w_8_16 = getByte(2 + MATCH_p);
06359 if ((MATCH_w_8_16 & 0x7)
06360 == 5 &&
06361 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06362 &&
06363 (MATCH_w_8_16 >> 3 & 0x7)
06364 < 8))
06365 goto MATCH_label_c1012;
06366 else
06367 goto MATCH_label_c1011;
06368
06369 break;
06370 case 5:
06371 goto MATCH_label_c1013; break;
06372 default: assert(0);
06373 }
06374 break;
06375 case 1:
06376 MATCH_w_8_16 = getByte(2 + MATCH_p);
06377 if ((MATCH_w_8_8 & 0x7) == 4 &&
06378 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06379 &&
06380 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06381 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06382 unsigned r8 =
06383 (MATCH_w_8_8 >> 3 & 0x7) ;
06384 nextPC = 4 + MATCH_p;
06385
06386 #line 1531 "frontend/machine/pentium/decoder.m"
06387
06388
06389 stmts = instantiate(pc, "SUBmrb", DIS_EADDR8, DIS_R8);
06390
06391
06392
06393
06394
06395
06396 }
06397 else
06398 goto MATCH_label_c1011;
06399
06400 break;
06401 case 2:
06402 MATCH_w_8_16 = getByte(2 + MATCH_p);
06403 if ((MATCH_w_8_8 & 0x7) == 4 &&
06404 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06405 &&
06406 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06407 goto MATCH_label_c1012;
06408 else
06409 goto MATCH_label_c1013;
06410
06411 break;
06412 case 3:
06413 goto MATCH_label_c1010; break;
06414 default: assert(0);
06415 }
06416
06417 break;
06418 case 1:
06419 MATCH_w_8_8 = getByte(1 + MATCH_p);
06420
06421 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06422 case 0:
06423
06424 switch((MATCH_w_8_8 & 0x7) ) {
06425 case 0: case 1: case 2: case 3: case 6: case 7:
06426 goto MATCH_label_c1014; break;
06427 case 4:
06428 MATCH_w_8_16 = getByte(2 + MATCH_p);
06429 if ((MATCH_w_8_16 & 0x7)
06430 == 5 &&
06431 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06432 &&
06433 (MATCH_w_8_16 >> 3 & 0x7)
06434 < 8))
06435 goto MATCH_label_c1016;
06436 else
06437 goto MATCH_label_c1015;
06438
06439 break;
06440 case 5:
06441 goto MATCH_label_c1017; break;
06442 default: assert(0);
06443 }
06444 break;
06445 case 1:
06446 MATCH_w_8_16 = getByte(2 + MATCH_p);
06447 if ((MATCH_w_8_8 & 0x7) == 4 &&
06448 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06449 &&
06450 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06451 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06452 unsigned reg =
06453 (MATCH_w_8_8 >> 3 & 0x7) ;
06454 nextPC = 4 + MATCH_p;
06455
06456 #line 1489 "frontend/machine/pentium/decoder.m"
06457
06458
06459 stmts = instantiate(pc, "SUBmrod", DIS_EADDR32, DIS_REG32);
06460
06461
06462
06463
06464
06465
06466 }
06467 else
06468 goto MATCH_label_c1015;
06469
06470 break;
06471 case 2:
06472 MATCH_w_8_16 = getByte(2 + MATCH_p);
06473 if ((MATCH_w_8_8 & 0x7) == 4 &&
06474 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06475 &&
06476 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06477 goto MATCH_label_c1016;
06478 else
06479 goto MATCH_label_c1017;
06480
06481 break;
06482 case 3:
06483 goto MATCH_label_c1014; break;
06484 default: assert(0);
06485 }
06486
06487 break;
06488 case 2:
06489 MATCH_w_8_8 = getByte(1 + MATCH_p);
06490
06491 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06492 case 0:
06493
06494 switch((MATCH_w_8_8 & 0x7) ) {
06495 case 0: case 1: case 2: case 3: case 6: case 7:
06496 goto MATCH_label_c1018; break;
06497 case 4:
06498 MATCH_w_8_16 = getByte(2 + MATCH_p);
06499 if ((MATCH_w_8_16 & 0x7)
06500 == 5 &&
06501 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06502 &&
06503 (MATCH_w_8_16 >> 3 & 0x7)
06504 < 8))
06505 goto MATCH_label_c1020;
06506 else
06507 goto MATCH_label_c1019;
06508
06509 break;
06510 case 5:
06511 goto MATCH_label_c1021; break;
06512 default: assert(0);
06513 }
06514 break;
06515 case 1:
06516 MATCH_w_8_16 = getByte(2 + MATCH_p);
06517 if ((MATCH_w_8_8 & 0x7) == 4 &&
06518 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06519 &&
06520 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06521 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06522 unsigned r8 =
06523 (MATCH_w_8_8 >> 3 & 0x7) ;
06524 nextPC = 4 + MATCH_p;
06525
06526 #line 1459 "frontend/machine/pentium/decoder.m"
06527
06528
06529 stmts = instantiate(pc, "SUBrmb", DIS_R8, DIS_EADDR8);
06530
06531
06532
06533
06534
06535
06536 }
06537 else
06538 goto MATCH_label_c1019;
06539
06540 break;
06541 case 2:
06542 MATCH_w_8_16 = getByte(2 + MATCH_p);
06543 if ((MATCH_w_8_8 & 0x7) == 4 &&
06544 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06545 &&
06546 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06547 goto MATCH_label_c1020;
06548 else
06549 goto MATCH_label_c1021;
06550
06551 break;
06552 case 3:
06553 goto MATCH_label_c1018; break;
06554 default: assert(0);
06555 }
06556
06557 break;
06558 case 3:
06559 MATCH_w_8_8 = getByte(1 + MATCH_p);
06560
06561 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06562 case 0:
06563
06564 switch((MATCH_w_8_8 & 0x7) ) {
06565 case 0: case 1: case 2: case 3: case 6: case 7:
06566 goto MATCH_label_c1022; break;
06567 case 4:
06568 MATCH_w_8_16 = getByte(2 + MATCH_p);
06569 if ((MATCH_w_8_16 & 0x7)
06570 == 5 &&
06571 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06572 &&
06573 (MATCH_w_8_16 >> 3 & 0x7)
06574 < 8))
06575 goto MATCH_label_c1024;
06576 else
06577 goto MATCH_label_c1023;
06578
06579 break;
06580 case 5:
06581 goto MATCH_label_c1025; break;
06582 default: assert(0);
06583 }
06584 break;
06585 case 1:
06586 MATCH_w_8_16 = getByte(2 + MATCH_p);
06587 if ((MATCH_w_8_8 & 0x7) == 4 &&
06588 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06589 &&
06590 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06591 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06592 unsigned reg =
06593 (MATCH_w_8_8 >> 3 & 0x7) ;
06594 nextPC = 4 + MATCH_p;
06595
06596 #line 1417 "frontend/machine/pentium/decoder.m"
06597
06598
06599 stmts = instantiate(pc, "SUBrmod", DIS_REG32, DIS_EADDR32);
06600
06601
06602
06603
06604
06605
06606 }
06607 else
06608 goto MATCH_label_c1023;
06609
06610 break;
06611 case 2:
06612 MATCH_w_8_16 = getByte(2 + MATCH_p);
06613 if ((MATCH_w_8_8 & 0x7) == 4 &&
06614 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06615 &&
06616 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06617 goto MATCH_label_c1024;
06618 else
06619 goto MATCH_label_c1025;
06620
06621 break;
06622 case 3:
06623 goto MATCH_label_c1022; break;
06624 default: assert(0);
06625 }
06626
06627 break;
06628 case 4:
06629 MATCH_w_8_8 = getByte(1 + MATCH_p);
06630 {
06631 int i8 =
06632 sign_extend((MATCH_w_8_8 & 0xff) , 8);
06633 nextPC = 2 + MATCH_p;
06634
06635 #line 1726 "frontend/machine/pentium/decoder.m"
06636
06637
06638 stmts = instantiate(pc, "SUBiAL", DIS_I8);
06639
06640
06641
06642
06643
06644
06645 }
06646
06647 break;
06648 case 5:
06649 MATCH_w_32_8 = getDword(1 + MATCH_p);
06650 {
06651 unsigned i32 = MATCH_w_32_8 ;
06652 nextPC = 5 + MATCH_p;
06653
06654 #line 1678 "frontend/machine/pentium/decoder.m"
06655
06656
06657 stmts = instantiate(pc, "SUBiEAX", DIS_I32);
06658
06659
06660
06661
06662
06663
06664 }
06665
06666 break;
06667 case 6:
06668 nextPC = 1 + MATCH_p;
06669
06670 #line 330 "frontend/machine/pentium/decoder.m"
06671
06672
06673 stmts = instantiate(pc, "NOP");
06674
06675
06676
06677
06678
06679
06680
06681 break;
06682 case 7:
06683 nextPC = 1 + MATCH_p;
06684
06685 #line 1220 "frontend/machine/pentium/decoder.m"
06686
06687
06688 stmts = instantiate(pc, "DAS");
06689
06690
06691
06692
06693
06694
06695
06696 break;
06697 default: assert(0);
06698 }
06699 break;
06700 case 3:
06701
06702 switch((MATCH_w_8_0 & 0x7) ) {
06703 case 0:
06704 MATCH_w_8_8 = getByte(1 + MATCH_p);
06705
06706 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06707 case 0:
06708
06709 switch((MATCH_w_8_8 & 0x7) ) {
06710 case 0: case 1: case 2: case 3: case 6: case 7:
06711 goto MATCH_label_c1026; break;
06712 case 4:
06713 MATCH_w_8_16 = getByte(2 + MATCH_p);
06714 if ((MATCH_w_8_16 & 0x7)
06715 == 5 &&
06716 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06717 &&
06718 (MATCH_w_8_16 >> 3 & 0x7)
06719 < 8))
06720 goto MATCH_label_c1028;
06721 else
06722 goto MATCH_label_c1027;
06723
06724 break;
06725 case 5:
06726 goto MATCH_label_c1029; break;
06727 default: assert(0);
06728 }
06729 break;
06730 case 1:
06731 MATCH_w_8_16 = getByte(2 + MATCH_p);
06732 if ((MATCH_w_8_8 & 0x7) == 4 &&
06733 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06734 &&
06735 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06736 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06737 unsigned r8 =
06738 (MATCH_w_8_8 >> 3 & 0x7) ;
06739 nextPC = 4 + MATCH_p;
06740
06741 #line 1525 "frontend/machine/pentium/decoder.m"
06742
06743
06744 stmts = instantiate(pc, "CMPmrb", DIS_EADDR8, DIS_R8);
06745
06746
06747
06748
06749
06750
06751 }
06752 else
06753 goto MATCH_label_c1027;
06754
06755 break;
06756 case 2:
06757 MATCH_w_8_16 = getByte(2 + MATCH_p);
06758 if ((MATCH_w_8_8 & 0x7) == 4 &&
06759 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06760 &&
06761 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06762 goto MATCH_label_c1028;
06763 else
06764 goto MATCH_label_c1029;
06765
06766 break;
06767 case 3:
06768 goto MATCH_label_c1026; break;
06769 default: assert(0);
06770 }
06771
06772 break;
06773 case 1:
06774 MATCH_w_8_8 = getByte(1 + MATCH_p);
06775
06776 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06777 case 0:
06778
06779 switch((MATCH_w_8_8 & 0x7) ) {
06780 case 0: case 1: case 2: case 3: case 6: case 7:
06781 goto MATCH_label_c1030; break;
06782 case 4:
06783 MATCH_w_8_16 = getByte(2 + MATCH_p);
06784 if ((MATCH_w_8_16 & 0x7)
06785 == 5 &&
06786 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06787 &&
06788 (MATCH_w_8_16 >> 3 & 0x7)
06789 < 8))
06790 goto MATCH_label_c1032;
06791 else
06792 goto MATCH_label_c1031;
06793
06794 break;
06795 case 5:
06796 goto MATCH_label_c1033; break;
06797 default: assert(0);
06798 }
06799 break;
06800 case 1:
06801 MATCH_w_8_16 = getByte(2 + MATCH_p);
06802 if ((MATCH_w_8_8 & 0x7) == 4 &&
06803 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06804 &&
06805 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06806 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06807 unsigned reg =
06808 (MATCH_w_8_8 >> 3 & 0x7) ;
06809 nextPC = 4 + MATCH_p;
06810
06811 #line 1477 "frontend/machine/pentium/decoder.m"
06812
06813
06814 stmts = instantiate(pc, "CMPmrod", DIS_EADDR32, DIS_REG32);
06815
06816
06817
06818
06819
06820
06821 }
06822 else
06823 goto MATCH_label_c1031;
06824
06825 break;
06826 case 2:
06827 MATCH_w_8_16 = getByte(2 + MATCH_p);
06828 if ((MATCH_w_8_8 & 0x7) == 4 &&
06829 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06830 &&
06831 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06832 goto MATCH_label_c1032;
06833 else
06834 goto MATCH_label_c1033;
06835
06836 break;
06837 case 3:
06838 goto MATCH_label_c1030; break;
06839 default: assert(0);
06840 }
06841
06842 break;
06843 case 2:
06844 MATCH_w_8_8 = getByte(1 + MATCH_p);
06845
06846 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06847 case 0:
06848
06849 switch((MATCH_w_8_8 & 0x7) ) {
06850 case 0: case 1: case 2: case 3: case 6: case 7:
06851 goto MATCH_label_c1034; break;
06852 case 4:
06853 MATCH_w_8_16 = getByte(2 + MATCH_p);
06854 if ((MATCH_w_8_16 & 0x7)
06855 == 5 &&
06856 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06857 &&
06858 (MATCH_w_8_16 >> 3 & 0x7)
06859 < 8))
06860 goto MATCH_label_c1036;
06861 else
06862 goto MATCH_label_c1035;
06863
06864 break;
06865 case 5:
06866 goto MATCH_label_c1037; break;
06867 default: assert(0);
06868 }
06869 break;
06870 case 1:
06871 MATCH_w_8_16 = getByte(2 + MATCH_p);
06872 if ((MATCH_w_8_8 & 0x7) == 4 &&
06873 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06874 &&
06875 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06876 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06877 unsigned r8 =
06878 (MATCH_w_8_8 >> 3 & 0x7) ;
06879 nextPC = 4 + MATCH_p;
06880
06881 #line 1453 "frontend/machine/pentium/decoder.m"
06882
06883
06884 stmts = instantiate(pc, "CMPrmb", DIS_R8, DIS_EADDR8);
06885
06886
06887
06888
06889
06890
06891 }
06892 else
06893 goto MATCH_label_c1035;
06894
06895 break;
06896 case 2:
06897 MATCH_w_8_16 = getByte(2 + MATCH_p);
06898 if ((MATCH_w_8_8 & 0x7) == 4 &&
06899 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06900 &&
06901 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06902 goto MATCH_label_c1036;
06903 else
06904 goto MATCH_label_c1037;
06905
06906 break;
06907 case 3:
06908 goto MATCH_label_c1034; break;
06909 default: assert(0);
06910 }
06911
06912 break;
06913 case 3:
06914 MATCH_w_8_8 = getByte(1 + MATCH_p);
06915
06916 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
06917 case 0:
06918
06919 switch((MATCH_w_8_8 & 0x7) ) {
06920 case 0: case 1: case 2: case 3: case 6: case 7:
06921 goto MATCH_label_c1038; break;
06922 case 4:
06923 MATCH_w_8_16 = getByte(2 + MATCH_p);
06924 if ((MATCH_w_8_16 & 0x7)
06925 == 5 &&
06926 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06927 &&
06928 (MATCH_w_8_16 >> 3 & 0x7)
06929 < 8))
06930 goto MATCH_label_c1040;
06931 else
06932 goto MATCH_label_c1039;
06933
06934 break;
06935 case 5:
06936 goto MATCH_label_c1041; break;
06937 default: assert(0);
06938 }
06939 break;
06940 case 1:
06941 MATCH_w_8_16 = getByte(2 + MATCH_p);
06942 if ((MATCH_w_8_8 & 0x7) == 4 &&
06943 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06944 &&
06945 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
06946 unsigned Eaddr = 1 + addressToPC(MATCH_p);
06947 unsigned reg =
06948 (MATCH_w_8_8 >> 3 & 0x7) ;
06949 nextPC = 4 + MATCH_p;
06950
06951 #line 1405 "frontend/machine/pentium/decoder.m"
06952
06953
06954 stmts = instantiate(pc, "CMPrmod", DIS_REG32, DIS_EADDR32);
06955
06956
06957
06958
06959
06960
06961 }
06962 else
06963 goto MATCH_label_c1039;
06964
06965 break;
06966 case 2:
06967 MATCH_w_8_16 = getByte(2 + MATCH_p);
06968 if ((MATCH_w_8_8 & 0x7) == 4 &&
06969 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
06970 &&
06971 (MATCH_w_8_16 >> 3 & 0x7) < 8))
06972 goto MATCH_label_c1040;
06973 else
06974 goto MATCH_label_c1041;
06975
06976 break;
06977 case 3:
06978 goto MATCH_label_c1038; break;
06979 default: assert(0);
06980 }
06981
06982 break;
06983 case 4:
06984 MATCH_w_8_8 = getByte(1 + MATCH_p);
06985 {
06986 int i8 =
06987 sign_extend((MATCH_w_8_8 & 0xff) , 8);
06988 nextPC = 2 + MATCH_p;
06989
06990 #line 1720 "frontend/machine/pentium/decoder.m"
06991
06992
06993 stmts = instantiate(pc, "CMPiAL", DIS_I8);
06994
06995
06996
06997
06998
06999
07000 }
07001
07002 break;
07003 case 5:
07004 MATCH_w_32_8 = getDword(1 + MATCH_p);
07005 {
07006 unsigned i32 = MATCH_w_32_8 ;
07007 nextPC = 5 + MATCH_p;
07008
07009 #line 1672 "frontend/machine/pentium/decoder.m"
07010
07011
07012 stmts = instantiate(pc, "CMPiEAX", DIS_I32);
07013
07014
07015
07016
07017
07018
07019 }
07020
07021 break;
07022 case 6:
07023 nextPC = 1 + MATCH_p;
07024
07025 #line 333 "frontend/machine/pentium/decoder.m"
07026
07027
07028 stmts = instantiate(pc, "NOP");
07029
07030
07031
07032
07033
07034
07035
07036 break;
07037 case 7:
07038 goto MATCH_label_c64; break;
07039 default: assert(0);
07040 }
07041 break;
07042 case 4:
07043 {
07044 unsigned r32 = (MATCH_w_8_0 & 0x7) ;
07045 nextPC = 1 + MATCH_p;
07046
07047 #line 1205 "frontend/machine/pentium/decoder.m"
07048
07049
07050 stmts = instantiate(pc, "DECod", DIS_R32);
07051
07052
07053
07054
07055
07056
07057 }
07058
07059 break;
07060 case 5:
07061 {
07062 unsigned r32 = (MATCH_w_8_0 & 0x7) ;
07063 nextPC = 1 + MATCH_p;
07064
07065 #line 871 "frontend/machine/pentium/decoder.m"
07066
07067
07068 stmts = instantiate(pc, "POPod", DIS_R32);
07069
07070
07071
07072
07073
07074
07075 }
07076
07077 break;
07078 case 6:
07079
07080 switch((MATCH_w_8_0 & 0x7) ) {
07081 case 0:
07082 MATCH_w_32_8 = getDword(1 + MATCH_p);
07083 {
07084 unsigned i32 = MATCH_w_32_8 ;
07085 nextPC = 5 + MATCH_p;
07086
07087 #line 820 "frontend/machine/pentium/decoder.m"
07088
07089
07090 stmts = instantiate(pc, "PUSH.Ivod", DIS_I32);
07091
07092
07093
07094
07095
07096
07097 }
07098
07099 break;
07100 case 1:
07101 MATCH_w_8_8 = getByte(1 + MATCH_p);
07102
07103 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
07104 case 0:
07105
07106 switch((MATCH_w_8_8 & 0x7) ) {
07107 case 0: case 1: case 2: case 3: case 6: case 7:
07108 MATCH_w_32_16 = getDword(2 + MATCH_p);
07109 goto MATCH_label_c1042;
07110
07111 break;
07112 case 4:
07113 MATCH_w_8_16 = getByte(2 + MATCH_p);
07114 if ((MATCH_w_8_16 & 0x7)
07115 == 5 &&
07116 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07117 &&
07118 (MATCH_w_8_16 >> 3 & 0x7)
07119 < 8)) {
07120 MATCH_w_32_56 = getDword(7 + MATCH_p);
07121 goto MATCH_label_c1044;
07122
07123 }
07124 else {
07125 MATCH_w_32_24 = getDword(3 + MATCH_p);
07126 goto MATCH_label_c1043;
07127
07128 }
07129
07130 break;
07131 case 5:
07132 MATCH_w_32_48 = getDword(6 + MATCH_p);
07133 goto MATCH_label_c1045;
07134
07135 break;
07136 default: assert(0);
07137 }
07138 break;
07139 case 1:
07140 MATCH_w_8_16 = getByte(2 + MATCH_p);
07141 if ((MATCH_w_8_8 & 0x7) == 4 &&
07142 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07143 &&
07144 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07145 MATCH_w_32_32 = getDword(4 + MATCH_p);
07146 {
07147 unsigned Eaddr = 1 + addressToPC(MATCH_p);
07148 unsigned i32 = MATCH_w_32_32 ;
07149 unsigned reg =
07150 (MATCH_w_8_8 >> 3 & 0x7) ;
07151 nextPC = 8 + MATCH_p;
07152
07153 #line 1154 "frontend/machine/pentium/decoder.m"
07154
07155
07156 stmts = instantiate(pc, "IMUL.Ivd", DIS_REG32, DIS_EADDR32, DIS_I32);
07157
07158
07159
07160
07161
07162
07163 }
07164
07165 }
07166 else {
07167 MATCH_w_32_24 = getDword(3 + MATCH_p);
07168 goto MATCH_label_c1043;
07169
07170 }
07171
07172 break;
07173 case 2:
07174 MATCH_w_8_16 = getByte(2 + MATCH_p);
07175 if ((MATCH_w_8_8 & 0x7) == 4 &&
07176 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07177 &&
07178 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07179 MATCH_w_32_56 = getDword(7 + MATCH_p);
07180 goto MATCH_label_c1044;
07181
07182 }
07183 else {
07184 MATCH_w_32_48 = getDword(6 + MATCH_p);
07185 goto MATCH_label_c1045;
07186
07187 }
07188
07189 break;
07190 case 3:
07191 MATCH_w_32_16 = getDword(2 + MATCH_p);
07192 goto MATCH_label_c1042;
07193
07194 break;
07195 default: assert(0);
07196 }
07197
07198 break;
07199 case 2:
07200 MATCH_w_8_8 = getByte(1 + MATCH_p);
07201 {
07202 int i8 =
07203 sign_extend((MATCH_w_8_8 & 0xff) , 8);
07204 nextPC = 2 + MATCH_p;
07205
07206 #line 826 "frontend/machine/pentium/decoder.m"
07207
07208
07209 stmts = instantiate(pc, "PUSH.Ixob", DIS_I8);
07210
07211
07212
07213
07214
07215
07216 }
07217
07218 break;
07219 case 3:
07220 MATCH_w_8_8 = getByte(1 + MATCH_p);
07221
07222 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
07223 case 0:
07224
07225 switch((MATCH_w_8_8 & 0x7) ) {
07226 case 0: case 1: case 2: case 3: case 6: case 7:
07227 MATCH_w_8_16 = getByte(2 + MATCH_p);
07228 goto MATCH_label_c1046;
07229
07230 break;
07231 case 4:
07232 MATCH_w_8_16 = getByte(2 + MATCH_p);
07233 if ((MATCH_w_8_16 & 0x7)
07234 == 5 &&
07235 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07236 &&
07237 (MATCH_w_8_16 >> 3 & 0x7)
07238 < 8)) {
07239 MATCH_w_8_56 = getByte(7 + MATCH_p);
07240 goto MATCH_label_c1048;
07241
07242 }
07243 else {
07244 MATCH_w_8_24 = getByte(3 + MATCH_p);
07245 goto MATCH_label_c1047;
07246
07247 }
07248
07249 break;
07250 case 5:
07251 MATCH_w_8_48 = getByte(6 + MATCH_p);
07252 goto MATCH_label_c1049;
07253
07254 break;
07255 default: assert(0);
07256 }
07257 break;
07258 case 1:
07259 MATCH_w_8_16 = getByte(2 + MATCH_p);
07260 if ((MATCH_w_8_8 & 0x7) == 4 &&
07261 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07262 &&
07263 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07264 MATCH_w_8_32 = getByte(4 + MATCH_p);
07265 {
07266 unsigned Eaddr = 1 + addressToPC(MATCH_p);
07267 int i8 =
07268 sign_extend((MATCH_w_8_32 & 0xff)
07269 , 8);
07270 unsigned reg =
07271 (MATCH_w_8_8 >> 3 & 0x7) ;
07272 nextPC = 5 + MATCH_p;
07273
07274 #line 1160 "frontend/machine/pentium/decoder.m"
07275
07276
07277 stmts = instantiate(pc, "IMUL.Ibod", DIS_REG32, DIS_EADDR32, DIS_I8);
07278
07279
07280
07281
07282
07283
07284 }
07285
07286 }
07287 else {
07288 MATCH_w_8_24 = getByte(3 + MATCH_p);
07289 goto MATCH_label_c1047;
07290
07291 }
07292
07293 break;
07294 case 2:
07295 MATCH_w_8_16 = getByte(2 + MATCH_p);
07296 if ((MATCH_w_8_8 & 0x7) == 4 &&
07297 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07298 &&
07299 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07300 MATCH_w_8_56 = getByte(7 + MATCH_p);
07301 goto MATCH_label_c1048;
07302
07303 }
07304 else {
07305 MATCH_w_8_48 = getByte(6 + MATCH_p);
07306 goto MATCH_label_c1049;
07307
07308 }
07309
07310 break;
07311 case 3:
07312 MATCH_w_8_16 = getByte(2 + MATCH_p);
07313 goto MATCH_label_c1046;
07314
07315 break;
07316 default: assert(0);
07317 }
07318
07319 break;
07320 case 4: case 5: case 6: case 7:
07321 goto MATCH_label_c64; break;
07322 default: assert(0);
07323 }
07324 break;
07325 case 7:
07326
07327 switch((MATCH_w_8_0 & 0x7) ) {
07328 case 0:
07329 MATCH_w_8_8 = getByte(1 + MATCH_p);
07330 {
07331 unsigned relocd =
07332 2 + sign_extend((MATCH_w_8_8 & 0xff) ,
07333 8) + addressToPC(MATCH_p);
07334 nextPC = 2 + MATCH_p;
07335
07336 #line 174 "frontend/machine/pentium/decoder.m"
07337
07338
07339 COND_JUMP("Jb.S", 2, relocd, BRANCH_JMI)
07340
07341
07342
07343
07344 }
07345
07346 break;
07347 case 1:
07348 MATCH_w_8_8 = getByte(1 + MATCH_p);
07349 {
07350 unsigned relocd =
07351 2 + sign_extend((MATCH_w_8_8 & 0xff) ,
07352 8) + addressToPC(MATCH_p);
07353 nextPC = 2 + MATCH_p;
07354
07355 #line 172 "frontend/machine/pentium/decoder.m"
07356
07357
07358 COND_JUMP("Jb.NS", 2, relocd, BRANCH_JPOS)
07359
07360
07361
07362
07363 }
07364
07365 break;
07366 case 2:
07367 MATCH_w_8_8 = getByte(1 + MATCH_p);
07368 {
07369 unsigned relocd =
07370 2 + sign_extend((MATCH_w_8_8 & 0xff) ,
07371 8) + addressToPC(MATCH_p);
07372 nextPC = 2 + MATCH_p;
07373
07374 #line 170 "frontend/machine/pentium/decoder.m"
07375
07376
07377 COND_JUMP("Jb.P", 2, relocd, BRANCH_JPAR)
07378
07379
07380
07381
07382 }
07383
07384 break;
07385 case 3:
07386 MATCH_w_8_8 = getByte(1 + MATCH_p);
07387 {
07388 unsigned relocd =
07389 2 + sign_extend((MATCH_w_8_8 & 0xff) ,
07390 8) + addressToPC(MATCH_p);
07391 nextPC = 2 + MATCH_p;
07392
07393 #line 168 "frontend/machine/pentium/decoder.m"
07394
07395
07396 COND_JUMP("Jb.NP", 2, relocd, (BRANCH_TYPE)0)
07397
07398
07399
07400
07401 }
07402
07403 break;
07404 case 4:
07405 MATCH_w_8_8 = getByte(1 + MATCH_p);
07406 {
07407 unsigned relocd =
07408 2 + sign_extend((MATCH_w_8_8 & 0xff) ,
07409 8) + addressToPC(MATCH_p);
07410 nextPC = 2 + MATCH_p;
07411
07412 #line 166 "frontend/machine/pentium/decoder.m"
07413
07414
07415 COND_JUMP("Jb.L", 2, relocd, BRANCH_JSL)
07416
07417
07418
07419
07420 }
07421
07422 break;
07423 case 5:
07424 MATCH_w_8_8 = getByte(1 + MATCH_p);
07425 {
07426 unsigned relocd =
07427 2 + sign_extend((MATCH_w_8_8 & 0xff) ,
07428 8) + addressToPC(MATCH_p);
07429 nextPC = 2 + MATCH_p;
07430
07431 #line 164 "frontend/machine/pentium/decoder.m"
07432
07433
07434 COND_JUMP("Jb.NL", 2, relocd, BRANCH_JSGE)
07435
07436
07437
07438
07439 }
07440
07441 break;
07442 case 6:
07443 MATCH_w_8_8 = getByte(1 + MATCH_p);
07444 {
07445 unsigned relocd =
07446 2 + sign_extend((MATCH_w_8_8 & 0xff) ,
07447 8) + addressToPC(MATCH_p);
07448 nextPC = 2 + MATCH_p;
07449
07450 #line 162 "frontend/machine/pentium/decoder.m"
07451
07452
07453 COND_JUMP("Jb.LE", 2, relocd, BRANCH_JSLE)
07454
07455
07456
07457
07458 }
07459
07460 break;
07461 case 7:
07462 MATCH_w_8_8 = getByte(1 + MATCH_p);
07463 {
07464 unsigned relocd =
07465 2 + sign_extend((MATCH_w_8_8 & 0xff) ,
07466 8) + addressToPC(MATCH_p);
07467 nextPC = 2 + MATCH_p;
07468
07469 #line 160 "frontend/machine/pentium/decoder.m"
07470
07471
07472 COND_JUMP("Jb.NLE", 2, relocd, BRANCH_JSG)
07473
07474
07475
07476
07477 }
07478
07479 break;
07480 default: assert(0);
07481 }
07482 break;
07483 case 8:
07484
07485 switch((MATCH_w_8_0 & 0x7) ) {
07486 case 0:
07487 MATCH_w_8_8 = getByte(1 + MATCH_p);
07488
07489 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
07490 case 0:
07491
07492 switch((MATCH_w_8_8 & 0x7) ) {
07493 case 0: case 1: case 2: case 3: case 6: case 7:
07494 goto MATCH_label_c1050; break;
07495 case 4:
07496 MATCH_w_8_16 = getByte(2 + MATCH_p);
07497 if ((MATCH_w_8_16 & 0x7)
07498 == 5 &&
07499 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07500 &&
07501 (MATCH_w_8_16 >> 3 & 0x7)
07502 < 8))
07503 goto MATCH_label_c1052;
07504 else
07505 goto MATCH_label_c1051;
07506
07507 break;
07508 case 5:
07509 goto MATCH_label_c1053; break;
07510 default: assert(0);
07511 }
07512 break;
07513 case 1:
07514 MATCH_w_8_16 = getByte(2 + MATCH_p);
07515 if ((MATCH_w_8_8 & 0x7) == 4 &&
07516 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07517 &&
07518 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07519 unsigned Eaddr = 1 + addressToPC(MATCH_p);
07520 unsigned reg =
07521 (MATCH_w_8_8 >> 3 & 0x7) ;
07522 nextPC = 4 + MATCH_p;
07523
07524 #line 1037 "frontend/machine/pentium/decoder.m"
07525
07526
07527 stmts = instantiate(pc, "MOVmrb", DIS_EADDR8, DIS_REG8);
07528
07529
07530
07531
07532
07533
07534 }
07535 else
07536 goto MATCH_label_c1051;
07537
07538 break;
07539 case 2:
07540 MATCH_w_8_16 = getByte(2 + MATCH_p);
07541 if ((MATCH_w_8_8 & 0x7) == 4 &&
07542 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07543 &&
07544 (MATCH_w_8_16 >> 3 & 0x7) < 8))
07545 goto MATCH_label_c1052;
07546 else
07547 goto MATCH_label_c1053;
07548
07549 break;
07550 case 3:
07551 goto MATCH_label_c1050; break;
07552 default: assert(0);
07553 }
07554
07555 break;
07556 case 1:
07557 MATCH_w_8_8 = getByte(1 + MATCH_p);
07558
07559 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
07560 case 0:
07561
07562 switch((MATCH_w_8_8 & 0x7) ) {
07563 case 0: case 1: case 2: case 3: case 6: case 7:
07564 goto MATCH_label_c1054; break;
07565 case 4:
07566 MATCH_w_8_16 = getByte(2 + MATCH_p);
07567 if ((MATCH_w_8_16 & 0x7)
07568 == 5 &&
07569 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07570 &&
07571 (MATCH_w_8_16 >> 3 & 0x7)
07572 < 8))
07573 goto MATCH_label_c1056;
07574 else
07575 goto MATCH_label_c1055;
07576
07577 break;
07578 case 5:
07579 goto MATCH_label_c1057; break;
07580 default: assert(0);
07581 }
07582 break;
07583 case 1:
07584 MATCH_w_8_16 = getByte(2 + MATCH_p);
07585 if ((MATCH_w_8_8 & 0x7) == 4 &&
07586 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07587 &&
07588 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07589 unsigned Eaddr = 1 + addressToPC(MATCH_p);
07590 unsigned reg =
07591 (MATCH_w_8_8 >> 3 & 0x7) ;
07592 nextPC = 4 + MATCH_p;
07593
07594 #line 1031 "frontend/machine/pentium/decoder.m"
07595
07596
07597 stmts = instantiate(pc, "MOVmrod", DIS_EADDR32, DIS_REG32);
07598
07599
07600
07601
07602
07603
07604 }
07605 else
07606 goto MATCH_label_c1055;
07607
07608 break;
07609 case 2:
07610 MATCH_w_8_16 = getByte(2 + MATCH_p);
07611 if ((MATCH_w_8_8 & 0x7) == 4 &&
07612 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07613 &&
07614 (MATCH_w_8_16 >> 3 & 0x7) < 8))
07615 goto MATCH_label_c1056;
07616 else
07617 goto MATCH_label_c1057;
07618
07619 break;
07620 case 3:
07621 goto MATCH_label_c1054; break;
07622 default: assert(0);
07623 }
07624
07625 break;
07626 case 2:
07627 MATCH_w_8_8 = getByte(1 + MATCH_p);
07628
07629 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
07630 case 0:
07631
07632 switch((MATCH_w_8_8 & 0x7) ) {
07633 case 0: case 1: case 2: case 3: case 6: case 7:
07634 goto MATCH_label_c1058; break;
07635 case 4:
07636 MATCH_w_8_16 = getByte(2 + MATCH_p);
07637 if ((MATCH_w_8_16 & 0x7)
07638 == 5 &&
07639 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07640 &&
07641 (MATCH_w_8_16 >> 3 & 0x7)
07642 < 8))
07643 goto MATCH_label_c1060;
07644 else
07645 goto MATCH_label_c1059;
07646
07647 break;
07648 case 5:
07649 goto MATCH_label_c1061; break;
07650 default: assert(0);
07651 }
07652 break;
07653 case 1:
07654 MATCH_w_8_16 = getByte(2 + MATCH_p);
07655 if ((MATCH_w_8_8 & 0x7) == 4 &&
07656 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07657 &&
07658 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07659 unsigned Eaddr = 1 + addressToPC(MATCH_p);
07660 unsigned reg =
07661 (MATCH_w_8_8 >> 3 & 0x7) ;
07662 nextPC = 4 + MATCH_p;
07663
07664 #line 1028 "frontend/machine/pentium/decoder.m"
07665
07666
07667 stmts = instantiate(pc, "MOVrmb", DIS_REG8, DIS_EADDR8);
07668
07669
07670
07671
07672
07673
07674 }
07675 else
07676 goto MATCH_label_c1059;
07677
07678 break;
07679 case 2:
07680 MATCH_w_8_16 = getByte(2 + MATCH_p);
07681 if ((MATCH_w_8_8 & 0x7) == 4 &&
07682 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07683 &&
07684 (MATCH_w_8_16 >> 3 & 0x7) < 8))
07685 goto MATCH_label_c1060;
07686 else
07687 goto MATCH_label_c1061;
07688
07689 break;
07690 case 3:
07691 goto MATCH_label_c1058; break;
07692 default: assert(0);
07693 }
07694
07695 break;
07696 case 3:
07697 MATCH_w_8_8 = getByte(1 + MATCH_p);
07698
07699 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
07700 case 0:
07701
07702 switch((MATCH_w_8_8 & 0x7) ) {
07703 case 0: case 1: case 2: case 3: case 6: case 7:
07704 goto MATCH_label_c1062; break;
07705 case 4:
07706 MATCH_w_8_16 = getByte(2 + MATCH_p);
07707 if ((MATCH_w_8_16 & 0x7)
07708 == 5 &&
07709 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07710 &&
07711 (MATCH_w_8_16 >> 3 & 0x7)
07712 < 8))
07713 goto MATCH_label_c1064;
07714 else
07715 goto MATCH_label_c1063;
07716
07717 break;
07718 case 5:
07719 goto MATCH_label_c1065; break;
07720 default: assert(0);
07721 }
07722 break;
07723 case 1:
07724 MATCH_w_8_16 = getByte(2 + MATCH_p);
07725 if ((MATCH_w_8_8 & 0x7) == 4 &&
07726 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07727 &&
07728 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07729 unsigned Eaddr = 1 + addressToPC(MATCH_p);
07730 unsigned reg =
07731 (MATCH_w_8_8 >> 3 & 0x7) ;
07732 nextPC = 4 + MATCH_p;
07733
07734 #line 1022 "frontend/machine/pentium/decoder.m"
07735
07736
07737 stmts = instantiate(pc, "MOVrmod", DIS_REG32, DIS_EADDR32);
07738
07739
07740
07741
07742
07743
07744 }
07745 else
07746 goto MATCH_label_c1063;
07747
07748 break;
07749 case 2:
07750 MATCH_w_8_16 = getByte(2 + MATCH_p);
07751 if ((MATCH_w_8_8 & 0x7) == 4 &&
07752 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07753 &&
07754 (MATCH_w_8_16 >> 3 & 0x7) < 8))
07755 goto MATCH_label_c1064;
07756 else
07757 goto MATCH_label_c1065;
07758
07759 break;
07760 case 3:
07761 goto MATCH_label_c1062; break;
07762 default: assert(0);
07763 }
07764
07765 break;
07766 case 4: case 6:
07767 goto MATCH_label_c64; break;
07768 case 5:
07769 MATCH_w_8_8 = getByte(1 + MATCH_p);
07770
07771 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
07772 case 0:
07773
07774 switch((MATCH_w_8_8 & 0x7) ) {
07775 case 0: case 1: case 2: case 3: case 6: case 7:
07776 {
07777 unsigned Mem = 1 + addressToPC(MATCH_p);
07778 unsigned reg =
07779 (MATCH_w_8_8 >> 3 & 0x7)
07780 ;
07781 nextPC = 2 + MATCH_p;
07782
07783 #line 1073 "frontend/machine/pentium/decoder.m"
07784
07785
07786 stmts = instantiate(pc, "LEA.od", DIS_REG32, DIS_MEM);
07787
07788
07789
07790
07791
07792
07793 }
07794
07795 break;
07796 case 4:
07797 MATCH_w_8_16 = getByte(2 + MATCH_p);
07798 if ((MATCH_w_8_16 & 0x7)
07799 == 5 &&
07800 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07801 &&
07802 (MATCH_w_8_16 >> 3 & 0x7)
07803 < 8))
07804 goto MATCH_label_c1067;
07805 else
07806 goto MATCH_label_c1066;
07807
07808 break;
07809 case 5:
07810 goto MATCH_label_c1068; break;
07811 default: assert(0);
07812 }
07813 break;
07814 case 1:
07815 MATCH_w_8_16 = getByte(2 + MATCH_p);
07816 if ((MATCH_w_8_8 & 0x7) == 4 &&
07817 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07818 &&
07819 (MATCH_w_8_16 >> 3 & 0x7) < 8)) {
07820 unsigned Mem = 1 + addressToPC(MATCH_p);
07821 unsigned reg =
07822 (MATCH_w_8_8 >> 3 & 0x7) ;
07823 nextPC = 4 + MATCH_p;
07824
07825 #line 1073 "frontend/machine/pentium/decoder.m"
07826
07827
07828 stmts = instantiate(pc, "LEA.od", DIS_REG32, DIS_MEM);
07829
07830
07831
07832
07833
07834
07835 }
07836 else
07837 goto MATCH_label_c1066;
07838
07839 break;
07840 case 2:
07841 MATCH_w_8_16 = getByte(2 + MATCH_p);
07842 if ((MATCH_w_8_8 & 0x7) == 4 &&
07843 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07844 &&
07845 (MATCH_w_8_16 >> 3 & 0x7) < 8))
07846 goto MATCH_label_c1067;
07847 else
07848 goto MATCH_label_c1068;
07849
07850 break;
07851 case 3:
07852 goto MATCH_label_c64; break;
07853 default: assert(0);
07854 }
07855
07856 break;
07857 case 7:
07858 MATCH_w_8_8 = getByte(1 + MATCH_p);
07859 if ((MATCH_w_8_8 >> 3 & 0x7) == 0)
07860
07861 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
07862 case 0:
07863
07864 switch((MATCH_w_8_8 & 0x7) ) {
07865 case 0: case 1: case 2: case 3: case 6: case 7:
07866 goto MATCH_label_c1069; break;
07867 case 4:
07868 MATCH_w_8_16 = getByte(2 + MATCH_p);
07869 if ((MATCH_w_8_16 & 0x7)
07870 == 5 &&
07871 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07872 &&
07873 (MATCH_w_8_16 >> 3 & 0x7)
07874 < 8))
07875 goto MATCH_label_c1071;
07876 else
07877 goto MATCH_label_c1070;
07878
07879 break;
07880 case 5:
07881 goto MATCH_label_c1072; break;
07882 default: assert(0);
07883 }
07884 break;
07885 case 1:
07886 MATCH_w_8_16 = getByte(2 + MATCH_p);
07887 if ((MATCH_w_8_8 & 0x7) == 4 &&
07888 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07889 &&
07890 (MATCH_w_8_16 >> 3 & 0x7)
07891 < 8)) {
07892 unsigned Eaddr = 1 + addressToPC(MATCH_p);
07893 nextPC = 4 + MATCH_p;
07894
07895 #line 877 "frontend/machine/pentium/decoder.m"
07896
07897
07898 stmts = instantiate(pc, "POP.Evod", DIS_EADDR32);
07899
07900
07901
07902
07903
07904
07905 }
07906 else
07907 goto MATCH_label_c1070;
07908
07909 break;
07910 case 2:
07911 MATCH_w_8_16 = getByte(2 + MATCH_p);
07912 if ((MATCH_w_8_8 & 0x7) == 4 &&
07913 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
07914 &&
07915 (MATCH_w_8_16 >> 3 & 0x7) < 8))
07916 goto MATCH_label_c1071;
07917 else
07918 goto MATCH_label_c1072;
07919
07920 break;
07921 case 3:
07922 goto MATCH_label_c1069; break;
07923 default: assert(0);
07924 }
07925 else
07926 goto MATCH_label_c64;
07927
07928 break;
07929 default: assert(0);
07930 }
07931 break;
07932 case 9:
07933
07934 switch((MATCH_w_8_0 & 0x7) ) {
07935 case 0:
07936 nextPC = 1 + MATCH_p;
07937
07938 #line 1271 "frontend/machine/pentium/decoder.m"
07939
07940
07941 stmts = instantiate(pc, "CWDE");
07942
07943
07944
07945
07946
07947
07948
07949 break;
07950 case 1:
07951 nextPC = 1 + MATCH_p;
07952
07953 #line 1226 "frontend/machine/pentium/decoder.m"
07954
07955
07956 stmts = instantiate(pc, "CDQ");
07957
07958
07959
07960
07961
07962
07963
07964 break;
07965 case 2:
07966 MATCH_w_32_8 = getDword(1 + MATCH_p);
07967 MATCH_w_16_40 = getWord(5 + MATCH_p);
07968 {
07969 unsigned off = MATCH_w_32_8 ;
07970 unsigned seg = (MATCH_w_16_40 & 0xffff) ;
07971 nextPC = 7 + MATCH_p;
07972
07973 #line 1279 "frontend/machine/pentium/decoder.m"
07974
07975
07976 unused(seg); unused(off);
07977
07978 stmts = instantiate(pc, "NOP");
07979
07980
07981
07982
07983
07984
07985 }
07986
07987 break;
07988 case 3:
07989 nextPC = 1 + MATCH_p;
07990
07991 #line 369 "frontend/machine/pentium/decoder.m"
07992
07993
07994 stmts = instantiate(pc, "WAIT");
07995
07996
07997
07998
07999
08000
08001
08002 break;
08003 case 4: case 5:
08004 goto MATCH_label_c64; break;
08005 case 6:
08006 nextPC = 1 + MATCH_p;
08007
08008 #line 472 "frontend/machine/pentium/decoder.m"
08009
08010
08011 stmts = instantiate(pc, "SAHF");
08012
08013
08014
08015
08016
08017
08018
08019 break;
08020 case 7:
08021 nextPC = 1 + MATCH_p;
08022
08023 #line 1088 "frontend/machine/pentium/decoder.m"
08024
08025
08026 stmts = instantiate(pc, "LAHF");
08027
08028
08029
08030
08031
08032
08033
08034
08035
08036 break;
08037 default: assert(0);
08038 }
08039 break;
08040 case 10:
08041
08042 switch((MATCH_w_8_0 & 0x7) ) {
08043 case 0:
08044 MATCH_w_8_8 = getByte(1 + MATCH_p);
08045 {
08046 unsigned i8 = (MATCH_w_8_8 & 0xff) ;
08047 nextPC = 2 + MATCH_p;
08048
08049 #line 402 "frontend/machine/pentium/decoder.m"
08050
08051
08052 stmts = instantiate(pc, "TEST.AL.Ib", DIS_I8);
08053
08054
08055
08056
08057
08058
08059 }
08060
08061 break;
08062 case 1:
08063 MATCH_w_32_8 = getDword(1 + MATCH_p);
08064 {
08065 unsigned i32 = MATCH_w_32_8 ;
08066 nextPC = 5 + MATCH_p;
08067
08068 #line 396 "frontend/machine/pentium/decoder.m"
08069
08070
08071 stmts = instantiate(pc, "TEST.eAX.Ivod", DIS_I32);
08072
08073
08074
08075
08076
08077
08078 }
08079
08080 break;
08081 case 2:
08082 nextPC = 1 + MATCH_p;
08083
08084 #line 414 "frontend/machine/pentium/decoder.m"
08085
08086
08087 stmts = instantiate(pc, "STOSB");
08088
08089
08090
08091
08092
08093
08094
08095 break;
08096 case 3:
08097 nextPC = 1 + MATCH_p;
08098
08099 #line 408 "frontend/machine/pentium/decoder.m"
08100
08101
08102 stmts = instantiate(pc, "STOSvod");
08103
08104
08105
08106
08107
08108
08109
08110 break;
08111 case 4:
08112 nextPC = 1 + MATCH_p;
08113
08114 #line 1750 "frontend/machine/pentium/decoder.m"
08115
08116
08117 stmts = instantiate(pc, "LODSB");
08118
08119
08120
08121
08122
08123
08124
08125
08126
08127 break;
08128 case 5:
08129 nextPC = 1 + MATCH_p;
08130
08131 #line 1744 "frontend/machine/pentium/decoder.m"
08132
08133
08134 stmts = instantiate(pc, "LODSvod");
08135
08136
08137
08138
08139
08140
08141
08142 break;
08143 case 6:
08144 nextPC = 1 + MATCH_p;
08145
08146 #line 469 "frontend/machine/pentium/decoder.m"
08147
08148
08149 stmts = instantiate(pc, "SCASB");
08150
08151
08152
08153
08154
08155
08156
08157 break;
08158 case 7:
08159 nextPC = 1 + MATCH_p;
08160
08161 #line 463 "frontend/machine/pentium/decoder.m"
08162
08163
08164 stmts = instantiate(pc, "SCASvod");
08165
08166
08167
08168
08169
08170
08171
08172 break;
08173 default: assert(0);
08174 }
08175 break;
08176 case 11:
08177 MATCH_w_32_8 = getDword(1 + MATCH_p);
08178 {
08179 unsigned i32 = MATCH_w_32_8 ;
08180 unsigned r32 = (MATCH_w_8_0 & 0x7) ;
08181 nextPC = 5 + MATCH_p;
08182
08183 #line 989 "frontend/machine/pentium/decoder.m"
08184
08185
08186 stmts = instantiate(pc, "MOVid", DIS_R32, DIS_I32);
08187
08188
08189
08190
08191
08192
08193 }
08194
08195 break;
08196 case 12:
08197
08198 switch((MATCH_w_8_0 & 0x7) ) {
08199 case 0:
08200 MATCH_w_16_8 = getWord(1 + MATCH_p);
08201 MATCH_w_8_24 = getByte(3 + MATCH_p);
08202 {
08203 unsigned i16 = (MATCH_w_16_8 & 0xffff) ;
08204 int i8 =
08205 sign_extend((MATCH_w_8_24 & 0xff) , 8);
08206 nextPC = 4 + MATCH_p;
08207
08208 #line 1193 "frontend/machine/pentium/decoder.m"
08209
08210
08211 stmts = instantiate(pc, "ENTER", DIS_I16, DIS_I8);
08212
08213
08214
08215
08216
08217
08218 }
08219
08220 break;
08221 case 1:
08222 nextPC = 1 + MATCH_p;
08223
08224 #line 1070 "frontend/machine/pentium/decoder.m"
08225
08226
08227 stmts = instantiate(pc, "LEAVE");
08228
08229
08230
08231
08232
08233
08234
08235 break;
08236 case 2:
08237 MATCH_w_16_8 = getWord(1 + MATCH_p);
08238 {
08239 unsigned i16 = (MATCH_w_16_8 & 0xffff) ;
08240 nextPC = 3 + MATCH_p;
08241
08242 #line 478 "frontend/machine/pentium/decoder.m"
08243
08244
08245 stmts = instantiate(pc, "RET.far.Iw", DIS_I16);
08246
08247 ReturnStatement *ret = new ReturnStatement;
08248
08249 result.rtl = new RTL(pc, stmts);
08250
08251 result.rtl->appendStmt(ret);
08252
08253
08254
08255
08256
08257
08258 }
08259
08260 break;
08261 case 3:
08262 nextPC = 1 + MATCH_p;
08263
08264 #line 490 "frontend/machine/pentium/decoder.m"
08265
08266
08267 stmts = instantiate(pc, "RET.far");
08268
08269 result.rtl = new RTL(pc, stmts);
08270
08271 result.rtl->appendStmt(new ReturnStatement);
08272
08273
08274
08275
08276
08277
08278
08279 break;
08280 case 4:
08281 goto MATCH_label_c64; break;
08282 case 5:
08283 MATCH_w_8_8 = getByte(1 + MATCH_p);
08284 {
08285 int i8 =
08286 sign_extend((MATCH_w_8_8 & 0xff) , 8);
08287 nextPC = 2 + MATCH_p;
08288
08289 #line 1104 "frontend/machine/pentium/decoder.m"
08290
08291
08292 stmts = instantiate(pc, "INT.Ib", DIS_I8);
08293
08294
08295
08296
08297
08298
08299
08300
08301
08302
08303
08304
08305
08306
08307
08308
08309
08310
08311
08312
08313
08314
08315
08316
08317
08318
08319
08320
08321
08322
08323
08324
08325
08326
08327 }
08328
08329 break;
08330 case 6:
08331 nextPC = 1 + MATCH_p;
08332
08333 #line 1101 "frontend/machine/pentium/decoder.m"
08334
08335
08336 stmts = instantiate(pc, "INTO");
08337
08338
08339
08340
08341
08342
08343
08344 break;
08345 case 7:
08346 nextPC = 1 + MATCH_p;
08347
08348 #line 1092 "frontend/machine/pentium/decoder.m"
08349
08350
08351 stmts = instantiate(pc, "IRET");
08352
08353
08354
08355
08356
08357
08358
08359 break;
08360 default: assert(0);
08361 }
08362 break;
08363 case 13:
08364
08365 switch((MATCH_w_8_0 & 0x7) ) {
08366 case 0:
08367 MATCH_w_8_8 = getByte(1 + MATCH_p);
08368
08369 switch((MATCH_w_8_8 >> 3 & 0x7) ) {
08370 case 0:
08371
08372 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
08373 case 0:
08374
08375 switch((MATCH_w_8_8 & 0x7) ) {
08376 case 0: case 1: case 2: case 3: case 6:
08377 case 7:
08378 {
08379 unsigned Mem32 =
08380 1 + addressToPC(MATCH_p);
08381 nextPC = 2 + MATCH_p;
08382
08383 #line 1760 "frontend/machine/pentium/decoder.m"
08384
08385
08386 stmts = instantiate(pc, "FADD.R32", DIS_MEM32);
08387
08388
08389
08390
08391
08392
08393 }
08394
08395 break;
08396 case 4:
08397 MATCH_w_8_16 = getByte(2 + MATCH_p);
08398 if ((MATCH_w_8_16 & 0x7)
08399 == 5 &&
08400 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08401 &&
08402 (MATCH_w_8_16 >> 3 & 0x7)
08403 < 8))
08404 goto MATCH_label_c1074;
08405 else
08406 goto MATCH_label_c1073;
08407
08408 break;
08409 case 5:
08410 goto MATCH_label_c1075; break;
08411 default: assert(0);
08412 }
08413 break;
08414 case 1:
08415 MATCH_w_8_16 = getByte(2 + MATCH_p);
08416 if ((MATCH_w_8_8 & 0x7) == 4 &&
08417 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08418 &&
08419 (MATCH_w_8_16 >> 3 & 0x7)
08420 < 8)) {
08421 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08422 nextPC = 4 + MATCH_p;
08423
08424 #line 1760 "frontend/machine/pentium/decoder.m"
08425
08426
08427 stmts = instantiate(pc, "FADD.R32", DIS_MEM32);
08428
08429
08430
08431
08432
08433
08434 }
08435 else
08436 goto MATCH_label_c1073;
08437
08438 break;
08439 case 2:
08440 MATCH_w_8_16 = getByte(2 + MATCH_p);
08441 if ((MATCH_w_8_8 & 0x7) == 4 &&
08442 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08443 &&
08444 (MATCH_w_8_16 >> 3 & 0x7)
08445 < 8))
08446 goto MATCH_label_c1074;
08447 else
08448 goto MATCH_label_c1075;
08449
08450 break;
08451 case 3:
08452 {
08453 unsigned idx =
08454 (MATCH_w_8_8 & 0x7) ;
08455 nextPC = 2 + MATCH_p;
08456
08457 #line 1766 "frontend/machine/pentium/decoder.m"
08458
08459
08460 stmts = instantiate(pc, "FADD.St.STi", DIS_IDX);
08461
08462
08463
08464
08465
08466
08467 }
08468
08469 break;
08470 default: assert(0);
08471 }
08472 break;
08473 case 1:
08474
08475 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
08476 case 0:
08477
08478 switch((MATCH_w_8_8 & 0x7) ) {
08479 case 0: case 1: case 2: case 3: case 6:
08480 case 7:
08481 {
08482 unsigned Mem32 =
08483 1 + addressToPC(MATCH_p);
08484 nextPC = 2 + MATCH_p;
08485
08486 #line 1954 "frontend/machine/pentium/decoder.m"
08487
08488
08489 stmts = instantiate(pc, "FMUL.R32", DIS_MEM32);
08490
08491
08492
08493
08494
08495
08496 }
08497
08498 break;
08499 case 4:
08500 MATCH_w_8_16 = getByte(2 + MATCH_p);
08501 if ((MATCH_w_8_16 & 0x7)
08502 == 5 &&
08503 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08504 &&
08505 (MATCH_w_8_16 >> 3 & 0x7)
08506 < 8))
08507 goto MATCH_label_c1077;
08508 else
08509 goto MATCH_label_c1076;
08510
08511 break;
08512 case 5:
08513 goto MATCH_label_c1078; break;
08514 default: assert(0);
08515 }
08516 break;
08517 case 1:
08518 MATCH_w_8_16 = getByte(2 + MATCH_p);
08519 if ((MATCH_w_8_8 & 0x7) == 4 &&
08520 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08521 &&
08522 (MATCH_w_8_16 >> 3 & 0x7)
08523 < 8)) {
08524 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08525 nextPC = 4 + MATCH_p;
08526
08527 #line 1954 "frontend/machine/pentium/decoder.m"
08528
08529
08530 stmts = instantiate(pc, "FMUL.R32", DIS_MEM32);
08531
08532
08533
08534
08535
08536
08537 }
08538 else
08539 goto MATCH_label_c1076;
08540
08541 break;
08542 case 2:
08543 MATCH_w_8_16 = getByte(2 + MATCH_p);
08544 if ((MATCH_w_8_8 & 0x7) == 4 &&
08545 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08546 &&
08547 (MATCH_w_8_16 >> 3 & 0x7)
08548 < 8))
08549 goto MATCH_label_c1077;
08550 else
08551 goto MATCH_label_c1078;
08552
08553 break;
08554 case 3:
08555 {
08556 unsigned idx =
08557 (MATCH_w_8_8 & 0x7) ;
08558 nextPC = 2 + MATCH_p;
08559
08560 #line 1960 "frontend/machine/pentium/decoder.m"
08561
08562
08563 stmts = instantiate(pc, "FMUL.ST.STi", DIS_IDX);
08564
08565
08566
08567
08568
08569
08570 }
08571
08572 break;
08573 default: assert(0);
08574 }
08575 break;
08576 case 2:
08577
08578 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
08579 case 0:
08580
08581 switch((MATCH_w_8_8 & 0x7) ) {
08582 case 0: case 1: case 2: case 3: case 6:
08583 case 7:
08584 {
08585 unsigned Mem32 =
08586 1 + addressToPC(MATCH_p);
08587 nextPC = 2 + MATCH_p;
08588
08589 #line 1793 "frontend/machine/pentium/decoder.m"
08590
08591
08592 stmts = instantiate(pc, "FCOM.R32", DIS_MEM32);
08593
08594
08595
08596
08597
08598
08599 }
08600
08601 break;
08602 case 4:
08603 MATCH_w_8_16 = getByte(2 + MATCH_p);
08604 if ((MATCH_w_8_16 & 0x7)
08605 == 5 &&
08606 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08607 &&
08608 (MATCH_w_8_16 >> 3 & 0x7)
08609 < 8))
08610 goto MATCH_label_c1080;
08611 else
08612 goto MATCH_label_c1079;
08613
08614 break;
08615 case 5:
08616 goto MATCH_label_c1081; break;
08617 default: assert(0);
08618 }
08619 break;
08620 case 1:
08621 MATCH_w_8_16 = getByte(2 + MATCH_p);
08622 if ((MATCH_w_8_8 & 0x7) == 4 &&
08623 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08624 &&
08625 (MATCH_w_8_16 >> 3 & 0x7)
08626 < 8)) {
08627 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08628 nextPC = 4 + MATCH_p;
08629
08630 #line 1793 "frontend/machine/pentium/decoder.m"
08631
08632
08633 stmts = instantiate(pc, "FCOM.R32", DIS_MEM32);
08634
08635
08636
08637
08638
08639
08640 }
08641 else
08642 goto MATCH_label_c1079;
08643
08644 break;
08645 case 2:
08646 MATCH_w_8_16 = getByte(2 + MATCH_p);
08647 if ((MATCH_w_8_8 & 0x7) == 4 &&
08648 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08649 &&
08650 (MATCH_w_8_16 >> 3 & 0x7)
08651 < 8))
08652 goto MATCH_label_c1080;
08653 else
08654 goto MATCH_label_c1081;
08655
08656 break;
08657 case 3:
08658 {
08659 unsigned idx =
08660 (MATCH_w_8_8 & 0x7) ;
08661 nextPC = 2 + MATCH_p;
08662
08663 #line 1811 "frontend/machine/pentium/decoder.m"
08664
08665
08666 stmts = instantiate(pc, "FCOM.ST.STi", DIS_IDX);
08667
08668
08669
08670
08671
08672
08673 }
08674
08675 break;
08676 default: assert(0);
08677 }
08678 break;
08679 case 3:
08680
08681 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
08682 case 0:
08683
08684 switch((MATCH_w_8_8 & 0x7) ) {
08685 case 0: case 1: case 2: case 3: case 6:
08686 case 7:
08687 {
08688 unsigned Mem32 =
08689 1 + addressToPC(MATCH_p);
08690 nextPC = 2 + MATCH_p;
08691
08692 #line 1805 "frontend/machine/pentium/decoder.m"
08693
08694
08695 stmts = instantiate(pc, "FCOMP.R32", DIS_MEM32);
08696
08697
08698
08699
08700
08701
08702 }
08703
08704 break;
08705 case 4:
08706 MATCH_w_8_16 = getByte(2 + MATCH_p);
08707 if ((MATCH_w_8_16 & 0x7)
08708 == 5 &&
08709 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08710 &&
08711 (MATCH_w_8_16 >> 3 & 0x7)
08712 < 8))
08713 goto MATCH_label_c1083;
08714 else
08715 goto MATCH_label_c1082;
08716
08717 break;
08718 case 5:
08719 goto MATCH_label_c1084; break;
08720 default: assert(0);
08721 }
08722 break;
08723 case 1:
08724 MATCH_w_8_16 = getByte(2 + MATCH_p);
08725 if ((MATCH_w_8_8 & 0x7) == 4 &&
08726 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08727 &&
08728 (MATCH_w_8_16 >> 3 & 0x7)
08729 < 8)) {
08730 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08731 nextPC = 4 + MATCH_p;
08732
08733 #line 1805 "frontend/machine/pentium/decoder.m"
08734
08735
08736 stmts = instantiate(pc, "FCOMP.R32", DIS_MEM32);
08737
08738
08739
08740
08741
08742
08743 }
08744 else
08745 goto MATCH_label_c1082;
08746
08747 break;
08748 case 2:
08749 MATCH_w_8_16 = getByte(2 + MATCH_p);
08750 if ((MATCH_w_8_8 & 0x7) == 4 &&
08751 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08752 &&
08753 (MATCH_w_8_16 >> 3 & 0x7)
08754 < 8))
08755 goto MATCH_label_c1083;
08756 else
08757 goto MATCH_label_c1084;
08758
08759 break;
08760 case 3:
08761 {
08762 unsigned idx =
08763 (MATCH_w_8_8 & 0x7) ;
08764 nextPC = 2 + MATCH_p;
08765
08766 #line 1814 "frontend/machine/pentium/decoder.m"
08767
08768
08769 stmts = instantiate(pc, "FCOMP.ST.STi", DIS_IDX);
08770
08771
08772
08773
08774
08775
08776 }
08777
08778 break;
08779 default: assert(0);
08780 }
08781 break;
08782 case 4:
08783
08784 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
08785 case 0:
08786
08787 switch((MATCH_w_8_8 & 0x7) ) {
08788 case 0: case 1: case 2: case 3: case 6:
08789 case 7:
08790 {
08791 unsigned Mem32 =
08792 1 + addressToPC(MATCH_p);
08793 nextPC = 2 + MATCH_p;
08794
08795 #line 2044 "frontend/machine/pentium/decoder.m"
08796
08797
08798 stmts = instantiate(pc, "FSUB.R32", DIS_MEM32);
08799
08800
08801
08802
08803
08804
08805 }
08806
08807 break;
08808 case 4:
08809 MATCH_w_8_16 = getByte(2 + MATCH_p);
08810 if ((MATCH_w_8_16 & 0x7)
08811 == 5 &&
08812 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08813 &&
08814 (MATCH_w_8_16 >> 3 & 0x7)
08815 < 8))
08816 goto MATCH_label_c1086;
08817 else
08818 goto MATCH_label_c1085;
08819
08820 break;
08821 case 5:
08822 goto MATCH_label_c1087; break;
08823 default: assert(0);
08824 }
08825 break;
08826 case 1:
08827 MATCH_w_8_16 = getByte(2 + MATCH_p);
08828 if ((MATCH_w_8_8 & 0x7) == 4 &&
08829 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08830 &&
08831 (MATCH_w_8_16 >> 3 & 0x7)
08832 < 8)) {
08833 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08834 nextPC = 4 + MATCH_p;
08835
08836 #line 2044 "frontend/machine/pentium/decoder.m"
08837
08838
08839 stmts = instantiate(pc, "FSUB.R32", DIS_MEM32);
08840
08841
08842
08843
08844
08845
08846 }
08847 else
08848 goto MATCH_label_c1085;
08849
08850 break;
08851 case 2:
08852 MATCH_w_8_16 = getByte(2 + MATCH_p);
08853 if ((MATCH_w_8_8 & 0x7) == 4 &&
08854 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08855 &&
08856 (MATCH_w_8_16 >> 3 & 0x7)
08857 < 8))
08858 goto MATCH_label_c1086;
08859 else
08860 goto MATCH_label_c1087;
08861
08862 break;
08863 case 3:
08864 {
08865 unsigned idx =
08866 (MATCH_w_8_8 & 0x7) ;
08867 nextPC = 2 + MATCH_p;
08868
08869 #line 2050 "frontend/machine/pentium/decoder.m"
08870
08871
08872 stmts = instantiate(pc, "FSUB.ST.STi", DIS_IDX);
08873
08874
08875
08876
08877
08878
08879 }
08880
08881 break;
08882 default: assert(0);
08883 }
08884 break;
08885 case 5:
08886
08887 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
08888 case 0:
08889
08890 switch((MATCH_w_8_8 & 0x7) ) {
08891 case 0: case 1: case 2: case 3: case 6:
08892 case 7:
08893 {
08894 unsigned Mem32 =
08895 1 + addressToPC(MATCH_p);
08896 nextPC = 2 + MATCH_p;
08897
08898 #line 2065 "frontend/machine/pentium/decoder.m"
08899
08900
08901 stmts = instantiate(pc, "FSUBR.R32", DIS_MEM32);
08902
08903
08904
08905
08906
08907
08908 }
08909
08910 break;
08911 case 4:
08912 MATCH_w_8_16 = getByte(2 + MATCH_p);
08913 if ((MATCH_w_8_16 & 0x7)
08914 == 5 &&
08915 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08916 &&
08917 (MATCH_w_8_16 >> 3 & 0x7)
08918 < 8))
08919 goto MATCH_label_c1089;
08920 else
08921 goto MATCH_label_c1088;
08922
08923 break;
08924 case 5:
08925 goto MATCH_label_c1090; break;
08926 default: assert(0);
08927 }
08928 break;
08929 case 1:
08930 MATCH_w_8_16 = getByte(2 + MATCH_p);
08931 if ((MATCH_w_8_8 & 0x7) == 4 &&
08932 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08933 &&
08934 (MATCH_w_8_16 >> 3 & 0x7)
08935 < 8)) {
08936 unsigned Mem32 = 1 + addressToPC(MATCH_p);
08937 nextPC = 4 + MATCH_p;
08938
08939 #line 2065 "frontend/machine/pentium/decoder.m"
08940
08941
08942 stmts = instantiate(pc, "FSUBR.R32", DIS_MEM32);
08943
08944
08945
08946
08947
08948
08949 }
08950 else
08951 goto MATCH_label_c1088;
08952
08953 break;
08954 case 2:
08955 MATCH_w_8_16 = getByte(2 + MATCH_p);
08956 if ((MATCH_w_8_8 & 0x7) == 4 &&
08957 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
08958 &&
08959 (MATCH_w_8_16 >> 3 & 0x7)
08960 < 8))
08961 goto MATCH_label_c1089;
08962 else
08963 goto MATCH_label_c1090;
08964
08965 break;
08966 case 3:
08967 {
08968 unsigned idx =
08969 (MATCH_w_8_8 & 0x7) ;
08970 nextPC = 2 + MATCH_p;
08971
08972 #line 2071 "frontend/machine/pentium/decoder.m"
08973
08974
08975 stmts = instantiate(pc, "FSUBR.ST.STi", DIS_IDX);
08976
08977
08978
08979
08980
08981
08982 }
08983
08984 break;
08985 default: assert(0);
08986 }
08987 break;
08988 case 6:
08989
08990 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
08991 case 0:
08992
08993 switch((MATCH_w_8_8 & 0x7) ) {
08994 case 0: case 1: case 2: case 3: case 6:
08995 case 7:
08996 {
08997 unsigned Mem32 =
08998 1 + addressToPC(MATCH_p);
08999 nextPC = 2 + MATCH_p;
09000
09001 #line 1838 "frontend/machine/pentium/decoder.m"
09002
09003
09004 stmts = instantiate(pc, "FDIV.R32", DIS_MEM32);
09005
09006
09007
09008
09009
09010
09011 }
09012
09013 break;
09014 case 4:
09015 MATCH_w_8_16 = getByte(2 + MATCH_p);
09016 if ((MATCH_w_8_16 & 0x7)
09017 == 5 &&
09018 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09019 &&
09020 (MATCH_w_8_16 >> 3 & 0x7)
09021 < 8))
09022 goto MATCH_label_c1092;
09023 else
09024 goto MATCH_label_c1091;
09025
09026 break;
09027 case 5:
09028 goto MATCH_label_c1093; break;
09029 default: assert(0);
09030 }
09031 break;
09032 case 1:
09033 MATCH_w_8_16 = getByte(2 + MATCH_p);
09034 if ((MATCH_w_8_8 & 0x7) == 4 &&
09035 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09036 &&
09037 (MATCH_w_8_16 >> 3 & 0x7)
09038 < 8)) {
09039 unsigned Mem32 = 1 + addressToPC(MATCH_p);
09040 nextPC = 4 + MATCH_p;
09041
09042 #line 1838 "frontend/machine/pentium/decoder.m"
09043
09044
09045 stmts = instantiate(pc, "FDIV.R32", DIS_MEM32);
09046
09047
09048
09049
09050
09051
09052 }
09053 else
09054 goto MATCH_label_c1091;
09055
09056 break;
09057 case 2:
09058 MATCH_w_8_16 = getByte(2 + MATCH_p);
09059 if ((MATCH_w_8_8 & 0x7) == 4 &&
09060 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09061 &&
09062 (MATCH_w_8_16 >> 3 & 0x7)
09063 < 8))
09064 goto MATCH_label_c1092;
09065 else
09066 goto MATCH_label_c1093;
09067
09068 break;
09069 case 3:
09070 {
09071 unsigned idx =
09072 (MATCH_w_8_8 & 0x7) ;
09073 nextPC = 2 + MATCH_p;
09074
09075 #line 1844 "frontend/machine/pentium/decoder.m"
09076
09077
09078 stmts = instantiate(pc, "FDIV.ST.STi", DIS_IDX);
09079
09080
09081
09082
09083
09084
09085 }
09086
09087 break;
09088 default: assert(0);
09089 }
09090 break;
09091 case 7:
09092
09093 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
09094 case 0:
09095
09096 switch((MATCH_w_8_8 & 0x7) ) {
09097 case 0: case 1: case 2: case 3: case 6:
09098 case 7:
09099 {
09100 unsigned Mem32 =
09101 1 + addressToPC(MATCH_p);
09102 nextPC = 2 + MATCH_p;
09103
09104 #line 1859 "frontend/machine/pentium/decoder.m"
09105
09106
09107 stmts = instantiate(pc, "FDIVR.R32", DIS_MEM32);
09108
09109
09110
09111
09112
09113
09114 }
09115
09116 break;
09117 case 4:
09118 MATCH_w_8_16 = getByte(2 + MATCH_p);
09119 if ((MATCH_w_8_16 & 0x7)
09120 == 5 &&
09121 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09122 &&
09123 (MATCH_w_8_16 >> 3 & 0x7)
09124 < 8))
09125 goto MATCH_label_c1095;
09126 else
09127 goto MATCH_label_c1094;
09128
09129 break;
09130 case 5:
09131 goto MATCH_label_c1096; break;
09132 default: assert(0);
09133 }
09134 break;
09135 case 1:
09136 MATCH_w_8_16 = getByte(2 + MATCH_p);
09137 if ((MATCH_w_8_8 & 0x7) == 4 &&
09138 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09139 &&
09140 (MATCH_w_8_16 >> 3 & 0x7)
09141 < 8)) {
09142 unsigned Mem32 = 1 + addressToPC(MATCH_p);
09143 nextPC = 4 + MATCH_p;
09144
09145 #line 1859 "frontend/machine/pentium/decoder.m"
09146
09147
09148 stmts = instantiate(pc, "FDIVR.R32", DIS_MEM32);
09149
09150
09151
09152
09153
09154
09155 }
09156 else
09157 goto MATCH_label_c1094;
09158
09159 break;
09160 case 2:
09161 MATCH_w_8_16 = getByte(2 + MATCH_p);
09162 if ((MATCH_w_8_8 & 0x7) == 4 &&
09163 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09164 &&
09165 (MATCH_w_8_16 >> 3 & 0x7)
09166 < 8))
09167 goto MATCH_label_c1095;
09168 else
09169 goto MATCH_label_c1096;
09170
09171 break;
09172 case 3:
09173 {
09174 unsigned idx =
09175 (MATCH_w_8_8 & 0x7) ;
09176 nextPC = 2 + MATCH_p;
09177
09178 #line 1865 "frontend/machine/pentium/decoder.m"
09179
09180
09181 stmts = instantiate(pc, "FDIVR.ST.STi", DIS_IDX);
09182
09183
09184
09185
09186
09187
09188 }
09189
09190 break;
09191 default: assert(0);
09192 }
09193 break;
09194 default: assert(0);
09195 }
09196
09197 break;
09198 case 1:
09199 MATCH_w_8_8 = getByte(1 + MATCH_p);
09200
09201 switch((MATCH_w_8_8 >> 3 & 0x7) ) {
09202 case 0:
09203
09204 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
09205 case 0:
09206
09207 switch((MATCH_w_8_8 & 0x7) ) {
09208 case 0: case 1: case 2: case 3: case 6:
09209 case 7:
09210 {
09211 unsigned Mem32 =
09212 1 + addressToPC(MATCH_p);
09213 nextPC = 2 + MATCH_p;
09214
09215 #line 1910 "frontend/machine/pentium/decoder.m"
09216
09217
09218 stmts = instantiate(pc, "FLD.lsR32", DIS_MEM32);
09219
09220
09221
09222
09223
09224
09225 }
09226
09227 break;
09228 case 4:
09229 MATCH_w_8_16 = getByte(2 + MATCH_p);
09230 if ((MATCH_w_8_16 & 0x7)
09231 == 5 &&
09232 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09233 &&
09234 (MATCH_w_8_16 >> 3 & 0x7)
09235 < 8))
09236 goto MATCH_label_c1098;
09237 else
09238 goto MATCH_label_c1097;
09239
09240 break;
09241 case 5:
09242 goto MATCH_label_c1099; break;
09243 default: assert(0);
09244 }
09245 break;
09246 case 1:
09247 MATCH_w_8_16 = getByte(2 + MATCH_p);
09248 if ((MATCH_w_8_8 & 0x7) == 4 &&
09249 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09250 &&
09251 (MATCH_w_8_16 >> 3 & 0x7)
09252 < 8)) {
09253 unsigned Mem32 = 1 + addressToPC(MATCH_p);
09254 nextPC = 4 + MATCH_p;
09255
09256 #line 1910 "frontend/machine/pentium/decoder.m"
09257
09258
09259 stmts = instantiate(pc, "FLD.lsR32", DIS_MEM32);
09260
09261
09262
09263
09264
09265
09266 }
09267 else
09268 goto MATCH_label_c1097;
09269
09270 break;
09271 case 2:
09272 MATCH_w_8_16 = getByte(2 + MATCH_p);
09273 if ((MATCH_w_8_8 & 0x7) == 4 &&
09274 (0 <= (MATCH_w_8_16 >> 3 & 0x7)
09275 &&
09276 (MATCH_w_8_16 >> 3 & 0x7)
09277 < 8))
09278 goto MATCH_label_c1098;
09279 else
09280 goto MATCH_label_c1099;
09281
09282 break;
09283 case 3:
09284 {
09285 unsigned idx =
09286 (MATCH_w_8_8 & 0x7) ;
09287 nextPC = 2 + MATCH_p;
09288
09289 #line 1924 "frontend/machine/pentium/decoder.m"
09290
09291
09292 stmts = instantiate(pc, "FLD.STi", DIS_IDXP1);
09293
09294
09295
09296
09297
09298
09299 }
09300
09301 break;
09302 default: assert(0);
09303 }
09304 break;
09305 case 1:
09306 if ((MATCH_w_8_8 >> 6 & 0x3) == 3) {
09307 unsigned idx = (MATCH_w_8_8 & 0x7) ;
09308 nextPC = 2 + MATCH_p;
09309
09310 #line 2107 "frontend/machine/pentium/decoder.m"
09311
09312
09313 stmts = instantiate(pc, "FXCH", DIS_IDX);
09314
09315
09316
09317
09318
09319
09320 }
09321 else
09322 goto MATCH_label_c64;
09323
09324 break;
09325 case 2:
09326
09327 switch((MATCH_w_8_8 >> 6 & 0x3) ) {
09328 case 0:
09329
09330 switch((MATCH_w_8_8 & 0x7) ) {
09331 case 0: case 1: case 2: case 3: case 6:
09332 case 7:
09333 {
09334 unsigned Mem32 =
09335 1 + addressToPC(MATCH_p);
09336 nextPC = 2 + MATCH_p;
09337
09338 #line 2011 "frontend/machine/pentium/decoder.m"
09339
09340
09341 stmts = instantiate(pc, "FST.lsR32", DIS_MEM32);