]> git.proxmox.com Git - qemu.git/blame - ops_template.h
projects / qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
added vm86.c
[qemu.git] / ops_template.h
CommitLineData
66fb9763
FB		 1/*
2 * i386 micro operations (included several times to generate
3 * different operand sizes)
4 *
5 * Copyright (c) 2003 Fabrice Bellard
6 *
d691f669
FB		 7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2 of the License, or (at your option) any later version.
66fb9763 11 *
d691f669
FB		 12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
66fb9763 16 *
d691f669
FB		 17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
66fb9763 20 */
367e86e8
FB		 21#define DATA_BITS (1 << (3 + SHIFT))
22#define SHIFT_MASK (DATA_BITS - 1)
23#define SIGN_MASK (1 << (DATA_BITS - 1))
24
25#if DATA_BITS == 8
26#define SUFFIX b
27#define DATA_TYPE uint8_t
28#define DATA_STYPE int8_t
29#define DATA_MASK 0xff
30#elif DATA_BITS == 16
31#define SUFFIX w
32#define DATA_TYPE uint16_t
33#define DATA_STYPE int16_t
34#define DATA_MASK 0xffff
35#elif DATA_BITS == 32
36#define SUFFIX l
37#define DATA_TYPE uint32_t
38#define DATA_STYPE int32_t
39#define DATA_MASK 0xffffffff
40#else
41#error unhandled operand size
42#endif
43
44/* dynamic flags computation */
45
46static int glue(compute_all_add, SUFFIX)(void)
47{
48 int cf, pf, af, zf, sf, of;
49 int src1, src2;
50 src1 = CC_SRC;
51 src2 = CC_DST - CC_SRC;
52 cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
53 pf = parity_table[(uint8_t)CC_DST];
54 af = (CC_DST ^ src1 ^ src2) & 0x10;
4b74fe1f 55 zf = ((DATA_TYPE)CC_DST == 0) << 6;
367e86e8
FB		 56 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
57 of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
58 return cf | pf | af | zf | sf | of;
59}
60
61static int glue(compute_c_add, SUFFIX)(void)
62{
63 int src1, cf;
64 src1 = CC_SRC;
65 cf = (DATA_TYPE)CC_DST < (DATA_TYPE)src1;
66 return cf;
67}
68
4b74fe1f
FB		 69static int glue(compute_all_adc, SUFFIX)(void)
70{
71 int cf, pf, af, zf, sf, of;
72 int src1, src2;
73 src1 = CC_SRC;
74 src2 = CC_DST - CC_SRC - 1;
75 cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
76 pf = parity_table[(uint8_t)CC_DST];
77 af = (CC_DST ^ src1 ^ src2) & 0x10;
78 zf = ((DATA_TYPE)CC_DST == 0) << 6;
79 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
80 of = lshift((src1 ^ src2 ^ -1) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
81 return cf | pf | af | zf | sf | of;
82}
83
84static int glue(compute_c_adc, SUFFIX)(void)
85{
86 int src1, cf;
87 src1 = CC_SRC;
88 cf = (DATA_TYPE)CC_DST <= (DATA_TYPE)src1;
89 return cf;
90}
91
367e86e8
FB		 92static int glue(compute_all_sub, SUFFIX)(void)
93{
94 int cf, pf, af, zf, sf, of;
95 int src1, src2;
96 src1 = CC_SRC;
97 src2 = CC_SRC - CC_DST;
98 cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
99 pf = parity_table[(uint8_t)CC_DST];
100 af = (CC_DST ^ src1 ^ src2) & 0x10;
4b74fe1f 101 zf = ((DATA_TYPE)CC_DST == 0) << 6;
367e86e8 102 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
4b74fe1f 103 of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
367e86e8
FB		 104 return cf | pf | af | zf | sf | of;
105}
106
107static int glue(compute_c_sub, SUFFIX)(void)
108{
109 int src1, src2, cf;
110 src1 = CC_SRC;
111 src2 = CC_SRC - CC_DST;
4b74fe1f
FB		 112 cf = (DATA_TYPE)src1 < (DATA_TYPE)src2;
113 return cf;
114}
115
116static int glue(compute_all_sbb, SUFFIX)(void)
117{
118 int cf, pf, af, zf, sf, of;
119 int src1, src2;
120 src1 = CC_SRC;
121 src2 = CC_SRC - CC_DST - 1;
122 cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
123 pf = parity_table[(uint8_t)CC_DST];
124 af = (CC_DST ^ src1 ^ src2) & 0x10;
125 zf = ((DATA_TYPE)CC_DST == 0) << 6;
126 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
127 of = lshift((src1 ^ src2) & (src1 ^ CC_DST), 12 - DATA_BITS) & CC_O;
128 return cf | pf | af | zf | sf | of;
129}
130
131static int glue(compute_c_sbb, SUFFIX)(void)
132{
133 int src1, src2, cf;
134 src1 = CC_SRC;
135 src2 = CC_SRC - CC_DST - 1;
136 cf = (DATA_TYPE)src1 <= (DATA_TYPE)src2;
367e86e8
FB		 137 return cf;
138}
139
140static int glue(compute_all_logic, SUFFIX)(void)
141{
142 int cf, pf, af, zf, sf, of;
143 cf = 0;
144 pf = parity_table[(uint8_t)CC_DST];
145 af = 0;
4b74fe1f 146 zf = ((DATA_TYPE)CC_DST == 0) << 6;
367e86e8
FB		 147 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
148 of = 0;
149 return cf | pf | af | zf | sf | of;
150}
151
152static int glue(compute_c_logic, SUFFIX)(void)
153{
154 return 0;
155}
156
157static int glue(compute_all_inc, SUFFIX)(void)
158{
159 int cf, pf, af, zf, sf, of;
160 int src1, src2;
161 src1 = CC_DST - 1;
162 src2 = 1;
163 cf = CC_SRC;
164 pf = parity_table[(uint8_t)CC_DST];
165 af = (CC_DST ^ src1 ^ src2) & 0x10;
4b74fe1f 166 zf = ((DATA_TYPE)CC_DST == 0) << 6;
367e86e8 167 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
4b74fe1f 168 of = ((CC_DST & DATA_MASK) == SIGN_MASK) << 11;
367e86e8
FB		 169 return cf | pf | af | zf | sf | of;
170}
171
4b74fe1f 172#if DATA_BITS == 32
367e86e8
FB		 173static int glue(compute_c_inc, SUFFIX)(void)
174{
175 return CC_SRC;
176}
4b74fe1f 177#endif
367e86e8
FB		 178
179static int glue(compute_all_dec, SUFFIX)(void)
180{
181 int cf, pf, af, zf, sf, of;
182 int src1, src2;
183 src1 = CC_DST + 1;
184 src2 = 1;
185 cf = CC_SRC;
186 pf = parity_table[(uint8_t)CC_DST];
187 af = (CC_DST ^ src1 ^ src2) & 0x10;
4b74fe1f 188 zf = ((DATA_TYPE)CC_DST == 0) << 6;
367e86e8 189 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
4b74fe1f 190 of = ((CC_DST & DATA_MASK) == ((uint32_t)SIGN_MASK - 1)) << 11;
367e86e8
FB		 191 return cf | pf | af | zf | sf | of;
192}
193
194static int glue(compute_all_shl, SUFFIX)(void)
195{
196 int cf, pf, af, zf, sf, of;
d57c4e01 197 cf = (CC_SRC >> (DATA_BITS - 1)) & CC_C;
367e86e8
FB		 198 pf = parity_table[(uint8_t)CC_DST];
199 af = 0; /* undefined */
4b74fe1f 200 zf = ((DATA_TYPE)CC_DST == 0) << 6;
367e86e8 201 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
d57c4e01
FB		 202 /* of is defined if shift count == 1 */
203 of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O;
367e86e8
FB		 204 return cf | pf | af | zf | sf | of;
205}
206
4b74fe1f 207#if DATA_BITS == 32
367e86e8
FB		 208static int glue(compute_c_shl, SUFFIX)(void)
209{
210 return CC_SRC & 1;
211}
4b74fe1f
FB		 212#endif
213
214static int glue(compute_all_sar, SUFFIX)(void)
215{
216 int cf, pf, af, zf, sf, of;
217 cf = CC_SRC & 1;
218 pf = parity_table[(uint8_t)CC_DST];
219 af = 0; /* undefined */
220 zf = ((DATA_TYPE)CC_DST == 0) << 6;
221 sf = lshift(CC_DST, 8 - DATA_BITS) & 0x80;
d57c4e01
FB		 222 /* of is defined if shift count == 1 */
223 of = lshift(CC_SRC ^ CC_DST, 12 - DATA_BITS) & CC_O;
4b74fe1f
FB		 224 return cf | pf | af | zf | sf | of;
225}
367e86e8
FB		 226
227/* various optimized jumps cases */
228
229void OPPROTO glue(op_jb_sub, SUFFIX)(void)
230{
231 int src1, src2;
232 src1 = CC_SRC;
233 src2 = CC_SRC - CC_DST;
234
235 if ((DATA_TYPE)src1 < (DATA_TYPE)src2)
dab2ed99 236 EIP = PARAM1;
367e86e8 237 else
dab2ed99 238 EIP = PARAM2;
367e86e8
FB		 239 FORCE_RET();
240}
241
242void OPPROTO glue(op_jz_sub, SUFFIX)(void)
243{
4b74fe1f 244 if ((DATA_TYPE)CC_DST == 0)
dab2ed99 245 EIP = PARAM1;
367e86e8 246 else
dab2ed99 247 EIP = PARAM2;
367e86e8
FB		 248 FORCE_RET();
249}
250
251void OPPROTO glue(op_jbe_sub, SUFFIX)(void)
252{
253 int src1, src2;
254 src1 = CC_SRC;
255 src2 = CC_SRC - CC_DST;
256
257 if ((DATA_TYPE)src1 <= (DATA_TYPE)src2)
dab2ed99 258 EIP = PARAM1;
367e86e8 259 else
dab2ed99 260 EIP = PARAM2;
367e86e8
FB		 261 FORCE_RET();
262}
263
264void OPPROTO glue(op_js_sub, SUFFIX)(void)
265{
266 if (CC_DST & SIGN_MASK)
dab2ed99 267 EIP = PARAM1;
367e86e8 268 else
dab2ed99 269 EIP = PARAM2;
367e86e8
FB		 270 FORCE_RET();
271}
272
273void OPPROTO glue(op_jl_sub, SUFFIX)(void)
274{
275 int src1, src2;
276 src1 = CC_SRC;
277 src2 = CC_SRC - CC_DST;
278
279 if ((DATA_STYPE)src1 < (DATA_STYPE)src2)
dab2ed99 280 EIP = PARAM1;
367e86e8 281 else
dab2ed99 282 EIP = PARAM2;
367e86e8
FB		 283 FORCE_RET();
284}
285
286void OPPROTO glue(op_jle_sub, SUFFIX)(void)
287{
288 int src1, src2;
289 src1 = CC_SRC;
290 src2 = CC_SRC - CC_DST;
291
292 if ((DATA_STYPE)src1 <= (DATA_STYPE)src2)
dab2ed99 293 EIP = PARAM1;
367e86e8 294 else
dab2ed99 295 EIP = PARAM2;
367e86e8
FB		 296 FORCE_RET();
297}
298
1a9353d2
FB		 299/* oldies */
300
301#if DATA_BITS >= 16
302
303void OPPROTO glue(op_loopnz, SUFFIX)(void)
304{
305 unsigned int tmp;
306 int eflags;
307 eflags = cc_table[CC_OP].compute_all();
308 tmp = (ECX - 1) & DATA_MASK;
309 ECX = (ECX & ~DATA_MASK) | tmp;
310 if (tmp != 0 && !(eflags & CC_Z))
dab2ed99 311 EIP = PARAM1;
1a9353d2 312 else
dab2ed99 313 EIP = PARAM2;
1a9353d2
FB		 314 FORCE_RET();
315}
316
317void OPPROTO glue(op_loopz, SUFFIX)(void)
318{
319 unsigned int tmp;
320 int eflags;
321 eflags = cc_table[CC_OP].compute_all();
322 tmp = (ECX - 1) & DATA_MASK;
323 ECX = (ECX & ~DATA_MASK) | tmp;
324 if (tmp != 0 && (eflags & CC_Z))
dab2ed99 325 EIP = PARAM1;
1a9353d2 326 else
dab2ed99 327 EIP = PARAM2;
1a9353d2
FB		 328 FORCE_RET();
329}
330
331void OPPROTO glue(op_loop, SUFFIX)(void)
332{
333 unsigned int tmp;
334 tmp = (ECX - 1) & DATA_MASK;
335 ECX = (ECX & ~DATA_MASK) | tmp;
336 if (tmp != 0)
dab2ed99 337 EIP = PARAM1;
1a9353d2 338 else
dab2ed99 339 EIP = PARAM2;
1a9353d2
FB		 340 FORCE_RET();
341}
342
343void OPPROTO glue(op_jecxz, SUFFIX)(void)
344{
345 if ((DATA_TYPE)ECX == 0)
dab2ed99 346 EIP = PARAM1;
1a9353d2 347 else
dab2ed99 348 EIP = PARAM2;
1a9353d2
FB		 349 FORCE_RET();
350}
351
352#endif
353
367e86e8
FB		 354/* various optimized set cases */
355
356void OPPROTO glue(op_setb_T0_sub, SUFFIX)(void)
357{
358 int src1, src2;
359 src1 = CC_SRC;
360 src2 = CC_SRC - CC_DST;
361
362 T0 = ((DATA_TYPE)src1 < (DATA_TYPE)src2);
363}
364
365void OPPROTO glue(op_setz_T0_sub, SUFFIX)(void)
366{
4b74fe1f 367 T0 = ((DATA_TYPE)CC_DST == 0);
367e86e8
FB		 368}
369
370void OPPROTO glue(op_setbe_T0_sub, SUFFIX)(void)
371{
372 int src1, src2;
373 src1 = CC_SRC;
374 src2 = CC_SRC - CC_DST;
375
376 T0 = ((DATA_TYPE)src1 <= (DATA_TYPE)src2);
377}
378
379void OPPROTO glue(op_sets_T0_sub, SUFFIX)(void)
380{
381 T0 = lshift(CC_DST, -(DATA_BITS - 1)) & 1;
382}
383
384void OPPROTO glue(op_setl_T0_sub, SUFFIX)(void)
385{
386 int src1, src2;
387 src1 = CC_SRC;
388 src2 = CC_SRC - CC_DST;
389
390 T0 = ((DATA_STYPE)src1 < (DATA_STYPE)src2);
391}
392
393void OPPROTO glue(op_setle_T0_sub, SUFFIX)(void)
394{
395 int src1, src2;
396 src1 = CC_SRC;
397 src2 = CC_SRC - CC_DST;
398
399 T0 = ((DATA_STYPE)src1 <= (DATA_STYPE)src2);
400}
401
402/* shifts */
403
404void OPPROTO glue(glue(op_rol, SUFFIX), _T0_T1_cc)(void)
405{
406 int count, src;
407 count = T1 & SHIFT_MASK;
408 if (count) {
409 CC_SRC = cc_table[CC_OP].compute_all() & ~(CC_O | CC_C);
410 src = T0;
411 T0 &= DATA_MASK;
412 T0 = (T0 << count) | (T0 >> (DATA_BITS - count));
413 CC_SRC |= (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) |
414 (T0 & CC_C);
415 CC_OP = CC_OP_EFLAGS;
416 }
4b74fe1f 417 FORCE_RET();
367e86e8
FB		 418}
419
dc99065b
FB		 420void OPPROTO glue(glue(op_rol, SUFFIX), _T0_T1)(void)
421{
422 int count;
423 count = T1 & SHIFT_MASK;
424 if (count) {
425 T0 &= DATA_MASK;
426 T0 = (T0 << count) | (T0 >> (DATA_BITS - count));
427 }
428 FORCE_RET();
429}
430
367e86e8
FB		 431void OPPROTO glue(glue(op_ror, SUFFIX), _T0_T1_cc)(void)
432{
433 int count, src;
434 count = T1 & SHIFT_MASK;
435 if (count) {
436 CC_SRC = cc_table[CC_OP].compute_all() & ~(CC_O | CC_C);
437 src = T0;
438 T0 &= DATA_MASK;
439 T0 = (T0 >> count) | (T0 << (DATA_BITS - count));
440 CC_SRC |= (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) |
441 ((T0 >> (DATA_BITS - 1)) & CC_C);
442 CC_OP = CC_OP_EFLAGS;
443 }
4b74fe1f 444 FORCE_RET();
367e86e8
FB		 445}
446
dc99065b
FB		 447void OPPROTO glue(glue(op_ror, SUFFIX), _T0_T1)(void)
448{
449 int count;
450 count = T1 & SHIFT_MASK;
451 if (count) {
452 T0 &= DATA_MASK;
453 T0 = (T0 >> count) | (T0 << (DATA_BITS - count));
454 }
455 FORCE_RET();
456}
457
367e86e8
FB		 458void OPPROTO glue(glue(op_rcl, SUFFIX), _T0_T1_cc)(void)
459{
460 int count, res, eflags;
461 unsigned int src;
462
463 count = T1 & 0x1f;
464#if DATA_BITS == 16
465 count = rclw_table[count];
466#elif DATA_BITS == 8
467 count = rclb_table[count];
468#endif
469 if (count) {
470 eflags = cc_table[CC_OP].compute_all();
4b74fe1f 471 T0 &= DATA_MASK;
367e86e8
FB		 472 src = T0;
473 res = (T0 << count) | ((eflags & CC_C) << (count - 1));
474 if (count > 1)
475 res |= T0 >> (DATA_BITS + 1 - count);
476 T0 = res;
477 CC_SRC = (eflags & ~(CC_C | CC_O)) |
478 (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) |
479 ((src >> (DATA_BITS - count)) & CC_C);
480 CC_OP = CC_OP_EFLAGS;
481 }
4b74fe1f 482 FORCE_RET();
367e86e8
FB		 483}
484
485void OPPROTO glue(glue(op_rcr, SUFFIX), _T0_T1_cc)(void)
486{
487 int count, res, eflags;
488 unsigned int src;
489
490 count = T1 & 0x1f;
491#if DATA_BITS == 16
492 count = rclw_table[count];
493#elif DATA_BITS == 8
494 count = rclb_table[count];
495#endif
496 if (count) {
497 eflags = cc_table[CC_OP].compute_all();
4b74fe1f 498 T0 &= DATA_MASK;
367e86e8
FB		 499 src = T0;
500 res = (T0 >> count) | ((eflags & CC_C) << (DATA_BITS - count));
501 if (count > 1)
502 res |= T0 << (DATA_BITS + 1 - count);
503 T0 = res;
504 CC_SRC = (eflags & ~(CC_C | CC_O)) |
505 (lshift(src ^ T0, 11 - (DATA_BITS - 1)) & CC_O) |
506 ((src >> (count - 1)) & CC_C);
507 CC_OP = CC_OP_EFLAGS;
508 }
4b74fe1f 509 FORCE_RET();
367e86e8
FB		 510}
511
512void OPPROTO glue(glue(op_shl, SUFFIX), _T0_T1_cc)(void)
513{
514 int count;
515 count = T1 & 0x1f;
d57c4e01
FB		 516 if (count) {
517 CC_SRC = (DATA_TYPE)T0 << (count - 1);
367e86e8
FB		 518 T0 = T0 << count;
519 CC_DST = T0;
520 CC_OP = CC_OP_SHLB + SHIFT;
521 }
4b74fe1f 522 FORCE_RET();
367e86e8
FB		 523}
524
dc99065b
FB		 525void OPPROTO glue(glue(op_shl, SUFFIX), _T0_T1)(void)
526{
527 int count;
528 count = T1 & 0x1f;
529 T0 = T0 << count;
530 FORCE_RET();
531}
532
367e86e8
FB		 533void OPPROTO glue(glue(op_shr, SUFFIX), _T0_T1_cc)(void)
534{
535 int count;
536 count = T1 & 0x1f;
537 if (count) {
538 T0 &= DATA_MASK;
539 CC_SRC = T0 >> (count - 1);
540 T0 = T0 >> count;
541 CC_DST = T0;
d57c4e01 542 CC_OP = CC_OP_SARB + SHIFT;
367e86e8 543 }
4b74fe1f 544 FORCE_RET();
367e86e8
FB		 545}
546
dc99065b
FB		 547void OPPROTO glue(glue(op_shr, SUFFIX), _T0_T1)(void)
548{
549 int count;
550 count = T1 & 0x1f;
551 T0 &= DATA_MASK;
552 T0 = T0 >> count;
553 FORCE_RET();
554}
555
367e86e8
FB		 556void OPPROTO glue(glue(op_sar, SUFFIX), _T0_T1_cc)(void)
557{
558 int count, src;
559 count = T1 & 0x1f;
560 if (count) {
561 src = (DATA_STYPE)T0;
d57c4e01 562 CC_SRC = src >> (count - 1);
367e86e8
FB		 563 T0 = src >> count;
564 CC_DST = T0;
4b74fe1f 565 CC_OP = CC_OP_SARB + SHIFT;
367e86e8 566 }
4b74fe1f 567 FORCE_RET();
367e86e8
FB		 568}
569
dc99065b
FB		 570void OPPROTO glue(glue(op_sar, SUFFIX), _T0_T1)(void)
571{
572 int count, src;
573 count = T1 & 0x1f;
574 src = (DATA_STYPE)T0;
575 T0 = src >> count;
576 FORCE_RET();
577}
578
d57c4e01
FB		 579#if DATA_BITS == 16
580/* XXX: overflow flag might be incorrect in some cases in shldw */
581void OPPROTO glue(glue(op_shld, SUFFIX), _T0_T1_im_cc)(void)
582{
583 int count;
584 unsigned int res;
585 count = PARAM1;
586 T1 &= 0xffff;
587 res = T1 | (T0 << 16);
588 CC_SRC = res >> (32 - count);
589 res <<= count;
590 if (count > 16)
591 res |= T1 << (count - 16);
592 T0 = res >> 16;
593 CC_DST = T0;
594}
595
596void OPPROTO glue(glue(op_shld, SUFFIX), _T0_T1_ECX_cc)(void)
597{
598 int count;
599 unsigned int res;
600 count = ECX & 0x1f;
601 if (count) {
602 T1 &= 0xffff;
603 res = T1 | (T0 << 16);
604 CC_SRC = res >> (32 - count);
605 res <<= count;
606 if (count > 16)
607 res |= T1 << (count - 16);
608 T0 = res >> 16;
609 CC_DST = T0;
610 CC_OP = CC_OP_SARB + SHIFT;
611 }
7fe70ecc 612 FORCE_RET();
d57c4e01
FB		 613}
614
615void OPPROTO glue(glue(op_shrd, SUFFIX), _T0_T1_im_cc)(void)
616{
617 int count;
618 unsigned int res;
619
620 count = PARAM1;
621 res = (T0 & 0xffff) | (T1 << 16);
622 CC_SRC = res >> (count - 1);
623 res >>= count;
624 if (count > 16)
625 res |= T1 << (32 - count);
626 T0 = res;
627 CC_DST = T0;
628}
629
630
631void OPPROTO glue(glue(op_shrd, SUFFIX), _T0_T1_ECX_cc)(void)
632{
633 int count;
634 unsigned int res;
635
636 count = ECX & 0x1f;
637 if (count) {
638 res = (T0 & 0xffff) | (T1 << 16);
639 CC_SRC = res >> (count - 1);
640 res >>= count;
641 if (count > 16)
642 res |= T1 << (32 - count);
643 T0 = res;
644 CC_DST = T0;
645 CC_OP = CC_OP_SARB + SHIFT;
646 }
7fe70ecc 647 FORCE_RET();
d57c4e01
FB		 648}
649#endif
650
651#if DATA_BITS == 32
652void OPPROTO glue(glue(op_shld, SUFFIX), _T0_T1_im_cc)(void)
653{
654 int count;
655 count = PARAM1;
656 T0 &= DATA_MASK;
657 T1 &= DATA_MASK;
658 CC_SRC = T0 << (count - 1);
659 T0 = (T0 << count) | (T1 >> (DATA_BITS - count));
660 CC_DST = T0;
661}
662
663void OPPROTO glue(glue(op_shld, SUFFIX), _T0_T1_ECX_cc)(void)
664{
665 int count;
666 count = ECX & 0x1f;
667 if (count) {
668 T0 &= DATA_MASK;
669 T1 &= DATA_MASK;
670 CC_SRC = T0 << (count - 1);
671 T0 = (T0 << count) | (T1 >> (DATA_BITS - count));
672 CC_DST = T0;
673 CC_OP = CC_OP_SHLB + SHIFT;
674 }
7fe70ecc 675 FORCE_RET();
d57c4e01
FB		 676}
677
678void OPPROTO glue(glue(op_shrd, SUFFIX), _T0_T1_im_cc)(void)
679{
680 int count;
681 count = PARAM1;
682 T0 &= DATA_MASK;
683 T1 &= DATA_MASK;
684 CC_SRC = T0 >> (count - 1);
685 T0 = (T0 >> count) | (T1 << (DATA_BITS - count));
686 CC_DST = T0;
687}
688
689
690void OPPROTO glue(glue(op_shrd, SUFFIX), _T0_T1_ECX_cc)(void)
691{
692 int count;
693 count = ECX & 0x1f;
694 if (count) {
695 T0 &= DATA_MASK;
696 T1 &= DATA_MASK;
697 CC_SRC = T0 >> (count - 1);
698 T0 = (T0 >> count) | (T1 << (DATA_BITS - count));
699 CC_DST = T0;
700 CC_OP = CC_OP_SARB + SHIFT;
701 }
7fe70ecc 702 FORCE_RET();
d57c4e01
FB		 703}
704#endif
705
4b74fe1f
FB		 706/* carry add/sub (we only need to set CC_OP differently) */
707
708void OPPROTO glue(glue(op_adc, SUFFIX), _T0_T1_cc)(void)
709{
710 int cf;
711 cf = cc_table[CC_OP].compute_c();
712 CC_SRC = T0;
713 T0 = T0 + T1 + cf;
714 CC_DST = T0;
715 CC_OP = CC_OP_ADDB + SHIFT + cf * 3;
716}
717
718void OPPROTO glue(glue(op_sbb, SUFFIX), _T0_T1_cc)(void)
719{
720 int cf;
721 cf = cc_table[CC_OP].compute_c();
722 CC_SRC = T0;
723 T0 = T0 - T1 - cf;
724 CC_DST = T0;
725 CC_OP = CC_OP_SUBB + SHIFT + cf * 3;
726}
727
1a9353d2
FB		 728void OPPROTO glue(glue(op_cmpxchg, SUFFIX), _T0_T1_EAX_cc)(void)
729{
730 CC_SRC = EAX;
731 CC_DST = EAX - T0;
732 if ((DATA_TYPE)CC_DST == 0) {
733 T0 = T1;
734 } else {
735 EAX = (EAX & ~DATA_MASK) | (T0 & DATA_MASK);
736 }
737 FORCE_RET();
738}
739
4b74fe1f
FB		 740/* bit operations */
741#if DATA_BITS >= 16
742
743void OPPROTO glue(glue(op_bt, SUFFIX), _T0_T1_cc)(void)
744{
745 int count;
746 count = T1 & SHIFT_MASK;
747 CC_SRC = T0 >> count;
748}
749
750void OPPROTO glue(glue(op_bts, SUFFIX), _T0_T1_cc)(void)
751{
752 int count;
753 count = T1 & SHIFT_MASK;
754 CC_SRC = T0 >> count;
755 T0 |= (1 << count);
756}
757
758void OPPROTO glue(glue(op_btr, SUFFIX), _T0_T1_cc)(void)
759{
760 int count;
761 count = T1 & SHIFT_MASK;
762 CC_SRC = T0 >> count;
763 T0 &= ~(1 << count);
764}
765
766void OPPROTO glue(glue(op_btc, SUFFIX), _T0_T1_cc)(void)
767{
768 int count;
769 count = T1 & SHIFT_MASK;
770 CC_SRC = T0 >> count;
771 T0 ^= (1 << count);
772}
773
77f8dd5a
FB		 774void OPPROTO glue(glue(op_bsf, SUFFIX), _T0_cc)(void)
775{
776 int res, count;
777 res = T0 & DATA_MASK;
778 if (res != 0) {
779 count = 0;
780 while ((res & 1) == 0) {
781 count++;
782 res >>= 1;
783 }
784 T0 = count;
785 CC_DST = 1; /* ZF = 1 */
786 } else {
787 CC_DST = 0; /* ZF = 1 */
788 }
789 FORCE_RET();
790}
791
792void OPPROTO glue(glue(op_bsr, SUFFIX), _T0_cc)(void)
793{
794 int res, count;
795 res = T0 & DATA_MASK;
796 if (res != 0) {
797 count = DATA_BITS - 1;
798 while ((res & SIGN_MASK) == 0) {
799 count--;
800 res <<= 1;
801 }
802 T0 = count;
803 CC_DST = 1; /* ZF = 1 */
804 } else {
805 CC_DST = 0; /* ZF = 1 */
806 }
807 FORCE_RET();
808}
809
4b74fe1f
FB		 810#endif
811
367e86e8 812/* string operations */
24f9e90b
FB		 813/* XXX: maybe use lower level instructions to ease 16 bit / segment handling */
814
815#define STRING_SUFFIX _fast
816#define SI_ADDR (void *)ESI
817#define DI_ADDR (void *)EDI
818#define INC_SI() ESI += inc
819#define INC_DI() EDI += inc
820#define CX ECX
821#define DEC_CX() ECX--
822#include "op_string.h"
823
824#define STRING_SUFFIX _a32
825#define SI_ADDR (uint8_t *)A0 + ESI
826#define DI_ADDR env->seg_cache[R_ES].base + EDI
827#define INC_SI() ESI += inc
828#define INC_DI() EDI += inc
829#define CX ECX
830#define DEC_CX() ECX--
831#include "op_string.h"
832
833#define STRING_SUFFIX _a16
834#define SI_ADDR (uint8_t *)A0 + (ESI & 0xffff)
835#define DI_ADDR env->seg_cache[R_ES].base + (EDI & 0xffff)
836#define INC_SI() ESI = (ESI & ~0xffff) | ((ESI + inc) & 0xffff)
837#define INC_DI() EDI = (EDI & ~0xffff) | ((EDI + inc) & 0xffff)
838#define CX (ECX & 0xffff)
839#define DEC_CX() ECX = (ECX & ~0xffff) | ((ECX - 1) & 0xffff)
840#include "op_string.h"
367e86e8 841
ba1c6e37
FB		 842/* port I/O */
843
ba1c6e37
FB		 844void OPPROTO glue(glue(op_out, SUFFIX), _T0_T1)(void)
845{
bf7c65bd 846 glue(cpu_x86_out, SUFFIX)(env, T0 & 0xffff, T1 & DATA_MASK);
ba1c6e37
FB		 847}
848
849void OPPROTO glue(glue(op_in, SUFFIX), _T0_T1)(void)
850{
bf7c65bd 851 T1 = glue(cpu_x86_in, SUFFIX)(env, T0 & 0xffff);
ba1c6e37
FB		 852}
853
367e86e8
FB		 854#undef DATA_BITS
855#undef SHIFT_MASK
856#undef SIGN_MASK
857#undef DATA_TYPE
858#undef DATA_STYPE
859#undef DATA_MASK
860#undef SUFFIX
Qemu copy for testing