Revision 61382a50 target-i386/translate.c
| b/target-i386/translate.c | ||
|---|---|---|
| 570 | 570 |
}; |
| 571 | 571 |
|
| 572 | 572 |
static GenOpFunc *gen_op_lds_T0_A0[3 * 3] = {
|
| 573 |
gen_op_ldsb_T0_A0, |
|
| 574 |
gen_op_ldsw_T0_A0, |
|
| 573 |
gen_op_ldsb_raw_T0_A0,
|
|
| 574 |
gen_op_ldsw_raw_T0_A0,
|
|
| 575 | 575 |
NULL, |
| 576 |
|
|
| 576 |
#ifndef CONFIG_USER_ONLY |
|
| 577 | 577 |
gen_op_ldsb_kernel_T0_A0, |
| 578 | 578 |
gen_op_ldsw_kernel_T0_A0, |
| 579 | 579 |
NULL, |
| ... | ... | |
| 581 | 581 |
gen_op_ldsb_user_T0_A0, |
| 582 | 582 |
gen_op_ldsw_user_T0_A0, |
| 583 | 583 |
NULL, |
| 584 |
#endif |
|
| 584 | 585 |
}; |
| 585 | 586 |
|
| 586 | 587 |
static GenOpFunc *gen_op_ldu_T0_A0[3 * 3] = {
|
| 587 |
gen_op_ldub_T0_A0, |
|
| 588 |
gen_op_lduw_T0_A0, |
|
| 588 |
gen_op_ldub_raw_T0_A0,
|
|
| 589 |
gen_op_lduw_raw_T0_A0,
|
|
| 589 | 590 |
NULL, |
| 590 | 591 |
|
| 592 |
#ifndef CONFIG_USER_ONLY |
|
| 591 | 593 |
gen_op_ldub_kernel_T0_A0, |
| 592 | 594 |
gen_op_lduw_kernel_T0_A0, |
| 593 | 595 |
NULL, |
| ... | ... | |
| 595 | 597 |
gen_op_ldub_user_T0_A0, |
| 596 | 598 |
gen_op_lduw_user_T0_A0, |
| 597 | 599 |
NULL, |
| 600 |
#endif |
|
| 598 | 601 |
}; |
| 599 | 602 |
|
| 600 | 603 |
/* sign does not matter, except for lidt/lgdt call (TODO: fix it) */ |
| 601 | 604 |
static GenOpFunc *gen_op_ld_T0_A0[3 * 3] = {
|
| 602 |
gen_op_ldub_T0_A0, |
|
| 603 |
gen_op_lduw_T0_A0, |
|
| 604 |
gen_op_ldl_T0_A0, |
|
| 605 |
gen_op_ldub_raw_T0_A0,
|
|
| 606 |
gen_op_lduw_raw_T0_A0,
|
|
| 607 |
gen_op_ldl_raw_T0_A0,
|
|
| 605 | 608 |
|
| 609 |
#ifndef CONFIG_USER_ONLY |
|
| 606 | 610 |
gen_op_ldub_kernel_T0_A0, |
| 607 | 611 |
gen_op_lduw_kernel_T0_A0, |
| 608 | 612 |
gen_op_ldl_kernel_T0_A0, |
| ... | ... | |
| 610 | 614 |
gen_op_ldub_user_T0_A0, |
| 611 | 615 |
gen_op_lduw_user_T0_A0, |
| 612 | 616 |
gen_op_ldl_user_T0_A0, |
| 617 |
#endif |
|
| 613 | 618 |
}; |
| 614 | 619 |
|
| 615 | 620 |
static GenOpFunc *gen_op_ld_T1_A0[3 * 3] = {
|
| 616 |
gen_op_ldub_T1_A0, |
|
| 617 |
gen_op_lduw_T1_A0, |
|
| 618 |
gen_op_ldl_T1_A0, |
|
| 621 |
gen_op_ldub_raw_T1_A0,
|
|
| 622 |
gen_op_lduw_raw_T1_A0,
|
|
| 623 |
gen_op_ldl_raw_T1_A0,
|
|
| 619 | 624 |
|
| 625 |
#ifndef CONFIG_USER_ONLY |
|
| 620 | 626 |
gen_op_ldub_kernel_T1_A0, |
| 621 | 627 |
gen_op_lduw_kernel_T1_A0, |
| 622 | 628 |
gen_op_ldl_kernel_T1_A0, |
| ... | ... | |
| 624 | 630 |
gen_op_ldub_user_T1_A0, |
| 625 | 631 |
gen_op_lduw_user_T1_A0, |
| 626 | 632 |
gen_op_ldl_user_T1_A0, |
| 633 |
#endif |
|
| 627 | 634 |
}; |
| 628 | 635 |
|
| 629 | 636 |
static GenOpFunc *gen_op_st_T0_A0[3 * 3] = {
|
| 630 |
gen_op_stb_T0_A0, |
|
| 631 |
gen_op_stw_T0_A0, |
|
| 632 |
gen_op_stl_T0_A0, |
|
| 637 |
gen_op_stb_raw_T0_A0,
|
|
| 638 |
gen_op_stw_raw_T0_A0,
|
|
| 639 |
gen_op_stl_raw_T0_A0,
|
|
| 633 | 640 |
|
| 641 |
#ifndef CONFIG_USER_ONLY |
|
| 634 | 642 |
gen_op_stb_kernel_T0_A0, |
| 635 | 643 |
gen_op_stw_kernel_T0_A0, |
| 636 | 644 |
gen_op_stl_kernel_T0_A0, |
| ... | ... | |
| 638 | 646 |
gen_op_stb_user_T0_A0, |
| 639 | 647 |
gen_op_stw_user_T0_A0, |
| 640 | 648 |
gen_op_stl_user_T0_A0, |
| 649 |
#endif |
|
| 641 | 650 |
}; |
| 642 | 651 |
|
| 643 | 652 |
static inline void gen_string_movl_A0_ESI(DisasContext *s) |
| ... | ... | |
| 1176 | 1185 |
|
| 1177 | 1186 |
if (base == 4) {
|
| 1178 | 1187 |
havesib = 1; |
| 1179 |
code = ldub(s->pc++); |
|
| 1188 |
code = ldub_code(s->pc++);
|
|
| 1180 | 1189 |
scale = (code >> 6) & 3; |
| 1181 | 1190 |
index = (code >> 3) & 7; |
| 1182 | 1191 |
base = code & 7; |
| ... | ... | |
| 1186 | 1195 |
case 0: |
| 1187 | 1196 |
if (base == 5) {
|
| 1188 | 1197 |
base = -1; |
| 1189 |
disp = ldl(s->pc); |
|
| 1198 |
disp = ldl_code(s->pc);
|
|
| 1190 | 1199 |
s->pc += 4; |
| 1191 | 1200 |
} else {
|
| 1192 | 1201 |
disp = 0; |
| 1193 | 1202 |
} |
| 1194 | 1203 |
break; |
| 1195 | 1204 |
case 1: |
| 1196 |
disp = (int8_t)ldub(s->pc++); |
|
| 1205 |
disp = (int8_t)ldub_code(s->pc++);
|
|
| 1197 | 1206 |
break; |
| 1198 | 1207 |
default: |
| 1199 | 1208 |
case 2: |
| 1200 |
disp = ldl(s->pc); |
|
| 1209 |
disp = ldl_code(s->pc);
|
|
| 1201 | 1210 |
s->pc += 4; |
| 1202 | 1211 |
break; |
| 1203 | 1212 |
} |
| ... | ... | |
| 1229 | 1238 |
switch (mod) {
|
| 1230 | 1239 |
case 0: |
| 1231 | 1240 |
if (rm == 6) {
|
| 1232 |
disp = lduw(s->pc); |
|
| 1241 |
disp = lduw_code(s->pc);
|
|
| 1233 | 1242 |
s->pc += 2; |
| 1234 | 1243 |
gen_op_movl_A0_im(disp); |
| 1235 | 1244 |
rm = 0; /* avoid SS override */ |
| ... | ... | |
| 1239 | 1248 |
} |
| 1240 | 1249 |
break; |
| 1241 | 1250 |
case 1: |
| 1242 |
disp = (int8_t)ldub(s->pc++); |
|
| 1251 |
disp = (int8_t)ldub_code(s->pc++);
|
|
| 1243 | 1252 |
break; |
| 1244 | 1253 |
default: |
| 1245 | 1254 |
case 2: |
| 1246 |
disp = lduw(s->pc); |
|
| 1255 |
disp = lduw_code(s->pc);
|
|
| 1247 | 1256 |
s->pc += 2; |
| 1248 | 1257 |
break; |
| 1249 | 1258 |
} |
| ... | ... | |
| 1337 | 1346 |
|
| 1338 | 1347 |
switch(ot) {
|
| 1339 | 1348 |
case OT_BYTE: |
| 1340 |
ret = ldub(s->pc); |
|
| 1349 |
ret = ldub_code(s->pc);
|
|
| 1341 | 1350 |
s->pc++; |
| 1342 | 1351 |
break; |
| 1343 | 1352 |
case OT_WORD: |
| 1344 |
ret = lduw(s->pc); |
|
| 1353 |
ret = lduw_code(s->pc);
|
|
| 1345 | 1354 |
s->pc += 2; |
| 1346 | 1355 |
break; |
| 1347 | 1356 |
default: |
| 1348 | 1357 |
case OT_LONG: |
| 1349 |
ret = ldl(s->pc); |
|
| 1358 |
ret = ldl_code(s->pc);
|
|
| 1350 | 1359 |
s->pc += 4; |
| 1351 | 1360 |
break; |
| 1352 | 1361 |
} |
| ... | ... | |
| 1756 | 1765 |
dflag = s->code32; |
| 1757 | 1766 |
s->override = -1; |
| 1758 | 1767 |
next_byte: |
| 1759 |
b = ldub(s->pc); |
|
| 1768 |
b = ldub_code(s->pc);
|
|
| 1760 | 1769 |
s->pc++; |
| 1761 | 1770 |
/* check prefixes */ |
| 1762 | 1771 |
switch (b) {
|
| ... | ... | |
| 1814 | 1823 |
case 0x0f: |
| 1815 | 1824 |
/**************************/ |
| 1816 | 1825 |
/* extended op code */ |
| 1817 |
b = ldub(s->pc++) | 0x100; |
|
| 1826 |
b = ldub_code(s->pc++) | 0x100;
|
|
| 1818 | 1827 |
goto reswitch; |
| 1819 | 1828 |
|
| 1820 | 1829 |
/**************************/ |
| ... | ... | |
| 1839 | 1848 |
|
| 1840 | 1849 |
switch(f) {
|
| 1841 | 1850 |
case 0: /* OP Ev, Gv */ |
| 1842 |
modrm = ldub(s->pc++); |
|
| 1851 |
modrm = ldub_code(s->pc++);
|
|
| 1843 | 1852 |
reg = ((modrm >> 3) & 7); |
| 1844 | 1853 |
mod = (modrm >> 6) & 3; |
| 1845 | 1854 |
rm = modrm & 7; |
| ... | ... | |
| 1861 | 1870 |
gen_op(s, op, ot, opreg); |
| 1862 | 1871 |
break; |
| 1863 | 1872 |
case 1: /* OP Gv, Ev */ |
| 1864 |
modrm = ldub(s->pc++); |
|
| 1873 |
modrm = ldub_code(s->pc++);
|
|
| 1865 | 1874 |
mod = (modrm >> 6) & 3; |
| 1866 | 1875 |
reg = ((modrm >> 3) & 7); |
| 1867 | 1876 |
rm = modrm & 7; |
| ... | ... | |
| 1895 | 1904 |
else |
| 1896 | 1905 |
ot = dflag ? OT_LONG : OT_WORD; |
| 1897 | 1906 |
|
| 1898 |
modrm = ldub(s->pc++); |
|
| 1907 |
modrm = ldub_code(s->pc++);
|
|
| 1899 | 1908 |
mod = (modrm >> 6) & 3; |
| 1900 | 1909 |
rm = modrm & 7; |
| 1901 | 1910 |
op = (modrm >> 3) & 7; |
| ... | ... | |
| 1939 | 1948 |
else |
| 1940 | 1949 |
ot = dflag ? OT_LONG : OT_WORD; |
| 1941 | 1950 |
|
| 1942 |
modrm = ldub(s->pc++); |
|
| 1951 |
modrm = ldub_code(s->pc++);
|
|
| 1943 | 1952 |
mod = (modrm >> 6) & 3; |
| 1944 | 1953 |
rm = modrm & 7; |
| 1945 | 1954 |
op = (modrm >> 3) & 7; |
| ... | ... | |
| 2045 | 2054 |
else |
| 2046 | 2055 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2047 | 2056 |
|
| 2048 |
modrm = ldub(s->pc++); |
|
| 2057 |
modrm = ldub_code(s->pc++);
|
|
| 2049 | 2058 |
mod = (modrm >> 6) & 3; |
| 2050 | 2059 |
rm = modrm & 7; |
| 2051 | 2060 |
op = (modrm >> 3) & 7; |
| ... | ... | |
| 2085 | 2094 |
gen_push_T0(s); |
| 2086 | 2095 |
gen_eob(s); |
| 2087 | 2096 |
break; |
| 2088 |
case 3: /*< lcall Ev */
|
|
| 2097 |
case 3: /* lcall Ev */ |
|
| 2089 | 2098 |
gen_op_ld_T1_A0[ot + s->mem_index](); |
| 2090 | 2099 |
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1)); |
| 2091 |
gen_op_ld_T0_A0[OT_WORD + s->mem_index](); |
|
| 2100 |
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
|
|
| 2092 | 2101 |
do_lcall: |
| 2093 | 2102 |
if (s->pe && !s->vm86) {
|
| 2094 | 2103 |
if (s->cc_op != CC_OP_DYNAMIC) |
| ... | ... | |
| 2109 | 2118 |
case 5: /* ljmp Ev */ |
| 2110 | 2119 |
gen_op_ld_T1_A0[ot + s->mem_index](); |
| 2111 | 2120 |
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1)); |
| 2112 |
gen_op_lduw_T0_A0();
|
|
| 2121 |
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
|
|
| 2113 | 2122 |
do_ljmp: |
| 2114 | 2123 |
if (s->pe && !s->vm86) {
|
| 2115 | 2124 |
if (s->cc_op != CC_OP_DYNAMIC) |
| ... | ... | |
| 2138 | 2147 |
else |
| 2139 | 2148 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2140 | 2149 |
|
| 2141 |
modrm = ldub(s->pc++); |
|
| 2150 |
modrm = ldub_code(s->pc++);
|
|
| 2142 | 2151 |
mod = (modrm >> 6) & 3; |
| 2143 | 2152 |
rm = modrm & 7; |
| 2144 | 2153 |
reg = (modrm >> 3) & 7; |
| ... | ... | |
| 2179 | 2188 |
case 0x69: /* imul Gv, Ev, I */ |
| 2180 | 2189 |
case 0x6b: |
| 2181 | 2190 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2182 |
modrm = ldub(s->pc++); |
|
| 2191 |
modrm = ldub_code(s->pc++);
|
|
| 2183 | 2192 |
reg = ((modrm >> 3) & 7) + OR_EAX; |
| 2184 | 2193 |
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0); |
| 2185 | 2194 |
if (b == 0x69) {
|
| ... | ... | |
| 2206 | 2215 |
ot = OT_BYTE; |
| 2207 | 2216 |
else |
| 2208 | 2217 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2209 |
modrm = ldub(s->pc++); |
|
| 2218 |
modrm = ldub_code(s->pc++);
|
|
| 2210 | 2219 |
reg = (modrm >> 3) & 7; |
| 2211 | 2220 |
mod = (modrm >> 6) & 3; |
| 2212 | 2221 |
if (mod == 3) {
|
| ... | ... | |
| 2233 | 2242 |
ot = OT_BYTE; |
| 2234 | 2243 |
else |
| 2235 | 2244 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2236 |
modrm = ldub(s->pc++); |
|
| 2245 |
modrm = ldub_code(s->pc++);
|
|
| 2237 | 2246 |
reg = (modrm >> 3) & 7; |
| 2238 | 2247 |
mod = (modrm >> 6) & 3; |
| 2239 | 2248 |
gen_op_mov_TN_reg[ot][1][reg](); |
| ... | ... | |
| 2250 | 2259 |
s->cc_op = CC_OP_SUBB + ot; |
| 2251 | 2260 |
break; |
| 2252 | 2261 |
case 0x1c7: /* cmpxchg8b */ |
| 2253 |
modrm = ldub(s->pc++); |
|
| 2262 |
modrm = ldub_code(s->pc++);
|
|
| 2254 | 2263 |
mod = (modrm >> 6) & 3; |
| 2255 | 2264 |
if (mod == 3) |
| 2256 | 2265 |
goto illegal_op; |
| ... | ... | |
| 2291 | 2300 |
break; |
| 2292 | 2301 |
case 0x8f: /* pop Ev */ |
| 2293 | 2302 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2294 |
modrm = ldub(s->pc++); |
|
| 2303 |
modrm = ldub_code(s->pc++);
|
|
| 2295 | 2304 |
gen_pop_T0(s); |
| 2296 | 2305 |
s->popl_esp_hack = 2 << dflag; |
| 2297 | 2306 |
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1); |
| ... | ... | |
| 2301 | 2310 |
case 0xc8: /* enter */ |
| 2302 | 2311 |
{
|
| 2303 | 2312 |
int level; |
| 2304 |
val = lduw(s->pc); |
|
| 2313 |
val = lduw_code(s->pc);
|
|
| 2305 | 2314 |
s->pc += 2; |
| 2306 |
level = ldub(s->pc++); |
|
| 2315 |
level = ldub_code(s->pc++);
|
|
| 2307 | 2316 |
gen_enter(s, val, level); |
| 2308 | 2317 |
} |
| 2309 | 2318 |
break; |
| ... | ... | |
| 2369 | 2378 |
ot = OT_BYTE; |
| 2370 | 2379 |
else |
| 2371 | 2380 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2372 |
modrm = ldub(s->pc++); |
|
| 2381 |
modrm = ldub_code(s->pc++);
|
|
| 2373 | 2382 |
reg = (modrm >> 3) & 7; |
| 2374 | 2383 |
|
| 2375 | 2384 |
/* generate a generic store */ |
| ... | ... | |
| 2381 | 2390 |
ot = OT_BYTE; |
| 2382 | 2391 |
else |
| 2383 | 2392 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2384 |
modrm = ldub(s->pc++); |
|
| 2393 |
modrm = ldub_code(s->pc++);
|
|
| 2385 | 2394 |
mod = (modrm >> 6) & 3; |
| 2386 | 2395 |
if (mod != 3) |
| 2387 | 2396 |
gen_lea_modrm(s, modrm, ®_addr, &offset_addr); |
| ... | ... | |
| 2398 | 2407 |
ot = OT_BYTE; |
| 2399 | 2408 |
else |
| 2400 | 2409 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2401 |
modrm = ldub(s->pc++); |
|
| 2410 |
modrm = ldub_code(s->pc++);
|
|
| 2402 | 2411 |
reg = (modrm >> 3) & 7; |
| 2403 | 2412 |
|
| 2404 | 2413 |
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0); |
| 2405 | 2414 |
gen_op_mov_reg_T0[ot][reg](); |
| 2406 | 2415 |
break; |
| 2407 | 2416 |
case 0x8e: /* mov seg, Gv */ |
| 2408 |
modrm = ldub(s->pc++); |
|
| 2417 |
modrm = ldub_code(s->pc++);
|
|
| 2409 | 2418 |
reg = (modrm >> 3) & 7; |
| 2410 | 2419 |
if (reg >= 6 || reg == R_CS) |
| 2411 | 2420 |
goto illegal_op; |
| ... | ... | |
| 2422 | 2431 |
} |
| 2423 | 2432 |
break; |
| 2424 | 2433 |
case 0x8c: /* mov Gv, seg */ |
| 2425 |
modrm = ldub(s->pc++); |
|
| 2434 |
modrm = ldub_code(s->pc++);
|
|
| 2426 | 2435 |
reg = (modrm >> 3) & 7; |
| 2427 | 2436 |
mod = (modrm >> 6) & 3; |
| 2428 | 2437 |
if (reg >= 6) |
| ... | ... | |
| 2444 | 2453 |
d_ot = dflag + OT_WORD; |
| 2445 | 2454 |
/* ot is the size of source */ |
| 2446 | 2455 |
ot = (b & 1) + OT_BYTE; |
| 2447 |
modrm = ldub(s->pc++); |
|
| 2456 |
modrm = ldub_code(s->pc++);
|
|
| 2448 | 2457 |
reg = ((modrm >> 3) & 7) + OR_EAX; |
| 2449 | 2458 |
mod = (modrm >> 6) & 3; |
| 2450 | 2459 |
rm = modrm & 7; |
| ... | ... | |
| 2481 | 2490 |
|
| 2482 | 2491 |
case 0x8d: /* lea */ |
| 2483 | 2492 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2484 |
modrm = ldub(s->pc++); |
|
| 2493 |
modrm = ldub_code(s->pc++);
|
|
| 2485 | 2494 |
reg = (modrm >> 3) & 7; |
| 2486 | 2495 |
/* we must ensure that no segment is added */ |
| 2487 | 2496 |
s->override = -1; |
| ... | ... | |
| 2574 | 2583 |
ot = OT_BYTE; |
| 2575 | 2584 |
else |
| 2576 | 2585 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2577 |
modrm = ldub(s->pc++); |
|
| 2586 |
modrm = ldub_code(s->pc++);
|
|
| 2578 | 2587 |
reg = (modrm >> 3) & 7; |
| 2579 | 2588 |
mod = (modrm >> 6) & 3; |
| 2580 | 2589 |
if (mod == 3) {
|
| ... | ... | |
| 2613 | 2622 |
op = R_GS; |
| 2614 | 2623 |
do_lxx: |
| 2615 | 2624 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2616 |
modrm = ldub(s->pc++); |
|
| 2625 |
modrm = ldub_code(s->pc++);
|
|
| 2617 | 2626 |
reg = (modrm >> 3) & 7; |
| 2618 | 2627 |
mod = (modrm >> 6) & 3; |
| 2619 | 2628 |
if (mod == 3) |
| ... | ... | |
| 2622 | 2631 |
gen_op_ld_T1_A0[ot + s->mem_index](); |
| 2623 | 2632 |
gen_op_addl_A0_im(1 << (ot - OT_WORD + 1)); |
| 2624 | 2633 |
/* load the segment first to handle exceptions properly */ |
| 2625 |
gen_op_lduw_T0_A0();
|
|
| 2634 |
gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
|
|
| 2626 | 2635 |
gen_movl_seg_T0(s, op, pc_start - s->cs_base); |
| 2627 | 2636 |
/* then put the data */ |
| 2628 | 2637 |
gen_op_mov_reg_T1[ot][reg](); |
| ... | ... | |
| 2645 | 2654 |
else |
| 2646 | 2655 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2647 | 2656 |
|
| 2648 |
modrm = ldub(s->pc++); |
|
| 2657 |
modrm = ldub_code(s->pc++);
|
|
| 2649 | 2658 |
mod = (modrm >> 6) & 3; |
| 2650 | 2659 |
rm = modrm & 7; |
| 2651 | 2660 |
op = (modrm >> 3) & 7; |
| ... | ... | |
| 2662 | 2671 |
gen_shift(s, op, ot, opreg, OR_ECX); |
| 2663 | 2672 |
} else {
|
| 2664 | 2673 |
if (shift == 2) {
|
| 2665 |
shift = ldub(s->pc++); |
|
| 2674 |
shift = ldub_code(s->pc++);
|
|
| 2666 | 2675 |
} |
| 2667 | 2676 |
gen_shifti(s, op, ot, opreg, shift); |
| 2668 | 2677 |
} |
| ... | ... | |
| 2696 | 2705 |
shift = 0; |
| 2697 | 2706 |
do_shiftd: |
| 2698 | 2707 |
ot = dflag ? OT_LONG : OT_WORD; |
| 2699 |
modrm = ldub(s->pc++); |
|
| 2708 |
modrm = ldub_code(s->pc++);
|
|
| 2700 | 2709 |
mod = (modrm >> 6) & 3; |
| 2701 | 2710 |
rm = modrm & 7; |
| 2702 | 2711 |
reg = (modrm >> 3) & 7; |
| ... | ... | |
| 2710 | 2719 |
gen_op_mov_TN_reg[ot][1][reg](); |
| 2711 | 2720 |
|
| 2712 | 2721 |
if (shift) {
|
| 2713 |
val = ldub(s->pc++); |
|
| 2722 |
val = ldub_code(s->pc++);
|
|
| 2714 | 2723 |
val &= 0x1f; |
| 2715 | 2724 |
if (val) {
|
| 2716 | 2725 |
if (mod == 3) |
| ... | ... | |
| 2739 | 2748 |
/************************/ |
| 2740 | 2749 |
/* floats */ |
| 2741 | 2750 |
case 0xd8 ... 0xdf: |
| 2742 |
modrm = ldub(s->pc++); |
|
| 2751 |
modrm = ldub_code(s->pc++);
|
|
| 2743 | 2752 |
mod = (modrm >> 6) & 3; |
| 2744 | 2753 |
rm = modrm & 7; |
| 2745 | 2754 |
op = ((b & 7) << 3) | ((modrm >> 3) & 7); |
| ... | ... | |
| 3256 | 3265 |
ot = OT_BYTE; |
| 3257 | 3266 |
else |
| 3258 | 3267 |
ot = dflag ? OT_LONG : OT_WORD; |
| 3259 |
val = ldub(s->pc++); |
|
| 3268 |
val = ldub_code(s->pc++);
|
|
| 3260 | 3269 |
gen_op_movl_T0_im(val); |
| 3261 | 3270 |
gen_op_in[ot](); |
| 3262 | 3271 |
gen_op_mov_reg_T1[ot][R_EAX](); |
| ... | ... | |
| 3271 | 3280 |
ot = OT_BYTE; |
| 3272 | 3281 |
else |
| 3273 | 3282 |
ot = dflag ? OT_LONG : OT_WORD; |
| 3274 |
val = ldub(s->pc++); |
|
| 3283 |
val = ldub_code(s->pc++);
|
|
| 3275 | 3284 |
gen_op_movl_T0_im(val); |
| 3276 | 3285 |
gen_op_mov_TN_reg[ot][1][R_EAX](); |
| 3277 | 3286 |
gen_op_out[ot](); |
| ... | ... | |
| 3309 | 3318 |
/************************/ |
| 3310 | 3319 |
/* control */ |
| 3311 | 3320 |
case 0xc2: /* ret im */ |
| 3312 |
val = ldsw(s->pc); |
|
| 3321 |
val = ldsw_code(s->pc);
|
|
| 3313 | 3322 |
s->pc += 2; |
| 3314 | 3323 |
gen_pop_T0(s); |
| 3315 | 3324 |
gen_stack_update(s, val + (2 << s->dflag)); |
| ... | ... | |
| 3327 | 3336 |
gen_eob(s); |
| 3328 | 3337 |
break; |
| 3329 | 3338 |
case 0xca: /* lret im */ |
| 3330 |
val = ldsw(s->pc); |
|
| 3339 |
val = ldsw_code(s->pc);
|
|
| 3331 | 3340 |
s->pc += 2; |
| 3332 | 3341 |
do_lret: |
| 3333 | 3342 |
if (s->pe && !s->vm86) {
|
| ... | ... | |
| 3443 | 3452 |
break; |
| 3444 | 3453 |
|
| 3445 | 3454 |
case 0x190 ... 0x19f: /* setcc Gv */ |
| 3446 |
modrm = ldub(s->pc++); |
|
| 3455 |
modrm = ldub_code(s->pc++);
|
|
| 3447 | 3456 |
gen_setcc(s, b); |
| 3448 | 3457 |
gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1); |
| 3449 | 3458 |
break; |
| 3450 | 3459 |
case 0x140 ... 0x14f: /* cmov Gv, Ev */ |
| 3451 | 3460 |
ot = dflag ? OT_LONG : OT_WORD; |
| 3452 |
modrm = ldub(s->pc++); |
|
| 3461 |
modrm = ldub_code(s->pc++);
|
|
| 3453 | 3462 |
reg = (modrm >> 3) & 7; |
| 3454 | 3463 |
mod = (modrm >> 6) & 3; |
| 3455 | 3464 |
gen_setcc(s, b); |
| ... | ... | |
| 3542 | 3551 |
/* bit operations */ |
| 3543 | 3552 |
case 0x1ba: /* bt/bts/btr/btc Gv, im */ |
| 3544 | 3553 |
ot = dflag ? OT_LONG : OT_WORD; |
| 3545 |
modrm = ldub(s->pc++); |
|
| 3554 |
modrm = ldub_code(s->pc++);
|
|
| 3546 | 3555 |
op = (modrm >> 3) & 7; |
| 3547 | 3556 |
mod = (modrm >> 6) & 3; |
| 3548 | 3557 |
rm = modrm & 7; |
| ... | ... | |
| 3553 | 3562 |
gen_op_mov_TN_reg[ot][0][rm](); |
| 3554 | 3563 |
} |
| 3555 | 3564 |
/* load shift */ |
| 3556 |
val = ldub(s->pc++); |
|
| 3565 |
val = ldub_code(s->pc++);
|
|
| 3557 | 3566 |
gen_op_movl_T1_im(val); |
| 3558 | 3567 |
if (op < 4) |
| 3559 | 3568 |
goto illegal_op; |
| ... | ... | |
| 3581 | 3590 |
op = 3; |
| 3582 | 3591 |
do_btx: |
| 3583 | 3592 |
ot = dflag ? OT_LONG : OT_WORD; |
| 3584 |
modrm = ldub(s->pc++); |
|
| 3593 |
modrm = ldub_code(s->pc++);
|
|
| 3585 | 3594 |
reg = (modrm >> 3) & 7; |
| 3586 | 3595 |
mod = (modrm >> 6) & 3; |
| 3587 | 3596 |
rm = modrm & 7; |
| ... | ... | |
| 3610 | 3619 |
case 0x1bc: /* bsf */ |
| 3611 | 3620 |
case 0x1bd: /* bsr */ |
| 3612 | 3621 |
ot = dflag ? OT_LONG : OT_WORD; |
| 3613 |
modrm = ldub(s->pc++); |
|
| 3622 |
modrm = ldub_code(s->pc++);
|
|
| 3614 | 3623 |
reg = (modrm >> 3) & 7; |
| 3615 | 3624 |
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0); |
| 3616 | 3625 |
gen_op_bsx_T0_cc[ot - OT_WORD][b & 1](); |
| ... | ... | |
| 3646 | 3655 |
s->cc_op = CC_OP_EFLAGS; |
| 3647 | 3656 |
break; |
| 3648 | 3657 |
case 0xd4: /* aam */ |
| 3649 |
val = ldub(s->pc++); |
|
| 3658 |
val = ldub_code(s->pc++);
|
|
| 3650 | 3659 |
gen_op_aam(val); |
| 3651 | 3660 |
s->cc_op = CC_OP_LOGICB; |
| 3652 | 3661 |
break; |
| 3653 | 3662 |
case 0xd5: /* aad */ |
| 3654 |
val = ldub(s->pc++); |
|
| 3663 |
val = ldub_code(s->pc++);
|
|
| 3655 | 3664 |
gen_op_aad(val); |
| 3656 | 3665 |
s->cc_op = CC_OP_LOGICB; |
| 3657 | 3666 |
break; |
| ... | ... | |
| 3665 | 3674 |
gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base); |
| 3666 | 3675 |
break; |
| 3667 | 3676 |
case 0xcd: /* int N */ |
| 3668 |
val = ldub(s->pc++); |
|
| 3677 |
val = ldub_code(s->pc++);
|
|
| 3669 | 3678 |
/* XXX: add error code for vm86 GPF */ |
| 3670 | 3679 |
if (!s->vm86) |
| 3671 | 3680 |
gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base); |
| ... | ... | |
| 3718 | 3727 |
break; |
| 3719 | 3728 |
case 0x62: /* bound */ |
| 3720 | 3729 |
ot = dflag ? OT_LONG : OT_WORD; |
| 3721 |
modrm = ldub(s->pc++); |
|
| 3730 |
modrm = ldub_code(s->pc++);
|
|
| 3722 | 3731 |
reg = (modrm >> 3) & 7; |
| 3723 | 3732 |
mod = (modrm >> 6) & 3; |
| 3724 | 3733 |
if (mod == 3) |
| ... | ... | |
| 3785 | 3794 |
} |
| 3786 | 3795 |
break; |
| 3787 | 3796 |
case 0x100: |
| 3788 |
modrm = ldub(s->pc++); |
|
| 3797 |
modrm = ldub_code(s->pc++);
|
|
| 3789 | 3798 |
mod = (modrm >> 6) & 3; |
| 3790 | 3799 |
op = (modrm >> 3) & 7; |
| 3791 | 3800 |
switch(op) {
|
| ... | ... | |
| 3828 | 3837 |
} |
| 3829 | 3838 |
break; |
| 3830 | 3839 |
case 0x101: |
| 3831 |
modrm = ldub(s->pc++); |
|
| 3840 |
modrm = ldub_code(s->pc++);
|
|
| 3832 | 3841 |
mod = (modrm >> 6) & 3; |
| 3833 | 3842 |
op = (modrm >> 3) & 7; |
| 3834 | 3843 |
switch(op) {
|
| ... | ... | |
| 3904 | 3913 |
if (!s->pe || s->vm86) |
| 3905 | 3914 |
goto illegal_op; |
| 3906 | 3915 |
ot = dflag ? OT_LONG : OT_WORD; |
| 3907 |
modrm = ldub(s->pc++); |
|
| 3916 |
modrm = ldub_code(s->pc++);
|
|
| 3908 | 3917 |
reg = (modrm >> 3) & 7; |
| 3909 | 3918 |
gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0); |
| 3910 | 3919 |
gen_op_mov_TN_reg[ot][1][reg](); |
| ... | ... | |
| 3918 | 3927 |
gen_op_mov_reg_T1[ot][reg](); |
| 3919 | 3928 |
break; |
| 3920 | 3929 |
case 0x118: |
| 3921 |
modrm = ldub(s->pc++); |
|
| 3930 |
modrm = ldub_code(s->pc++);
|
|
| 3922 | 3931 |
mod = (modrm >> 6) & 3; |
| 3923 | 3932 |
op = (modrm >> 3) & 7; |
| 3924 | 3933 |
switch(op) {
|
| ... | ... | |
| 3940 | 3949 |
if (s->cpl != 0) {
|
| 3941 | 3950 |
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base); |
| 3942 | 3951 |
} else {
|
| 3943 |
modrm = ldub(s->pc++); |
|
| 3952 |
modrm = ldub_code(s->pc++);
|
|
| 3944 | 3953 |
if ((modrm & 0xc0) != 0xc0) |
| 3945 | 3954 |
goto illegal_op; |
| 3946 | 3955 |
rm = modrm & 7; |
| ... | ... | |
| 3970 | 3979 |
if (s->cpl != 0) {
|
| 3971 | 3980 |
gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base); |
| 3972 | 3981 |
} else {
|
| 3973 |
modrm = ldub(s->pc++); |
|
| 3982 |
modrm = ldub_code(s->pc++);
|
|
| 3974 | 3983 |
if ((modrm & 0xc0) != 0xc0) |
| 3975 | 3984 |
goto illegal_op; |
| 3976 | 3985 |
rm = modrm & 7; |
Also available in: Unified diff