?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge remote-tracking branch 'kiszka/queues/slirp' into staging
[qemu/aliguori.git] / target-i386 / translate.c
blobccef381be8e12355247545ce67483ebbe9719a77
1 /*
2 * i386 translation
3 *
4 * Copyright (c) 2003 Fabrice Bellard
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 */
19 #include <stdarg.h>
20 #include <stdlib.h>
21 #include <stdio.h>
22 #include <string.h>
23 #include <inttypes.h>
24 #include <signal.h>
25
26 #include "cpu.h"
27 #include "disas.h"
28 #include "tcg-op.h"
29
30 #include "helper.h"
31 #define GEN_HELPER 1
32 #include "helper.h"
33
34 #define PREFIX_REPZ 0x01
35 #define PREFIX_REPNZ 0x02
36 #define PREFIX_LOCK 0x04
37 #define PREFIX_DATA 0x08
38 #define PREFIX_ADR 0x10
39
40 #ifdef TARGET_X86_64
41 #define X86_64_ONLY(x) x
42 #define X86_64_DEF(...) __VA_ARGS__
43 #define CODE64(s) ((s)->code64)
44 #define REX_X(s) ((s)->rex_x)
45 #define REX_B(s) ((s)->rex_b)
46 /* XXX: gcc generates push/pop in some opcodes, so we cannot use them */
47 #if 1
48 #define BUGGY_64(x) NULL
49 #endif
50 #else
51 #define X86_64_ONLY(x) NULL
52 #define X86_64_DEF(...)
53 #define CODE64(s) 0
54 #define REX_X(s) 0
55 #define REX_B(s) 0
56 #endif
57
58 //#define MACRO_TEST 1
59
60 /* global register indexes */
61 static TCGv_ptr cpu_env;
62 static TCGv cpu_A0, cpu_cc_src, cpu_cc_dst, cpu_cc_tmp;
63 static TCGv_i32 cpu_cc_op;
64 static TCGv cpu_regs[CPU_NB_REGS];
65 /* local temps */
66 static TCGv cpu_T[2], cpu_T3;
67 /* local register indexes (only used inside old micro ops) */
68 static TCGv cpu_tmp0, cpu_tmp4;
69 static TCGv_ptr cpu_ptr0, cpu_ptr1;
70 static TCGv_i32 cpu_tmp2_i32, cpu_tmp3_i32;
71 static TCGv_i64 cpu_tmp1_i64;
72 static TCGv cpu_tmp5;
73
74 static uint8_t gen_opc_cc_op[OPC_BUF_SIZE];
75
76 #include "gen-icount.h"
77
78 #ifdef TARGET_X86_64
79 static int x86_64_hregs;
80 #endif
81
82 typedef struct DisasContext {
83 /* current insn context */
84 int override; /* -1 if no override */
85 int prefix;
86 int aflag, dflag;
87 target_ulong pc; /* pc = eip + cs_base */
88 int is_jmp; /* 1 = means jump (stop translation), 2 means CPU
89 static state change (stop translation) */
90 /* current block context */
91 target_ulong cs_base; /* base of CS segment */
92 int pe; /* protected mode */
93 int code32; /* 32 bit code segment */
94 #ifdef TARGET_X86_64
95 int lma; /* long mode active */
96 int code64; /* 64 bit code segment */
97 int rex_x, rex_b;
98 #endif
99 int ss32; /* 32 bit stack segment */
100 int cc_op; /* current CC operation */
101 int addseg; /* non zero if either DS/ES/SS have a non zero base */
102 int f_st; /* currently unused */
103 int vm86; /* vm86 mode */
104 int cpl;
105 int iopl;
106 int tf; /* TF cpu flag */
107 int singlestep_enabled; /* "hardware" single step enabled */
108 int jmp_opt; /* use direct block chaining for direct jumps */
109 int mem_index; /* select memory access functions */
110 uint64_t flags; /* all execution flags */
111 struct TranslationBlock *tb;
112 int popl_esp_hack; /* for correct popl with esp base handling */
113 int rip_offset; /* only used in x86_64, but left for simplicity */
114 int cpuid_features;
115 int cpuid_ext_features;
116 int cpuid_ext2_features;
117 int cpuid_ext3_features;
118 } DisasContext;
119
120 static void gen_eob(DisasContext *s);
121 static void gen_jmp(DisasContext *s, target_ulong eip);
122 static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num);
123
124 /* i386 arith/logic operations */
125 enum {
126 OP_ADDL,
127 OP_ORL,
128 OP_ADCL,
129 OP_SBBL,
130 OP_ANDL,
131 OP_SUBL,
132 OP_XORL,
133 OP_CMPL,
134 };
135
136 /* i386 shift ops */
137 enum {
138 OP_ROL,
139 OP_ROR,
140 OP_RCL,
141 OP_RCR,
142 OP_SHL,
143 OP_SHR,
144 OP_SHL1, /* undocumented */
145 OP_SAR = 7,
146 };
147
148 enum {
149 JCC_O,
150 JCC_B,
151 JCC_Z,
152 JCC_BE,
153 JCC_S,
154 JCC_P,
155 JCC_L,
156 JCC_LE,
157 };
158
159 /* operand size */
160 enum {
161 OT_BYTE = 0,
162 OT_WORD,
163 OT_LONG,
164 OT_QUAD,
165 };
166
167 enum {
168 /* I386 int registers */
169 OR_EAX, /* MUST be even numbered */
170 OR_ECX,
171 OR_EDX,
172 OR_EBX,
173 OR_ESP,
174 OR_EBP,
175 OR_ESI,
176 OR_EDI,
177
178 OR_TMP0 = 16, /* temporary operand register */
179 OR_TMP1,
180 OR_A0, /* temporary register used when doing address evaluation */
181 };
182
183 static inline void gen_op_movl_T0_0(void)
184 {
185 tcg_gen_movi_tl(cpu_T[0], 0);
186 }
187
188 static inline void gen_op_movl_T0_im(int32_t val)
189 {
190 tcg_gen_movi_tl(cpu_T[0], val);
191 }
192
193 static inline void gen_op_movl_T0_imu(uint32_t val)
194 {
195 tcg_gen_movi_tl(cpu_T[0], val);
196 }
197
198 static inline void gen_op_movl_T1_im(int32_t val)
199 {
200 tcg_gen_movi_tl(cpu_T[1], val);
201 }
202
203 static inline void gen_op_movl_T1_imu(uint32_t val)
204 {
205 tcg_gen_movi_tl(cpu_T[1], val);
206 }
207
208 static inline void gen_op_movl_A0_im(uint32_t val)
209 {
210 tcg_gen_movi_tl(cpu_A0, val);
211 }
212
213 #ifdef TARGET_X86_64
214 static inline void gen_op_movq_A0_im(int64_t val)
215 {
216 tcg_gen_movi_tl(cpu_A0, val);
217 }
218 #endif
219
220 static inline void gen_movtl_T0_im(target_ulong val)
221 {
222 tcg_gen_movi_tl(cpu_T[0], val);
223 }
224
225 static inline void gen_movtl_T1_im(target_ulong val)
226 {
227 tcg_gen_movi_tl(cpu_T[1], val);
228 }
229
230 static inline void gen_op_andl_T0_ffff(void)
231 {
232 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xffff);
233 }
234
235 static inline void gen_op_andl_T0_im(uint32_t val)
236 {
237 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], val);
238 }
239
240 static inline void gen_op_movl_T0_T1(void)
241 {
242 tcg_gen_mov_tl(cpu_T[0], cpu_T[1]);
243 }
244
245 static inline void gen_op_andl_A0_ffff(void)
246 {
247 tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffff);
248 }
249
250 #ifdef TARGET_X86_64
251
252 #define NB_OP_SIZES 4
253
254 #else /* !TARGET_X86_64 */
255
256 #define NB_OP_SIZES 3
257
258 #endif /* !TARGET_X86_64 */
259
260 #if defined(HOST_WORDS_BIGENDIAN)
261 #define REG_B_OFFSET (sizeof(target_ulong) - 1)
262 #define REG_H_OFFSET (sizeof(target_ulong) - 2)
263 #define REG_W_OFFSET (sizeof(target_ulong) - 2)
264 #define REG_L_OFFSET (sizeof(target_ulong) - 4)
265 #define REG_LH_OFFSET (sizeof(target_ulong) - 8)
266 #else
267 #define REG_B_OFFSET 0
268 #define REG_H_OFFSET 1
269 #define REG_W_OFFSET 0
270 #define REG_L_OFFSET 0
271 #define REG_LH_OFFSET 4
272 #endif
273
274 static inline void gen_op_mov_reg_v(int ot, int reg, TCGv t0)
275 {
276 switch(ot) {
277 case OT_BYTE:
278 if (reg < 4 X86_64_DEF( || reg >= 8 || x86_64_hregs)) {
279 tcg_gen_deposit_tl(cpu_regs[reg], cpu_regs[reg], t0, 0, 8);
280 } else {
281 tcg_gen_deposit_tl(cpu_regs[reg - 4], cpu_regs[reg - 4], t0, 8, 8);
282 }
283 break;
284 case OT_WORD:
285 tcg_gen_deposit_tl(cpu_regs[reg], cpu_regs[reg], t0, 0, 16);
286 break;
287 default: /* XXX this shouldn't be reached; abort? */
288 case OT_LONG:
289 /* For x86_64, this sets the higher half of register to zero.
290 For i386, this is equivalent to a mov. */
291 tcg_gen_ext32u_tl(cpu_regs[reg], t0);
292 break;
293 #ifdef TARGET_X86_64
294 case OT_QUAD:
295 tcg_gen_mov_tl(cpu_regs[reg], t0);
296 break;
297 #endif
298 }
299 }
300
301 static inline void gen_op_mov_reg_T0(int ot, int reg)
302 {
303 gen_op_mov_reg_v(ot, reg, cpu_T[0]);
304 }
305
306 static inline void gen_op_mov_reg_T1(int ot, int reg)
307 {
308 gen_op_mov_reg_v(ot, reg, cpu_T[1]);
309 }
310
311 static inline void gen_op_mov_reg_A0(int size, int reg)
312 {
313 switch(size) {
314 case 0:
315 tcg_gen_deposit_tl(cpu_regs[reg], cpu_regs[reg], cpu_A0, 0, 16);
316 break;
317 default: /* XXX this shouldn't be reached; abort? */
318 case 1:
319 /* For x86_64, this sets the higher half of register to zero.
320 For i386, this is equivalent to a mov. */
321 tcg_gen_ext32u_tl(cpu_regs[reg], cpu_A0);
322 break;
323 #ifdef TARGET_X86_64
324 case 2:
325 tcg_gen_mov_tl(cpu_regs[reg], cpu_A0);
326 break;
327 #endif
328 }
329 }
330
331 static inline void gen_op_mov_v_reg(int ot, TCGv t0, int reg)
332 {
333 switch(ot) {
334 case OT_BYTE:
335 if (reg < 4 X86_64_DEF( || reg >= 8 || x86_64_hregs)) {
336 goto std_case;
337 } else {
338 tcg_gen_shri_tl(t0, cpu_regs[reg - 4], 8);
339 tcg_gen_ext8u_tl(t0, t0);
340 }
341 break;
342 default:
343 std_case:
344 tcg_gen_mov_tl(t0, cpu_regs[reg]);
345 break;
346 }
347 }
348
349 static inline void gen_op_mov_TN_reg(int ot, int t_index, int reg)
350 {
351 gen_op_mov_v_reg(ot, cpu_T[t_index], reg);
352 }
353
354 static inline void gen_op_movl_A0_reg(int reg)
355 {
356 tcg_gen_mov_tl(cpu_A0, cpu_regs[reg]);
357 }
358
359 static inline void gen_op_addl_A0_im(int32_t val)
360 {
361 tcg_gen_addi_tl(cpu_A0, cpu_A0, val);
362 #ifdef TARGET_X86_64
363 tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
364 #endif
365 }
366
367 #ifdef TARGET_X86_64
368 static inline void gen_op_addq_A0_im(int64_t val)
369 {
370 tcg_gen_addi_tl(cpu_A0, cpu_A0, val);
371 }
372 #endif
373
374 static void gen_add_A0_im(DisasContext *s, int val)
375 {
376 #ifdef TARGET_X86_64
377 if (CODE64(s))
378 gen_op_addq_A0_im(val);
379 else
380 #endif
381 gen_op_addl_A0_im(val);
382 }
383
384 static inline void gen_op_addl_T0_T1(void)
385 {
386 tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
387 }
388
389 static inline void gen_op_jmp_T0(void)
390 {
391 tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUState, eip));
392 }
393
394 static inline void gen_op_add_reg_im(int size, int reg, int32_t val)
395 {
396 switch(size) {
397 case 0:
398 tcg_gen_addi_tl(cpu_tmp0, cpu_regs[reg], val);
399 tcg_gen_deposit_tl(cpu_regs[reg], cpu_regs[reg], cpu_tmp0, 0, 16);
400 break;
401 case 1:
402 tcg_gen_addi_tl(cpu_tmp0, cpu_regs[reg], val);
403 /* For x86_64, this sets the higher half of register to zero.
404 For i386, this is equivalent to a nop. */
405 tcg_gen_ext32u_tl(cpu_tmp0, cpu_tmp0);
406 tcg_gen_mov_tl(cpu_regs[reg], cpu_tmp0);
407 break;
408 #ifdef TARGET_X86_64
409 case 2:
410 tcg_gen_addi_tl(cpu_regs[reg], cpu_regs[reg], val);
411 break;
412 #endif
413 }
414 }
415
416 static inline void gen_op_add_reg_T0(int size, int reg)
417 {
418 switch(size) {
419 case 0:
420 tcg_gen_add_tl(cpu_tmp0, cpu_regs[reg], cpu_T[0]);
421 tcg_gen_deposit_tl(cpu_regs[reg], cpu_regs[reg], cpu_tmp0, 0, 16);
422 break;
423 case 1:
424 tcg_gen_add_tl(cpu_tmp0, cpu_regs[reg], cpu_T[0]);
425 /* For x86_64, this sets the higher half of register to zero.
426 For i386, this is equivalent to a nop. */
427 tcg_gen_ext32u_tl(cpu_tmp0, cpu_tmp0);
428 tcg_gen_mov_tl(cpu_regs[reg], cpu_tmp0);
429 break;
430 #ifdef TARGET_X86_64
431 case 2:
432 tcg_gen_add_tl(cpu_regs[reg], cpu_regs[reg], cpu_T[0]);
433 break;
434 #endif
435 }
436 }
437
438 static inline void gen_op_set_cc_op(int32_t val)
439 {
440 tcg_gen_movi_i32(cpu_cc_op, val);
441 }
442
443 static inline void gen_op_addl_A0_reg_sN(int shift, int reg)
444 {
445 tcg_gen_mov_tl(cpu_tmp0, cpu_regs[reg]);
446 if (shift != 0)
447 tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, shift);
448 tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
449 /* For x86_64, this sets the higher half of register to zero.
450 For i386, this is equivalent to a nop. */
451 tcg_gen_ext32u_tl(cpu_A0, cpu_A0);
452 }
453
454 static inline void gen_op_movl_A0_seg(int reg)
455 {
456 tcg_gen_ld32u_tl(cpu_A0, cpu_env, offsetof(CPUState, segs[reg].base) + REG_L_OFFSET);
457 }
458
459 static inline void gen_op_addl_A0_seg(int reg)
460 {
461 tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUState, segs[reg].base));
462 tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
463 #ifdef TARGET_X86_64
464 tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
465 #endif
466 }
467
468 #ifdef TARGET_X86_64
469 static inline void gen_op_movq_A0_seg(int reg)
470 {
471 tcg_gen_ld_tl(cpu_A0, cpu_env, offsetof(CPUState, segs[reg].base));
472 }
473
474 static inline void gen_op_addq_A0_seg(int reg)
475 {
476 tcg_gen_ld_tl(cpu_tmp0, cpu_env, offsetof(CPUState, segs[reg].base));
477 tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
478 }
479
480 static inline void gen_op_movq_A0_reg(int reg)
481 {
482 tcg_gen_mov_tl(cpu_A0, cpu_regs[reg]);
483 }
484
485 static inline void gen_op_addq_A0_reg_sN(int shift, int reg)
486 {
487 tcg_gen_mov_tl(cpu_tmp0, cpu_regs[reg]);
488 if (shift != 0)
489 tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, shift);
490 tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
491 }
492 #endif
493
494 static inline void gen_op_lds_T0_A0(int idx)
495 {
496 int mem_index = (idx >> 2) - 1;
497 switch(idx & 3) {
498 case 0:
499 tcg_gen_qemu_ld8s(cpu_T[0], cpu_A0, mem_index);
500 break;
501 case 1:
502 tcg_gen_qemu_ld16s(cpu_T[0], cpu_A0, mem_index);
503 break;
504 default:
505 case 2:
506 tcg_gen_qemu_ld32s(cpu_T[0], cpu_A0, mem_index);
507 break;
508 }
509 }
510
511 static inline void gen_op_ld_v(int idx, TCGv t0, TCGv a0)
512 {
513 int mem_index = (idx >> 2) - 1;
514 switch(idx & 3) {
515 case 0:
516 tcg_gen_qemu_ld8u(t0, a0, mem_index);
517 break;
518 case 1:
519 tcg_gen_qemu_ld16u(t0, a0, mem_index);
520 break;
521 case 2:
522 tcg_gen_qemu_ld32u(t0, a0, mem_index);
523 break;
524 default:
525 case 3:
526 /* Should never happen on 32-bit targets. */
527 #ifdef TARGET_X86_64
528 tcg_gen_qemu_ld64(t0, a0, mem_index);
529 #endif
530 break;
531 }
532 }
533
534 /* XXX: always use ldu or lds */
535 static inline void gen_op_ld_T0_A0(int idx)
536 {
537 gen_op_ld_v(idx, cpu_T[0], cpu_A0);
538 }
539
540 static inline void gen_op_ldu_T0_A0(int idx)
541 {
542 gen_op_ld_v(idx, cpu_T[0], cpu_A0);
543 }
544
545 static inline void gen_op_ld_T1_A0(int idx)
546 {
547 gen_op_ld_v(idx, cpu_T[1], cpu_A0);
548 }
549
550 static inline void gen_op_st_v(int idx, TCGv t0, TCGv a0)
551 {
552 int mem_index = (idx >> 2) - 1;
553 switch(idx & 3) {
554 case 0:
555 tcg_gen_qemu_st8(t0, a0, mem_index);
556 break;
557 case 1:
558 tcg_gen_qemu_st16(t0, a0, mem_index);
559 break;
560 case 2:
561 tcg_gen_qemu_st32(t0, a0, mem_index);
562 break;
563 default:
564 case 3:
565 /* Should never happen on 32-bit targets. */
566 #ifdef TARGET_X86_64
567 tcg_gen_qemu_st64(t0, a0, mem_index);
568 #endif
569 break;
570 }
571 }
572
573 static inline void gen_op_st_T0_A0(int idx)
574 {
575 gen_op_st_v(idx, cpu_T[0], cpu_A0);
576 }
577
578 static inline void gen_op_st_T1_A0(int idx)
579 {
580 gen_op_st_v(idx, cpu_T[1], cpu_A0);
581 }
582
583 static inline void gen_jmp_im(target_ulong pc)
584 {
585 tcg_gen_movi_tl(cpu_tmp0, pc);
586 tcg_gen_st_tl(cpu_tmp0, cpu_env, offsetof(CPUState, eip));
587 }
588
589 static inline void gen_string_movl_A0_ESI(DisasContext *s)
590 {
591 int override;
592
593 override = s->override;
594 #ifdef TARGET_X86_64
595 if (s->aflag == 2) {
596 if (override >= 0) {
597 gen_op_movq_A0_seg(override);
598 gen_op_addq_A0_reg_sN(0, R_ESI);
599 } else {
600 gen_op_movq_A0_reg(R_ESI);
601 }
602 } else
603 #endif
604 if (s->aflag) {
605 /* 32 bit address */
606 if (s->addseg && override < 0)
607 override = R_DS;
608 if (override >= 0) {
609 gen_op_movl_A0_seg(override);
610 gen_op_addl_A0_reg_sN(0, R_ESI);
611 } else {
612 gen_op_movl_A0_reg(R_ESI);
613 }
614 } else {
615 /* 16 address, always override */
616 if (override < 0)
617 override = R_DS;
618 gen_op_movl_A0_reg(R_ESI);
619 gen_op_andl_A0_ffff();
620 gen_op_addl_A0_seg(override);
621 }
622 }
623
624 static inline void gen_string_movl_A0_EDI(DisasContext *s)
625 {
626 #ifdef TARGET_X86_64
627 if (s->aflag == 2) {
628 gen_op_movq_A0_reg(R_EDI);
629 } else
630 #endif
631 if (s->aflag) {
632 if (s->addseg) {
633 gen_op_movl_A0_seg(R_ES);
634 gen_op_addl_A0_reg_sN(0, R_EDI);
635 } else {
636 gen_op_movl_A0_reg(R_EDI);
637 }
638 } else {
639 gen_op_movl_A0_reg(R_EDI);
640 gen_op_andl_A0_ffff();
641 gen_op_addl_A0_seg(R_ES);
642 }
643 }
644
645 static inline void gen_op_movl_T0_Dshift(int ot)
646 {
647 tcg_gen_ld32s_tl(cpu_T[0], cpu_env, offsetof(CPUState, df));
648 tcg_gen_shli_tl(cpu_T[0], cpu_T[0], ot);
649 };
650
651 static void gen_extu(int ot, TCGv reg)
652 {
653 switch(ot) {
654 case OT_BYTE:
655 tcg_gen_ext8u_tl(reg, reg);
656 break;
657 case OT_WORD:
658 tcg_gen_ext16u_tl(reg, reg);
659 break;
660 case OT_LONG:
661 tcg_gen_ext32u_tl(reg, reg);
662 break;
663 default:
664 break;
665 }
666 }
667
668 static void gen_exts(int ot, TCGv reg)
669 {
670 switch(ot) {
671 case OT_BYTE:
672 tcg_gen_ext8s_tl(reg, reg);
673 break;
674 case OT_WORD:
675 tcg_gen_ext16s_tl(reg, reg);
676 break;
677 case OT_LONG:
678 tcg_gen_ext32s_tl(reg, reg);
679 break;
680 default:
681 break;
682 }
683 }
684
685 static inline void gen_op_jnz_ecx(int size, int label1)
686 {
687 tcg_gen_mov_tl(cpu_tmp0, cpu_regs[R_ECX]);
688 gen_extu(size + 1, cpu_tmp0);
689 tcg_gen_brcondi_tl(TCG_COND_NE, cpu_tmp0, 0, label1);
690 }
691
692 static inline void gen_op_jz_ecx(int size, int label1)
693 {
694 tcg_gen_mov_tl(cpu_tmp0, cpu_regs[R_ECX]);
695 gen_extu(size + 1, cpu_tmp0);
696 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, label1);
697 }
698
699 static void gen_helper_in_func(int ot, TCGv v, TCGv_i32 n)
700 {
701 switch (ot) {
702 case 0: gen_helper_inb(v, n); break;
703 case 1: gen_helper_inw(v, n); break;
704 case 2: gen_helper_inl(v, n); break;
705 }
706
707 }
708
709 static void gen_helper_out_func(int ot, TCGv_i32 v, TCGv_i32 n)
710 {
711 switch (ot) {
712 case 0: gen_helper_outb(v, n); break;
713 case 1: gen_helper_outw(v, n); break;
714 case 2: gen_helper_outl(v, n); break;
715 }
716
717 }
718
719 static void gen_check_io(DisasContext *s, int ot, target_ulong cur_eip,
720 uint32_t svm_flags)
721 {
722 int state_saved;
723 target_ulong next_eip;
724
725 state_saved = 0;
726 if (s->pe && (s->cpl > s->iopl || s->vm86)) {
727 if (s->cc_op != CC_OP_DYNAMIC)
728 gen_op_set_cc_op(s->cc_op);
729 gen_jmp_im(cur_eip);
730 state_saved = 1;
731 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
732 switch (ot) {
733 case 0: gen_helper_check_iob(cpu_tmp2_i32); break;
734 case 1: gen_helper_check_iow(cpu_tmp2_i32); break;
735 case 2: gen_helper_check_iol(cpu_tmp2_i32); break;
736 }
737 }
738 if(s->flags & HF_SVMI_MASK) {
739 if (!state_saved) {
740 if (s->cc_op != CC_OP_DYNAMIC)
741 gen_op_set_cc_op(s->cc_op);
742 gen_jmp_im(cur_eip);
743 }
744 svm_flags |= (1 << (4 + ot));
745 next_eip = s->pc - s->cs_base;
746 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
747 gen_helper_svm_check_io(cpu_tmp2_i32, tcg_const_i32(svm_flags),
748 tcg_const_i32(next_eip - cur_eip));
749 }
750 }
751
752 static inline void gen_movs(DisasContext *s, int ot)
753 {
754 gen_string_movl_A0_ESI(s);
755 gen_op_ld_T0_A0(ot + s->mem_index);
756 gen_string_movl_A0_EDI(s);
757 gen_op_st_T0_A0(ot + s->mem_index);
758 gen_op_movl_T0_Dshift(ot);
759 gen_op_add_reg_T0(s->aflag, R_ESI);
760 gen_op_add_reg_T0(s->aflag, R_EDI);
761 }
762
763 static inline void gen_update_cc_op(DisasContext *s)
764 {
765 if (s->cc_op != CC_OP_DYNAMIC) {
766 gen_op_set_cc_op(s->cc_op);
767 s->cc_op = CC_OP_DYNAMIC;
768 }
769 }
770
771 static void gen_op_update1_cc(void)
772 {
773 tcg_gen_discard_tl(cpu_cc_src);
774 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
775 }
776
777 static void gen_op_update2_cc(void)
778 {
779 tcg_gen_mov_tl(cpu_cc_src, cpu_T[1]);
780 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
781 }
782
783 static inline void gen_op_cmpl_T0_T1_cc(void)
784 {
785 tcg_gen_mov_tl(cpu_cc_src, cpu_T[1]);
786 tcg_gen_sub_tl(cpu_cc_dst, cpu_T[0], cpu_T[1]);
787 }
788
789 static inline void gen_op_testl_T0_T1_cc(void)
790 {
791 tcg_gen_discard_tl(cpu_cc_src);
792 tcg_gen_and_tl(cpu_cc_dst, cpu_T[0], cpu_T[1]);
793 }
794
795 static void gen_op_update_neg_cc(void)
796 {
797 tcg_gen_neg_tl(cpu_cc_src, cpu_T[0]);
798 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
799 }
800
801 /* compute eflags.C to reg */
802 static void gen_compute_eflags_c(TCGv reg)
803 {
804 gen_helper_cc_compute_c(cpu_tmp2_i32, cpu_cc_op);
805 tcg_gen_extu_i32_tl(reg, cpu_tmp2_i32);
806 }
807
808 /* compute all eflags to cc_src */
809 static void gen_compute_eflags(TCGv reg)
810 {
811 gen_helper_cc_compute_all(cpu_tmp2_i32, cpu_cc_op);
812 tcg_gen_extu_i32_tl(reg, cpu_tmp2_i32);
813 }
814
815 static inline void gen_setcc_slow_T0(DisasContext *s, int jcc_op)
816 {
817 if (s->cc_op != CC_OP_DYNAMIC)
818 gen_op_set_cc_op(s->cc_op);
819 switch(jcc_op) {
820 case JCC_O:
821 gen_compute_eflags(cpu_T[0]);
822 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 11);
823 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 1);
824 break;
825 case JCC_B:
826 gen_compute_eflags_c(cpu_T[0]);
827 break;
828 case JCC_Z:
829 gen_compute_eflags(cpu_T[0]);
830 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 6);
831 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 1);
832 break;
833 case JCC_BE:
834 gen_compute_eflags(cpu_tmp0);
835 tcg_gen_shri_tl(cpu_T[0], cpu_tmp0, 6);
836 tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
837 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 1);
838 break;
839 case JCC_S:
840 gen_compute_eflags(cpu_T[0]);
841 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 7);
842 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 1);
843 break;
844 case JCC_P:
845 gen_compute_eflags(cpu_T[0]);
846 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 2);
847 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 1);
848 break;
849 case JCC_L:
850 gen_compute_eflags(cpu_tmp0);
851 tcg_gen_shri_tl(cpu_T[0], cpu_tmp0, 11); /* CC_O */
852 tcg_gen_shri_tl(cpu_tmp0, cpu_tmp0, 7); /* CC_S */
853 tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
854 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 1);
855 break;
856 default:
857 case JCC_LE:
858 gen_compute_eflags(cpu_tmp0);
859 tcg_gen_shri_tl(cpu_T[0], cpu_tmp0, 11); /* CC_O */
860 tcg_gen_shri_tl(cpu_tmp4, cpu_tmp0, 7); /* CC_S */
861 tcg_gen_shri_tl(cpu_tmp0, cpu_tmp0, 6); /* CC_Z */
862 tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_tmp4);
863 tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
864 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 1);
865 break;
866 }
867 }
868
869 /* return true if setcc_slow is not needed (WARNING: must be kept in
870 sync with gen_jcc1) */
871 static int is_fast_jcc_case(DisasContext *s, int b)
872 {
873 int jcc_op;
874 jcc_op = (b >> 1) & 7;
875 switch(s->cc_op) {
876 /* we optimize the cmp/jcc case */
877 case CC_OP_SUBB:
878 case CC_OP_SUBW:
879 case CC_OP_SUBL:
880 case CC_OP_SUBQ:
881 if (jcc_op == JCC_O || jcc_op == JCC_P)
882 goto slow_jcc;
883 break;
884
885 /* some jumps are easy to compute */
886 case CC_OP_ADDB:
887 case CC_OP_ADDW:
888 case CC_OP_ADDL:
889 case CC_OP_ADDQ:
890
891 case CC_OP_LOGICB:
892 case CC_OP_LOGICW:
893 case CC_OP_LOGICL:
894 case CC_OP_LOGICQ:
895
896 case CC_OP_INCB:
897 case CC_OP_INCW:
898 case CC_OP_INCL:
899 case CC_OP_INCQ:
900
901 case CC_OP_DECB:
902 case CC_OP_DECW:
903 case CC_OP_DECL:
904 case CC_OP_DECQ:
905
906 case CC_OP_SHLB:
907 case CC_OP_SHLW:
908 case CC_OP_SHLL:
909 case CC_OP_SHLQ:
910 if (jcc_op != JCC_Z && jcc_op != JCC_S)
911 goto slow_jcc;
912 break;
913 default:
914 slow_jcc:
915 return 0;
916 }
917 return 1;
918 }
919
920 /* generate a conditional jump to label 'l1' according to jump opcode
921 value 'b'. In the fast case, T0 is guaranted not to be used. */
922 static inline void gen_jcc1(DisasContext *s, int cc_op, int b, int l1)
923 {
924 int inv, jcc_op, size, cond;
925 TCGv t0;
926
927 inv = b & 1;
928 jcc_op = (b >> 1) & 7;
929
930 switch(cc_op) {
931 /* we optimize the cmp/jcc case */
932 case CC_OP_SUBB:
933 case CC_OP_SUBW:
934 case CC_OP_SUBL:
935 case CC_OP_SUBQ:
936
937 size = cc_op - CC_OP_SUBB;
938 switch(jcc_op) {
939 case JCC_Z:
940 fast_jcc_z:
941 switch(size) {
942 case 0:
943 tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0xff);
944 t0 = cpu_tmp0;
945 break;
946 case 1:
947 tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0xffff);
948 t0 = cpu_tmp0;
949 break;
950 #ifdef TARGET_X86_64
951 case 2:
952 tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0xffffffff);
953 t0 = cpu_tmp0;
954 break;
955 #endif
956 default:
957 t0 = cpu_cc_dst;
958 break;
959 }
960 tcg_gen_brcondi_tl(inv ? TCG_COND_NE : TCG_COND_EQ, t0, 0, l1);
961 break;
962 case JCC_S:
963 fast_jcc_s:
964 switch(size) {
965 case 0:
966 tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0x80);
967 tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,
968 0, l1);
969 break;
970 case 1:
971 tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0x8000);
972 tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,
973 0, l1);
974 break;
975 #ifdef TARGET_X86_64
976 case 2:
977 tcg_gen_andi_tl(cpu_tmp0, cpu_cc_dst, 0x80000000);
978 tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE, cpu_tmp0,
979 0, l1);
980 break;
981 #endif
982 default:
983 tcg_gen_brcondi_tl(inv ? TCG_COND_GE : TCG_COND_LT, cpu_cc_dst,
984 0, l1);
985 break;
986 }
987 break;
988
989 case JCC_B:
990 cond = inv ? TCG_COND_GEU : TCG_COND_LTU;
991 goto fast_jcc_b;
992 case JCC_BE:
993 cond = inv ? TCG_COND_GTU : TCG_COND_LEU;
994 fast_jcc_b:
995 tcg_gen_add_tl(cpu_tmp4, cpu_cc_dst, cpu_cc_src);
996 switch(size) {
997 case 0:
998 t0 = cpu_tmp0;
999 tcg_gen_andi_tl(cpu_tmp4, cpu_tmp4, 0xff);
1000 tcg_gen_andi_tl(t0, cpu_cc_src, 0xff);
1001 break;
1002 case 1:
1003 t0 = cpu_tmp0;
1004 tcg_gen_andi_tl(cpu_tmp4, cpu_tmp4, 0xffff);
1005 tcg_gen_andi_tl(t0, cpu_cc_src, 0xffff);
1006 break;
1007 #ifdef TARGET_X86_64
1008 case 2:
1009 t0 = cpu_tmp0;
1010 tcg_gen_andi_tl(cpu_tmp4, cpu_tmp4, 0xffffffff);
1011 tcg_gen_andi_tl(t0, cpu_cc_src, 0xffffffff);
1012 break;
1013 #endif
1014 default:
1015 t0 = cpu_cc_src;
1016 break;
1017 }
1018 tcg_gen_brcond_tl(cond, cpu_tmp4, t0, l1);
1019 break;
1020
1021 case JCC_L:
1022 cond = inv ? TCG_COND_GE : TCG_COND_LT;
1023 goto fast_jcc_l;
1024 case JCC_LE:
1025 cond = inv ? TCG_COND_GT : TCG_COND_LE;
1026 fast_jcc_l:
1027 tcg_gen_add_tl(cpu_tmp4, cpu_cc_dst, cpu_cc_src);
1028 switch(size) {
1029 case 0:
1030 t0 = cpu_tmp0;
1031 tcg_gen_ext8s_tl(cpu_tmp4, cpu_tmp4);
1032 tcg_gen_ext8s_tl(t0, cpu_cc_src);
1033 break;
1034 case 1:
1035 t0 = cpu_tmp0;
1036 tcg_gen_ext16s_tl(cpu_tmp4, cpu_tmp4);
1037 tcg_gen_ext16s_tl(t0, cpu_cc_src);
1038 break;
1039 #ifdef TARGET_X86_64
1040 case 2:
1041 t0 = cpu_tmp0;
1042 tcg_gen_ext32s_tl(cpu_tmp4, cpu_tmp4);
1043 tcg_gen_ext32s_tl(t0, cpu_cc_src);
1044 break;
1045 #endif
1046 default:
1047 t0 = cpu_cc_src;
1048 break;
1049 }
1050 tcg_gen_brcond_tl(cond, cpu_tmp4, t0, l1);
1051 break;
1052
1053 default:
1054 goto slow_jcc;
1055 }
1056 break;
1057
1058 /* some jumps are easy to compute */
1059 case CC_OP_ADDB:
1060 case CC_OP_ADDW:
1061 case CC_OP_ADDL:
1062 case CC_OP_ADDQ:
1063
1064 case CC_OP_ADCB:
1065 case CC_OP_ADCW:
1066 case CC_OP_ADCL:
1067 case CC_OP_ADCQ:
1068
1069 case CC_OP_SBBB:
1070 case CC_OP_SBBW:
1071 case CC_OP_SBBL:
1072 case CC_OP_SBBQ:
1073
1074 case CC_OP_LOGICB:
1075 case CC_OP_LOGICW:
1076 case CC_OP_LOGICL:
1077 case CC_OP_LOGICQ:
1078
1079 case CC_OP_INCB:
1080 case CC_OP_INCW:
1081 case CC_OP_INCL:
1082 case CC_OP_INCQ:
1083
1084 case CC_OP_DECB:
1085 case CC_OP_DECW:
1086 case CC_OP_DECL:
1087 case CC_OP_DECQ:
1088
1089 case CC_OP_SHLB:
1090 case CC_OP_SHLW:
1091 case CC_OP_SHLL:
1092 case CC_OP_SHLQ:
1093
1094 case CC_OP_SARB:
1095 case CC_OP_SARW:
1096 case CC_OP_SARL:
1097 case CC_OP_SARQ:
1098 switch(jcc_op) {
1099 case JCC_Z:
1100 size = (cc_op - CC_OP_ADDB) & 3;
1101 goto fast_jcc_z;
1102 case JCC_S:
1103 size = (cc_op - CC_OP_ADDB) & 3;
1104 goto fast_jcc_s;
1105 default:
1106 goto slow_jcc;
1107 }
1108 break;
1109 default:
1110 slow_jcc:
1111 gen_setcc_slow_T0(s, jcc_op);
1112 tcg_gen_brcondi_tl(inv ? TCG_COND_EQ : TCG_COND_NE,
1113 cpu_T[0], 0, l1);
1114 break;
1115 }
1116 }
1117
1118 /* XXX: does not work with gdbstub "ice" single step - not a
1119 serious problem */
1120 static int gen_jz_ecx_string(DisasContext *s, target_ulong next_eip)
1121 {
1122 int l1, l2;
1123
1124 l1 = gen_new_label();
1125 l2 = gen_new_label();
1126 gen_op_jnz_ecx(s->aflag, l1);
1127 gen_set_label(l2);
1128 gen_jmp_tb(s, next_eip, 1);
1129 gen_set_label(l1);
1130 return l2;
1131 }
1132
1133 static inline void gen_stos(DisasContext *s, int ot)
1134 {
1135 gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
1136 gen_string_movl_A0_EDI(s);
1137 gen_op_st_T0_A0(ot + s->mem_index);
1138 gen_op_movl_T0_Dshift(ot);
1139 gen_op_add_reg_T0(s->aflag, R_EDI);
1140 }
1141
1142 static inline void gen_lods(DisasContext *s, int ot)
1143 {
1144 gen_string_movl_A0_ESI(s);
1145 gen_op_ld_T0_A0(ot + s->mem_index);
1146 gen_op_mov_reg_T0(ot, R_EAX);
1147 gen_op_movl_T0_Dshift(ot);
1148 gen_op_add_reg_T0(s->aflag, R_ESI);
1149 }
1150
1151 static inline void gen_scas(DisasContext *s, int ot)
1152 {
1153 gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
1154 gen_string_movl_A0_EDI(s);
1155 gen_op_ld_T1_A0(ot + s->mem_index);
1156 gen_op_cmpl_T0_T1_cc();
1157 gen_op_movl_T0_Dshift(ot);
1158 gen_op_add_reg_T0(s->aflag, R_EDI);
1159 }
1160
1161 static inline void gen_cmps(DisasContext *s, int ot)
1162 {
1163 gen_string_movl_A0_ESI(s);
1164 gen_op_ld_T0_A0(ot + s->mem_index);
1165 gen_string_movl_A0_EDI(s);
1166 gen_op_ld_T1_A0(ot + s->mem_index);
1167 gen_op_cmpl_T0_T1_cc();
1168 gen_op_movl_T0_Dshift(ot);
1169 gen_op_add_reg_T0(s->aflag, R_ESI);
1170 gen_op_add_reg_T0(s->aflag, R_EDI);
1171 }
1172
1173 static inline void gen_ins(DisasContext *s, int ot)
1174 {
1175 if (use_icount)
1176 gen_io_start();
1177 gen_string_movl_A0_EDI(s);
1178 /* Note: we must do this dummy write first to be restartable in
1179 case of page fault. */
1180 gen_op_movl_T0_0();
1181 gen_op_st_T0_A0(ot + s->mem_index);
1182 gen_op_mov_TN_reg(OT_WORD, 1, R_EDX);
1183 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[1]);
1184 tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
1185 gen_helper_in_func(ot, cpu_T[0], cpu_tmp2_i32);
1186 gen_op_st_T0_A0(ot + s->mem_index);
1187 gen_op_movl_T0_Dshift(ot);
1188 gen_op_add_reg_T0(s->aflag, R_EDI);
1189 if (use_icount)
1190 gen_io_end();
1191 }
1192
1193 static inline void gen_outs(DisasContext *s, int ot)
1194 {
1195 if (use_icount)
1196 gen_io_start();
1197 gen_string_movl_A0_ESI(s);
1198 gen_op_ld_T0_A0(ot + s->mem_index);
1199
1200 gen_op_mov_TN_reg(OT_WORD, 1, R_EDX);
1201 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[1]);
1202 tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
1203 tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[0]);
1204 gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
1205
1206 gen_op_movl_T0_Dshift(ot);
1207 gen_op_add_reg_T0(s->aflag, R_ESI);
1208 if (use_icount)
1209 gen_io_end();
1210 }
1211
1212 /* same method as Valgrind : we generate jumps to current or next
1213 instruction */
1214 #define GEN_REPZ(op) \
1215 static inline void gen_repz_ ## op(DisasContext *s, int ot, \
1216 target_ulong cur_eip, target_ulong next_eip) \
1217 { \
1218 int l2;\
1219 gen_update_cc_op(s); \
1220 l2 = gen_jz_ecx_string(s, next_eip); \
1221 gen_ ## op(s, ot); \
1222 gen_op_add_reg_im(s->aflag, R_ECX, -1); \
1223 /* a loop would cause two single step exceptions if ECX = 1 \
1224 before rep string_insn */ \
1225 if (!s->jmp_opt) \
1226 gen_op_jz_ecx(s->aflag, l2); \
1227 gen_jmp(s, cur_eip); \
1228 }
1229
1230 #define GEN_REPZ2(op) \
1231 static inline void gen_repz_ ## op(DisasContext *s, int ot, \
1232 target_ulong cur_eip, \
1233 target_ulong next_eip, \
1234 int nz) \
1235 { \
1236 int l2;\
1237 gen_update_cc_op(s); \
1238 l2 = gen_jz_ecx_string(s, next_eip); \
1239 gen_ ## op(s, ot); \
1240 gen_op_add_reg_im(s->aflag, R_ECX, -1); \
1241 gen_op_set_cc_op(CC_OP_SUBB + ot); \
1242 gen_jcc1(s, CC_OP_SUBB + ot, (JCC_Z << 1) | (nz ^ 1), l2); \
1243 if (!s->jmp_opt) \
1244 gen_op_jz_ecx(s->aflag, l2); \
1245 gen_jmp(s, cur_eip); \
1246 }
1247
1248 GEN_REPZ(movs)
1249 GEN_REPZ(stos)
1250 GEN_REPZ(lods)
1251 GEN_REPZ(ins)
1252 GEN_REPZ(outs)
1253 GEN_REPZ2(scas)
1254 GEN_REPZ2(cmps)
1255
1256 static void gen_helper_fp_arith_ST0_FT0(int op)
1257 {
1258 switch (op) {
1259 case 0: gen_helper_fadd_ST0_FT0(); break;
1260 case 1: gen_helper_fmul_ST0_FT0(); break;
1261 case 2: gen_helper_fcom_ST0_FT0(); break;
1262 case 3: gen_helper_fcom_ST0_FT0(); break;
1263 case 4: gen_helper_fsub_ST0_FT0(); break;
1264 case 5: gen_helper_fsubr_ST0_FT0(); break;
1265 case 6: gen_helper_fdiv_ST0_FT0(); break;
1266 case 7: gen_helper_fdivr_ST0_FT0(); break;
1267 }
1268 }
1269
1270 /* NOTE the exception in "r" op ordering */
1271 static void gen_helper_fp_arith_STN_ST0(int op, int opreg)
1272 {
1273 TCGv_i32 tmp = tcg_const_i32(opreg);
1274 switch (op) {
1275 case 0: gen_helper_fadd_STN_ST0(tmp); break;
1276 case 1: gen_helper_fmul_STN_ST0(tmp); break;
1277 case 4: gen_helper_fsubr_STN_ST0(tmp); break;
1278 case 5: gen_helper_fsub_STN_ST0(tmp); break;
1279 case 6: gen_helper_fdivr_STN_ST0(tmp); break;
1280 case 7: gen_helper_fdiv_STN_ST0(tmp); break;
1281 }
1282 }
1283
1284 /* if d == OR_TMP0, it means memory operand (address in A0) */
1285 static void gen_op(DisasContext *s1, int op, int ot, int d)
1286 {
1287 if (d != OR_TMP0) {
1288 gen_op_mov_TN_reg(ot, 0, d);
1289 } else {
1290 gen_op_ld_T0_A0(ot + s1->mem_index);
1291 }
1292 switch(op) {
1293 case OP_ADCL:
1294 if (s1->cc_op != CC_OP_DYNAMIC)
1295 gen_op_set_cc_op(s1->cc_op);
1296 gen_compute_eflags_c(cpu_tmp4);
1297 tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1298 tcg_gen_add_tl(cpu_T[0], cpu_T[0], cpu_tmp4);
1299 if (d != OR_TMP0)
1300 gen_op_mov_reg_T0(ot, d);
1301 else
1302 gen_op_st_T0_A0(ot + s1->mem_index);
1303 tcg_gen_mov_tl(cpu_cc_src, cpu_T[1]);
1304 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
1305 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_tmp4);
1306 tcg_gen_shli_i32(cpu_tmp2_i32, cpu_tmp2_i32, 2);
1307 tcg_gen_addi_i32(cpu_cc_op, cpu_tmp2_i32, CC_OP_ADDB + ot);
1308 s1->cc_op = CC_OP_DYNAMIC;
1309 break;
1310 case OP_SBBL:
1311 if (s1->cc_op != CC_OP_DYNAMIC)
1312 gen_op_set_cc_op(s1->cc_op);
1313 gen_compute_eflags_c(cpu_tmp4);
1314 tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1315 tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_tmp4);
1316 if (d != OR_TMP0)
1317 gen_op_mov_reg_T0(ot, d);
1318 else
1319 gen_op_st_T0_A0(ot + s1->mem_index);
1320 tcg_gen_mov_tl(cpu_cc_src, cpu_T[1]);
1321 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
1322 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_tmp4);
1323 tcg_gen_shli_i32(cpu_tmp2_i32, cpu_tmp2_i32, 2);
1324 tcg_gen_addi_i32(cpu_cc_op, cpu_tmp2_i32, CC_OP_SUBB + ot);
1325 s1->cc_op = CC_OP_DYNAMIC;
1326 break;
1327 case OP_ADDL:
1328 gen_op_addl_T0_T1();
1329 if (d != OR_TMP0)
1330 gen_op_mov_reg_T0(ot, d);
1331 else
1332 gen_op_st_T0_A0(ot + s1->mem_index);
1333 gen_op_update2_cc();
1334 s1->cc_op = CC_OP_ADDB + ot;
1335 break;
1336 case OP_SUBL:
1337 tcg_gen_sub_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1338 if (d != OR_TMP0)
1339 gen_op_mov_reg_T0(ot, d);
1340 else
1341 gen_op_st_T0_A0(ot + s1->mem_index);
1342 gen_op_update2_cc();
1343 s1->cc_op = CC_OP_SUBB + ot;
1344 break;
1345 default:
1346 case OP_ANDL:
1347 tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1348 if (d != OR_TMP0)
1349 gen_op_mov_reg_T0(ot, d);
1350 else
1351 gen_op_st_T0_A0(ot + s1->mem_index);
1352 gen_op_update1_cc();
1353 s1->cc_op = CC_OP_LOGICB + ot;
1354 break;
1355 case OP_ORL:
1356 tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1357 if (d != OR_TMP0)
1358 gen_op_mov_reg_T0(ot, d);
1359 else
1360 gen_op_st_T0_A0(ot + s1->mem_index);
1361 gen_op_update1_cc();
1362 s1->cc_op = CC_OP_LOGICB + ot;
1363 break;
1364 case OP_XORL:
1365 tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1366 if (d != OR_TMP0)
1367 gen_op_mov_reg_T0(ot, d);
1368 else
1369 gen_op_st_T0_A0(ot + s1->mem_index);
1370 gen_op_update1_cc();
1371 s1->cc_op = CC_OP_LOGICB + ot;
1372 break;
1373 case OP_CMPL:
1374 gen_op_cmpl_T0_T1_cc();
1375 s1->cc_op = CC_OP_SUBB + ot;
1376 break;
1377 }
1378 }
1379
1380 /* if d == OR_TMP0, it means memory operand (address in A0) */
1381 static void gen_inc(DisasContext *s1, int ot, int d, int c)
1382 {
1383 if (d != OR_TMP0)
1384 gen_op_mov_TN_reg(ot, 0, d);
1385 else
1386 gen_op_ld_T0_A0(ot + s1->mem_index);
1387 if (s1->cc_op != CC_OP_DYNAMIC)
1388 gen_op_set_cc_op(s1->cc_op);
1389 if (c > 0) {
1390 tcg_gen_addi_tl(cpu_T[0], cpu_T[0], 1);
1391 s1->cc_op = CC_OP_INCB + ot;
1392 } else {
1393 tcg_gen_addi_tl(cpu_T[0], cpu_T[0], -1);
1394 s1->cc_op = CC_OP_DECB + ot;
1395 }
1396 if (d != OR_TMP0)
1397 gen_op_mov_reg_T0(ot, d);
1398 else
1399 gen_op_st_T0_A0(ot + s1->mem_index);
1400 gen_compute_eflags_c(cpu_cc_src);
1401 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
1402 }
1403
1404 static void gen_shift_rm_T1(DisasContext *s, int ot, int op1,
1405 int is_right, int is_arith)
1406 {
1407 target_ulong mask;
1408 int shift_label;
1409 TCGv t0, t1;
1410
1411 if (ot == OT_QUAD)
1412 mask = 0x3f;
1413 else
1414 mask = 0x1f;
1415
1416 /* load */
1417 if (op1 == OR_TMP0)
1418 gen_op_ld_T0_A0(ot + s->mem_index);
1419 else
1420 gen_op_mov_TN_reg(ot, 0, op1);
1421
1422 tcg_gen_andi_tl(cpu_T[1], cpu_T[1], mask);
1423
1424 tcg_gen_addi_tl(cpu_tmp5, cpu_T[1], -1);
1425
1426 if (is_right) {
1427 if (is_arith) {
1428 gen_exts(ot, cpu_T[0]);
1429 tcg_gen_sar_tl(cpu_T3, cpu_T[0], cpu_tmp5);
1430 tcg_gen_sar_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1431 } else {
1432 gen_extu(ot, cpu_T[0]);
1433 tcg_gen_shr_tl(cpu_T3, cpu_T[0], cpu_tmp5);
1434 tcg_gen_shr_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1435 }
1436 } else {
1437 tcg_gen_shl_tl(cpu_T3, cpu_T[0], cpu_tmp5);
1438 tcg_gen_shl_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
1439 }
1440
1441 /* store */
1442 if (op1 == OR_TMP0)
1443 gen_op_st_T0_A0(ot + s->mem_index);
1444 else
1445 gen_op_mov_reg_T0(ot, op1);
1446
1447 /* update eflags if non zero shift */
1448 if (s->cc_op != CC_OP_DYNAMIC)
1449 gen_op_set_cc_op(s->cc_op);
1450
1451 /* XXX: inefficient */
1452 t0 = tcg_temp_local_new();
1453 t1 = tcg_temp_local_new();
1454
1455 tcg_gen_mov_tl(t0, cpu_T[0]);
1456 tcg_gen_mov_tl(t1, cpu_T3);
1457
1458 shift_label = gen_new_label();
1459 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_T[1], 0, shift_label);
1460
1461 tcg_gen_mov_tl(cpu_cc_src, t1);
1462 tcg_gen_mov_tl(cpu_cc_dst, t0);
1463 if (is_right)
1464 tcg_gen_movi_i32(cpu_cc_op, CC_OP_SARB + ot);
1465 else
1466 tcg_gen_movi_i32(cpu_cc_op, CC_OP_SHLB + ot);
1467
1468 gen_set_label(shift_label);
1469 s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
1470
1471 tcg_temp_free(t0);
1472 tcg_temp_free(t1);
1473 }
1474
1475 static void gen_shift_rm_im(DisasContext *s, int ot, int op1, int op2,
1476 int is_right, int is_arith)
1477 {
1478 int mask;
1479
1480 if (ot == OT_QUAD)
1481 mask = 0x3f;
1482 else
1483 mask = 0x1f;
1484
1485 /* load */
1486 if (op1 == OR_TMP0)
1487 gen_op_ld_T0_A0(ot + s->mem_index);
1488 else
1489 gen_op_mov_TN_reg(ot, 0, op1);
1490
1491 op2 &= mask;
1492 if (op2 != 0) {
1493 if (is_right) {
1494 if (is_arith) {
1495 gen_exts(ot, cpu_T[0]);
1496 tcg_gen_sari_tl(cpu_tmp4, cpu_T[0], op2 - 1);
1497 tcg_gen_sari_tl(cpu_T[0], cpu_T[0], op2);
1498 } else {
1499 gen_extu(ot, cpu_T[0]);
1500 tcg_gen_shri_tl(cpu_tmp4, cpu_T[0], op2 - 1);
1501 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], op2);
1502 }
1503 } else {
1504 tcg_gen_shli_tl(cpu_tmp4, cpu_T[0], op2 - 1);
1505 tcg_gen_shli_tl(cpu_T[0], cpu_T[0], op2);
1506 }
1507 }
1508
1509 /* store */
1510 if (op1 == OR_TMP0)
1511 gen_op_st_T0_A0(ot + s->mem_index);
1512 else
1513 gen_op_mov_reg_T0(ot, op1);
1514
1515 /* update eflags if non zero shift */
1516 if (op2 != 0) {
1517 tcg_gen_mov_tl(cpu_cc_src, cpu_tmp4);
1518 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
1519 if (is_right)
1520 s->cc_op = CC_OP_SARB + ot;
1521 else
1522 s->cc_op = CC_OP_SHLB + ot;
1523 }
1524 }
1525
1526 static inline void tcg_gen_lshift(TCGv ret, TCGv arg1, target_long arg2)
1527 {
1528 if (arg2 >= 0)
1529 tcg_gen_shli_tl(ret, arg1, arg2);
1530 else
1531 tcg_gen_shri_tl(ret, arg1, -arg2);
1532 }
1533
1534 static void gen_rot_rm_T1(DisasContext *s, int ot, int op1,
1535 int is_right)
1536 {
1537 target_ulong mask;
1538 int label1, label2, data_bits;
1539 TCGv t0, t1, t2, a0;
1540
1541 /* XXX: inefficient, but we must use local temps */
1542 t0 = tcg_temp_local_new();
1543 t1 = tcg_temp_local_new();
1544 t2 = tcg_temp_local_new();
1545 a0 = tcg_temp_local_new();
1546
1547 if (ot == OT_QUAD)
1548 mask = 0x3f;
1549 else
1550 mask = 0x1f;
1551
1552 /* load */
1553 if (op1 == OR_TMP0) {
1554 tcg_gen_mov_tl(a0, cpu_A0);
1555 gen_op_ld_v(ot + s->mem_index, t0, a0);
1556 } else {
1557 gen_op_mov_v_reg(ot, t0, op1);
1558 }
1559
1560 tcg_gen_mov_tl(t1, cpu_T[1]);
1561
1562 tcg_gen_andi_tl(t1, t1, mask);
1563
1564 /* Must test zero case to avoid using undefined behaviour in TCG
1565 shifts. */
1566 label1 = gen_new_label();
1567 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, label1);
1568
1569 if (ot <= OT_WORD)
1570 tcg_gen_andi_tl(cpu_tmp0, t1, (1 << (3 + ot)) - 1);
1571 else
1572 tcg_gen_mov_tl(cpu_tmp0, t1);
1573
1574 gen_extu(ot, t0);
1575 tcg_gen_mov_tl(t2, t0);
1576
1577 data_bits = 8 << ot;
1578 /* XXX: rely on behaviour of shifts when operand 2 overflows (XXX:
1579 fix TCG definition) */
1580 if (is_right) {
1581 tcg_gen_shr_tl(cpu_tmp4, t0, cpu_tmp0);
1582 tcg_gen_subfi_tl(cpu_tmp0, data_bits, cpu_tmp0);
1583 tcg_gen_shl_tl(t0, t0, cpu_tmp0);
1584 } else {
1585 tcg_gen_shl_tl(cpu_tmp4, t0, cpu_tmp0);
1586 tcg_gen_subfi_tl(cpu_tmp0, data_bits, cpu_tmp0);
1587 tcg_gen_shr_tl(t0, t0, cpu_tmp0);
1588 }
1589 tcg_gen_or_tl(t0, t0, cpu_tmp4);
1590
1591 gen_set_label(label1);
1592 /* store */
1593 if (op1 == OR_TMP0) {
1594 gen_op_st_v(ot + s->mem_index, t0, a0);
1595 } else {
1596 gen_op_mov_reg_v(ot, op1, t0);
1597 }
1598
1599 /* update eflags */
1600 if (s->cc_op != CC_OP_DYNAMIC)
1601 gen_op_set_cc_op(s->cc_op);
1602
1603 label2 = gen_new_label();
1604 tcg_gen_brcondi_tl(TCG_COND_EQ, t1, 0, label2);
1605
1606 gen_compute_eflags(cpu_cc_src);
1607 tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~(CC_O | CC_C));
1608 tcg_gen_xor_tl(cpu_tmp0, t2, t0);
1609 tcg_gen_lshift(cpu_tmp0, cpu_tmp0, 11 - (data_bits - 1));
1610 tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, CC_O);
1611 tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_tmp0);
1612 if (is_right) {
1613 tcg_gen_shri_tl(t0, t0, data_bits - 1);
1614 }
1615 tcg_gen_andi_tl(t0, t0, CC_C);
1616 tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t0);
1617
1618 tcg_gen_discard_tl(cpu_cc_dst);
1619 tcg_gen_movi_i32(cpu_cc_op, CC_OP_EFLAGS);
1620
1621 gen_set_label(label2);
1622 s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
1623
1624 tcg_temp_free(t0);
1625 tcg_temp_free(t1);
1626 tcg_temp_free(t2);
1627 tcg_temp_free(a0);
1628 }
1629
1630 static void gen_rot_rm_im(DisasContext *s, int ot, int op1, int op2,
1631 int is_right)
1632 {
1633 int mask;
1634 int data_bits;
1635 TCGv t0, t1, a0;
1636
1637 /* XXX: inefficient, but we must use local temps */
1638 t0 = tcg_temp_local_new();
1639 t1 = tcg_temp_local_new();
1640 a0 = tcg_temp_local_new();
1641
1642 if (ot == OT_QUAD)
1643 mask = 0x3f;
1644 else
1645 mask = 0x1f;
1646
1647 /* load */
1648 if (op1 == OR_TMP0) {
1649 tcg_gen_mov_tl(a0, cpu_A0);
1650 gen_op_ld_v(ot + s->mem_index, t0, a0);
1651 } else {
1652 gen_op_mov_v_reg(ot, t0, op1);
1653 }
1654
1655 gen_extu(ot, t0);
1656 tcg_gen_mov_tl(t1, t0);
1657
1658 op2 &= mask;
1659 data_bits = 8 << ot;
1660 if (op2 != 0) {
1661 int shift = op2 & ((1 << (3 + ot)) - 1);
1662 if (is_right) {
1663 tcg_gen_shri_tl(cpu_tmp4, t0, shift);
1664 tcg_gen_shli_tl(t0, t0, data_bits - shift);
1665 }
1666 else {
1667 tcg_gen_shli_tl(cpu_tmp4, t0, shift);
1668 tcg_gen_shri_tl(t0, t0, data_bits - shift);
1669 }
1670 tcg_gen_or_tl(t0, t0, cpu_tmp4);
1671 }
1672
1673 /* store */
1674 if (op1 == OR_TMP0) {
1675 gen_op_st_v(ot + s->mem_index, t0, a0);
1676 } else {
1677 gen_op_mov_reg_v(ot, op1, t0);
1678 }
1679
1680 if (op2 != 0) {
1681 /* update eflags */
1682 if (s->cc_op != CC_OP_DYNAMIC)
1683 gen_op_set_cc_op(s->cc_op);
1684
1685 gen_compute_eflags(cpu_cc_src);
1686 tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~(CC_O | CC_C));
1687 tcg_gen_xor_tl(cpu_tmp0, t1, t0);
1688 tcg_gen_lshift(cpu_tmp0, cpu_tmp0, 11 - (data_bits - 1));
1689 tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, CC_O);
1690 tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_tmp0);
1691 if (is_right) {
1692 tcg_gen_shri_tl(t0, t0, data_bits - 1);
1693 }
1694 tcg_gen_andi_tl(t0, t0, CC_C);
1695 tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t0);
1696
1697 tcg_gen_discard_tl(cpu_cc_dst);
1698 tcg_gen_movi_i32(cpu_cc_op, CC_OP_EFLAGS);
1699 s->cc_op = CC_OP_EFLAGS;
1700 }
1701
1702 tcg_temp_free(t0);
1703 tcg_temp_free(t1);
1704 tcg_temp_free(a0);
1705 }
1706
1707 /* XXX: add faster immediate = 1 case */
1708 static void gen_rotc_rm_T1(DisasContext *s, int ot, int op1,
1709 int is_right)
1710 {
1711 int label1;
1712
1713 if (s->cc_op != CC_OP_DYNAMIC)
1714 gen_op_set_cc_op(s->cc_op);
1715
1716 /* load */
1717 if (op1 == OR_TMP0)
1718 gen_op_ld_T0_A0(ot + s->mem_index);
1719 else
1720 gen_op_mov_TN_reg(ot, 0, op1);
1721
1722 if (is_right) {
1723 switch (ot) {
1724 case 0: gen_helper_rcrb(cpu_T[0], cpu_T[0], cpu_T[1]); break;
1725 case 1: gen_helper_rcrw(cpu_T[0], cpu_T[0], cpu_T[1]); break;
1726 case 2: gen_helper_rcrl(cpu_T[0], cpu_T[0], cpu_T[1]); break;
1727 #ifdef TARGET_X86_64
1728 case 3: gen_helper_rcrq(cpu_T[0], cpu_T[0], cpu_T[1]); break;
1729 #endif
1730 }
1731 } else {
1732 switch (ot) {
1733 case 0: gen_helper_rclb(cpu_T[0], cpu_T[0], cpu_T[1]); break;
1734 case 1: gen_helper_rclw(cpu_T[0], cpu_T[0], cpu_T[1]); break;
1735 case 2: gen_helper_rcll(cpu_T[0], cpu_T[0], cpu_T[1]); break;
1736 #ifdef TARGET_X86_64
1737 case 3: gen_helper_rclq(cpu_T[0], cpu_T[0], cpu_T[1]); break;
1738 #endif
1739 }
1740 }
1741 /* store */
1742 if (op1 == OR_TMP0)
1743 gen_op_st_T0_A0(ot + s->mem_index);
1744 else
1745 gen_op_mov_reg_T0(ot, op1);
1746
1747 /* update eflags */
1748 label1 = gen_new_label();
1749 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_cc_tmp, -1, label1);
1750
1751 tcg_gen_mov_tl(cpu_cc_src, cpu_cc_tmp);
1752 tcg_gen_discard_tl(cpu_cc_dst);
1753 tcg_gen_movi_i32(cpu_cc_op, CC_OP_EFLAGS);
1754
1755 gen_set_label(label1);
1756 s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
1757 }
1758
1759 /* XXX: add faster immediate case */
1760 static void gen_shiftd_rm_T1_T3(DisasContext *s, int ot, int op1,
1761 int is_right)
1762 {
1763 int label1, label2, data_bits;
1764 target_ulong mask;
1765 TCGv t0, t1, t2, a0;
1766
1767 t0 = tcg_temp_local_new();
1768 t1 = tcg_temp_local_new();
1769 t2 = tcg_temp_local_new();
1770 a0 = tcg_temp_local_new();
1771
1772 if (ot == OT_QUAD)
1773 mask = 0x3f;
1774 else
1775 mask = 0x1f;
1776
1777 /* load */
1778 if (op1 == OR_TMP0) {
1779 tcg_gen_mov_tl(a0, cpu_A0);
1780 gen_op_ld_v(ot + s->mem_index, t0, a0);
1781 } else {
1782 gen_op_mov_v_reg(ot, t0, op1);
1783 }
1784
1785 tcg_gen_andi_tl(cpu_T3, cpu_T3, mask);
1786
1787 tcg_gen_mov_tl(t1, cpu_T[1]);
1788 tcg_gen_mov_tl(t2, cpu_T3);
1789
1790 /* Must test zero case to avoid using undefined behaviour in TCG
1791 shifts. */
1792 label1 = gen_new_label();
1793 tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, label1);
1794
1795 tcg_gen_addi_tl(cpu_tmp5, t2, -1);
1796 if (ot == OT_WORD) {
1797 /* Note: we implement the Intel behaviour for shift count > 16 */
1798 if (is_right) {
1799 tcg_gen_andi_tl(t0, t0, 0xffff);
1800 tcg_gen_shli_tl(cpu_tmp0, t1, 16);
1801 tcg_gen_or_tl(t0, t0, cpu_tmp0);
1802 tcg_gen_ext32u_tl(t0, t0);
1803
1804 tcg_gen_shr_tl(cpu_tmp4, t0, cpu_tmp5);
1805
1806 /* only needed if count > 16, but a test would complicate */
1807 tcg_gen_subfi_tl(cpu_tmp5, 32, t2);
1808 tcg_gen_shl_tl(cpu_tmp0, t0, cpu_tmp5);
1809
1810 tcg_gen_shr_tl(t0, t0, t2);
1811
1812 tcg_gen_or_tl(t0, t0, cpu_tmp0);
1813 } else {
1814 /* XXX: not optimal */
1815 tcg_gen_andi_tl(t0, t0, 0xffff);
1816 tcg_gen_shli_tl(t1, t1, 16);
1817 tcg_gen_or_tl(t1, t1, t0);
1818 tcg_gen_ext32u_tl(t1, t1);
1819
1820 tcg_gen_shl_tl(cpu_tmp4, t0, cpu_tmp5);
1821 tcg_gen_subfi_tl(cpu_tmp0, 32, cpu_tmp5);
1822 tcg_gen_shr_tl(cpu_tmp5, t1, cpu_tmp0);
1823 tcg_gen_or_tl(cpu_tmp4, cpu_tmp4, cpu_tmp5);
1824
1825 tcg_gen_shl_tl(t0, t0, t2);
1826 tcg_gen_subfi_tl(cpu_tmp5, 32, t2);
1827 tcg_gen_shr_tl(t1, t1, cpu_tmp5);
1828 tcg_gen_or_tl(t0, t0, t1);
1829 }
1830 } else {
1831 data_bits = 8 << ot;
1832 if (is_right) {
1833 if (ot == OT_LONG)
1834 tcg_gen_ext32u_tl(t0, t0);
1835
1836 tcg_gen_shr_tl(cpu_tmp4, t0, cpu_tmp5);
1837
1838 tcg_gen_shr_tl(t0, t0, t2);
1839 tcg_gen_subfi_tl(cpu_tmp5, data_bits, t2);
1840 tcg_gen_shl_tl(t1, t1, cpu_tmp5);
1841 tcg_gen_or_tl(t0, t0, t1);
1842
1843 } else {
1844 if (ot == OT_LONG)
1845 tcg_gen_ext32u_tl(t1, t1);
1846
1847 tcg_gen_shl_tl(cpu_tmp4, t0, cpu_tmp5);
1848
1849 tcg_gen_shl_tl(t0, t0, t2);
1850 tcg_gen_subfi_tl(cpu_tmp5, data_bits, t2);
1851 tcg_gen_shr_tl(t1, t1, cpu_tmp5);
1852 tcg_gen_or_tl(t0, t0, t1);
1853 }
1854 }
1855 tcg_gen_mov_tl(t1, cpu_tmp4);
1856
1857 gen_set_label(label1);
1858 /* store */
1859 if (op1 == OR_TMP0) {
1860 gen_op_st_v(ot + s->mem_index, t0, a0);
1861 } else {
1862 gen_op_mov_reg_v(ot, op1, t0);
1863 }
1864
1865 /* update eflags */
1866 if (s->cc_op != CC_OP_DYNAMIC)
1867 gen_op_set_cc_op(s->cc_op);
1868
1869 label2 = gen_new_label();
1870 tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, label2);
1871
1872 tcg_gen_mov_tl(cpu_cc_src, t1);
1873 tcg_gen_mov_tl(cpu_cc_dst, t0);
1874 if (is_right) {
1875 tcg_gen_movi_i32(cpu_cc_op, CC_OP_SARB + ot);
1876 } else {
1877 tcg_gen_movi_i32(cpu_cc_op, CC_OP_SHLB + ot);
1878 }
1879 gen_set_label(label2);
1880 s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
1881
1882 tcg_temp_free(t0);
1883 tcg_temp_free(t1);
1884 tcg_temp_free(t2);
1885 tcg_temp_free(a0);
1886 }
1887
1888 static void gen_shift(DisasContext *s1, int op, int ot, int d, int s)
1889 {
1890 if (s != OR_TMP1)
1891 gen_op_mov_TN_reg(ot, 1, s);
1892 switch(op) {
1893 case OP_ROL:
1894 gen_rot_rm_T1(s1, ot, d, 0);
1895 break;
1896 case OP_ROR:
1897 gen_rot_rm_T1(s1, ot, d, 1);
1898 break;
1899 case OP_SHL:
1900 case OP_SHL1:
1901 gen_shift_rm_T1(s1, ot, d, 0, 0);
1902 break;
1903 case OP_SHR:
1904 gen_shift_rm_T1(s1, ot, d, 1, 0);
1905 break;
1906 case OP_SAR:
1907 gen_shift_rm_T1(s1, ot, d, 1, 1);
1908 break;
1909 case OP_RCL:
1910 gen_rotc_rm_T1(s1, ot, d, 0);
1911 break;
1912 case OP_RCR:
1913 gen_rotc_rm_T1(s1, ot, d, 1);
1914 break;
1915 }
1916 }
1917
1918 static void gen_shifti(DisasContext *s1, int op, int ot, int d, int c)
1919 {
1920 switch(op) {
1921 case OP_ROL:
1922 gen_rot_rm_im(s1, ot, d, c, 0);
1923 break;
1924 case OP_ROR:
1925 gen_rot_rm_im(s1, ot, d, c, 1);
1926 break;
1927 case OP_SHL:
1928 case OP_SHL1:
1929 gen_shift_rm_im(s1, ot, d, c, 0, 0);
1930 break;
1931 case OP_SHR:
1932 gen_shift_rm_im(s1, ot, d, c, 1, 0);
1933 break;
1934 case OP_SAR:
1935 gen_shift_rm_im(s1, ot, d, c, 1, 1);
1936 break;
1937 default:
1938 /* currently not optimized */
1939 gen_op_movl_T1_im(c);
1940 gen_shift(s1, op, ot, d, OR_TMP1);
1941 break;
1942 }
1943 }
1944
1945 static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_ptr)
1946 {
1947 target_long disp;
1948 int havesib;
1949 int base;
1950 int index;
1951 int scale;
1952 int opreg;
1953 int mod, rm, code, override, must_add_seg;
1954
1955 override = s->override;
1956 must_add_seg = s->addseg;
1957 if (override >= 0)
1958 must_add_seg = 1;
1959 mod = (modrm >> 6) & 3;
1960 rm = modrm & 7;
1961
1962 if (s->aflag) {
1963
1964 havesib = 0;
1965 base = rm;
1966 index = 0;
1967 scale = 0;
1968
1969 if (base == 4) {
1970 havesib = 1;
1971 code = ldub_code(s->pc++);
1972 scale = (code >> 6) & 3;
1973 index = ((code >> 3) & 7) | REX_X(s);
1974 base = (code & 7);
1975 }
1976 base |= REX_B(s);
1977
1978 switch (mod) {
1979 case 0:
1980 if ((base & 7) == 5) {
1981 base = -1;
1982 disp = (int32_t)ldl_code(s->pc);
1983 s->pc += 4;
1984 if (CODE64(s) && !havesib) {
1985 disp += s->pc + s->rip_offset;
1986 }
1987 } else {
1988 disp = 0;
1989 }
1990 break;
1991 case 1:
1992 disp = (int8_t)ldub_code(s->pc++);
1993 break;
1994 default:
1995 case 2:
1996 disp = (int32_t)ldl_code(s->pc);
1997 s->pc += 4;
1998 break;
1999 }
2000
2001 if (base >= 0) {
2002 /* for correct popl handling with esp */
2003 if (base == 4 && s->popl_esp_hack)
2004 disp += s->popl_esp_hack;
2005 #ifdef TARGET_X86_64
2006 if (s->aflag == 2) {
2007 gen_op_movq_A0_reg(base);
2008 if (disp != 0) {
2009 gen_op_addq_A0_im(disp);
2010 }
2011 } else
2012 #endif
2013 {
2014 gen_op_movl_A0_reg(base);
2015 if (disp != 0)
2016 gen_op_addl_A0_im(disp);
2017 }
2018 } else {
2019 #ifdef TARGET_X86_64
2020 if (s->aflag == 2) {
2021 gen_op_movq_A0_im(disp);
2022 } else
2023 #endif
2024 {
2025 gen_op_movl_A0_im(disp);
2026 }
2027 }
2028 /* index == 4 means no index */
2029 if (havesib && (index != 4)) {
2030 #ifdef TARGET_X86_64
2031 if (s->aflag == 2) {
2032 gen_op_addq_A0_reg_sN(scale, index);
2033 } else
2034 #endif
2035 {
2036 gen_op_addl_A0_reg_sN(scale, index);
2037 }
2038 }
2039 if (must_add_seg) {
2040 if (override < 0) {
2041 if (base == R_EBP || base == R_ESP)
2042 override = R_SS;
2043 else
2044 override = R_DS;
2045 }
2046 #ifdef TARGET_X86_64
2047 if (s->aflag == 2) {
2048 gen_op_addq_A0_seg(override);
2049 } else
2050 #endif
2051 {
2052 gen_op_addl_A0_seg(override);
2053 }
2054 }
2055 } else {
2056 switch (mod) {
2057 case 0:
2058 if (rm == 6) {
2059 disp = lduw_code(s->pc);
2060 s->pc += 2;
2061 gen_op_movl_A0_im(disp);
2062 rm = 0; /* avoid SS override */
2063 goto no_rm;
2064 } else {
2065 disp = 0;
2066 }
2067 break;
2068 case 1:
2069 disp = (int8_t)ldub_code(s->pc++);
2070 break;
2071 default:
2072 case 2:
2073 disp = lduw_code(s->pc);
2074 s->pc += 2;
2075 break;
2076 }
2077 switch(rm) {
2078 case 0:
2079 gen_op_movl_A0_reg(R_EBX);
2080 gen_op_addl_A0_reg_sN(0, R_ESI);
2081 break;
2082 case 1:
2083 gen_op_movl_A0_reg(R_EBX);
2084 gen_op_addl_A0_reg_sN(0, R_EDI);
2085 break;
2086 case 2:
2087 gen_op_movl_A0_reg(R_EBP);
2088 gen_op_addl_A0_reg_sN(0, R_ESI);
2089 break;
2090 case 3:
2091 gen_op_movl_A0_reg(R_EBP);
2092 gen_op_addl_A0_reg_sN(0, R_EDI);
2093 break;
2094 case 4:
2095 gen_op_movl_A0_reg(R_ESI);
2096 break;
2097 case 5:
2098 gen_op_movl_A0_reg(R_EDI);
2099 break;
2100 case 6:
2101 gen_op_movl_A0_reg(R_EBP);
2102 break;
2103 default:
2104 case 7:
2105 gen_op_movl_A0_reg(R_EBX);
2106 break;
2107 }
2108 if (disp != 0)
2109 gen_op_addl_A0_im(disp);
2110 gen_op_andl_A0_ffff();
2111 no_rm:
2112 if (must_add_seg) {
2113 if (override < 0) {
2114 if (rm == 2 || rm == 3 || rm == 6)
2115 override = R_SS;
2116 else
2117 override = R_DS;
2118 }
2119 gen_op_addl_A0_seg(override);
2120 }
2121 }
2122
2123 opreg = OR_A0;
2124 disp = 0;
2125 *reg_ptr = opreg;
2126 *offset_ptr = disp;
2127 }
2128
2129 static void gen_nop_modrm(DisasContext *s, int modrm)
2130 {
2131 int mod, rm, base, code;
2132
2133 mod = (modrm >> 6) & 3;
2134 if (mod == 3)
2135 return;
2136 rm = modrm & 7;
2137
2138 if (s->aflag) {
2139
2140 base = rm;
2141
2142 if (base == 4) {
2143 code = ldub_code(s->pc++);
2144 base = (code & 7);
2145 }
2146
2147 switch (mod) {
2148 case 0:
2149 if (base == 5) {
2150 s->pc += 4;
2151 }
2152 break;
2153 case 1:
2154 s->pc++;
2155 break;
2156 default:
2157 case 2:
2158 s->pc += 4;
2159 break;
2160 }
2161 } else {
2162 switch (mod) {
2163 case 0:
2164 if (rm == 6) {
2165 s->pc += 2;
2166 }
2167 break;
2168 case 1:
2169 s->pc++;
2170 break;
2171 default:
2172 case 2:
2173 s->pc += 2;
2174 break;
2175 }
2176 }
2177 }
2178
2179 /* used for LEA and MOV AX, mem */
2180 static void gen_add_A0_ds_seg(DisasContext *s)
2181 {
2182 int override, must_add_seg;
2183 must_add_seg = s->addseg;
2184 override = R_DS;
2185 if (s->override >= 0) {
2186 override = s->override;
2187 must_add_seg = 1;
2188 }
2189 if (must_add_seg) {
2190 #ifdef TARGET_X86_64
2191 if (CODE64(s)) {
2192 gen_op_addq_A0_seg(override);
2193 } else
2194 #endif
2195 {
2196 gen_op_addl_A0_seg(override);
2197 }
2198 }
2199 }
2200
2201 /* generate modrm memory load or store of 'reg'. TMP0 is used if reg ==
2202 OR_TMP0 */
2203 static void gen_ldst_modrm(DisasContext *s, int modrm, int ot, int reg, int is_store)
2204 {
2205 int mod, rm, opreg, disp;
2206
2207 mod = (modrm >> 6) & 3;
2208 rm = (modrm & 7) | REX_B(s);
2209 if (mod == 3) {
2210 if (is_store) {
2211 if (reg != OR_TMP0)
2212 gen_op_mov_TN_reg(ot, 0, reg);
2213 gen_op_mov_reg_T0(ot, rm);
2214 } else {
2215 gen_op_mov_TN_reg(ot, 0, rm);
2216 if (reg != OR_TMP0)
2217 gen_op_mov_reg_T0(ot, reg);
2218 }
2219 } else {
2220 gen_lea_modrm(s, modrm, &opreg, &disp);
2221 if (is_store) {
2222 if (reg != OR_TMP0)
2223 gen_op_mov_TN_reg(ot, 0, reg);
2224 gen_op_st_T0_A0(ot + s->mem_index);
2225 } else {
2226 gen_op_ld_T0_A0(ot + s->mem_index);
2227 if (reg != OR_TMP0)
2228 gen_op_mov_reg_T0(ot, reg);
2229 }
2230 }
2231 }
2232
2233 static inline uint32_t insn_get(DisasContext *s, int ot)
2234 {
2235 uint32_t ret;
2236
2237 switch(ot) {
2238 case OT_BYTE:
2239 ret = ldub_code(s->pc);
2240 s->pc++;
2241 break;
2242 case OT_WORD:
2243 ret = lduw_code(s->pc);
2244 s->pc += 2;
2245 break;
2246 default:
2247 case OT_LONG:
2248 ret = ldl_code(s->pc);
2249 s->pc += 4;
2250 break;
2251 }
2252 return ret;
2253 }
2254
2255 static inline int insn_const_size(unsigned int ot)
2256 {
2257 if (ot <= OT_LONG)
2258 return 1 << ot;
2259 else
2260 return 4;
2261 }
2262
2263 static inline void gen_goto_tb(DisasContext *s, int tb_num, target_ulong eip)
2264 {
2265 TranslationBlock *tb;
2266 target_ulong pc;
2267
2268 pc = s->cs_base + eip;
2269 tb = s->tb;
2270 /* NOTE: we handle the case where the TB spans two pages here */
2271 if ((pc & TARGET_PAGE_MASK) == (tb->pc & TARGET_PAGE_MASK) ||
2272 (pc & TARGET_PAGE_MASK) == ((s->pc - 1) & TARGET_PAGE_MASK)) {
2273 /* jump to same page: we can use a direct jump */
2274 tcg_gen_goto_tb(tb_num);
2275 gen_jmp_im(eip);
2276 tcg_gen_exit_tb((tcg_target_long)tb + tb_num);
2277 } else {
2278 /* jump to another page: currently not optimized */
2279 gen_jmp_im(eip);
2280 gen_eob(s);
2281 }
2282 }
2283
2284 static inline void gen_jcc(DisasContext *s, int b,
2285 target_ulong val, target_ulong next_eip)
2286 {
2287 int l1, l2, cc_op;
2288
2289 cc_op = s->cc_op;
2290 gen_update_cc_op(s);
2291 if (s->jmp_opt) {
2292 l1 = gen_new_label();
2293 gen_jcc1(s, cc_op, b, l1);
2294
2295 gen_goto_tb(s, 0, next_eip);
2296
2297 gen_set_label(l1);
2298 gen_goto_tb(s, 1, val);
2299 s->is_jmp = DISAS_TB_JUMP;
2300 } else {
2301
2302 l1 = gen_new_label();
2303 l2 = gen_new_label();
2304 gen_jcc1(s, cc_op, b, l1);
2305
2306 gen_jmp_im(next_eip);
2307 tcg_gen_br(l2);
2308
2309 gen_set_label(l1);
2310 gen_jmp_im(val);
2311 gen_set_label(l2);
2312 gen_eob(s);
2313 }
2314 }
2315
2316 static void gen_setcc(DisasContext *s, int b)
2317 {
2318 int inv, jcc_op, l1;
2319 TCGv t0;
2320
2321 if (is_fast_jcc_case(s, b)) {
2322 /* nominal case: we use a jump */
2323 /* XXX: make it faster by adding new instructions in TCG */
2324 t0 = tcg_temp_local_new();
2325 tcg_gen_movi_tl(t0, 0);
2326 l1 = gen_new_label();
2327 gen_jcc1(s, s->cc_op, b ^ 1, l1);
2328 tcg_gen_movi_tl(t0, 1);
2329 gen_set_label(l1);
2330 tcg_gen_mov_tl(cpu_T[0], t0);
2331 tcg_temp_free(t0);
2332 } else {
2333 /* slow case: it is more efficient not to generate a jump,
2334 although it is questionnable whether this optimization is
2335 worth to */
2336 inv = b & 1;
2337 jcc_op = (b >> 1) & 7;
2338 gen_setcc_slow_T0(s, jcc_op);
2339 if (inv) {
2340 tcg_gen_xori_tl(cpu_T[0], cpu_T[0], 1);
2341 }
2342 }
2343 }
2344
2345 static inline void gen_op_movl_T0_seg(int seg_reg)
2346 {
2347 tcg_gen_ld32u_tl(cpu_T[0], cpu_env,
2348 offsetof(CPUX86State,segs[seg_reg].selector));
2349 }
2350
2351 static inline void gen_op_movl_seg_T0_vm(int seg_reg)
2352 {
2353 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xffff);
2354 tcg_gen_st32_tl(cpu_T[0], cpu_env,
2355 offsetof(CPUX86State,segs[seg_reg].selector));
2356 tcg_gen_shli_tl(cpu_T[0], cpu_T[0], 4);
2357 tcg_gen_st_tl(cpu_T[0], cpu_env,
2358 offsetof(CPUX86State,segs[seg_reg].base));
2359 }
2360
2361 /* move T0 to seg_reg and compute if the CPU state may change. Never
2362 call this function with seg_reg == R_CS */
2363 static void gen_movl_seg_T0(DisasContext *s, int seg_reg, target_ulong cur_eip)
2364 {
2365 if (s->pe && !s->vm86) {
2366 /* XXX: optimize by finding processor state dynamically */
2367 if (s->cc_op != CC_OP_DYNAMIC)
2368 gen_op_set_cc_op(s->cc_op);
2369 gen_jmp_im(cur_eip);
2370 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
2371 gen_helper_load_seg(tcg_const_i32(seg_reg), cpu_tmp2_i32);
2372 /* abort translation because the addseg value may change or
2373 because ss32 may change. For R_SS, translation must always
2374 stop as a special handling must be done to disable hardware
2375 interrupts for the next instruction */
2376 if (seg_reg == R_SS || (s->code32 && seg_reg < R_FS))
2377 s->is_jmp = DISAS_TB_JUMP;
2378 } else {
2379 gen_op_movl_seg_T0_vm(seg_reg);
2380 if (seg_reg == R_SS)
2381 s->is_jmp = DISAS_TB_JUMP;
2382 }
2383 }
2384
2385 static inline int svm_is_rep(int prefixes)
2386 {
2387 return ((prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) ? 8 : 0);
2388 }
2389
2390 static inline void
2391 gen_svm_check_intercept_param(DisasContext *s, target_ulong pc_start,
2392 uint32_t type, uint64_t param)
2393 {
2394 /* no SVM activated; fast case */
2395 if (likely(!(s->flags & HF_SVMI_MASK)))
2396 return;
2397 if (s->cc_op != CC_OP_DYNAMIC)
2398 gen_op_set_cc_op(s->cc_op);
2399 gen_jmp_im(pc_start - s->cs_base);
2400 gen_helper_svm_check_intercept_param(tcg_const_i32(type),
2401 tcg_const_i64(param));
2402 }
2403
2404 static inline void
2405 gen_svm_check_intercept(DisasContext *s, target_ulong pc_start, uint64_t type)
2406 {
2407 gen_svm_check_intercept_param(s, pc_start, type, 0);
2408 }
2409
2410 static inline void gen_stack_update(DisasContext *s, int addend)
2411 {
2412 #ifdef TARGET_X86_64
2413 if (CODE64(s)) {
2414 gen_op_add_reg_im(2, R_ESP, addend);
2415 } else
2416 #endif
2417 if (s->ss32) {
2418 gen_op_add_reg_im(1, R_ESP, addend);
2419 } else {
2420 gen_op_add_reg_im(0, R_ESP, addend);
2421 }
2422 }
2423
2424 /* generate a push. It depends on ss32, addseg and dflag */
2425 static void gen_push_T0(DisasContext *s)
2426 {
2427 #ifdef TARGET_X86_64
2428 if (CODE64(s)) {
2429 gen_op_movq_A0_reg(R_ESP);
2430 if (s->dflag) {
2431 gen_op_addq_A0_im(-8);
2432 gen_op_st_T0_A0(OT_QUAD + s->mem_index);
2433 } else {
2434 gen_op_addq_A0_im(-2);
2435 gen_op_st_T0_A0(OT_WORD + s->mem_index);
2436 }
2437 gen_op_mov_reg_A0(2, R_ESP);
2438 } else
2439 #endif
2440 {
2441 gen_op_movl_A0_reg(R_ESP);
2442 if (!s->dflag)
2443 gen_op_addl_A0_im(-2);
2444 else
2445 gen_op_addl_A0_im(-4);
2446 if (s->ss32) {
2447 if (s->addseg) {
2448 tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2449 gen_op_addl_A0_seg(R_SS);
2450 }
2451 } else {
2452 gen_op_andl_A0_ffff();
2453 tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2454 gen_op_addl_A0_seg(R_SS);
2455 }
2456 gen_op_st_T0_A0(s->dflag + 1 + s->mem_index);
2457 if (s->ss32 && !s->addseg)
2458 gen_op_mov_reg_A0(1, R_ESP);
2459 else
2460 gen_op_mov_reg_T1(s->ss32 + 1, R_ESP);
2461 }
2462 }
2463
2464 /* generate a push. It depends on ss32, addseg and dflag */
2465 /* slower version for T1, only used for call Ev */
2466 static void gen_push_T1(DisasContext *s)
2467 {
2468 #ifdef TARGET_X86_64
2469 if (CODE64(s)) {
2470 gen_op_movq_A0_reg(R_ESP);
2471 if (s->dflag) {
2472 gen_op_addq_A0_im(-8);
2473 gen_op_st_T1_A0(OT_QUAD + s->mem_index);
2474 } else {
2475 gen_op_addq_A0_im(-2);
2476 gen_op_st_T0_A0(OT_WORD + s->mem_index);
2477 }
2478 gen_op_mov_reg_A0(2, R_ESP);
2479 } else
2480 #endif
2481 {
2482 gen_op_movl_A0_reg(R_ESP);
2483 if (!s->dflag)
2484 gen_op_addl_A0_im(-2);
2485 else
2486 gen_op_addl_A0_im(-4);
2487 if (s->ss32) {
2488 if (s->addseg) {
2489 gen_op_addl_A0_seg(R_SS);
2490 }
2491 } else {
2492 gen_op_andl_A0_ffff();
2493 gen_op_addl_A0_seg(R_SS);
2494 }
2495 gen_op_st_T1_A0(s->dflag + 1 + s->mem_index);
2496
2497 if (s->ss32 && !s->addseg)
2498 gen_op_mov_reg_A0(1, R_ESP);
2499 else
2500 gen_stack_update(s, (-2) << s->dflag);
2501 }
2502 }
2503
2504 /* two step pop is necessary for precise exceptions */
2505 static void gen_pop_T0(DisasContext *s)
2506 {
2507 #ifdef TARGET_X86_64
2508 if (CODE64(s)) {
2509 gen_op_movq_A0_reg(R_ESP);
2510 gen_op_ld_T0_A0((s->dflag ? OT_QUAD : OT_WORD) + s->mem_index);
2511 } else
2512 #endif
2513 {
2514 gen_op_movl_A0_reg(R_ESP);
2515 if (s->ss32) {
2516 if (s->addseg)
2517 gen_op_addl_A0_seg(R_SS);
2518 } else {
2519 gen_op_andl_A0_ffff();
2520 gen_op_addl_A0_seg(R_SS);
2521 }
2522 gen_op_ld_T0_A0(s->dflag + 1 + s->mem_index);
2523 }
2524 }
2525
2526 static void gen_pop_update(DisasContext *s)
2527 {
2528 #ifdef TARGET_X86_64
2529 if (CODE64(s) && s->dflag) {
2530 gen_stack_update(s, 8);
2531 } else
2532 #endif
2533 {
2534 gen_stack_update(s, 2 << s->dflag);
2535 }
2536 }
2537
2538 static void gen_stack_A0(DisasContext *s)
2539 {
2540 gen_op_movl_A0_reg(R_ESP);
2541 if (!s->ss32)
2542 gen_op_andl_A0_ffff();
2543 tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2544 if (s->addseg)
2545 gen_op_addl_A0_seg(R_SS);
2546 }
2547
2548 /* NOTE: wrap around in 16 bit not fully handled */
2549 static void gen_pusha(DisasContext *s)
2550 {
2551 int i;
2552 gen_op_movl_A0_reg(R_ESP);
2553 gen_op_addl_A0_im(-16 << s->dflag);
2554 if (!s->ss32)
2555 gen_op_andl_A0_ffff();
2556 tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2557 if (s->addseg)
2558 gen_op_addl_A0_seg(R_SS);
2559 for(i = 0;i < 8; i++) {
2560 gen_op_mov_TN_reg(OT_LONG, 0, 7 - i);
2561 gen_op_st_T0_A0(OT_WORD + s->dflag + s->mem_index);
2562 gen_op_addl_A0_im(2 << s->dflag);
2563 }
2564 gen_op_mov_reg_T1(OT_WORD + s->ss32, R_ESP);
2565 }
2566
2567 /* NOTE: wrap around in 16 bit not fully handled */
2568 static void gen_popa(DisasContext *s)
2569 {
2570 int i;
2571 gen_op_movl_A0_reg(R_ESP);
2572 if (!s->ss32)
2573 gen_op_andl_A0_ffff();
2574 tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2575 tcg_gen_addi_tl(cpu_T[1], cpu_T[1], 16 << s->dflag);
2576 if (s->addseg)
2577 gen_op_addl_A0_seg(R_SS);
2578 for(i = 0;i < 8; i++) {
2579 /* ESP is not reloaded */
2580 if (i != 3) {
2581 gen_op_ld_T0_A0(OT_WORD + s->dflag + s->mem_index);
2582 gen_op_mov_reg_T0(OT_WORD + s->dflag, 7 - i);
2583 }
2584 gen_op_addl_A0_im(2 << s->dflag);
2585 }
2586 gen_op_mov_reg_T1(OT_WORD + s->ss32, R_ESP);
2587 }
2588
2589 static void gen_enter(DisasContext *s, int esp_addend, int level)
2590 {
2591 int ot, opsize;
2592
2593 level &= 0x1f;
2594 #ifdef TARGET_X86_64
2595 if (CODE64(s)) {
2596 ot = s->dflag ? OT_QUAD : OT_WORD;
2597 opsize = 1 << ot;
2598
2599 gen_op_movl_A0_reg(R_ESP);
2600 gen_op_addq_A0_im(-opsize);
2601 tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2602
2603 /* push bp */
2604 gen_op_mov_TN_reg(OT_LONG, 0, R_EBP);
2605 gen_op_st_T0_A0(ot + s->mem_index);
2606 if (level) {
2607 /* XXX: must save state */
2608 gen_helper_enter64_level(tcg_const_i32(level),
2609 tcg_const_i32((ot == OT_QUAD)),
2610 cpu_T[1]);
2611 }
2612 gen_op_mov_reg_T1(ot, R_EBP);
2613 tcg_gen_addi_tl(cpu_T[1], cpu_T[1], -esp_addend + (-opsize * level));
2614 gen_op_mov_reg_T1(OT_QUAD, R_ESP);
2615 } else
2616 #endif
2617 {
2618 ot = s->dflag + OT_WORD;
2619 opsize = 2 << s->dflag;
2620
2621 gen_op_movl_A0_reg(R_ESP);
2622 gen_op_addl_A0_im(-opsize);
2623 if (!s->ss32)
2624 gen_op_andl_A0_ffff();
2625 tcg_gen_mov_tl(cpu_T[1], cpu_A0);
2626 if (s->addseg)
2627 gen_op_addl_A0_seg(R_SS);
2628 /* push bp */
2629 gen_op_mov_TN_reg(OT_LONG, 0, R_EBP);
2630 gen_op_st_T0_A0(ot + s->mem_index);
2631 if (level) {
2632 /* XXX: must save state */
2633 gen_helper_enter_level(tcg_const_i32(level),
2634 tcg_const_i32(s->dflag),
2635 cpu_T[1]);
2636 }
2637 gen_op_mov_reg_T1(ot, R_EBP);
2638 tcg_gen_addi_tl(cpu_T[1], cpu_T[1], -esp_addend + (-opsize * level));
2639 gen_op_mov_reg_T1(OT_WORD + s->ss32, R_ESP);
2640 }
2641 }
2642
2643 static void gen_exception(DisasContext *s, int trapno, target_ulong cur_eip)
2644 {
2645 if (s->cc_op != CC_OP_DYNAMIC)
2646 gen_op_set_cc_op(s->cc_op);
2647 gen_jmp_im(cur_eip);
2648 gen_helper_raise_exception(tcg_const_i32(trapno));
2649 s->is_jmp = DISAS_TB_JUMP;
2650 }
2651
2652 /* an interrupt is different from an exception because of the
2653 privilege checks */
2654 static void gen_interrupt(DisasContext *s, int intno,
2655 target_ulong cur_eip, target_ulong next_eip)
2656 {
2657 if (s->cc_op != CC_OP_DYNAMIC)
2658 gen_op_set_cc_op(s->cc_op);
2659 gen_jmp_im(cur_eip);
2660 gen_helper_raise_interrupt(tcg_const_i32(intno),
2661 tcg_const_i32(next_eip - cur_eip));
2662 s->is_jmp = DISAS_TB_JUMP;
2663 }
2664
2665 static void gen_debug(DisasContext *s, target_ulong cur_eip)
2666 {
2667 if (s->cc_op != CC_OP_DYNAMIC)
2668 gen_op_set_cc_op(s->cc_op);
2669 gen_jmp_im(cur_eip);
2670 gen_helper_debug();
2671 s->is_jmp = DISAS_TB_JUMP;
2672 }
2673
2674 /* generate a generic end of block. Trace exception is also generated
2675 if needed */
2676 static void gen_eob(DisasContext *s)
2677 {
2678 if (s->cc_op != CC_OP_DYNAMIC)
2679 gen_op_set_cc_op(s->cc_op);
2680 if (s->tb->flags & HF_INHIBIT_IRQ_MASK) {
2681 gen_helper_reset_inhibit_irq();
2682 }
2683 if (s->tb->flags & HF_RF_MASK) {
2684 gen_helper_reset_rf();
2685 }
2686 if (s->singlestep_enabled) {
2687 gen_helper_debug();
2688 } else if (s->tf) {
2689 gen_helper_single_step();
2690 } else {
2691 tcg_gen_exit_tb(0);
2692 }
2693 s->is_jmp = DISAS_TB_JUMP;
2694 }
2695
2696 /* generate a jump to eip. No segment change must happen before as a
2697 direct call to the next block may occur */
2698 static void gen_jmp_tb(DisasContext *s, target_ulong eip, int tb_num)
2699 {
2700 if (s->jmp_opt) {
2701 gen_update_cc_op(s);
2702 gen_goto_tb(s, tb_num, eip);
2703 s->is_jmp = DISAS_TB_JUMP;
2704 } else {
2705 gen_jmp_im(eip);
2706 gen_eob(s);
2707 }
2708 }
2709
2710 static void gen_jmp(DisasContext *s, target_ulong eip)
2711 {
2712 gen_jmp_tb(s, eip, 0);
2713 }
2714
2715 static inline void gen_ldq_env_A0(int idx, int offset)
2716 {
2717 int mem_index = (idx >> 2) - 1;
2718 tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0, mem_index);
2719 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset);
2720 }
2721
2722 static inline void gen_stq_env_A0(int idx, int offset)
2723 {
2724 int mem_index = (idx >> 2) - 1;
2725 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset);
2726 tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0, mem_index);
2727 }
2728
2729 static inline void gen_ldo_env_A0(int idx, int offset)
2730 {
2731 int mem_index = (idx >> 2) - 1;
2732 tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0, mem_index);
2733 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(0)));
2734 tcg_gen_addi_tl(cpu_tmp0, cpu_A0, 8);
2735 tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_tmp0, mem_index);
2736 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(1)));
2737 }
2738
2739 static inline void gen_sto_env_A0(int idx, int offset)
2740 {
2741 int mem_index = (idx >> 2) - 1;
2742 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(0)));
2743 tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0, mem_index);
2744 tcg_gen_addi_tl(cpu_tmp0, cpu_A0, 8);
2745 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, offset + offsetof(XMMReg, XMM_Q(1)));
2746 tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_tmp0, mem_index);
2747 }
2748
2749 static inline void gen_op_movo(int d_offset, int s_offset)
2750 {
2751 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset);
2752 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
2753 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset + 8);
2754 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset + 8);
2755 }
2756
2757 static inline void gen_op_movq(int d_offset, int s_offset)
2758 {
2759 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env, s_offset);
2760 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
2761 }
2762
2763 static inline void gen_op_movl(int d_offset, int s_offset)
2764 {
2765 tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env, s_offset);
2766 tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, d_offset);
2767 }
2768
2769 static inline void gen_op_movq_env_0(int d_offset)
2770 {
2771 tcg_gen_movi_i64(cpu_tmp1_i64, 0);
2772 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env, d_offset);
2773 }
2774
2775 #define SSE_SPECIAL ((void *)1)
2776 #define SSE_DUMMY ((void *)2)
2777
2778 #define MMX_OP2(x) { gen_helper_ ## x ## _mmx, gen_helper_ ## x ## _xmm }
2779 #define SSE_FOP(x) { gen_helper_ ## x ## ps, gen_helper_ ## x ## pd, \
2780 gen_helper_ ## x ## ss, gen_helper_ ## x ## sd, }
2781
2782 static void *sse_op_table1[256][4] = {
2783 /* 3DNow! extensions */
2784 [0x0e] = { SSE_DUMMY }, /* femms */
2785 [0x0f] = { SSE_DUMMY }, /* pf... */
2786 /* pure SSE operations */
2787 [0x10] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movups, movupd, movss, movsd */
2788 [0x11] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movups, movupd, movss, movsd */
2789 [0x12] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movlps, movlpd, movsldup, movddup */
2790 [0x13] = { SSE_SPECIAL, SSE_SPECIAL }, /* movlps, movlpd */
2791 [0x14] = { gen_helper_punpckldq_xmm, gen_helper_punpcklqdq_xmm },
2792 [0x15] = { gen_helper_punpckhdq_xmm, gen_helper_punpckhqdq_xmm },
2793 [0x16] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movhps, movhpd, movshdup */
2794 [0x17] = { SSE_SPECIAL, SSE_SPECIAL }, /* movhps, movhpd */
2795
2796 [0x28] = { SSE_SPECIAL, SSE_SPECIAL }, /* movaps, movapd */
2797 [0x29] = { SSE_SPECIAL, SSE_SPECIAL }, /* movaps, movapd */
2798 [0x2a] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvtpi2ps, cvtpi2pd, cvtsi2ss, cvtsi2sd */
2799 [0x2b] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movntps, movntpd, movntss, movntsd */
2800 [0x2c] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvttps2pi, cvttpd2pi, cvttsd2si, cvttss2si */
2801 [0x2d] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* cvtps2pi, cvtpd2pi, cvtsd2si, cvtss2si */
2802 [0x2e] = { gen_helper_ucomiss, gen_helper_ucomisd },
2803 [0x2f] = { gen_helper_comiss, gen_helper_comisd },
2804 [0x50] = { SSE_SPECIAL, SSE_SPECIAL }, /* movmskps, movmskpd */
2805 [0x51] = SSE_FOP(sqrt),
2806 [0x52] = { gen_helper_rsqrtps, NULL, gen_helper_rsqrtss, NULL },
2807 [0x53] = { gen_helper_rcpps, NULL, gen_helper_rcpss, NULL },
2808 [0x54] = { gen_helper_pand_xmm, gen_helper_pand_xmm }, /* andps, andpd */
2809 [0x55] = { gen_helper_pandn_xmm, gen_helper_pandn_xmm }, /* andnps, andnpd */
2810 [0x56] = { gen_helper_por_xmm, gen_helper_por_xmm }, /* orps, orpd */
2811 [0x57] = { gen_helper_pxor_xmm, gen_helper_pxor_xmm }, /* xorps, xorpd */
2812 [0x58] = SSE_FOP(add),
2813 [0x59] = SSE_FOP(mul),
2814 [0x5a] = { gen_helper_cvtps2pd, gen_helper_cvtpd2ps,
2815 gen_helper_cvtss2sd, gen_helper_cvtsd2ss },
2816 [0x5b] = { gen_helper_cvtdq2ps, gen_helper_cvtps2dq, gen_helper_cvttps2dq },
2817 [0x5c] = SSE_FOP(sub),
2818 [0x5d] = SSE_FOP(min),
2819 [0x5e] = SSE_FOP(div),
2820 [0x5f] = SSE_FOP(max),
2821
2822 [0xc2] = SSE_FOP(cmpeq),
2823 [0xc6] = { gen_helper_shufps, gen_helper_shufpd },
2824
2825 [0x38] = { SSE_SPECIAL, SSE_SPECIAL, NULL, SSE_SPECIAL }, /* SSSE3/SSE4 */
2826 [0x3a] = { SSE_SPECIAL, SSE_SPECIAL }, /* SSSE3/SSE4 */
2827
2828 /* MMX ops and their SSE extensions */
2829 [0x60] = MMX_OP2(punpcklbw),
2830 [0x61] = MMX_OP2(punpcklwd),
2831 [0x62] = MMX_OP2(punpckldq),
2832 [0x63] = MMX_OP2(packsswb),
2833 [0x64] = MMX_OP2(pcmpgtb),
2834 [0x65] = MMX_OP2(pcmpgtw),
2835 [0x66] = MMX_OP2(pcmpgtl),
2836 [0x67] = MMX_OP2(packuswb),
2837 [0x68] = MMX_OP2(punpckhbw),
2838 [0x69] = MMX_OP2(punpckhwd),
2839 [0x6a] = MMX_OP2(punpckhdq),
2840 [0x6b] = MMX_OP2(packssdw),
2841 [0x6c] = { NULL, gen_helper_punpcklqdq_xmm },
2842 [0x6d] = { NULL, gen_helper_punpckhqdq_xmm },
2843 [0x6e] = { SSE_SPECIAL, SSE_SPECIAL }, /* movd mm, ea */
2844 [0x6f] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movq, movdqa, , movqdu */
2845 [0x70] = { gen_helper_pshufw_mmx,
2846 gen_helper_pshufd_xmm,
2847 gen_helper_pshufhw_xmm,
2848 gen_helper_pshuflw_xmm },
2849 [0x71] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftw */
2850 [0x72] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftd */
2851 [0x73] = { SSE_SPECIAL, SSE_SPECIAL }, /* shiftq */
2852 [0x74] = MMX_OP2(pcmpeqb),
2853 [0x75] = MMX_OP2(pcmpeqw),
2854 [0x76] = MMX_OP2(pcmpeql),
2855 [0x77] = { SSE_DUMMY }, /* emms */
2856 [0x78] = { NULL, SSE_SPECIAL, NULL, SSE_SPECIAL }, /* extrq_i, insertq_i */
2857 [0x79] = { NULL, gen_helper_extrq_r, NULL, gen_helper_insertq_r },
2858 [0x7c] = { NULL, gen_helper_haddpd, NULL, gen_helper_haddps },
2859 [0x7d] = { NULL, gen_helper_hsubpd, NULL, gen_helper_hsubps },
2860 [0x7e] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movd, movd, , movq */
2861 [0x7f] = { SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL }, /* movq, movdqa, movdqu */
2862 [0xc4] = { SSE_SPECIAL, SSE_SPECIAL }, /* pinsrw */
2863 [0xc5] = { SSE_SPECIAL, SSE_SPECIAL }, /* pextrw */
2864 [0xd0] = { NULL, gen_helper_addsubpd, NULL, gen_helper_addsubps },
2865 [0xd1] = MMX_OP2(psrlw),
2866 [0xd2] = MMX_OP2(psrld),
2867 [0xd3] = MMX_OP2(psrlq),
2868 [0xd4] = MMX_OP2(paddq),
2869 [0xd5] = MMX_OP2(pmullw),
2870 [0xd6] = { NULL, SSE_SPECIAL, SSE_SPECIAL, SSE_SPECIAL },
2871 [0xd7] = { SSE_SPECIAL, SSE_SPECIAL }, /* pmovmskb */
2872 [0xd8] = MMX_OP2(psubusb),
2873 [0xd9] = MMX_OP2(psubusw),
2874 [0xda] = MMX_OP2(pminub),
2875 [0xdb] = MMX_OP2(pand),
2876 [0xdc] = MMX_OP2(paddusb),
2877 [0xdd] = MMX_OP2(paddusw),
2878 [0xde] = MMX_OP2(pmaxub),
2879 [0xdf] = MMX_OP2(pandn),
2880 [0xe0] = MMX_OP2(pavgb),
2881 [0xe1] = MMX_OP2(psraw),
2882 [0xe2] = MMX_OP2(psrad),
2883 [0xe3] = MMX_OP2(pavgw),
2884 [0xe4] = MMX_OP2(pmulhuw),
2885 [0xe5] = MMX_OP2(pmulhw),
2886 [0xe6] = { NULL, gen_helper_cvttpd2dq, gen_helper_cvtdq2pd, gen_helper_cvtpd2dq },
2887 [0xe7] = { SSE_SPECIAL , SSE_SPECIAL }, /* movntq, movntq */
2888 [0xe8] = MMX_OP2(psubsb),
2889 [0xe9] = MMX_OP2(psubsw),
2890 [0xea] = MMX_OP2(pminsw),
2891 [0xeb] = MMX_OP2(por),
2892 [0xec] = MMX_OP2(paddsb),
2893 [0xed] = MMX_OP2(paddsw),
2894 [0xee] = MMX_OP2(pmaxsw),
2895 [0xef] = MMX_OP2(pxor),
2896 [0xf0] = { NULL, NULL, NULL, SSE_SPECIAL }, /* lddqu */
2897 [0xf1] = MMX_OP2(psllw),
2898 [0xf2] = MMX_OP2(pslld),
2899 [0xf3] = MMX_OP2(psllq),
2900 [0xf4] = MMX_OP2(pmuludq),
2901 [0xf5] = MMX_OP2(pmaddwd),
2902 [0xf6] = MMX_OP2(psadbw),
2903 [0xf7] = MMX_OP2(maskmov),
2904 [0xf8] = MMX_OP2(psubb),
2905 [0xf9] = MMX_OP2(psubw),
2906 [0xfa] = MMX_OP2(psubl),
2907 [0xfb] = MMX_OP2(psubq),
2908 [0xfc] = MMX_OP2(paddb),
2909 [0xfd] = MMX_OP2(paddw),
2910 [0xfe] = MMX_OP2(paddl),
2911 };
2912
2913 static void *sse_op_table2[3 * 8][2] = {
2914 [0 + 2] = MMX_OP2(psrlw),
2915 [0 + 4] = MMX_OP2(psraw),
2916 [0 + 6] = MMX_OP2(psllw),
2917 [8 + 2] = MMX_OP2(psrld),
2918 [8 + 4] = MMX_OP2(psrad),
2919 [8 + 6] = MMX_OP2(pslld),
2920 [16 + 2] = MMX_OP2(psrlq),
2921 [16 + 3] = { NULL, gen_helper_psrldq_xmm },
2922 [16 + 6] = MMX_OP2(psllq),
2923 [16 + 7] = { NULL, gen_helper_pslldq_xmm },
2924 };
2925
2926 static void *sse_op_table3[4 * 3] = {
2927 gen_helper_cvtsi2ss,
2928 gen_helper_cvtsi2sd,
2929 X86_64_ONLY(gen_helper_cvtsq2ss),
2930 X86_64_ONLY(gen_helper_cvtsq2sd),
2931
2932 gen_helper_cvttss2si,
2933 gen_helper_cvttsd2si,
2934 X86_64_ONLY(gen_helper_cvttss2sq),
2935 X86_64_ONLY(gen_helper_cvttsd2sq),
2936
2937 gen_helper_cvtss2si,
2938 gen_helper_cvtsd2si,
2939 X86_64_ONLY(gen_helper_cvtss2sq),
2940 X86_64_ONLY(gen_helper_cvtsd2sq),
2941 };
2942
2943 static void *sse_op_table4[8][4] = {
2944 SSE_FOP(cmpeq),
2945 SSE_FOP(cmplt),
2946 SSE_FOP(cmple),
2947 SSE_FOP(cmpunord),
2948 SSE_FOP(cmpneq),
2949 SSE_FOP(cmpnlt),
2950 SSE_FOP(cmpnle),
2951 SSE_FOP(cmpord),
2952 };
2953
2954 static void *sse_op_table5[256] = {
2955 [0x0c] = gen_helper_pi2fw,
2956 [0x0d] = gen_helper_pi2fd,
2957 [0x1c] = gen_helper_pf2iw,
2958 [0x1d] = gen_helper_pf2id,
2959 [0x8a] = gen_helper_pfnacc,
2960 [0x8e] = gen_helper_pfpnacc,
2961 [0x90] = gen_helper_pfcmpge,
2962 [0x94] = gen_helper_pfmin,
2963 [0x96] = gen_helper_pfrcp,
2964 [0x97] = gen_helper_pfrsqrt,
2965 [0x9a] = gen_helper_pfsub,
2966 [0x9e] = gen_helper_pfadd,
2967 [0xa0] = gen_helper_pfcmpgt,
2968 [0xa4] = gen_helper_pfmax,
2969 [0xa6] = gen_helper_movq, /* pfrcpit1; no need to actually increase precision */
2970 [0xa7] = gen_helper_movq, /* pfrsqit1 */
2971 [0xaa] = gen_helper_pfsubr,
2972 [0xae] = gen_helper_pfacc,
2973 [0xb0] = gen_helper_pfcmpeq,
2974 [0xb4] = gen_helper_pfmul,
2975 [0xb6] = gen_helper_movq, /* pfrcpit2 */
2976 [0xb7] = gen_helper_pmulhrw_mmx,
2977 [0xbb] = gen_helper_pswapd,
2978 [0xbf] = gen_helper_pavgb_mmx /* pavgusb */
2979 };
2980
2981 struct sse_op_helper_s {
2982 void *op[2]; uint32_t ext_mask;
2983 };
2984 #define SSSE3_OP(x) { MMX_OP2(x), CPUID_EXT_SSSE3 }
2985 #define SSE41_OP(x) { { NULL, gen_helper_ ## x ## _xmm }, CPUID_EXT_SSE41 }
2986 #define SSE42_OP(x) { { NULL, gen_helper_ ## x ## _xmm }, CPUID_EXT_SSE42 }
2987 #define SSE41_SPECIAL { { NULL, SSE_SPECIAL }, CPUID_EXT_SSE41 }
2988 static struct sse_op_helper_s sse_op_table6[256] = {
2989 [0x00] = SSSE3_OP(pshufb),
2990 [0x01] = SSSE3_OP(phaddw),
2991 [0x02] = SSSE3_OP(phaddd),
2992 [0x03] = SSSE3_OP(phaddsw),
2993 [0x04] = SSSE3_OP(pmaddubsw),
2994 [0x05] = SSSE3_OP(phsubw),
2995 [0x06] = SSSE3_OP(phsubd),
2996 [0x07] = SSSE3_OP(phsubsw),
2997 [0x08] = SSSE3_OP(psignb),
2998 [0x09] = SSSE3_OP(psignw),
2999 [0x0a] = SSSE3_OP(psignd),
3000 [0x0b] = SSSE3_OP(pmulhrsw),
3001 [0x10] = SSE41_OP(pblendvb),
3002 [0x14] = SSE41_OP(blendvps),
3003 [0x15] = SSE41_OP(blendvpd),
3004 [0x17] = SSE41_OP(ptest),
3005 [0x1c] = SSSE3_OP(pabsb),
3006 [0x1d] = SSSE3_OP(pabsw),
3007 [0x1e] = SSSE3_OP(pabsd),
3008 [0x20] = SSE41_OP(pmovsxbw),
3009 [0x21] = SSE41_OP(pmovsxbd),
3010 [0x22] = SSE41_OP(pmovsxbq),
3011 [0x23] = SSE41_OP(pmovsxwd),
3012 [0x24] = SSE41_OP(pmovsxwq),
3013 [0x25] = SSE41_OP(pmovsxdq),
3014 [0x28] = SSE41_OP(pmuldq),
3015 [0x29] = SSE41_OP(pcmpeqq),
3016 [0x2a] = SSE41_SPECIAL, /* movntqda */
3017 [0x2b] = SSE41_OP(packusdw),
3018 [0x30] = SSE41_OP(pmovzxbw),
3019 [0x31] = SSE41_OP(pmovzxbd),
3020 [0x32] = SSE41_OP(pmovzxbq),
3021 [0x33] = SSE41_OP(pmovzxwd),
3022 [0x34] = SSE41_OP(pmovzxwq),
3023 [0x35] = SSE41_OP(pmovzxdq),
3024 [0x37] = SSE42_OP(pcmpgtq),
3025 [0x38] = SSE41_OP(pminsb),
3026 [0x39] = SSE41_OP(pminsd),
3027 [0x3a] = SSE41_OP(pminuw),
3028 [0x3b] = SSE41_OP(pminud),
3029 [0x3c] = SSE41_OP(pmaxsb),
3030 [0x3d] = SSE41_OP(pmaxsd),
3031 [0x3e] = SSE41_OP(pmaxuw),
3032 [0x3f] = SSE41_OP(pmaxud),
3033 [0x40] = SSE41_OP(pmulld),
3034 [0x41] = SSE41_OP(phminposuw),
3035 };
3036
3037 static struct sse_op_helper_s sse_op_table7[256] = {
3038 [0x08] = SSE41_OP(roundps),
3039 [0x09] = SSE41_OP(roundpd),
3040 [0x0a] = SSE41_OP(roundss),
3041 [0x0b] = SSE41_OP(roundsd),
3042 [0x0c] = SSE41_OP(blendps),
3043 [0x0d] = SSE41_OP(blendpd),
3044 [0x0e] = SSE41_OP(pblendw),
3045 [0x0f] = SSSE3_OP(palignr),
3046 [0x14] = SSE41_SPECIAL, /* pextrb */
3047 [0x15] = SSE41_SPECIAL, /* pextrw */
3048 [0x16] = SSE41_SPECIAL, /* pextrd/pextrq */
3049 [0x17] = SSE41_SPECIAL, /* extractps */
3050 [0x20] = SSE41_SPECIAL, /* pinsrb */
3051 [0x21] = SSE41_SPECIAL, /* insertps */
3052 [0x22] = SSE41_SPECIAL, /* pinsrd/pinsrq */
3053 [0x40] = SSE41_OP(dpps),
3054 [0x41] = SSE41_OP(dppd),
3055 [0x42] = SSE41_OP(mpsadbw),
3056 [0x60] = SSE42_OP(pcmpestrm),
3057 [0x61] = SSE42_OP(pcmpestri),
3058 [0x62] = SSE42_OP(pcmpistrm),
3059 [0x63] = SSE42_OP(pcmpistri),
3060 };
3061
3062 static void gen_sse(DisasContext *s, int b, target_ulong pc_start, int rex_r)
3063 {
3064 int b1, op1_offset, op2_offset, is_xmm, val, ot;
3065 int modrm, mod, rm, reg, reg_addr, offset_addr;
3066 void *sse_op2;
3067
3068 b &= 0xff;
3069 if (s->prefix & PREFIX_DATA)
3070 b1 = 1;
3071 else if (s->prefix & PREFIX_REPZ)
3072 b1 = 2;
3073 else if (s->prefix & PREFIX_REPNZ)
3074 b1 = 3;
3075 else
3076 b1 = 0;
3077 sse_op2 = sse_op_table1[b][b1];
3078 if (!sse_op2)
3079 goto illegal_op;
3080 if ((b <= 0x5f && b >= 0x10) || b == 0xc6 || b == 0xc2) {
3081 is_xmm = 1;
3082 } else {
3083 if (b1 == 0) {
3084 /* MMX case */
3085 is_xmm = 0;
3086 } else {
3087 is_xmm = 1;
3088 }
3089 }
3090 /* simple MMX/SSE operation */
3091 if (s->flags & HF_TS_MASK) {
3092 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
3093 return;
3094 }
3095 if (s->flags & HF_EM_MASK) {
3096 illegal_op:
3097 gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
3098 return;
3099 }
3100 if (is_xmm && !(s->flags & HF_OSFXSR_MASK))
3101 if ((b != 0x38 && b != 0x3a) || (s->prefix & PREFIX_DATA))
3102 goto illegal_op;
3103 if (b == 0x0e) {
3104 if (!(s->cpuid_ext2_features & CPUID_EXT2_3DNOW))
3105 goto illegal_op;
3106 /* femms */
3107 gen_helper_emms();
3108 return;
3109 }
3110 if (b == 0x77) {
3111 /* emms */
3112 gen_helper_emms();
3113 return;
3114 }
3115 /* prepare MMX state (XXX: optimize by storing fptt and fptags in
3116 the static cpu state) */
3117 if (!is_xmm) {
3118 gen_helper_enter_mmx();
3119 }
3120
3121 modrm = ldub_code(s->pc++);
3122 reg = ((modrm >> 3) & 7);
3123 if (is_xmm)
3124 reg |= rex_r;
3125 mod = (modrm >> 6) & 3;
3126 if (sse_op2 == SSE_SPECIAL) {
3127 b |= (b1 << 8);
3128 switch(b) {
3129 case 0x0e7: /* movntq */
3130 if (mod == 3)
3131 goto illegal_op;
3132 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3133 gen_stq_env_A0(s->mem_index, offsetof(CPUX86State,fpregs[reg].mmx));
3134 break;
3135 case 0x1e7: /* movntdq */
3136 case 0x02b: /* movntps */
3137 case 0x12b: /* movntps */
3138 if (mod == 3)
3139 goto illegal_op;
3140 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3141 gen_sto_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg]));
3142 break;
3143 case 0x3f0: /* lddqu */
3144 if (mod == 3)
3145 goto illegal_op;
3146 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3147 gen_ldo_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg]));
3148 break;
3149 case 0x22b: /* movntss */
3150 case 0x32b: /* movntsd */
3151 if (mod == 3)
3152 goto illegal_op;
3153 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3154 if (b1 & 1) {
3155 gen_stq_env_A0(s->mem_index, offsetof(CPUX86State,
3156 xmm_regs[reg]));
3157 } else {
3158 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
3159 xmm_regs[reg].XMM_L(0)));
3160 gen_op_st_T0_A0(OT_LONG + s->mem_index);
3161 }
3162 break;
3163 case 0x6e: /* movd mm, ea */
3164 #ifdef TARGET_X86_64
3165 if (s->dflag == 2) {
3166 gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 0);
3167 tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,fpregs[reg].mmx));
3168 } else
3169 #endif
3170 {
3171 gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 0);
3172 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3173 offsetof(CPUX86State,fpregs[reg].mmx));
3174 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
3175 gen_helper_movl_mm_T0_mmx(cpu_ptr0, cpu_tmp2_i32);
3176 }
3177 break;
3178 case 0x16e: /* movd xmm, ea */
3179 #ifdef TARGET_X86_64
3180 if (s->dflag == 2) {
3181 gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 0);
3182 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3183 offsetof(CPUX86State,xmm_regs[reg]));
3184 gen_helper_movq_mm_T0_xmm(cpu_ptr0, cpu_T[0]);
3185 } else
3186 #endif
3187 {
3188 gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 0);
3189 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3190 offsetof(CPUX86State,xmm_regs[reg]));
3191 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
3192 gen_helper_movl_mm_T0_xmm(cpu_ptr0, cpu_tmp2_i32);
3193 }
3194 break;
3195 case 0x6f: /* movq mm, ea */
3196 if (mod != 3) {
3197 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3198 gen_ldq_env_A0(s->mem_index, offsetof(CPUX86State,fpregs[reg].mmx));
3199 } else {
3200 rm = (modrm & 7);
3201 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env,
3202 offsetof(CPUX86State,fpregs[rm].mmx));
3203 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env,
3204 offsetof(CPUX86State,fpregs[reg].mmx));
3205 }
3206 break;
3207 case 0x010: /* movups */
3208 case 0x110: /* movupd */
3209 case 0x028: /* movaps */
3210 case 0x128: /* movapd */
3211 case 0x16f: /* movdqa xmm, ea */
3212 case 0x26f: /* movdqu xmm, ea */
3213 if (mod != 3) {
3214 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3215 gen_ldo_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg]));
3216 } else {
3217 rm = (modrm & 7) | REX_B(s);
3218 gen_op_movo(offsetof(CPUX86State,xmm_regs[reg]),
3219 offsetof(CPUX86State,xmm_regs[rm]));
3220 }
3221 break;
3222 case 0x210: /* movss xmm, ea */
3223 if (mod != 3) {
3224 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3225 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
3226 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3227 gen_op_movl_T0_0();
3228 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)));
3229 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
3230 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
3231 } else {
3232 rm = (modrm & 7) | REX_B(s);
3233 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
3234 offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)));
3235 }
3236 break;
3237 case 0x310: /* movsd xmm, ea */
3238 if (mod != 3) {
3239 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3240 gen_ldq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3241 gen_op_movl_T0_0();
3242 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
3243 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
3244 } else {
3245 rm = (modrm & 7) | REX_B(s);
3246 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3247 offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3248 }
3249 break;
3250 case 0x012: /* movlps */
3251 case 0x112: /* movlpd */
3252 if (mod != 3) {
3253 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3254 gen_ldq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3255 } else {
3256 /* movhlps */
3257 rm = (modrm & 7) | REX_B(s);
3258 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3259 offsetof(CPUX86State,xmm_regs[rm].XMM_Q(1)));
3260 }
3261 break;
3262 case 0x212: /* movsldup */
3263 if (mod != 3) {
3264 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3265 gen_ldo_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg]));
3266 } else {
3267 rm = (modrm & 7) | REX_B(s);
3268 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
3269 offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)));
3270 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)),
3271 offsetof(CPUX86State,xmm_regs[rm].XMM_L(2)));
3272 }
3273 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)),
3274 offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3275 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)),
3276 offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)));
3277 break;
3278 case 0x312: /* movddup */
3279 if (mod != 3) {
3280 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3281 gen_ldq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3282 } else {
3283 rm = (modrm & 7) | REX_B(s);
3284 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3285 offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3286 }
3287 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)),
3288 offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3289 break;
3290 case 0x016: /* movhps */
3291 case 0x116: /* movhpd */
3292 if (mod != 3) {
3293 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3294 gen_ldq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
3295 } else {
3296 /* movlhps */
3297 rm = (modrm & 7) | REX_B(s);
3298 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)),
3299 offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3300 }
3301 break;
3302 case 0x216: /* movshdup */
3303 if (mod != 3) {
3304 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3305 gen_ldo_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg]));
3306 } else {
3307 rm = (modrm & 7) | REX_B(s);
3308 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)),
3309 offsetof(CPUX86State,xmm_regs[rm].XMM_L(1)));
3310 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)),
3311 offsetof(CPUX86State,xmm_regs[rm].XMM_L(3)));
3312 }
3313 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)),
3314 offsetof(CPUX86State,xmm_regs[reg].XMM_L(1)));
3315 gen_op_movl(offsetof(CPUX86State,xmm_regs[reg].XMM_L(2)),
3316 offsetof(CPUX86State,xmm_regs[reg].XMM_L(3)));
3317 break;
3318 case 0x178:
3319 case 0x378:
3320 {
3321 int bit_index, field_length;
3322
3323 if (b1 == 1 && reg != 0)
3324 goto illegal_op;
3325 field_length = ldub_code(s->pc++) & 0x3F;
3326 bit_index = ldub_code(s->pc++) & 0x3F;
3327 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3328 offsetof(CPUX86State,xmm_regs[reg]));
3329 if (b1 == 1)
3330 gen_helper_extrq_i(cpu_ptr0, tcg_const_i32(bit_index),
3331 tcg_const_i32(field_length));
3332 else
3333 gen_helper_insertq_i(cpu_ptr0, tcg_const_i32(bit_index),
3334 tcg_const_i32(field_length));
3335 }
3336 break;
3337 case 0x7e: /* movd ea, mm */
3338 #ifdef TARGET_X86_64
3339 if (s->dflag == 2) {
3340 tcg_gen_ld_i64(cpu_T[0], cpu_env,
3341 offsetof(CPUX86State,fpregs[reg].mmx));
3342 gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 1);
3343 } else
3344 #endif
3345 {
3346 tcg_gen_ld32u_tl(cpu_T[0], cpu_env,
3347 offsetof(CPUX86State,fpregs[reg].mmx.MMX_L(0)));
3348 gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 1);
3349 }
3350 break;
3351 case 0x17e: /* movd ea, xmm */
3352 #ifdef TARGET_X86_64
3353 if (s->dflag == 2) {
3354 tcg_gen_ld_i64(cpu_T[0], cpu_env,
3355 offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3356 gen_ldst_modrm(s, modrm, OT_QUAD, OR_TMP0, 1);
3357 } else
3358 #endif
3359 {
3360 tcg_gen_ld32u_tl(cpu_T[0], cpu_env,
3361 offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3362 gen_ldst_modrm(s, modrm, OT_LONG, OR_TMP0, 1);
3363 }
3364 break;
3365 case 0x27e: /* movq xmm, ea */
3366 if (mod != 3) {
3367 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3368 gen_ldq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3369 } else {
3370 rm = (modrm & 7) | REX_B(s);
3371 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3372 offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3373 }
3374 gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
3375 break;
3376 case 0x7f: /* movq ea, mm */
3377 if (mod != 3) {
3378 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3379 gen_stq_env_A0(s->mem_index, offsetof(CPUX86State,fpregs[reg].mmx));
3380 } else {
3381 rm = (modrm & 7);
3382 gen_op_movq(offsetof(CPUX86State,fpregs[rm].mmx),
3383 offsetof(CPUX86State,fpregs[reg].mmx));
3384 }
3385 break;
3386 case 0x011: /* movups */
3387 case 0x111: /* movupd */
3388 case 0x029: /* movaps */
3389 case 0x129: /* movapd */
3390 case 0x17f: /* movdqa ea, xmm */
3391 case 0x27f: /* movdqu ea, xmm */
3392 if (mod != 3) {
3393 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3394 gen_sto_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg]));
3395 } else {
3396 rm = (modrm & 7) | REX_B(s);
3397 gen_op_movo(offsetof(CPUX86State,xmm_regs[rm]),
3398 offsetof(CPUX86State,xmm_regs[reg]));
3399 }
3400 break;
3401 case 0x211: /* movss ea, xmm */
3402 if (mod != 3) {
3403 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3404 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3405 gen_op_st_T0_A0(OT_LONG + s->mem_index);
3406 } else {
3407 rm = (modrm & 7) | REX_B(s);
3408 gen_op_movl(offsetof(CPUX86State,xmm_regs[rm].XMM_L(0)),
3409 offsetof(CPUX86State,xmm_regs[reg].XMM_L(0)));
3410 }
3411 break;
3412 case 0x311: /* movsd ea, xmm */
3413 if (mod != 3) {
3414 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3415 gen_stq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3416 } else {
3417 rm = (modrm & 7) | REX_B(s);
3418 gen_op_movq(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)),
3419 offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3420 }
3421 break;
3422 case 0x013: /* movlps */
3423 case 0x113: /* movlpd */
3424 if (mod != 3) {
3425 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3426 gen_stq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3427 } else {
3428 goto illegal_op;
3429 }
3430 break;
3431 case 0x017: /* movhps */
3432 case 0x117: /* movhpd */
3433 if (mod != 3) {
3434 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3435 gen_stq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
3436 } else {
3437 goto illegal_op;
3438 }
3439 break;
3440 case 0x71: /* shift mm, im */
3441 case 0x72:
3442 case 0x73:
3443 case 0x171: /* shift xmm, im */
3444 case 0x172:
3445 case 0x173:
3446 if (b1 >= 2) {
3447 goto illegal_op;
3448 }
3449 val = ldub_code(s->pc++);
3450 if (is_xmm) {
3451 gen_op_movl_T0_im(val);
3452 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(0)));
3453 gen_op_movl_T0_0();
3454 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(1)));
3455 op1_offset = offsetof(CPUX86State,xmm_t0);
3456 } else {
3457 gen_op_movl_T0_im(val);
3458 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,mmx_t0.MMX_L(0)));
3459 gen_op_movl_T0_0();
3460 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,mmx_t0.MMX_L(1)));
3461 op1_offset = offsetof(CPUX86State,mmx_t0);
3462 }
3463 sse_op2 = sse_op_table2[((b - 1) & 3) * 8 + (((modrm >> 3)) & 7)][b1];
3464 if (!sse_op2)
3465 goto illegal_op;
3466 if (is_xmm) {
3467 rm = (modrm & 7) | REX_B(s);
3468 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3469 } else {
3470 rm = (modrm & 7);
3471 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3472 }
3473 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op2_offset);
3474 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op1_offset);
3475 ((void (*)(TCGv_ptr, TCGv_ptr))sse_op2)(cpu_ptr0, cpu_ptr1);
3476 break;
3477 case 0x050: /* movmskps */
3478 rm = (modrm & 7) | REX_B(s);
3479 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3480 offsetof(CPUX86State,xmm_regs[rm]));
3481 gen_helper_movmskps(cpu_tmp2_i32, cpu_ptr0);
3482 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
3483 gen_op_mov_reg_T0(OT_LONG, reg);
3484 break;
3485 case 0x150: /* movmskpd */
3486 rm = (modrm & 7) | REX_B(s);
3487 tcg_gen_addi_ptr(cpu_ptr0, cpu_env,
3488 offsetof(CPUX86State,xmm_regs[rm]));
3489 gen_helper_movmskpd(cpu_tmp2_i32, cpu_ptr0);
3490 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
3491 gen_op_mov_reg_T0(OT_LONG, reg);
3492 break;
3493 case 0x02a: /* cvtpi2ps */
3494 case 0x12a: /* cvtpi2pd */
3495 gen_helper_enter_mmx();
3496 if (mod != 3) {
3497 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3498 op2_offset = offsetof(CPUX86State,mmx_t0);
3499 gen_ldq_env_A0(s->mem_index, op2_offset);
3500 } else {
3501 rm = (modrm & 7);
3502 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3503 }
3504 op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3505 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3506 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
3507 switch(b >> 8) {
3508 case 0x0:
3509 gen_helper_cvtpi2ps(cpu_ptr0, cpu_ptr1);
3510 break;
3511 default:
3512 case 0x1:
3513 gen_helper_cvtpi2pd(cpu_ptr0, cpu_ptr1);
3514 break;
3515 }
3516 break;
3517 case 0x22a: /* cvtsi2ss */
3518 case 0x32a: /* cvtsi2sd */
3519 ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
3520 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
3521 op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3522 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3523 sse_op2 = sse_op_table3[(s->dflag == 2) * 2 + ((b >> 8) - 2)];
3524 if (ot == OT_LONG) {
3525 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
3526 ((void (*)(TCGv_ptr, TCGv_i32))sse_op2)(cpu_ptr0, cpu_tmp2_i32);
3527 } else {
3528 ((void (*)(TCGv_ptr, TCGv))sse_op2)(cpu_ptr0, cpu_T[0]);
3529 }
3530 break;
3531 case 0x02c: /* cvttps2pi */
3532 case 0x12c: /* cvttpd2pi */
3533 case 0x02d: /* cvtps2pi */
3534 case 0x12d: /* cvtpd2pi */
3535 gen_helper_enter_mmx();
3536 if (mod != 3) {
3537 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3538 op2_offset = offsetof(CPUX86State,xmm_t0);
3539 gen_ldo_env_A0(s->mem_index, op2_offset);
3540 } else {
3541 rm = (modrm & 7) | REX_B(s);
3542 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3543 }
3544 op1_offset = offsetof(CPUX86State,fpregs[reg & 7].mmx);
3545 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3546 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
3547 switch(b) {
3548 case 0x02c:
3549 gen_helper_cvttps2pi(cpu_ptr0, cpu_ptr1);
3550 break;
3551 case 0x12c:
3552 gen_helper_cvttpd2pi(cpu_ptr0, cpu_ptr1);
3553 break;
3554 case 0x02d:
3555 gen_helper_cvtps2pi(cpu_ptr0, cpu_ptr1);
3556 break;
3557 case 0x12d:
3558 gen_helper_cvtpd2pi(cpu_ptr0, cpu_ptr1);
3559 break;
3560 }
3561 break;
3562 case 0x22c: /* cvttss2si */
3563 case 0x32c: /* cvttsd2si */
3564 case 0x22d: /* cvtss2si */
3565 case 0x32d: /* cvtsd2si */
3566 ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
3567 if (mod != 3) {
3568 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3569 if ((b >> 8) & 1) {
3570 gen_ldq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_t0.XMM_Q(0)));
3571 } else {
3572 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
3573 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(0)));
3574 }
3575 op2_offset = offsetof(CPUX86State,xmm_t0);
3576 } else {
3577 rm = (modrm & 7) | REX_B(s);
3578 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3579 }
3580 sse_op2 = sse_op_table3[(s->dflag == 2) * 2 + ((b >> 8) - 2) + 4 +
3581 (b & 1) * 4];
3582 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op2_offset);
3583 if (ot == OT_LONG) {
3584 ((void (*)(TCGv_i32, TCGv_ptr))sse_op2)(cpu_tmp2_i32, cpu_ptr0);
3585 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
3586 } else {
3587 ((void (*)(TCGv, TCGv_ptr))sse_op2)(cpu_T[0], cpu_ptr0);
3588 }
3589 gen_op_mov_reg_T0(ot, reg);
3590 break;
3591 case 0xc4: /* pinsrw */
3592 case 0x1c4:
3593 s->rip_offset = 1;
3594 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
3595 val = ldub_code(s->pc++);
3596 if (b1) {
3597 val &= 7;
3598 tcg_gen_st16_tl(cpu_T[0], cpu_env,
3599 offsetof(CPUX86State,xmm_regs[reg].XMM_W(val)));
3600 } else {
3601 val &= 3;
3602 tcg_gen_st16_tl(cpu_T[0], cpu_env,
3603 offsetof(CPUX86State,fpregs[reg].mmx.MMX_W(val)));
3604 }
3605 break;
3606 case 0xc5: /* pextrw */
3607 case 0x1c5:
3608 if (mod != 3)
3609 goto illegal_op;
3610 ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
3611 val = ldub_code(s->pc++);
3612 if (b1) {
3613 val &= 7;
3614 rm = (modrm & 7) | REX_B(s);
3615 tcg_gen_ld16u_tl(cpu_T[0], cpu_env,
3616 offsetof(CPUX86State,xmm_regs[rm].XMM_W(val)));
3617 } else {
3618 val &= 3;
3619 rm = (modrm & 7);
3620 tcg_gen_ld16u_tl(cpu_T[0], cpu_env,
3621 offsetof(CPUX86State,fpregs[rm].mmx.MMX_W(val)));
3622 }
3623 reg = ((modrm >> 3) & 7) | rex_r;
3624 gen_op_mov_reg_T0(ot, reg);
3625 break;
3626 case 0x1d6: /* movq ea, xmm */
3627 if (mod != 3) {
3628 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3629 gen_stq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3630 } else {
3631 rm = (modrm & 7) | REX_B(s);
3632 gen_op_movq(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)),
3633 offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)));
3634 gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[rm].XMM_Q(1)));
3635 }
3636 break;
3637 case 0x2d6: /* movq2dq */
3638 gen_helper_enter_mmx();
3639 rm = (modrm & 7);
3640 gen_op_movq(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(0)),
3641 offsetof(CPUX86State,fpregs[rm].mmx));
3642 gen_op_movq_env_0(offsetof(CPUX86State,xmm_regs[reg].XMM_Q(1)));
3643 break;
3644 case 0x3d6: /* movdq2q */
3645 gen_helper_enter_mmx();
3646 rm = (modrm & 7) | REX_B(s);
3647 gen_op_movq(offsetof(CPUX86State,fpregs[reg & 7].mmx),
3648 offsetof(CPUX86State,xmm_regs[rm].XMM_Q(0)));
3649 break;
3650 case 0xd7: /* pmovmskb */
3651 case 0x1d7:
3652 if (mod != 3)
3653 goto illegal_op;
3654 if (b1) {
3655 rm = (modrm & 7) | REX_B(s);
3656 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, offsetof(CPUX86State,xmm_regs[rm]));
3657 gen_helper_pmovmskb_xmm(cpu_tmp2_i32, cpu_ptr0);
3658 } else {
3659 rm = (modrm & 7);
3660 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, offsetof(CPUX86State,fpregs[rm].mmx));
3661 gen_helper_pmovmskb_mmx(cpu_tmp2_i32, cpu_ptr0);
3662 }
3663 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
3664 reg = ((modrm >> 3) & 7) | rex_r;
3665 gen_op_mov_reg_T0(OT_LONG, reg);
3666 break;
3667 case 0x138:
3668 if (s->prefix & PREFIX_REPNZ)
3669 goto crc32;
3670 case 0x038:
3671 b = modrm;
3672 modrm = ldub_code(s->pc++);
3673 rm = modrm & 7;
3674 reg = ((modrm >> 3) & 7) | rex_r;
3675 mod = (modrm >> 6) & 3;
3676 if (b1 >= 2) {
3677 goto illegal_op;
3678 }
3679
3680 sse_op2 = sse_op_table6[b].op[b1];
3681 if (!sse_op2)
3682 goto illegal_op;
3683 if (!(s->cpuid_ext_features & sse_op_table6[b].ext_mask))
3684 goto illegal_op;
3685
3686 if (b1) {
3687 op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3688 if (mod == 3) {
3689 op2_offset = offsetof(CPUX86State,xmm_regs[rm | REX_B(s)]);
3690 } else {
3691 op2_offset = offsetof(CPUX86State,xmm_t0);
3692 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3693 switch (b) {
3694 case 0x20: case 0x30: /* pmovsxbw, pmovzxbw */
3695 case 0x23: case 0x33: /* pmovsxwd, pmovzxwd */
3696 case 0x25: case 0x35: /* pmovsxdq, pmovzxdq */
3697 gen_ldq_env_A0(s->mem_index, op2_offset +
3698 offsetof(XMMReg, XMM_Q(0)));
3699 break;
3700 case 0x21: case 0x31: /* pmovsxbd, pmovzxbd */
3701 case 0x24: case 0x34: /* pmovsxwq, pmovzxwq */
3702 tcg_gen_qemu_ld32u(cpu_tmp0, cpu_A0,
3703 (s->mem_index >> 2) - 1);
3704 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_tmp0);
3705 tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, op2_offset +
3706 offsetof(XMMReg, XMM_L(0)));
3707 break;
3708 case 0x22: case 0x32: /* pmovsxbq, pmovzxbq */
3709 tcg_gen_qemu_ld16u(cpu_tmp0, cpu_A0,
3710 (s->mem_index >> 2) - 1);
3711 tcg_gen_st16_tl(cpu_tmp0, cpu_env, op2_offset +
3712 offsetof(XMMReg, XMM_W(0)));
3713 break;
3714 case 0x2a: /* movntqda */
3715 gen_ldo_env_A0(s->mem_index, op1_offset);
3716 return;
3717 default:
3718 gen_ldo_env_A0(s->mem_index, op2_offset);
3719 }
3720 }
3721 } else {
3722 op1_offset = offsetof(CPUX86State,fpregs[reg].mmx);
3723 if (mod == 3) {
3724 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3725 } else {
3726 op2_offset = offsetof(CPUX86State,mmx_t0);
3727 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3728 gen_ldq_env_A0(s->mem_index, op2_offset);
3729 }
3730 }
3731 if (sse_op2 == SSE_SPECIAL)
3732 goto illegal_op;
3733
3734 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3735 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
3736 ((void (*)(TCGv_ptr, TCGv_ptr))sse_op2)(cpu_ptr0, cpu_ptr1);
3737
3738 if (b == 0x17)
3739 s->cc_op = CC_OP_EFLAGS;
3740 break;
3741 case 0x338: /* crc32 */
3742 crc32:
3743 b = modrm;
3744 modrm = ldub_code(s->pc++);
3745 reg = ((modrm >> 3) & 7) | rex_r;
3746
3747 if (b != 0xf0 && b != 0xf1)
3748 goto illegal_op;
3749 if (!(s->cpuid_ext_features & CPUID_EXT_SSE42))
3750 goto illegal_op;
3751
3752 if (b == 0xf0)
3753 ot = OT_BYTE;
3754 else if (b == 0xf1 && s->dflag != 2)
3755 if (s->prefix & PREFIX_DATA)
3756 ot = OT_WORD;
3757 else
3758 ot = OT_LONG;
3759 else
3760 ot = OT_QUAD;
3761
3762 gen_op_mov_TN_reg(OT_LONG, 0, reg);
3763 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
3764 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
3765 gen_helper_crc32(cpu_T[0], cpu_tmp2_i32,
3766 cpu_T[0], tcg_const_i32(8 << ot));
3767
3768 ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
3769 gen_op_mov_reg_T0(ot, reg);
3770 break;
3771 case 0x03a:
3772 case 0x13a:
3773 b = modrm;
3774 modrm = ldub_code(s->pc++);
3775 rm = modrm & 7;
3776 reg = ((modrm >> 3) & 7) | rex_r;
3777 mod = (modrm >> 6) & 3;
3778 if (b1 >= 2) {
3779 goto illegal_op;
3780 }
3781
3782 sse_op2 = sse_op_table7[b].op[b1];
3783 if (!sse_op2)
3784 goto illegal_op;
3785 if (!(s->cpuid_ext_features & sse_op_table7[b].ext_mask))
3786 goto illegal_op;
3787
3788 if (sse_op2 == SSE_SPECIAL) {
3789 ot = (s->dflag == 2) ? OT_QUAD : OT_LONG;
3790 rm = (modrm & 7) | REX_B(s);
3791 if (mod != 3)
3792 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3793 reg = ((modrm >> 3) & 7) | rex_r;
3794 val = ldub_code(s->pc++);
3795 switch (b) {
3796 case 0x14: /* pextrb */
3797 tcg_gen_ld8u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
3798 xmm_regs[reg].XMM_B(val & 15)));
3799 if (mod == 3)
3800 gen_op_mov_reg_T0(ot, rm);
3801 else
3802 tcg_gen_qemu_st8(cpu_T[0], cpu_A0,
3803 (s->mem_index >> 2) - 1);
3804 break;
3805 case 0x15: /* pextrw */
3806 tcg_gen_ld16u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
3807 xmm_regs[reg].XMM_W(val & 7)));
3808 if (mod == 3)
3809 gen_op_mov_reg_T0(ot, rm);
3810 else
3811 tcg_gen_qemu_st16(cpu_T[0], cpu_A0,
3812 (s->mem_index >> 2) - 1);
3813 break;
3814 case 0x16:
3815 if (ot == OT_LONG) { /* pextrd */
3816 tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env,
3817 offsetof(CPUX86State,
3818 xmm_regs[reg].XMM_L(val & 3)));
3819 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
3820 if (mod == 3)
3821 gen_op_mov_reg_v(ot, rm, cpu_T[0]);
3822 else
3823 tcg_gen_qemu_st32(cpu_T[0], cpu_A0,
3824 (s->mem_index >> 2) - 1);
3825 } else { /* pextrq */
3826 #ifdef TARGET_X86_64
3827 tcg_gen_ld_i64(cpu_tmp1_i64, cpu_env,
3828 offsetof(CPUX86State,
3829 xmm_regs[reg].XMM_Q(val & 1)));
3830 if (mod == 3)
3831 gen_op_mov_reg_v(ot, rm, cpu_tmp1_i64);
3832 else
3833 tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
3834 (s->mem_index >> 2) - 1);
3835 #else
3836 goto illegal_op;
3837 #endif
3838 }
3839 break;
3840 case 0x17: /* extractps */
3841 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,
3842 xmm_regs[reg].XMM_L(val & 3)));
3843 if (mod == 3)
3844 gen_op_mov_reg_T0(ot, rm);
3845 else
3846 tcg_gen_qemu_st32(cpu_T[0], cpu_A0,
3847 (s->mem_index >> 2) - 1);
3848 break;
3849 case 0x20: /* pinsrb */
3850 if (mod == 3)
3851 gen_op_mov_TN_reg(OT_LONG, 0, rm);
3852 else
3853 tcg_gen_qemu_ld8u(cpu_tmp0, cpu_A0,
3854 (s->mem_index >> 2) - 1);
3855 tcg_gen_st8_tl(cpu_tmp0, cpu_env, offsetof(CPUX86State,
3856 xmm_regs[reg].XMM_B(val & 15)));
3857 break;
3858 case 0x21: /* insertps */
3859 if (mod == 3) {
3860 tcg_gen_ld_i32(cpu_tmp2_i32, cpu_env,
3861 offsetof(CPUX86State,xmm_regs[rm]
3862 .XMM_L((val >> 6) & 3)));
3863 } else {
3864 tcg_gen_qemu_ld32u(cpu_tmp0, cpu_A0,
3865 (s->mem_index >> 2) - 1);
3866 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_tmp0);
3867 }
3868 tcg_gen_st_i32(cpu_tmp2_i32, cpu_env,
3869 offsetof(CPUX86State,xmm_regs[reg]
3870 .XMM_L((val >> 4) & 3)));
3871 if ((val >> 0) & 1)
3872 tcg_gen_st_i32(tcg_const_i32(0 /*float32_zero*/),
3873 cpu_env, offsetof(CPUX86State,
3874 xmm_regs[reg].XMM_L(0)));
3875 if ((val >> 1) & 1)
3876 tcg_gen_st_i32(tcg_const_i32(0 /*float32_zero*/),
3877 cpu_env, offsetof(CPUX86State,
3878 xmm_regs[reg].XMM_L(1)));
3879 if ((val >> 2) & 1)
3880 tcg_gen_st_i32(tcg_const_i32(0 /*float32_zero*/),
3881 cpu_env, offsetof(CPUX86State,
3882 xmm_regs[reg].XMM_L(2)));
3883 if ((val >> 3) & 1)
3884 tcg_gen_st_i32(tcg_const_i32(0 /*float32_zero*/),
3885 cpu_env, offsetof(CPUX86State,
3886 xmm_regs[reg].XMM_L(3)));
3887 break;
3888 case 0x22:
3889 if (ot == OT_LONG) { /* pinsrd */
3890 if (mod == 3)
3891 gen_op_mov_v_reg(ot, cpu_tmp0, rm);
3892 else
3893 tcg_gen_qemu_ld32u(cpu_tmp0, cpu_A0,
3894 (s->mem_index >> 2) - 1);
3895 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_tmp0);
3896 tcg_gen_st_i32(cpu_tmp2_i32, cpu_env,
3897 offsetof(CPUX86State,
3898 xmm_regs[reg].XMM_L(val & 3)));
3899 } else { /* pinsrq */
3900 #ifdef TARGET_X86_64
3901 if (mod == 3)
3902 gen_op_mov_v_reg(ot, cpu_tmp1_i64, rm);
3903 else
3904 tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
3905 (s->mem_index >> 2) - 1);
3906 tcg_gen_st_i64(cpu_tmp1_i64, cpu_env,
3907 offsetof(CPUX86State,
3908 xmm_regs[reg].XMM_Q(val & 1)));
3909 #else
3910 goto illegal_op;
3911 #endif
3912 }
3913 break;
3914 }
3915 return;
3916 }
3917
3918 if (b1) {
3919 op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3920 if (mod == 3) {
3921 op2_offset = offsetof(CPUX86State,xmm_regs[rm | REX_B(s)]);
3922 } else {
3923 op2_offset = offsetof(CPUX86State,xmm_t0);
3924 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3925 gen_ldo_env_A0(s->mem_index, op2_offset);
3926 }
3927 } else {
3928 op1_offset = offsetof(CPUX86State,fpregs[reg].mmx);
3929 if (mod == 3) {
3930 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3931 } else {
3932 op2_offset = offsetof(CPUX86State,mmx_t0);
3933 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3934 gen_ldq_env_A0(s->mem_index, op2_offset);
3935 }
3936 }
3937 val = ldub_code(s->pc++);
3938
3939 if ((b & 0xfc) == 0x60) { /* pcmpXstrX */
3940 s->cc_op = CC_OP_EFLAGS;
3941
3942 if (s->dflag == 2)
3943 /* The helper must use entire 64-bit gp registers */
3944 val |= 1 << 8;
3945 }
3946
3947 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
3948 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
3949 ((void (*)(TCGv_ptr, TCGv_ptr, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1, tcg_const_i32(val));
3950 break;
3951 default:
3952 goto illegal_op;
3953 }
3954 } else {
3955 /* generic MMX or SSE operation */
3956 switch(b) {
3957 case 0x70: /* pshufx insn */
3958 case 0xc6: /* pshufx insn */
3959 case 0xc2: /* compare insns */
3960 s->rip_offset = 1;
3961 break;
3962 default:
3963 break;
3964 }
3965 if (is_xmm) {
3966 op1_offset = offsetof(CPUX86State,xmm_regs[reg]);
3967 if (mod != 3) {
3968 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3969 op2_offset = offsetof(CPUX86State,xmm_t0);
3970 if (b1 >= 2 && ((b >= 0x50 && b <= 0x5f && b != 0x5b) ||
3971 b == 0xc2)) {
3972 /* specific case for SSE single instructions */
3973 if (b1 == 2) {
3974 /* 32 bit access */
3975 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
3976 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,xmm_t0.XMM_L(0)));
3977 } else {
3978 /* 64 bit access */
3979 gen_ldq_env_A0(s->mem_index, offsetof(CPUX86State,xmm_t0.XMM_D(0)));
3980 }
3981 } else {
3982 gen_ldo_env_A0(s->mem_index, op2_offset);
3983 }
3984 } else {
3985 rm = (modrm & 7) | REX_B(s);
3986 op2_offset = offsetof(CPUX86State,xmm_regs[rm]);
3987 }
3988 } else {
3989 op1_offset = offsetof(CPUX86State,fpregs[reg].mmx);
3990 if (mod != 3) {
3991 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3992 op2_offset = offsetof(CPUX86State,mmx_t0);
3993 gen_ldq_env_A0(s->mem_index, op2_offset);
3994 } else {
3995 rm = (modrm & 7);
3996 op2_offset = offsetof(CPUX86State,fpregs[rm].mmx);
3997 }
3998 }
3999 switch(b) {
4000 case 0x0f: /* 3DNow! data insns */
4001 if (!(s->cpuid_ext2_features & CPUID_EXT2_3DNOW))
4002 goto illegal_op;
4003 val = ldub_code(s->pc++);
4004 sse_op2 = sse_op_table5[val];
4005 if (!sse_op2)
4006 goto illegal_op;
4007 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4008 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4009 ((void (*)(TCGv_ptr, TCGv_ptr))sse_op2)(cpu_ptr0, cpu_ptr1);
4010 break;
4011 case 0x70: /* pshufx insn */
4012 case 0xc6: /* pshufx insn */
4013 val = ldub_code(s->pc++);
4014 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4015 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4016 ((void (*)(TCGv_ptr, TCGv_ptr, TCGv_i32))sse_op2)(cpu_ptr0, cpu_ptr1, tcg_const_i32(val));
4017 break;
4018 case 0xc2:
4019 /* compare insns */
4020 val = ldub_code(s->pc++);
4021 if (val >= 8)
4022 goto illegal_op;
4023 sse_op2 = sse_op_table4[val][b1];
4024 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4025 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4026 ((void (*)(TCGv_ptr, TCGv_ptr))sse_op2)(cpu_ptr0, cpu_ptr1);
4027 break;
4028 case 0xf7:
4029 /* maskmov : we must prepare A0 */
4030 if (mod != 3)
4031 goto illegal_op;
4032 #ifdef TARGET_X86_64
4033 if (s->aflag == 2) {
4034 gen_op_movq_A0_reg(R_EDI);
4035 } else
4036 #endif
4037 {
4038 gen_op_movl_A0_reg(R_EDI);
4039 if (s->aflag == 0)
4040 gen_op_andl_A0_ffff();
4041 }
4042 gen_add_A0_ds_seg(s);
4043
4044 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4045 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4046 ((void (*)(TCGv_ptr, TCGv_ptr, TCGv))sse_op2)(cpu_ptr0, cpu_ptr1, cpu_A0);
4047 break;
4048 default:
4049 tcg_gen_addi_ptr(cpu_ptr0, cpu_env, op1_offset);
4050 tcg_gen_addi_ptr(cpu_ptr1, cpu_env, op2_offset);
4051 ((void (*)(TCGv_ptr, TCGv_ptr))sse_op2)(cpu_ptr0, cpu_ptr1);
4052 break;
4053 }
4054 if (b == 0x2e || b == 0x2f) {
4055 s->cc_op = CC_OP_EFLAGS;
4056 }
4057 }
4058 }
4059
4060 /* convert one instruction. s->is_jmp is set if the translation must
4061 be stopped. Return the next pc value */
4062 static target_ulong disas_insn(DisasContext *s, target_ulong pc_start)
4063 {
4064 int b, prefixes, aflag, dflag;
4065 int shift, ot;
4066 int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
4067 target_ulong next_eip, tval;
4068 int rex_w, rex_r;
4069
4070 if (unlikely(qemu_loglevel_mask(CPU_LOG_TB_OP)))
4071 tcg_gen_debug_insn_start(pc_start);
4072 s->pc = pc_start;
4073 prefixes = 0;
4074 aflag = s->code32;
4075 dflag = s->code32;
4076 s->override = -1;
4077 rex_w = -1;
4078 rex_r = 0;
4079 #ifdef TARGET_X86_64
4080 s->rex_x = 0;
4081 s->rex_b = 0;
4082 x86_64_hregs = 0;
4083 #endif
4084 s->rip_offset = 0; /* for relative ip address */
4085 next_byte:
4086 b = ldub_code(s->pc);
4087 s->pc++;
4088 /* check prefixes */
4089 #ifdef TARGET_X86_64
4090 if (CODE64(s)) {
4091 switch (b) {
4092 case 0xf3:
4093 prefixes |= PREFIX_REPZ;
4094 goto next_byte;
4095 case 0xf2:
4096 prefixes |= PREFIX_REPNZ;
4097 goto next_byte;
4098 case 0xf0:
4099 prefixes |= PREFIX_LOCK;
4100 goto next_byte;
4101 case 0x2e:
4102 s->override = R_CS;
4103 goto next_byte;
4104 case 0x36:
4105 s->override = R_SS;
4106 goto next_byte;
4107 case 0x3e:
4108 s->override = R_DS;
4109 goto next_byte;
4110 case 0x26:
4111 s->override = R_ES;
4112 goto next_byte;
4113 case 0x64:
4114 s->override = R_FS;
4115 goto next_byte;
4116 case 0x65:
4117 s->override = R_GS;
4118 goto next_byte;
4119 case 0x66:
4120 prefixes |= PREFIX_DATA;
4121 goto next_byte;
4122 case 0x67:
4123 prefixes |= PREFIX_ADR;
4124 goto next_byte;
4125 case 0x40 ... 0x4f:
4126 /* REX prefix */
4127 rex_w = (b >> 3) & 1;
4128 rex_r = (b & 0x4) << 1;
4129 s->rex_x = (b & 0x2) << 2;
4130 REX_B(s) = (b & 0x1) << 3;
4131 x86_64_hregs = 1; /* select uniform byte register addressing */
4132 goto next_byte;
4133 }
4134 if (rex_w == 1) {
4135 /* 0x66 is ignored if rex.w is set */
4136 dflag = 2;
4137 } else {
4138 if (prefixes & PREFIX_DATA)
4139 dflag ^= 1;
4140 }
4141 if (!(prefixes & PREFIX_ADR))
4142 aflag = 2;
4143 } else
4144 #endif
4145 {
4146 switch (b) {
4147 case 0xf3:
4148 prefixes |= PREFIX_REPZ;
4149 goto next_byte;
4150 case 0xf2:
4151 prefixes |= PREFIX_REPNZ;
4152 goto next_byte;
4153 case 0xf0:
4154 prefixes |= PREFIX_LOCK;
4155 goto next_byte;
4156 case 0x2e:
4157 s->override = R_CS;
4158 goto next_byte;
4159 case 0x36:
4160 s->override = R_SS;
4161 goto next_byte;
4162 case 0x3e:
4163 s->override = R_DS;
4164 goto next_byte;
4165 case 0x26:
4166 s->override = R_ES;
4167 goto next_byte;
4168 case 0x64:
4169 s->override = R_FS;
4170 goto next_byte;
4171 case 0x65:
4172 s->override = R_GS;
4173 goto next_byte;
4174 case 0x66:
4175 prefixes |= PREFIX_DATA;
4176 goto next_byte;
4177 case 0x67:
4178 prefixes |= PREFIX_ADR;
4179 goto next_byte;
4180 }
4181 if (prefixes & PREFIX_DATA)
4182 dflag ^= 1;
4183 if (prefixes & PREFIX_ADR)
4184 aflag ^= 1;
4185 }
4186
4187 s->prefix = prefixes;
4188 s->aflag = aflag;
4189 s->dflag = dflag;
4190
4191 /* lock generation */
4192 if (prefixes & PREFIX_LOCK)
4193 gen_helper_lock();
4194
4195 /* now check op code */
4196 reswitch:
4197 switch(b) {
4198 case 0x0f:
4199 /**************************/
4200 /* extended op code */
4201 b = ldub_code(s->pc++) | 0x100;
4202 goto reswitch;
4203
4204 /**************************/
4205 /* arith & logic */
4206 case 0x00 ... 0x05:
4207 case 0x08 ... 0x0d:
4208 case 0x10 ... 0x15:
4209 case 0x18 ... 0x1d:
4210 case 0x20 ... 0x25:
4211 case 0x28 ... 0x2d:
4212 case 0x30 ... 0x35:
4213 case 0x38 ... 0x3d:
4214 {
4215 int op, f, val;
4216 op = (b >> 3) & 7;
4217 f = (b >> 1) & 3;
4218
4219 if ((b & 1) == 0)
4220 ot = OT_BYTE;
4221 else
4222 ot = dflag + OT_WORD;
4223
4224 switch(f) {
4225 case 0: /* OP Ev, Gv */
4226 modrm = ldub_code(s->pc++);
4227 reg = ((modrm >> 3) & 7) | rex_r;
4228 mod = (modrm >> 6) & 3;
4229 rm = (modrm & 7) | REX_B(s);
4230 if (mod != 3) {
4231 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4232 opreg = OR_TMP0;
4233 } else if (op == OP_XORL && rm == reg) {
4234 xor_zero:
4235 /* xor reg, reg optimisation */
4236 gen_op_movl_T0_0();
4237 s->cc_op = CC_OP_LOGICB + ot;
4238 gen_op_mov_reg_T0(ot, reg);
4239 gen_op_update1_cc();
4240 break;
4241 } else {
4242 opreg = rm;
4243 }
4244 gen_op_mov_TN_reg(ot, 1, reg);
4245 gen_op(s, op, ot, opreg);
4246 break;
4247 case 1: /* OP Gv, Ev */
4248 modrm = ldub_code(s->pc++);
4249 mod = (modrm >> 6) & 3;
4250 reg = ((modrm >> 3) & 7) | rex_r;
4251 rm = (modrm & 7) | REX_B(s);
4252 if (mod != 3) {
4253 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4254 gen_op_ld_T1_A0(ot + s->mem_index);
4255 } else if (op == OP_XORL && rm == reg) {
4256 goto xor_zero;
4257 } else {
4258 gen_op_mov_TN_reg(ot, 1, rm);
4259 }
4260 gen_op(s, op, ot, reg);
4261 break;
4262 case 2: /* OP A, Iv */
4263 val = insn_get(s, ot);
4264 gen_op_movl_T1_im(val);
4265 gen_op(s, op, ot, OR_EAX);
4266 break;
4267 }
4268 }
4269 break;
4270
4271 case 0x82:
4272 if (CODE64(s))
4273 goto illegal_op;
4274 case 0x80: /* GRP1 */
4275 case 0x81:
4276 case 0x83:
4277 {
4278 int val;
4279
4280 if ((b & 1) == 0)
4281 ot = OT_BYTE;
4282 else
4283 ot = dflag + OT_WORD;
4284
4285 modrm = ldub_code(s->pc++);
4286 mod = (modrm >> 6) & 3;
4287 rm = (modrm & 7) | REX_B(s);
4288 op = (modrm >> 3) & 7;
4289
4290 if (mod != 3) {
4291 if (b == 0x83)
4292 s->rip_offset = 1;
4293 else
4294 s->rip_offset = insn_const_size(ot);
4295 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4296 opreg = OR_TMP0;
4297 } else {
4298 opreg = rm;
4299 }
4300
4301 switch(b) {
4302 default:
4303 case 0x80:
4304 case 0x81:
4305 case 0x82:
4306 val = insn_get(s, ot);
4307 break;
4308 case 0x83:
4309 val = (int8_t)insn_get(s, OT_BYTE);
4310 break;
4311 }
4312 gen_op_movl_T1_im(val);
4313 gen_op(s, op, ot, opreg);
4314 }
4315 break;
4316
4317 /**************************/
4318 /* inc, dec, and other misc arith */
4319 case 0x40 ... 0x47: /* inc Gv */
4320 ot = dflag ? OT_LONG : OT_WORD;
4321 gen_inc(s, ot, OR_EAX + (b & 7), 1);
4322 break;
4323 case 0x48 ... 0x4f: /* dec Gv */
4324 ot = dflag ? OT_LONG : OT_WORD;
4325 gen_inc(s, ot, OR_EAX + (b & 7), -1);
4326 break;
4327 case 0xf6: /* GRP3 */
4328 case 0xf7:
4329 if ((b & 1) == 0)
4330 ot = OT_BYTE;
4331 else
4332 ot = dflag + OT_WORD;
4333
4334 modrm = ldub_code(s->pc++);
4335 mod = (modrm >> 6) & 3;
4336 rm = (modrm & 7) | REX_B(s);
4337 op = (modrm >> 3) & 7;
4338 if (mod != 3) {
4339 if (op == 0)
4340 s->rip_offset = insn_const_size(ot);
4341 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4342 gen_op_ld_T0_A0(ot + s->mem_index);
4343 } else {
4344 gen_op_mov_TN_reg(ot, 0, rm);
4345 }
4346
4347 switch(op) {
4348 case 0: /* test */
4349 val = insn_get(s, ot);
4350 gen_op_movl_T1_im(val);
4351 gen_op_testl_T0_T1_cc();
4352 s->cc_op = CC_OP_LOGICB + ot;
4353 break;
4354 case 2: /* not */
4355 tcg_gen_not_tl(cpu_T[0], cpu_T[0]);
4356 if (mod != 3) {
4357 gen_op_st_T0_A0(ot + s->mem_index);
4358 } else {
4359 gen_op_mov_reg_T0(ot, rm);
4360 }
4361 break;
4362 case 3: /* neg */
4363 tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
4364 if (mod != 3) {
4365 gen_op_st_T0_A0(ot + s->mem_index);
4366 } else {
4367 gen_op_mov_reg_T0(ot, rm);
4368 }
4369 gen_op_update_neg_cc();
4370 s->cc_op = CC_OP_SUBB + ot;
4371 break;
4372 case 4: /* mul */
4373 switch(ot) {
4374 case OT_BYTE:
4375 gen_op_mov_TN_reg(OT_BYTE, 1, R_EAX);
4376 tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
4377 tcg_gen_ext8u_tl(cpu_T[1], cpu_T[1]);
4378 /* XXX: use 32 bit mul which could be faster */
4379 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4380 gen_op_mov_reg_T0(OT_WORD, R_EAX);
4381 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4382 tcg_gen_andi_tl(cpu_cc_src, cpu_T[0], 0xff00);
4383 s->cc_op = CC_OP_MULB;
4384 break;
4385 case OT_WORD:
4386 gen_op_mov_TN_reg(OT_WORD, 1, R_EAX);
4387 tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
4388 tcg_gen_ext16u_tl(cpu_T[1], cpu_T[1]);
4389 /* XXX: use 32 bit mul which could be faster */
4390 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4391 gen_op_mov_reg_T0(OT_WORD, R_EAX);
4392 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4393 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
4394 gen_op_mov_reg_T0(OT_WORD, R_EDX);
4395 tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
4396 s->cc_op = CC_OP_MULW;
4397 break;
4398 default:
4399 case OT_LONG:
4400 #ifdef TARGET_X86_64
4401 gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
4402 tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
4403 tcg_gen_ext32u_tl(cpu_T[1], cpu_T[1]);
4404 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4405 gen_op_mov_reg_T0(OT_LONG, R_EAX);
4406 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4407 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);
4408 gen_op_mov_reg_T0(OT_LONG, R_EDX);
4409 tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
4410 #else
4411 {
4412 TCGv_i64 t0, t1;
4413 t0 = tcg_temp_new_i64();
4414 t1 = tcg_temp_new_i64();
4415 gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
4416 tcg_gen_extu_i32_i64(t0, cpu_T[0]);
4417 tcg_gen_extu_i32_i64(t1, cpu_T[1]);
4418 tcg_gen_mul_i64(t0, t0, t1);
4419 tcg_gen_trunc_i64_i32(cpu_T[0], t0);
4420 gen_op_mov_reg_T0(OT_LONG, R_EAX);
4421 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4422 tcg_gen_shri_i64(t0, t0, 32);
4423 tcg_gen_trunc_i64_i32(cpu_T[0], t0);
4424 gen_op_mov_reg_T0(OT_LONG, R_EDX);
4425 tcg_gen_mov_tl(cpu_cc_src, cpu_T[0]);
4426 }
4427 #endif
4428 s->cc_op = CC_OP_MULL;
4429 break;
4430 #ifdef TARGET_X86_64
4431 case OT_QUAD:
4432 gen_helper_mulq_EAX_T0(cpu_T[0]);
4433 s->cc_op = CC_OP_MULQ;
4434 break;
4435 #endif
4436 }
4437 break;
4438 case 5: /* imul */
4439 switch(ot) {
4440 case OT_BYTE:
4441 gen_op_mov_TN_reg(OT_BYTE, 1, R_EAX);
4442 tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
4443 tcg_gen_ext8s_tl(cpu_T[1], cpu_T[1]);
4444 /* XXX: use 32 bit mul which could be faster */
4445 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4446 gen_op_mov_reg_T0(OT_WORD, R_EAX);
4447 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4448 tcg_gen_ext8s_tl(cpu_tmp0, cpu_T[0]);
4449 tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
4450 s->cc_op = CC_OP_MULB;
4451 break;
4452 case OT_WORD:
4453 gen_op_mov_TN_reg(OT_WORD, 1, R_EAX);
4454 tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
4455 tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
4456 /* XXX: use 32 bit mul which could be faster */
4457 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4458 gen_op_mov_reg_T0(OT_WORD, R_EAX);
4459 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4460 tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
4461 tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
4462 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 16);
4463 gen_op_mov_reg_T0(OT_WORD, R_EDX);
4464 s->cc_op = CC_OP_MULW;
4465 break;
4466 default:
4467 case OT_LONG:
4468 #ifdef TARGET_X86_64
4469 gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
4470 tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
4471 tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);
4472 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4473 gen_op_mov_reg_T0(OT_LONG, R_EAX);
4474 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4475 tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);
4476 tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
4477 tcg_gen_shri_tl(cpu_T[0], cpu_T[0], 32);
4478 gen_op_mov_reg_T0(OT_LONG, R_EDX);
4479 #else
4480 {
4481 TCGv_i64 t0, t1;
4482 t0 = tcg_temp_new_i64();
4483 t1 = tcg_temp_new_i64();
4484 gen_op_mov_TN_reg(OT_LONG, 1, R_EAX);
4485 tcg_gen_ext_i32_i64(t0, cpu_T[0]);
4486 tcg_gen_ext_i32_i64(t1, cpu_T[1]);
4487 tcg_gen_mul_i64(t0, t0, t1);
4488 tcg_gen_trunc_i64_i32(cpu_T[0], t0);
4489 gen_op_mov_reg_T0(OT_LONG, R_EAX);
4490 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4491 tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);
4492 tcg_gen_shri_i64(t0, t0, 32);
4493 tcg_gen_trunc_i64_i32(cpu_T[0], t0);
4494 gen_op_mov_reg_T0(OT_LONG, R_EDX);
4495 tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
4496 }
4497 #endif
4498 s->cc_op = CC_OP_MULL;
4499 break;
4500 #ifdef TARGET_X86_64
4501 case OT_QUAD:
4502 gen_helper_imulq_EAX_T0(cpu_T[0]);
4503 s->cc_op = CC_OP_MULQ;
4504 break;
4505 #endif
4506 }
4507 break;
4508 case 6: /* div */
4509 switch(ot) {
4510 case OT_BYTE:
4511 gen_jmp_im(pc_start - s->cs_base);
4512 gen_helper_divb_AL(cpu_T[0]);
4513 break;
4514 case OT_WORD:
4515 gen_jmp_im(pc_start - s->cs_base);
4516 gen_helper_divw_AX(cpu_T[0]);
4517 break;
4518 default:
4519 case OT_LONG:
4520 gen_jmp_im(pc_start - s->cs_base);
4521 gen_helper_divl_EAX(cpu_T[0]);
4522 break;
4523 #ifdef TARGET_X86_64
4524 case OT_QUAD:
4525 gen_jmp_im(pc_start - s->cs_base);
4526 gen_helper_divq_EAX(cpu_T[0]);
4527 break;
4528 #endif
4529 }
4530 break;
4531 case 7: /* idiv */
4532 switch(ot) {
4533 case OT_BYTE:
4534 gen_jmp_im(pc_start - s->cs_base);
4535 gen_helper_idivb_AL(cpu_T[0]);
4536 break;
4537 case OT_WORD:
4538 gen_jmp_im(pc_start - s->cs_base);
4539 gen_helper_idivw_AX(cpu_T[0]);
4540 break;
4541 default:
4542 case OT_LONG:
4543 gen_jmp_im(pc_start - s->cs_base);
4544 gen_helper_idivl_EAX(cpu_T[0]);
4545 break;
4546 #ifdef TARGET_X86_64
4547 case OT_QUAD:
4548 gen_jmp_im(pc_start - s->cs_base);
4549 gen_helper_idivq_EAX(cpu_T[0]);
4550 break;
4551 #endif
4552 }
4553 break;
4554 default:
4555 goto illegal_op;
4556 }
4557 break;
4558
4559 case 0xfe: /* GRP4 */
4560 case 0xff: /* GRP5 */
4561 if ((b & 1) == 0)
4562 ot = OT_BYTE;
4563 else
4564 ot = dflag + OT_WORD;
4565
4566 modrm = ldub_code(s->pc++);
4567 mod = (modrm >> 6) & 3;
4568 rm = (modrm & 7) | REX_B(s);
4569 op = (modrm >> 3) & 7;
4570 if (op >= 2 && b == 0xfe) {
4571 goto illegal_op;
4572 }
4573 if (CODE64(s)) {
4574 if (op == 2 || op == 4) {
4575 /* operand size for jumps is 64 bit */
4576 ot = OT_QUAD;
4577 } else if (op == 3 || op == 5) {
4578 ot = dflag ? OT_LONG + (rex_w == 1) : OT_WORD;
4579 } else if (op == 6) {
4580 /* default push size is 64 bit */
4581 ot = dflag ? OT_QUAD : OT_WORD;
4582 }
4583 }
4584 if (mod != 3) {
4585 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4586 if (op >= 2 && op != 3 && op != 5)
4587 gen_op_ld_T0_A0(ot + s->mem_index);
4588 } else {
4589 gen_op_mov_TN_reg(ot, 0, rm);
4590 }
4591
4592 switch(op) {
4593 case 0: /* inc Ev */
4594 if (mod != 3)
4595 opreg = OR_TMP0;
4596 else
4597 opreg = rm;
4598 gen_inc(s, ot, opreg, 1);
4599 break;
4600 case 1: /* dec Ev */
4601 if (mod != 3)
4602 opreg = OR_TMP0;
4603 else
4604 opreg = rm;
4605 gen_inc(s, ot, opreg, -1);
4606 break;
4607 case 2: /* call Ev */
4608 /* XXX: optimize if memory (no 'and' is necessary) */
4609 if (s->dflag == 0)
4610 gen_op_andl_T0_ffff();
4611 next_eip = s->pc - s->cs_base;
4612 gen_movtl_T1_im(next_eip);
4613 gen_push_T1(s);
4614 gen_op_jmp_T0();
4615 gen_eob(s);
4616 break;
4617 case 3: /* lcall Ev */
4618 gen_op_ld_T1_A0(ot + s->mem_index);
4619 gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));
4620 gen_op_ldu_T0_A0(OT_WORD + s->mem_index);
4621 do_lcall:
4622 if (s->pe && !s->vm86) {
4623 if (s->cc_op != CC_OP_DYNAMIC)
4624 gen_op_set_cc_op(s->cc_op);
4625 gen_jmp_im(pc_start - s->cs_base);
4626 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4627 gen_helper_lcall_protected(cpu_tmp2_i32, cpu_T[1],
4628 tcg_const_i32(dflag),
4629 tcg_const_i32(s->pc - pc_start));
4630 } else {
4631 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4632 gen_helper_lcall_real(cpu_tmp2_i32, cpu_T[1],
4633 tcg_const_i32(dflag),
4634 tcg_const_i32(s->pc - s->cs_base));
4635 }
4636 gen_eob(s);
4637 break;
4638 case 4: /* jmp Ev */
4639 if (s->dflag == 0)
4640 gen_op_andl_T0_ffff();
4641 gen_op_jmp_T0();
4642 gen_eob(s);
4643 break;
4644 case 5: /* ljmp Ev */
4645 gen_op_ld_T1_A0(ot + s->mem_index);
4646 gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));
4647 gen_op_ldu_T0_A0(OT_WORD + s->mem_index);
4648 do_ljmp:
4649 if (s->pe && !s->vm86) {
4650 if (s->cc_op != CC_OP_DYNAMIC)
4651 gen_op_set_cc_op(s->cc_op);
4652 gen_jmp_im(pc_start - s->cs_base);
4653 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
4654 gen_helper_ljmp_protected(cpu_tmp2_i32, cpu_T[1],
4655 tcg_const_i32(s->pc - pc_start));
4656 } else {
4657 gen_op_movl_seg_T0_vm(R_CS);
4658 gen_op_movl_T0_T1();
4659 gen_op_jmp_T0();
4660 }
4661 gen_eob(s);
4662 break;
4663 case 6: /* push Ev */
4664 gen_push_T0(s);
4665 break;
4666 default:
4667 goto illegal_op;
4668 }
4669 break;
4670
4671 case 0x84: /* test Ev, Gv */
4672 case 0x85:
4673 if ((b & 1) == 0)
4674 ot = OT_BYTE;
4675 else
4676 ot = dflag + OT_WORD;
4677
4678 modrm = ldub_code(s->pc++);
4679 reg = ((modrm >> 3) & 7) | rex_r;
4680
4681 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
4682 gen_op_mov_TN_reg(ot, 1, reg);
4683 gen_op_testl_T0_T1_cc();
4684 s->cc_op = CC_OP_LOGICB + ot;
4685 break;
4686
4687 case 0xa8: /* test eAX, Iv */
4688 case 0xa9:
4689 if ((b & 1) == 0)
4690 ot = OT_BYTE;
4691 else
4692 ot = dflag + OT_WORD;
4693 val = insn_get(s, ot);
4694
4695 gen_op_mov_TN_reg(ot, 0, OR_EAX);
4696 gen_op_movl_T1_im(val);
4697 gen_op_testl_T0_T1_cc();
4698 s->cc_op = CC_OP_LOGICB + ot;
4699 break;
4700
4701 case 0x98: /* CWDE/CBW */
4702 #ifdef TARGET_X86_64
4703 if (dflag == 2) {
4704 gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
4705 tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
4706 gen_op_mov_reg_T0(OT_QUAD, R_EAX);
4707 } else
4708 #endif
4709 if (dflag == 1) {
4710 gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);
4711 tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
4712 gen_op_mov_reg_T0(OT_LONG, R_EAX);
4713 } else {
4714 gen_op_mov_TN_reg(OT_BYTE, 0, R_EAX);
4715 tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
4716 gen_op_mov_reg_T0(OT_WORD, R_EAX);
4717 }
4718 break;
4719 case 0x99: /* CDQ/CWD */
4720 #ifdef TARGET_X86_64
4721 if (dflag == 2) {
4722 gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);
4723 tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 63);
4724 gen_op_mov_reg_T0(OT_QUAD, R_EDX);
4725 } else
4726 #endif
4727 if (dflag == 1) {
4728 gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
4729 tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
4730 tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 31);
4731 gen_op_mov_reg_T0(OT_LONG, R_EDX);
4732 } else {
4733 gen_op_mov_TN_reg(OT_WORD, 0, R_EAX);
4734 tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
4735 tcg_gen_sari_tl(cpu_T[0], cpu_T[0], 15);
4736 gen_op_mov_reg_T0(OT_WORD, R_EDX);
4737 }
4738 break;
4739 case 0x1af: /* imul Gv, Ev */
4740 case 0x69: /* imul Gv, Ev, I */
4741 case 0x6b:
4742 ot = dflag + OT_WORD;
4743 modrm = ldub_code(s->pc++);
4744 reg = ((modrm >> 3) & 7) | rex_r;
4745 if (b == 0x69)
4746 s->rip_offset = insn_const_size(ot);
4747 else if (b == 0x6b)
4748 s->rip_offset = 1;
4749 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
4750 if (b == 0x69) {
4751 val = insn_get(s, ot);
4752 gen_op_movl_T1_im(val);
4753 } else if (b == 0x6b) {
4754 val = (int8_t)insn_get(s, OT_BYTE);
4755 gen_op_movl_T1_im(val);
4756 } else {
4757 gen_op_mov_TN_reg(ot, 1, reg);
4758 }
4759
4760 #ifdef TARGET_X86_64
4761 if (ot == OT_QUAD) {
4762 gen_helper_imulq_T0_T1(cpu_T[0], cpu_T[0], cpu_T[1]);
4763 } else
4764 #endif
4765 if (ot == OT_LONG) {
4766 #ifdef TARGET_X86_64
4767 tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
4768 tcg_gen_ext32s_tl(cpu_T[1], cpu_T[1]);
4769 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4770 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4771 tcg_gen_ext32s_tl(cpu_tmp0, cpu_T[0]);
4772 tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
4773 #else
4774 {
4775 TCGv_i64 t0, t1;
4776 t0 = tcg_temp_new_i64();
4777 t1 = tcg_temp_new_i64();
4778 tcg_gen_ext_i32_i64(t0, cpu_T[0]);
4779 tcg_gen_ext_i32_i64(t1, cpu_T[1]);
4780 tcg_gen_mul_i64(t0, t0, t1);
4781 tcg_gen_trunc_i64_i32(cpu_T[0], t0);
4782 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4783 tcg_gen_sari_tl(cpu_tmp0, cpu_T[0], 31);
4784 tcg_gen_shri_i64(t0, t0, 32);
4785 tcg_gen_trunc_i64_i32(cpu_T[1], t0);
4786 tcg_gen_sub_tl(cpu_cc_src, cpu_T[1], cpu_tmp0);
4787 }
4788 #endif
4789 } else {
4790 tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
4791 tcg_gen_ext16s_tl(cpu_T[1], cpu_T[1]);
4792 /* XXX: use 32 bit mul which could be faster */
4793 tcg_gen_mul_tl(cpu_T[0], cpu_T[0], cpu_T[1]);
4794 tcg_gen_mov_tl(cpu_cc_dst, cpu_T[0]);
4795 tcg_gen_ext16s_tl(cpu_tmp0, cpu_T[0]);
4796 tcg_gen_sub_tl(cpu_cc_src, cpu_T[0], cpu_tmp0);
4797 }
4798 gen_op_mov_reg_T0(ot, reg);
4799 s->cc_op = CC_OP_MULB + ot;
4800 break;
4801 case 0x1c0:
4802 case 0x1c1: /* xadd Ev, Gv */
4803 if ((b & 1) == 0)
4804 ot = OT_BYTE;
4805 else
4806 ot = dflag + OT_WORD;
4807 modrm = ldub_code(s->pc++);
4808 reg = ((modrm >> 3) & 7) | rex_r;
4809 mod = (modrm >> 6) & 3;
4810 if (mod == 3) {
4811 rm = (modrm & 7) | REX_B(s);
4812 gen_op_mov_TN_reg(ot, 0, reg);
4813 gen_op_mov_TN_reg(ot, 1, rm);
4814 gen_op_addl_T0_T1();
4815 gen_op_mov_reg_T1(ot, reg);
4816 gen_op_mov_reg_T0(ot, rm);
4817 } else {
4818 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4819 gen_op_mov_TN_reg(ot, 0, reg);
4820 gen_op_ld_T1_A0(ot + s->mem_index);
4821 gen_op_addl_T0_T1();
4822 gen_op_st_T0_A0(ot + s->mem_index);
4823 gen_op_mov_reg_T1(ot, reg);
4824 }
4825 gen_op_update2_cc();
4826 s->cc_op = CC_OP_ADDB + ot;
4827 break;
4828 case 0x1b0:
4829 case 0x1b1: /* cmpxchg Ev, Gv */
4830 {
4831 int label1, label2;
4832 TCGv t0, t1, t2, a0;
4833
4834 if ((b & 1) == 0)
4835 ot = OT_BYTE;
4836 else
4837 ot = dflag + OT_WORD;
4838 modrm = ldub_code(s->pc++);
4839 reg = ((modrm >> 3) & 7) | rex_r;
4840 mod = (modrm >> 6) & 3;
4841 t0 = tcg_temp_local_new();
4842 t1 = tcg_temp_local_new();
4843 t2 = tcg_temp_local_new();
4844 a0 = tcg_temp_local_new();
4845 gen_op_mov_v_reg(ot, t1, reg);
4846 if (mod == 3) {
4847 rm = (modrm & 7) | REX_B(s);
4848 gen_op_mov_v_reg(ot, t0, rm);
4849 } else {
4850 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4851 tcg_gen_mov_tl(a0, cpu_A0);
4852 gen_op_ld_v(ot + s->mem_index, t0, a0);
4853 rm = 0; /* avoid warning */
4854 }
4855 label1 = gen_new_label();
4856 tcg_gen_sub_tl(t2, cpu_regs[R_EAX], t0);
4857 gen_extu(ot, t2);
4858 tcg_gen_brcondi_tl(TCG_COND_EQ, t2, 0, label1);
4859 if (mod == 3) {
4860 label2 = gen_new_label();
4861 gen_op_mov_reg_v(ot, R_EAX, t0);
4862 tcg_gen_br(label2);
4863 gen_set_label(label1);
4864 gen_op_mov_reg_v(ot, rm, t1);
4865 gen_set_label(label2);
4866 } else {
4867 tcg_gen_mov_tl(t1, t0);
4868 gen_op_mov_reg_v(ot, R_EAX, t0);
4869 gen_set_label(label1);
4870 /* always store */
4871 gen_op_st_v(ot + s->mem_index, t1, a0);
4872 }
4873 tcg_gen_mov_tl(cpu_cc_src, t0);
4874 tcg_gen_mov_tl(cpu_cc_dst, t2);
4875 s->cc_op = CC_OP_SUBB + ot;
4876 tcg_temp_free(t0);
4877 tcg_temp_free(t1);
4878 tcg_temp_free(t2);
4879 tcg_temp_free(a0);
4880 }
4881 break;
4882 case 0x1c7: /* cmpxchg8b */
4883 modrm = ldub_code(s->pc++);
4884 mod = (modrm >> 6) & 3;
4885 if ((mod == 3) || ((modrm & 0x38) != 0x8))
4886 goto illegal_op;
4887 #ifdef TARGET_X86_64
4888 if (dflag == 2) {
4889 if (!(s->cpuid_ext_features & CPUID_EXT_CX16))
4890 goto illegal_op;
4891 gen_jmp_im(pc_start - s->cs_base);
4892 if (s->cc_op != CC_OP_DYNAMIC)
4893 gen_op_set_cc_op(s->cc_op);
4894 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4895 gen_helper_cmpxchg16b(cpu_A0);
4896 } else
4897 #endif
4898 {
4899 if (!(s->cpuid_features & CPUID_CX8))
4900 goto illegal_op;
4901 gen_jmp_im(pc_start - s->cs_base);
4902 if (s->cc_op != CC_OP_DYNAMIC)
4903 gen_op_set_cc_op(s->cc_op);
4904 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4905 gen_helper_cmpxchg8b(cpu_A0);
4906 }
4907 s->cc_op = CC_OP_EFLAGS;
4908 break;
4909
4910 /**************************/
4911 /* push/pop */
4912 case 0x50 ... 0x57: /* push */
4913 gen_op_mov_TN_reg(OT_LONG, 0, (b & 7) | REX_B(s));
4914 gen_push_T0(s);
4915 break;
4916 case 0x58 ... 0x5f: /* pop */
4917 if (CODE64(s)) {
4918 ot = dflag ? OT_QUAD : OT_WORD;
4919 } else {
4920 ot = dflag + OT_WORD;
4921 }
4922 gen_pop_T0(s);
4923 /* NOTE: order is important for pop %sp */
4924 gen_pop_update(s);
4925 gen_op_mov_reg_T0(ot, (b & 7) | REX_B(s));
4926 break;
4927 case 0x60: /* pusha */
4928 if (CODE64(s))
4929 goto illegal_op;
4930 gen_pusha(s);
4931 break;
4932 case 0x61: /* popa */
4933 if (CODE64(s))
4934 goto illegal_op;
4935 gen_popa(s);
4936 break;
4937 case 0x68: /* push Iv */
4938 case 0x6a:
4939 if (CODE64(s)) {
4940 ot = dflag ? OT_QUAD : OT_WORD;
4941 } else {
4942 ot = dflag + OT_WORD;
4943 }
4944 if (b == 0x68)
4945 val = insn_get(s, ot);
4946 else
4947 val = (int8_t)insn_get(s, OT_BYTE);
4948 gen_op_movl_T0_im(val);
4949 gen_push_T0(s);
4950 break;
4951 case 0x8f: /* pop Ev */
4952 if (CODE64(s)) {
4953 ot = dflag ? OT_QUAD : OT_WORD;
4954 } else {
4955 ot = dflag + OT_WORD;
4956 }
4957 modrm = ldub_code(s->pc++);
4958 mod = (modrm >> 6) & 3;
4959 gen_pop_T0(s);
4960 if (mod == 3) {
4961 /* NOTE: order is important for pop %sp */
4962 gen_pop_update(s);
4963 rm = (modrm & 7) | REX_B(s);
4964 gen_op_mov_reg_T0(ot, rm);
4965 } else {
4966 /* NOTE: order is important too for MMU exceptions */
4967 s->popl_esp_hack = 1 << ot;
4968 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
4969 s->popl_esp_hack = 0;
4970 gen_pop_update(s);
4971 }
4972 break;
4973 case 0xc8: /* enter */
4974 {
4975 int level;
4976 val = lduw_code(s->pc);
4977 s->pc += 2;
4978 level = ldub_code(s->pc++);
4979 gen_enter(s, val, level);
4980 }
4981 break;
4982 case 0xc9: /* leave */
4983 /* XXX: exception not precise (ESP is updated before potential exception) */
4984 if (CODE64(s)) {
4985 gen_op_mov_TN_reg(OT_QUAD, 0, R_EBP);
4986 gen_op_mov_reg_T0(OT_QUAD, R_ESP);
4987 } else if (s->ss32) {
4988 gen_op_mov_TN_reg(OT_LONG, 0, R_EBP);
4989 gen_op_mov_reg_T0(OT_LONG, R_ESP);
4990 } else {
4991 gen_op_mov_TN_reg(OT_WORD, 0, R_EBP);
4992 gen_op_mov_reg_T0(OT_WORD, R_ESP);
4993 }
4994 gen_pop_T0(s);
4995 if (CODE64(s)) {
4996 ot = dflag ? OT_QUAD : OT_WORD;
4997 } else {
4998 ot = dflag + OT_WORD;
4999 }
5000 gen_op_mov_reg_T0(ot, R_EBP);
5001 gen_pop_update(s);
5002 break;
5003 case 0x06: /* push es */
5004 case 0x0e: /* push cs */
5005 case 0x16: /* push ss */
5006 case 0x1e: /* push ds */
5007 if (CODE64(s))
5008 goto illegal_op;
5009 gen_op_movl_T0_seg(b >> 3);
5010 gen_push_T0(s);
5011 break;
5012 case 0x1a0: /* push fs */
5013 case 0x1a8: /* push gs */
5014 gen_op_movl_T0_seg((b >> 3) & 7);
5015 gen_push_T0(s);
5016 break;
5017 case 0x07: /* pop es */
5018 case 0x17: /* pop ss */
5019 case 0x1f: /* pop ds */
5020 if (CODE64(s))
5021 goto illegal_op;
5022 reg = b >> 3;
5023 gen_pop_T0(s);
5024 gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
5025 gen_pop_update(s);
5026 if (reg == R_SS) {
5027 /* if reg == SS, inhibit interrupts/trace. */
5028 /* If several instructions disable interrupts, only the
5029 _first_ does it */
5030 if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
5031 gen_helper_set_inhibit_irq();
5032 s->tf = 0;
5033 }
5034 if (s->is_jmp) {
5035 gen_jmp_im(s->pc - s->cs_base);
5036 gen_eob(s);
5037 }
5038 break;
5039 case 0x1a1: /* pop fs */
5040 case 0x1a9: /* pop gs */
5041 gen_pop_T0(s);
5042 gen_movl_seg_T0(s, (b >> 3) & 7, pc_start - s->cs_base);
5043 gen_pop_update(s);
5044 if (s->is_jmp) {
5045 gen_jmp_im(s->pc - s->cs_base);
5046 gen_eob(s);
5047 }
5048 break;
5049
5050 /**************************/
5051 /* mov */
5052 case 0x88:
5053 case 0x89: /* mov Gv, Ev */
5054 if ((b & 1) == 0)
5055 ot = OT_BYTE;
5056 else
5057 ot = dflag + OT_WORD;
5058 modrm = ldub_code(s->pc++);
5059 reg = ((modrm >> 3) & 7) | rex_r;
5060
5061 /* generate a generic store */
5062 gen_ldst_modrm(s, modrm, ot, reg, 1);
5063 break;
5064 case 0xc6:
5065 case 0xc7: /* mov Ev, Iv */
5066 if ((b & 1) == 0)
5067 ot = OT_BYTE;
5068 else
5069 ot = dflag + OT_WORD;
5070 modrm = ldub_code(s->pc++);
5071 mod = (modrm >> 6) & 3;
5072 if (mod != 3) {
5073 s->rip_offset = insn_const_size(ot);
5074 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5075 }
5076 val = insn_get(s, ot);
5077 gen_op_movl_T0_im(val);
5078 if (mod != 3)
5079 gen_op_st_T0_A0(ot + s->mem_index);
5080 else
5081 gen_op_mov_reg_T0(ot, (modrm & 7) | REX_B(s));
5082 break;
5083 case 0x8a:
5084 case 0x8b: /* mov Ev, Gv */
5085 if ((b & 1) == 0)
5086 ot = OT_BYTE;
5087 else
5088 ot = OT_WORD + dflag;
5089 modrm = ldub_code(s->pc++);
5090 reg = ((modrm >> 3) & 7) | rex_r;
5091
5092 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
5093 gen_op_mov_reg_T0(ot, reg);
5094 break;
5095 case 0x8e: /* mov seg, Gv */
5096 modrm = ldub_code(s->pc++);
5097 reg = (modrm >> 3) & 7;
5098 if (reg >= 6 || reg == R_CS)
5099 goto illegal_op;
5100 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
5101 gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
5102 if (reg == R_SS) {
5103 /* if reg == SS, inhibit interrupts/trace */
5104 /* If several instructions disable interrupts, only the
5105 _first_ does it */
5106 if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
5107 gen_helper_set_inhibit_irq();
5108 s->tf = 0;
5109 }
5110 if (s->is_jmp) {
5111 gen_jmp_im(s->pc - s->cs_base);
5112 gen_eob(s);
5113 }
5114 break;
5115 case 0x8c: /* mov Gv, seg */
5116 modrm = ldub_code(s->pc++);
5117 reg = (modrm >> 3) & 7;
5118 mod = (modrm >> 6) & 3;
5119 if (reg >= 6)
5120 goto illegal_op;
5121 gen_op_movl_T0_seg(reg);
5122 if (mod == 3)
5123 ot = OT_WORD + dflag;
5124 else
5125 ot = OT_WORD;
5126 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
5127 break;
5128
5129 case 0x1b6: /* movzbS Gv, Eb */
5130 case 0x1b7: /* movzwS Gv, Eb */
5131 case 0x1be: /* movsbS Gv, Eb */
5132 case 0x1bf: /* movswS Gv, Eb */
5133 {
5134 int d_ot;
5135 /* d_ot is the size of destination */
5136 d_ot = dflag + OT_WORD;
5137 /* ot is the size of source */
5138 ot = (b & 1) + OT_BYTE;
5139 modrm = ldub_code(s->pc++);
5140 reg = ((modrm >> 3) & 7) | rex_r;
5141 mod = (modrm >> 6) & 3;
5142 rm = (modrm & 7) | REX_B(s);
5143
5144 if (mod == 3) {
5145 gen_op_mov_TN_reg(ot, 0, rm);
5146 switch(ot | (b & 8)) {
5147 case OT_BYTE:
5148 tcg_gen_ext8u_tl(cpu_T[0], cpu_T[0]);
5149 break;
5150 case OT_BYTE | 8:
5151 tcg_gen_ext8s_tl(cpu_T[0], cpu_T[0]);
5152 break;
5153 case OT_WORD:
5154 tcg_gen_ext16u_tl(cpu_T[0], cpu_T[0]);
5155 break;
5156 default:
5157 case OT_WORD | 8:
5158 tcg_gen_ext16s_tl(cpu_T[0], cpu_T[0]);
5159 break;
5160 }
5161 gen_op_mov_reg_T0(d_ot, reg);
5162 } else {
5163 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5164 if (b & 8) {
5165 gen_op_lds_T0_A0(ot + s->mem_index);
5166 } else {
5167 gen_op_ldu_T0_A0(ot + s->mem_index);
5168 }
5169 gen_op_mov_reg_T0(d_ot, reg);
5170 }
5171 }
5172 break;
5173
5174 case 0x8d: /* lea */
5175 ot = dflag + OT_WORD;
5176 modrm = ldub_code(s->pc++);
5177 mod = (modrm >> 6) & 3;
5178 if (mod == 3)
5179 goto illegal_op;
5180 reg = ((modrm >> 3) & 7) | rex_r;
5181 /* we must ensure that no segment is added */
5182 s->override = -1;
5183 val = s->addseg;
5184 s->addseg = 0;
5185 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5186 s->addseg = val;
5187 gen_op_mov_reg_A0(ot - OT_WORD, reg);
5188 break;
5189
5190 case 0xa0: /* mov EAX, Ov */
5191 case 0xa1:
5192 case 0xa2: /* mov Ov, EAX */
5193 case 0xa3:
5194 {
5195 target_ulong offset_addr;
5196
5197 if ((b & 1) == 0)
5198 ot = OT_BYTE;
5199 else
5200 ot = dflag + OT_WORD;
5201 #ifdef TARGET_X86_64
5202 if (s->aflag == 2) {
5203 offset_addr = ldq_code(s->pc);
5204 s->pc += 8;
5205 gen_op_movq_A0_im(offset_addr);
5206 } else
5207 #endif
5208 {
5209 if (s->aflag) {
5210 offset_addr = insn_get(s, OT_LONG);
5211 } else {
5212 offset_addr = insn_get(s, OT_WORD);
5213 }
5214 gen_op_movl_A0_im(offset_addr);
5215 }
5216 gen_add_A0_ds_seg(s);
5217 if ((b & 2) == 0) {
5218 gen_op_ld_T0_A0(ot + s->mem_index);
5219 gen_op_mov_reg_T0(ot, R_EAX);
5220 } else {
5221 gen_op_mov_TN_reg(ot, 0, R_EAX);
5222 gen_op_st_T0_A0(ot + s->mem_index);
5223 }
5224 }
5225 break;
5226 case 0xd7: /* xlat */
5227 #ifdef TARGET_X86_64
5228 if (s->aflag == 2) {
5229 gen_op_movq_A0_reg(R_EBX);
5230 gen_op_mov_TN_reg(OT_QUAD, 0, R_EAX);
5231 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
5232 tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
5233 } else
5234 #endif
5235 {
5236 gen_op_movl_A0_reg(R_EBX);
5237 gen_op_mov_TN_reg(OT_LONG, 0, R_EAX);
5238 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], 0xff);
5239 tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_T[0]);
5240 if (s->aflag == 0)
5241 gen_op_andl_A0_ffff();
5242 else
5243 tcg_gen_andi_tl(cpu_A0, cpu_A0, 0xffffffff);
5244 }
5245 gen_add_A0_ds_seg(s);
5246 gen_op_ldu_T0_A0(OT_BYTE + s->mem_index);
5247 gen_op_mov_reg_T0(OT_BYTE, R_EAX);
5248 break;
5249 case 0xb0 ... 0xb7: /* mov R, Ib */
5250 val = insn_get(s, OT_BYTE);
5251 gen_op_movl_T0_im(val);
5252 gen_op_mov_reg_T0(OT_BYTE, (b & 7) | REX_B(s));
5253 break;
5254 case 0xb8 ... 0xbf: /* mov R, Iv */
5255 #ifdef TARGET_X86_64
5256 if (dflag == 2) {
5257 uint64_t tmp;
5258 /* 64 bit case */
5259 tmp = ldq_code(s->pc);
5260 s->pc += 8;
5261 reg = (b & 7) | REX_B(s);
5262 gen_movtl_T0_im(tmp);
5263 gen_op_mov_reg_T0(OT_QUAD, reg);
5264 } else
5265 #endif
5266 {
5267 ot = dflag ? OT_LONG : OT_WORD;
5268 val = insn_get(s, ot);
5269 reg = (b & 7) | REX_B(s);
5270 gen_op_movl_T0_im(val);
5271 gen_op_mov_reg_T0(ot, reg);
5272 }
5273 break;
5274
5275 case 0x91 ... 0x97: /* xchg R, EAX */
5276 do_xchg_reg_eax:
5277 ot = dflag + OT_WORD;
5278 reg = (b & 7) | REX_B(s);
5279 rm = R_EAX;
5280 goto do_xchg_reg;
5281 case 0x86:
5282 case 0x87: /* xchg Ev, Gv */
5283 if ((b & 1) == 0)
5284 ot = OT_BYTE;
5285 else
5286 ot = dflag + OT_WORD;
5287 modrm = ldub_code(s->pc++);
5288 reg = ((modrm >> 3) & 7) | rex_r;
5289 mod = (modrm >> 6) & 3;
5290 if (mod == 3) {
5291 rm = (modrm & 7) | REX_B(s);
5292 do_xchg_reg:
5293 gen_op_mov_TN_reg(ot, 0, reg);
5294 gen_op_mov_TN_reg(ot, 1, rm);
5295 gen_op_mov_reg_T0(ot, rm);
5296 gen_op_mov_reg_T1(ot, reg);
5297 } else {
5298 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5299 gen_op_mov_TN_reg(ot, 0, reg);
5300 /* for xchg, lock is implicit */
5301 if (!(prefixes & PREFIX_LOCK))
5302 gen_helper_lock();
5303 gen_op_ld_T1_A0(ot + s->mem_index);
5304 gen_op_st_T0_A0(ot + s->mem_index);
5305 if (!(prefixes & PREFIX_LOCK))
5306 gen_helper_unlock();
5307 gen_op_mov_reg_T1(ot, reg);
5308 }
5309 break;
5310 case 0xc4: /* les Gv */
5311 if (CODE64(s))
5312 goto illegal_op;
5313 op = R_ES;
5314 goto do_lxx;
5315 case 0xc5: /* lds Gv */
5316 if (CODE64(s))
5317 goto illegal_op;
5318 op = R_DS;
5319 goto do_lxx;
5320 case 0x1b2: /* lss Gv */
5321 op = R_SS;
5322 goto do_lxx;
5323 case 0x1b4: /* lfs Gv */
5324 op = R_FS;
5325 goto do_lxx;
5326 case 0x1b5: /* lgs Gv */
5327 op = R_GS;
5328 do_lxx:
5329 ot = dflag ? OT_LONG : OT_WORD;
5330 modrm = ldub_code(s->pc++);
5331 reg = ((modrm >> 3) & 7) | rex_r;
5332 mod = (modrm >> 6) & 3;
5333 if (mod == 3)
5334 goto illegal_op;
5335 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5336 gen_op_ld_T1_A0(ot + s->mem_index);
5337 gen_add_A0_im(s, 1 << (ot - OT_WORD + 1));
5338 /* load the segment first to handle exceptions properly */
5339 gen_op_ldu_T0_A0(OT_WORD + s->mem_index);
5340 gen_movl_seg_T0(s, op, pc_start - s->cs_base);
5341 /* then put the data */
5342 gen_op_mov_reg_T1(ot, reg);
5343 if (s->is_jmp) {
5344 gen_jmp_im(s->pc - s->cs_base);
5345 gen_eob(s);
5346 }
5347 break;
5348
5349 /************************/
5350 /* shifts */
5351 case 0xc0:
5352 case 0xc1:
5353 /* shift Ev,Ib */
5354 shift = 2;
5355 grp2:
5356 {
5357 if ((b & 1) == 0)
5358 ot = OT_BYTE;
5359 else
5360 ot = dflag + OT_WORD;
5361
5362 modrm = ldub_code(s->pc++);
5363 mod = (modrm >> 6) & 3;
5364 op = (modrm >> 3) & 7;
5365
5366 if (mod != 3) {
5367 if (shift == 2) {
5368 s->rip_offset = 1;
5369 }
5370 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5371 opreg = OR_TMP0;
5372 } else {
5373 opreg = (modrm & 7) | REX_B(s);
5374 }
5375
5376 /* simpler op */
5377 if (shift == 0) {
5378 gen_shift(s, op, ot, opreg, OR_ECX);
5379 } else {
5380 if (shift == 2) {
5381 shift = ldub_code(s->pc++);
5382 }
5383 gen_shifti(s, op, ot, opreg, shift);
5384 }
5385 }
5386 break;
5387 case 0xd0:
5388 case 0xd1:
5389 /* shift Ev,1 */
5390 shift = 1;
5391 goto grp2;
5392 case 0xd2:
5393 case 0xd3:
5394 /* shift Ev,cl */
5395 shift = 0;
5396 goto grp2;
5397
5398 case 0x1a4: /* shld imm */
5399 op = 0;
5400 shift = 1;
5401 goto do_shiftd;
5402 case 0x1a5: /* shld cl */
5403 op = 0;
5404 shift = 0;
5405 goto do_shiftd;
5406 case 0x1ac: /* shrd imm */
5407 op = 1;
5408 shift = 1;
5409 goto do_shiftd;
5410 case 0x1ad: /* shrd cl */
5411 op = 1;
5412 shift = 0;
5413 do_shiftd:
5414 ot = dflag + OT_WORD;
5415 modrm = ldub_code(s->pc++);
5416 mod = (modrm >> 6) & 3;
5417 rm = (modrm & 7) | REX_B(s);
5418 reg = ((modrm >> 3) & 7) | rex_r;
5419 if (mod != 3) {
5420 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5421 opreg = OR_TMP0;
5422 } else {
5423 opreg = rm;
5424 }
5425 gen_op_mov_TN_reg(ot, 1, reg);
5426
5427 if (shift) {
5428 val = ldub_code(s->pc++);
5429 tcg_gen_movi_tl(cpu_T3, val);
5430 } else {
5431 tcg_gen_mov_tl(cpu_T3, cpu_regs[R_ECX]);
5432 }
5433 gen_shiftd_rm_T1_T3(s, ot, opreg, op);
5434 break;
5435
5436 /************************/
5437 /* floats */
5438 case 0xd8 ... 0xdf:
5439 if (s->flags & (HF_EM_MASK | HF_TS_MASK)) {
5440 /* if CR0.EM or CR0.TS are set, generate an FPU exception */
5441 /* XXX: what to do if illegal op ? */
5442 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
5443 break;
5444 }
5445 modrm = ldub_code(s->pc++);
5446 mod = (modrm >> 6) & 3;
5447 rm = modrm & 7;
5448 op = ((b & 7) << 3) | ((modrm >> 3) & 7);
5449 if (mod != 3) {
5450 /* memory op */
5451 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
5452 switch(op) {
5453 case 0x00 ... 0x07: /* fxxxs */
5454 case 0x10 ... 0x17: /* fixxxl */
5455 case 0x20 ... 0x27: /* fxxxl */
5456 case 0x30 ... 0x37: /* fixxx */
5457 {
5458 int op1;
5459 op1 = op & 7;
5460
5461 switch(op >> 4) {
5462 case 0:
5463 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
5464 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
5465 gen_helper_flds_FT0(cpu_tmp2_i32);
5466 break;
5467 case 1:
5468 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
5469 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
5470 gen_helper_fildl_FT0(cpu_tmp2_i32);
5471 break;
5472 case 2:
5473 tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
5474 (s->mem_index >> 2) - 1);
5475 gen_helper_fldl_FT0(cpu_tmp1_i64);
5476 break;
5477 case 3:
5478 default:
5479 gen_op_lds_T0_A0(OT_WORD + s->mem_index);
5480 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
5481 gen_helper_fildl_FT0(cpu_tmp2_i32);
5482 break;
5483 }
5484
5485 gen_helper_fp_arith_ST0_FT0(op1);
5486 if (op1 == 3) {
5487 /* fcomp needs pop */
5488 gen_helper_fpop();
5489 }
5490 }
5491 break;
5492 case 0x08: /* flds */
5493 case 0x0a: /* fsts */
5494 case 0x0b: /* fstps */
5495 case 0x18 ... 0x1b: /* fildl, fisttpl, fistl, fistpl */
5496 case 0x28 ... 0x2b: /* fldl, fisttpll, fstl, fstpl */
5497 case 0x38 ... 0x3b: /* filds, fisttps, fists, fistps */
5498 switch(op & 7) {
5499 case 0:
5500 switch(op >> 4) {
5501 case 0:
5502 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
5503 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
5504 gen_helper_flds_ST0(cpu_tmp2_i32);
5505 break;
5506 case 1:
5507 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
5508 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
5509 gen_helper_fildl_ST0(cpu_tmp2_i32);
5510 break;
5511 case 2:
5512 tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
5513 (s->mem_index >> 2) - 1);
5514 gen_helper_fldl_ST0(cpu_tmp1_i64);
5515 break;
5516 case 3:
5517 default:
5518 gen_op_lds_T0_A0(OT_WORD + s->mem_index);
5519 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
5520 gen_helper_fildl_ST0(cpu_tmp2_i32);
5521 break;
5522 }
5523 break;
5524 case 1:
5525 /* XXX: the corresponding CPUID bit must be tested ! */
5526 switch(op >> 4) {
5527 case 1:
5528 gen_helper_fisttl_ST0(cpu_tmp2_i32);
5529 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
5530 gen_op_st_T0_A0(OT_LONG + s->mem_index);
5531 break;
5532 case 2:
5533 gen_helper_fisttll_ST0(cpu_tmp1_i64);
5534 tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
5535 (s->mem_index >> 2) - 1);
5536 break;
5537 case 3:
5538 default:
5539 gen_helper_fistt_ST0(cpu_tmp2_i32);
5540 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
5541 gen_op_st_T0_A0(OT_WORD + s->mem_index);
5542 break;
5543 }
5544 gen_helper_fpop();
5545 break;
5546 default:
5547 switch(op >> 4) {
5548 case 0:
5549 gen_helper_fsts_ST0(cpu_tmp2_i32);
5550 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
5551 gen_op_st_T0_A0(OT_LONG + s->mem_index);
5552 break;
5553 case 1:
5554 gen_helper_fistl_ST0(cpu_tmp2_i32);
5555 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
5556 gen_op_st_T0_A0(OT_LONG + s->mem_index);
5557 break;
5558 case 2:
5559 gen_helper_fstl_ST0(cpu_tmp1_i64);
5560 tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
5561 (s->mem_index >> 2) - 1);
5562 break;
5563 case 3:
5564 default:
5565 gen_helper_fist_ST0(cpu_tmp2_i32);
5566 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
5567 gen_op_st_T0_A0(OT_WORD + s->mem_index);
5568 break;
5569 }
5570 if ((op & 7) == 3)
5571 gen_helper_fpop();
5572 break;
5573 }
5574 break;
5575 case 0x0c: /* fldenv mem */
5576 if (s->cc_op != CC_OP_DYNAMIC)
5577 gen_op_set_cc_op(s->cc_op);
5578 gen_jmp_im(pc_start - s->cs_base);
5579 gen_helper_fldenv(
5580 cpu_A0, tcg_const_i32(s->dflag));
5581 break;
5582 case 0x0d: /* fldcw mem */
5583 gen_op_ld_T0_A0(OT_WORD + s->mem_index);
5584 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
5585 gen_helper_fldcw(cpu_tmp2_i32);
5586 break;
5587 case 0x0e: /* fnstenv mem */
5588 if (s->cc_op != CC_OP_DYNAMIC)
5589 gen_op_set_cc_op(s->cc_op);
5590 gen_jmp_im(pc_start - s->cs_base);
5591 gen_helper_fstenv(cpu_A0, tcg_const_i32(s->dflag));
5592 break;
5593 case 0x0f: /* fnstcw mem */
5594 gen_helper_fnstcw(cpu_tmp2_i32);
5595 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
5596 gen_op_st_T0_A0(OT_WORD + s->mem_index);
5597 break;
5598 case 0x1d: /* fldt mem */
5599 if (s->cc_op != CC_OP_DYNAMIC)
5600 gen_op_set_cc_op(s->cc_op);
5601 gen_jmp_im(pc_start - s->cs_base);
5602 gen_helper_fldt_ST0(cpu_A0);
5603 break;
5604 case 0x1f: /* fstpt mem */
5605 if (s->cc_op != CC_OP_DYNAMIC)
5606 gen_op_set_cc_op(s->cc_op);
5607 gen_jmp_im(pc_start - s->cs_base);
5608 gen_helper_fstt_ST0(cpu_A0);
5609 gen_helper_fpop();
5610 break;
5611 case 0x2c: /* frstor mem */
5612 if (s->cc_op != CC_OP_DYNAMIC)
5613 gen_op_set_cc_op(s->cc_op);
5614 gen_jmp_im(pc_start - s->cs_base);
5615 gen_helper_frstor(cpu_A0, tcg_const_i32(s->dflag));
5616 break;
5617 case 0x2e: /* fnsave mem */
5618 if (s->cc_op != CC_OP_DYNAMIC)
5619 gen_op_set_cc_op(s->cc_op);
5620 gen_jmp_im(pc_start - s->cs_base);
5621 gen_helper_fsave(cpu_A0, tcg_const_i32(s->dflag));
5622 break;
5623 case 0x2f: /* fnstsw mem */
5624 gen_helper_fnstsw(cpu_tmp2_i32);
5625 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
5626 gen_op_st_T0_A0(OT_WORD + s->mem_index);
5627 break;
5628 case 0x3c: /* fbld */
5629 if (s->cc_op != CC_OP_DYNAMIC)
5630 gen_op_set_cc_op(s->cc_op);
5631 gen_jmp_im(pc_start - s->cs_base);
5632 gen_helper_fbld_ST0(cpu_A0);
5633 break;
5634 case 0x3e: /* fbstp */
5635 if (s->cc_op != CC_OP_DYNAMIC)
5636 gen_op_set_cc_op(s->cc_op);
5637 gen_jmp_im(pc_start - s->cs_base);
5638 gen_helper_fbst_ST0(cpu_A0);
5639 gen_helper_fpop();
5640 break;
5641 case 0x3d: /* fildll */
5642 tcg_gen_qemu_ld64(cpu_tmp1_i64, cpu_A0,
5643 (s->mem_index >> 2) - 1);
5644 gen_helper_fildll_ST0(cpu_tmp1_i64);
5645 break;
5646 case 0x3f: /* fistpll */
5647 gen_helper_fistll_ST0(cpu_tmp1_i64);
5648 tcg_gen_qemu_st64(cpu_tmp1_i64, cpu_A0,
5649 (s->mem_index >> 2) - 1);
5650 gen_helper_fpop();
5651 break;
5652 default:
5653 goto illegal_op;
5654 }
5655 } else {
5656 /* register float ops */
5657 opreg = rm;
5658
5659 switch(op) {
5660 case 0x08: /* fld sti */
5661 gen_helper_fpush();
5662 gen_helper_fmov_ST0_STN(tcg_const_i32((opreg + 1) & 7));
5663 break;
5664 case 0x09: /* fxchg sti */
5665 case 0x29: /* fxchg4 sti, undocumented op */
5666 case 0x39: /* fxchg7 sti, undocumented op */
5667 gen_helper_fxchg_ST0_STN(tcg_const_i32(opreg));
5668 break;
5669 case 0x0a: /* grp d9/2 */
5670 switch(rm) {
5671 case 0: /* fnop */
5672 /* check exceptions (FreeBSD FPU probe) */
5673 if (s->cc_op != CC_OP_DYNAMIC)
5674 gen_op_set_cc_op(s->cc_op);
5675 gen_jmp_im(pc_start - s->cs_base);
5676 gen_helper_fwait();
5677 break;
5678 default:
5679 goto illegal_op;
5680 }
5681 break;
5682 case 0x0c: /* grp d9/4 */
5683 switch(rm) {
5684 case 0: /* fchs */
5685 gen_helper_fchs_ST0();
5686 break;
5687 case 1: /* fabs */
5688 gen_helper_fabs_ST0();
5689 break;
5690 case 4: /* ftst */
5691 gen_helper_fldz_FT0();
5692 gen_helper_fcom_ST0_FT0();
5693 break;
5694 case 5: /* fxam */
5695 gen_helper_fxam_ST0();
5696 break;
5697 default:
5698 goto illegal_op;
5699 }
5700 break;
5701 case 0x0d: /* grp d9/5 */
5702 {
5703 switch(rm) {
5704 case 0:
5705 gen_helper_fpush();
5706 gen_helper_fld1_ST0();
5707 break;
5708 case 1:
5709 gen_helper_fpush();
5710 gen_helper_fldl2t_ST0();
5711 break;
5712 case 2:
5713 gen_helper_fpush();
5714 gen_helper_fldl2e_ST0();
5715 break;
5716 case 3:
5717 gen_helper_fpush();
5718 gen_helper_fldpi_ST0();
5719 break;
5720 case 4:
5721 gen_helper_fpush();
5722 gen_helper_fldlg2_ST0();
5723 break;
5724 case 5:
5725 gen_helper_fpush();
5726 gen_helper_fldln2_ST0();
5727 break;
5728 case 6:
5729 gen_helper_fpush();
5730 gen_helper_fldz_ST0();
5731 break;
5732 default:
5733 goto illegal_op;
5734 }
5735 }
5736 break;
5737 case 0x0e: /* grp d9/6 */
5738 switch(rm) {
5739 case 0: /* f2xm1 */
5740 gen_helper_f2xm1();
5741 break;
5742 case 1: /* fyl2x */
5743 gen_helper_fyl2x();
5744 break;
5745 case 2: /* fptan */
5746 gen_helper_fptan();
5747 break;
5748 case 3: /* fpatan */
5749 gen_helper_fpatan();
5750 break;
5751 case 4: /* fxtract */
5752 gen_helper_fxtract();
5753 break;
5754 case 5: /* fprem1 */
5755 gen_helper_fprem1();
5756 break;
5757 case 6: /* fdecstp */
5758 gen_helper_fdecstp();
5759 break;
5760 default:
5761 case 7: /* fincstp */
5762 gen_helper_fincstp();
5763 break;
5764 }
5765 break;
5766 case 0x0f: /* grp d9/7 */
5767 switch(rm) {
5768 case 0: /* fprem */
5769 gen_helper_fprem();
5770 break;
5771 case 1: /* fyl2xp1 */
5772 gen_helper_fyl2xp1();
5773 break;
5774 case 2: /* fsqrt */
5775 gen_helper_fsqrt();
5776 break;
5777 case 3: /* fsincos */
5778 gen_helper_fsincos();
5779 break;
5780 case 5: /* fscale */
5781 gen_helper_fscale();
5782 break;
5783 case 4: /* frndint */
5784 gen_helper_frndint();
5785 break;
5786 case 6: /* fsin */
5787 gen_helper_fsin();
5788 break;
5789 default:
5790 case 7: /* fcos */
5791 gen_helper_fcos();
5792 break;
5793 }
5794 break;
5795 case 0x00: case 0x01: case 0x04 ... 0x07: /* fxxx st, sti */
5796 case 0x20: case 0x21: case 0x24 ... 0x27: /* fxxx sti, st */
5797 case 0x30: case 0x31: case 0x34 ... 0x37: /* fxxxp sti, st */
5798 {
5799 int op1;
5800
5801 op1 = op & 7;
5802 if (op >= 0x20) {
5803 gen_helper_fp_arith_STN_ST0(op1, opreg);
5804 if (op >= 0x30)
5805 gen_helper_fpop();
5806 } else {
5807 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5808 gen_helper_fp_arith_ST0_FT0(op1);
5809 }
5810 }
5811 break;
5812 case 0x02: /* fcom */
5813 case 0x22: /* fcom2, undocumented op */
5814 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5815 gen_helper_fcom_ST0_FT0();
5816 break;
5817 case 0x03: /* fcomp */
5818 case 0x23: /* fcomp3, undocumented op */
5819 case 0x32: /* fcomp5, undocumented op */
5820 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5821 gen_helper_fcom_ST0_FT0();
5822 gen_helper_fpop();
5823 break;
5824 case 0x15: /* da/5 */
5825 switch(rm) {
5826 case 1: /* fucompp */
5827 gen_helper_fmov_FT0_STN(tcg_const_i32(1));
5828 gen_helper_fucom_ST0_FT0();
5829 gen_helper_fpop();
5830 gen_helper_fpop();
5831 break;
5832 default:
5833 goto illegal_op;
5834 }
5835 break;
5836 case 0x1c:
5837 switch(rm) {
5838 case 0: /* feni (287 only, just do nop here) */
5839 break;
5840 case 1: /* fdisi (287 only, just do nop here) */
5841 break;
5842 case 2: /* fclex */
5843 gen_helper_fclex();
5844 break;
5845 case 3: /* fninit */
5846 gen_helper_fninit();
5847 break;
5848 case 4: /* fsetpm (287 only, just do nop here) */
5849 break;
5850 default:
5851 goto illegal_op;
5852 }
5853 break;
5854 case 0x1d: /* fucomi */
5855 if (s->cc_op != CC_OP_DYNAMIC)
5856 gen_op_set_cc_op(s->cc_op);
5857 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5858 gen_helper_fucomi_ST0_FT0();
5859 s->cc_op = CC_OP_EFLAGS;
5860 break;
5861 case 0x1e: /* fcomi */
5862 if (s->cc_op != CC_OP_DYNAMIC)
5863 gen_op_set_cc_op(s->cc_op);
5864 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5865 gen_helper_fcomi_ST0_FT0();
5866 s->cc_op = CC_OP_EFLAGS;
5867 break;
5868 case 0x28: /* ffree sti */
5869 gen_helper_ffree_STN(tcg_const_i32(opreg));
5870 break;
5871 case 0x2a: /* fst sti */
5872 gen_helper_fmov_STN_ST0(tcg_const_i32(opreg));
5873 break;
5874 case 0x2b: /* fstp sti */
5875 case 0x0b: /* fstp1 sti, undocumented op */
5876 case 0x3a: /* fstp8 sti, undocumented op */
5877 case 0x3b: /* fstp9 sti, undocumented op */
5878 gen_helper_fmov_STN_ST0(tcg_const_i32(opreg));
5879 gen_helper_fpop();
5880 break;
5881 case 0x2c: /* fucom st(i) */
5882 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5883 gen_helper_fucom_ST0_FT0();
5884 break;
5885 case 0x2d: /* fucomp st(i) */
5886 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5887 gen_helper_fucom_ST0_FT0();
5888 gen_helper_fpop();
5889 break;
5890 case 0x33: /* de/3 */
5891 switch(rm) {
5892 case 1: /* fcompp */
5893 gen_helper_fmov_FT0_STN(tcg_const_i32(1));
5894 gen_helper_fcom_ST0_FT0();
5895 gen_helper_fpop();
5896 gen_helper_fpop();
5897 break;
5898 default:
5899 goto illegal_op;
5900 }
5901 break;
5902 case 0x38: /* ffreep sti, undocumented op */
5903 gen_helper_ffree_STN(tcg_const_i32(opreg));
5904 gen_helper_fpop();
5905 break;
5906 case 0x3c: /* df/4 */
5907 switch(rm) {
5908 case 0:
5909 gen_helper_fnstsw(cpu_tmp2_i32);
5910 tcg_gen_extu_i32_tl(cpu_T[0], cpu_tmp2_i32);
5911 gen_op_mov_reg_T0(OT_WORD, R_EAX);
5912 break;
5913 default:
5914 goto illegal_op;
5915 }
5916 break;
5917 case 0x3d: /* fucomip */
5918 if (s->cc_op != CC_OP_DYNAMIC)
5919 gen_op_set_cc_op(s->cc_op);
5920 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5921 gen_helper_fucomi_ST0_FT0();
5922 gen_helper_fpop();
5923 s->cc_op = CC_OP_EFLAGS;
5924 break;
5925 case 0x3e: /* fcomip */
5926 if (s->cc_op != CC_OP_DYNAMIC)
5927 gen_op_set_cc_op(s->cc_op);
5928 gen_helper_fmov_FT0_STN(tcg_const_i32(opreg));
5929 gen_helper_fcomi_ST0_FT0();
5930 gen_helper_fpop();
5931 s->cc_op = CC_OP_EFLAGS;
5932 break;
5933 case 0x10 ... 0x13: /* fcmovxx */
5934 case 0x18 ... 0x1b:
5935 {
5936 int op1, l1;
5937 static const uint8_t fcmov_cc[8] = {
5938 (JCC_B << 1),
5939 (JCC_Z << 1),
5940 (JCC_BE << 1),
5941 (JCC_P << 1),
5942 };
5943 op1 = fcmov_cc[op & 3] | (((op >> 3) & 1) ^ 1);
5944 l1 = gen_new_label();
5945 gen_jcc1(s, s->cc_op, op1, l1);
5946 gen_helper_fmov_ST0_STN(tcg_const_i32(opreg));
5947 gen_set_label(l1);
5948 }
5949 break;
5950 default:
5951 goto illegal_op;
5952 }
5953 }
5954 break;
5955 /************************/
5956 /* string ops */
5957
5958 case 0xa4: /* movsS */
5959 case 0xa5:
5960 if ((b & 1) == 0)
5961 ot = OT_BYTE;
5962 else
5963 ot = dflag + OT_WORD;
5964
5965 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
5966 gen_repz_movs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
5967 } else {
5968 gen_movs(s, ot);
5969 }
5970 break;
5971
5972 case 0xaa: /* stosS */
5973 case 0xab:
5974 if ((b & 1) == 0)
5975 ot = OT_BYTE;
5976 else
5977 ot = dflag + OT_WORD;
5978
5979 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
5980 gen_repz_stos(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
5981 } else {
5982 gen_stos(s, ot);
5983 }
5984 break;
5985 case 0xac: /* lodsS */
5986 case 0xad:
5987 if ((b & 1) == 0)
5988 ot = OT_BYTE;
5989 else
5990 ot = dflag + OT_WORD;
5991 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
5992 gen_repz_lods(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
5993 } else {
5994 gen_lods(s, ot);
5995 }
5996 break;
5997 case 0xae: /* scasS */
5998 case 0xaf:
5999 if ((b & 1) == 0)
6000 ot = OT_BYTE;
6001 else
6002 ot = dflag + OT_WORD;
6003 if (prefixes & PREFIX_REPNZ) {
6004 gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
6005 } else if (prefixes & PREFIX_REPZ) {
6006 gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
6007 } else {
6008 gen_scas(s, ot);
6009 s->cc_op = CC_OP_SUBB + ot;
6010 }
6011 break;
6012
6013 case 0xa6: /* cmpsS */
6014 case 0xa7:
6015 if ((b & 1) == 0)
6016 ot = OT_BYTE;
6017 else
6018 ot = dflag + OT_WORD;
6019 if (prefixes & PREFIX_REPNZ) {
6020 gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
6021 } else if (prefixes & PREFIX_REPZ) {
6022 gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
6023 } else {
6024 gen_cmps(s, ot);
6025 s->cc_op = CC_OP_SUBB + ot;
6026 }
6027 break;
6028 case 0x6c: /* insS */
6029 case 0x6d:
6030 if ((b & 1) == 0)
6031 ot = OT_BYTE;
6032 else
6033 ot = dflag ? OT_LONG : OT_WORD;
6034 gen_op_mov_TN_reg(OT_WORD, 0, R_EDX);
6035 gen_op_andl_T0_ffff();
6036 gen_check_io(s, ot, pc_start - s->cs_base,
6037 SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes) | 4);
6038 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
6039 gen_repz_ins(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
6040 } else {
6041 gen_ins(s, ot);
6042 if (use_icount) {
6043 gen_jmp(s, s->pc - s->cs_base);
6044 }
6045 }
6046 break;
6047 case 0x6e: /* outsS */
6048 case 0x6f:
6049 if ((b & 1) == 0)
6050 ot = OT_BYTE;
6051 else
6052 ot = dflag ? OT_LONG : OT_WORD;
6053 gen_op_mov_TN_reg(OT_WORD, 0, R_EDX);
6054 gen_op_andl_T0_ffff();
6055 gen_check_io(s, ot, pc_start - s->cs_base,
6056 svm_is_rep(prefixes) | 4);
6057 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
6058 gen_repz_outs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
6059 } else {
6060 gen_outs(s, ot);
6061 if (use_icount) {
6062 gen_jmp(s, s->pc - s->cs_base);
6063 }
6064 }
6065 break;
6066
6067 /************************/
6068 /* port I/O */
6069
6070 case 0xe4:
6071 case 0xe5:
6072 if ((b & 1) == 0)
6073 ot = OT_BYTE;
6074 else
6075 ot = dflag ? OT_LONG : OT_WORD;
6076 val = ldub_code(s->pc++);
6077 gen_op_movl_T0_im(val);
6078 gen_check_io(s, ot, pc_start - s->cs_base,
6079 SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
6080 if (use_icount)
6081 gen_io_start();
6082 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6083 gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
6084 gen_op_mov_reg_T1(ot, R_EAX);
6085 if (use_icount) {
6086 gen_io_end();
6087 gen_jmp(s, s->pc - s->cs_base);
6088 }
6089 break;
6090 case 0xe6:
6091 case 0xe7:
6092 if ((b & 1) == 0)
6093 ot = OT_BYTE;
6094 else
6095 ot = dflag ? OT_LONG : OT_WORD;
6096 val = ldub_code(s->pc++);
6097 gen_op_movl_T0_im(val);
6098 gen_check_io(s, ot, pc_start - s->cs_base,
6099 svm_is_rep(prefixes));
6100 gen_op_mov_TN_reg(ot, 1, R_EAX);
6101
6102 if (use_icount)
6103 gen_io_start();
6104 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6105 tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
6106 tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
6107 gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
6108 if (use_icount) {
6109 gen_io_end();
6110 gen_jmp(s, s->pc - s->cs_base);
6111 }
6112 break;
6113 case 0xec:
6114 case 0xed:
6115 if ((b & 1) == 0)
6116 ot = OT_BYTE;
6117 else
6118 ot = dflag ? OT_LONG : OT_WORD;
6119 gen_op_mov_TN_reg(OT_WORD, 0, R_EDX);
6120 gen_op_andl_T0_ffff();
6121 gen_check_io(s, ot, pc_start - s->cs_base,
6122 SVM_IOIO_TYPE_MASK | svm_is_rep(prefixes));
6123 if (use_icount)
6124 gen_io_start();
6125 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6126 gen_helper_in_func(ot, cpu_T[1], cpu_tmp2_i32);
6127 gen_op_mov_reg_T1(ot, R_EAX);
6128 if (use_icount) {
6129 gen_io_end();
6130 gen_jmp(s, s->pc - s->cs_base);
6131 }
6132 break;
6133 case 0xee:
6134 case 0xef:
6135 if ((b & 1) == 0)
6136 ot = OT_BYTE;
6137 else
6138 ot = dflag ? OT_LONG : OT_WORD;
6139 gen_op_mov_TN_reg(OT_WORD, 0, R_EDX);
6140 gen_op_andl_T0_ffff();
6141 gen_check_io(s, ot, pc_start - s->cs_base,
6142 svm_is_rep(prefixes));
6143 gen_op_mov_TN_reg(ot, 1, R_EAX);
6144
6145 if (use_icount)
6146 gen_io_start();
6147 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6148 tcg_gen_andi_i32(cpu_tmp2_i32, cpu_tmp2_i32, 0xffff);
6149 tcg_gen_trunc_tl_i32(cpu_tmp3_i32, cpu_T[1]);
6150 gen_helper_out_func(ot, cpu_tmp2_i32, cpu_tmp3_i32);
6151 if (use_icount) {
6152 gen_io_end();
6153 gen_jmp(s, s->pc - s->cs_base);
6154 }
6155 break;
6156
6157 /************************/
6158 /* control */
6159 case 0xc2: /* ret im */
6160 val = ldsw_code(s->pc);
6161 s->pc += 2;
6162 gen_pop_T0(s);
6163 if (CODE64(s) && s->dflag)
6164 s->dflag = 2;
6165 gen_stack_update(s, val + (2 << s->dflag));
6166 if (s->dflag == 0)
6167 gen_op_andl_T0_ffff();
6168 gen_op_jmp_T0();
6169 gen_eob(s);
6170 break;
6171 case 0xc3: /* ret */
6172 gen_pop_T0(s);
6173 gen_pop_update(s);
6174 if (s->dflag == 0)
6175 gen_op_andl_T0_ffff();
6176 gen_op_jmp_T0();
6177 gen_eob(s);
6178 break;
6179 case 0xca: /* lret im */
6180 val = ldsw_code(s->pc);
6181 s->pc += 2;
6182 do_lret:
6183 if (s->pe && !s->vm86) {
6184 if (s->cc_op != CC_OP_DYNAMIC)
6185 gen_op_set_cc_op(s->cc_op);
6186 gen_jmp_im(pc_start - s->cs_base);
6187 gen_helper_lret_protected(tcg_const_i32(s->dflag),
6188 tcg_const_i32(val));
6189 } else {
6190 gen_stack_A0(s);
6191 /* pop offset */
6192 gen_op_ld_T0_A0(1 + s->dflag + s->mem_index);
6193 if (s->dflag == 0)
6194 gen_op_andl_T0_ffff();
6195 /* NOTE: keeping EIP updated is not a problem in case of
6196 exception */
6197 gen_op_jmp_T0();
6198 /* pop selector */
6199 gen_op_addl_A0_im(2 << s->dflag);
6200 gen_op_ld_T0_A0(1 + s->dflag + s->mem_index);
6201 gen_op_movl_seg_T0_vm(R_CS);
6202 /* add stack offset */
6203 gen_stack_update(s, val + (4 << s->dflag));
6204 }
6205 gen_eob(s);
6206 break;
6207 case 0xcb: /* lret */
6208 val = 0;
6209 goto do_lret;
6210 case 0xcf: /* iret */
6211 gen_svm_check_intercept(s, pc_start, SVM_EXIT_IRET);
6212 if (!s->pe) {
6213 /* real mode */
6214 gen_helper_iret_real(tcg_const_i32(s->dflag));
6215 s->cc_op = CC_OP_EFLAGS;
6216 } else if (s->vm86) {
6217 if (s->iopl != 3) {
6218 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6219 } else {
6220 gen_helper_iret_real(tcg_const_i32(s->dflag));
6221 s->cc_op = CC_OP_EFLAGS;
6222 }
6223 } else {
6224 if (s->cc_op != CC_OP_DYNAMIC)
6225 gen_op_set_cc_op(s->cc_op);
6226 gen_jmp_im(pc_start - s->cs_base);
6227 gen_helper_iret_protected(tcg_const_i32(s->dflag),
6228 tcg_const_i32(s->pc - s->cs_base));
6229 s->cc_op = CC_OP_EFLAGS;
6230 }
6231 gen_eob(s);
6232 break;
6233 case 0xe8: /* call im */
6234 {
6235 if (dflag)
6236 tval = (int32_t)insn_get(s, OT_LONG);
6237 else
6238 tval = (int16_t)insn_get(s, OT_WORD);
6239 next_eip = s->pc - s->cs_base;
6240 tval += next_eip;
6241 if (s->dflag == 0)
6242 tval &= 0xffff;
6243 else if(!CODE64(s))
6244 tval &= 0xffffffff;
6245 gen_movtl_T0_im(next_eip);
6246 gen_push_T0(s);
6247 gen_jmp(s, tval);
6248 }
6249 break;
6250 case 0x9a: /* lcall im */
6251 {
6252 unsigned int selector, offset;
6253
6254 if (CODE64(s))
6255 goto illegal_op;
6256 ot = dflag ? OT_LONG : OT_WORD;
6257 offset = insn_get(s, ot);
6258 selector = insn_get(s, OT_WORD);
6259
6260 gen_op_movl_T0_im(selector);
6261 gen_op_movl_T1_imu(offset);
6262 }
6263 goto do_lcall;
6264 case 0xe9: /* jmp im */
6265 if (dflag)
6266 tval = (int32_t)insn_get(s, OT_LONG);
6267 else
6268 tval = (int16_t)insn_get(s, OT_WORD);
6269 tval += s->pc - s->cs_base;
6270 if (s->dflag == 0)
6271 tval &= 0xffff;
6272 else if(!CODE64(s))
6273 tval &= 0xffffffff;
6274 gen_jmp(s, tval);
6275 break;
6276 case 0xea: /* ljmp im */
6277 {
6278 unsigned int selector, offset;
6279
6280 if (CODE64(s))
6281 goto illegal_op;
6282 ot = dflag ? OT_LONG : OT_WORD;
6283 offset = insn_get(s, ot);
6284 selector = insn_get(s, OT_WORD);
6285
6286 gen_op_movl_T0_im(selector);
6287 gen_op_movl_T1_imu(offset);
6288 }
6289 goto do_ljmp;
6290 case 0xeb: /* jmp Jb */
6291 tval = (int8_t)insn_get(s, OT_BYTE);
6292 tval += s->pc - s->cs_base;
6293 if (s->dflag == 0)
6294 tval &= 0xffff;
6295 gen_jmp(s, tval);
6296 break;
6297 case 0x70 ... 0x7f: /* jcc Jb */
6298 tval = (int8_t)insn_get(s, OT_BYTE);
6299 goto do_jcc;
6300 case 0x180 ... 0x18f: /* jcc Jv */
6301 if (dflag) {
6302 tval = (int32_t)insn_get(s, OT_LONG);
6303 } else {
6304 tval = (int16_t)insn_get(s, OT_WORD);
6305 }
6306 do_jcc:
6307 next_eip = s->pc - s->cs_base;
6308 tval += next_eip;
6309 if (s->dflag == 0)
6310 tval &= 0xffff;
6311 gen_jcc(s, b, tval, next_eip);
6312 break;
6313
6314 case 0x190 ... 0x19f: /* setcc Gv */
6315 modrm = ldub_code(s->pc++);
6316 gen_setcc(s, b);
6317 gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
6318 break;
6319 case 0x140 ... 0x14f: /* cmov Gv, Ev */
6320 {
6321 int l1;
6322 TCGv t0;
6323
6324 ot = dflag + OT_WORD;
6325 modrm = ldub_code(s->pc++);
6326 reg = ((modrm >> 3) & 7) | rex_r;
6327 mod = (modrm >> 6) & 3;
6328 t0 = tcg_temp_local_new();
6329 if (mod != 3) {
6330 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6331 gen_op_ld_v(ot + s->mem_index, t0, cpu_A0);
6332 } else {
6333 rm = (modrm & 7) | REX_B(s);
6334 gen_op_mov_v_reg(ot, t0, rm);
6335 }
6336 #ifdef TARGET_X86_64
6337 if (ot == OT_LONG) {
6338 /* XXX: specific Intel behaviour ? */
6339 l1 = gen_new_label();
6340 gen_jcc1(s, s->cc_op, b ^ 1, l1);
6341 tcg_gen_mov_tl(cpu_regs[reg], t0);
6342 gen_set_label(l1);
6343 tcg_gen_ext32u_tl(cpu_regs[reg], cpu_regs[reg]);
6344 } else
6345 #endif
6346 {
6347 l1 = gen_new_label();
6348 gen_jcc1(s, s->cc_op, b ^ 1, l1);
6349 gen_op_mov_reg_v(ot, reg, t0);
6350 gen_set_label(l1);
6351 }
6352 tcg_temp_free(t0);
6353 }
6354 break;
6355
6356 /************************/
6357 /* flags */
6358 case 0x9c: /* pushf */
6359 gen_svm_check_intercept(s, pc_start, SVM_EXIT_PUSHF);
6360 if (s->vm86 && s->iopl != 3) {
6361 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6362 } else {
6363 if (s->cc_op != CC_OP_DYNAMIC)
6364 gen_op_set_cc_op(s->cc_op);
6365 gen_helper_read_eflags(cpu_T[0]);
6366 gen_push_T0(s);
6367 }
6368 break;
6369 case 0x9d: /* popf */
6370 gen_svm_check_intercept(s, pc_start, SVM_EXIT_POPF);
6371 if (s->vm86 && s->iopl != 3) {
6372 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6373 } else {
6374 gen_pop_T0(s);
6375 if (s->cpl == 0) {
6376 if (s->dflag) {
6377 gen_helper_write_eflags(cpu_T[0],
6378 tcg_const_i32((TF_MASK | AC_MASK | ID_MASK | NT_MASK | IF_MASK | IOPL_MASK)));
6379 } else {
6380 gen_helper_write_eflags(cpu_T[0],
6381 tcg_const_i32((TF_MASK | AC_MASK | ID_MASK | NT_MASK | IF_MASK | IOPL_MASK) & 0xffff));
6382 }
6383 } else {
6384 if (s->cpl <= s->iopl) {
6385 if (s->dflag) {
6386 gen_helper_write_eflags(cpu_T[0],
6387 tcg_const_i32((TF_MASK | AC_MASK | ID_MASK | NT_MASK | IF_MASK)));
6388 } else {
6389 gen_helper_write_eflags(cpu_T[0],
6390 tcg_const_i32((TF_MASK | AC_MASK | ID_MASK | NT_MASK | IF_MASK) & 0xffff));
6391 }
6392 } else {
6393 if (s->dflag) {
6394 gen_helper_write_eflags(cpu_T[0],
6395 tcg_const_i32((TF_MASK | AC_MASK | ID_MASK | NT_MASK)));
6396 } else {
6397 gen_helper_write_eflags(cpu_T[0],
6398 tcg_const_i32((TF_MASK | AC_MASK | ID_MASK | NT_MASK) & 0xffff));
6399 }
6400 }
6401 }
6402 gen_pop_update(s);
6403 s->cc_op = CC_OP_EFLAGS;
6404 /* abort translation because TF flag may change */
6405 gen_jmp_im(s->pc - s->cs_base);
6406 gen_eob(s);
6407 }
6408 break;
6409 case 0x9e: /* sahf */
6410 if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
6411 goto illegal_op;
6412 gen_op_mov_TN_reg(OT_BYTE, 0, R_AH);
6413 if (s->cc_op != CC_OP_DYNAMIC)
6414 gen_op_set_cc_op(s->cc_op);
6415 gen_compute_eflags(cpu_cc_src);
6416 tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, CC_O);
6417 tcg_gen_andi_tl(cpu_T[0], cpu_T[0], CC_S | CC_Z | CC_A | CC_P | CC_C);
6418 tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, cpu_T[0]);
6419 s->cc_op = CC_OP_EFLAGS;
6420 break;
6421 case 0x9f: /* lahf */
6422 if (CODE64(s) && !(s->cpuid_ext3_features & CPUID_EXT3_LAHF_LM))
6423 goto illegal_op;
6424 if (s->cc_op != CC_OP_DYNAMIC)
6425 gen_op_set_cc_op(s->cc_op);
6426 gen_compute_eflags(cpu_T[0]);
6427 /* Note: gen_compute_eflags() only gives the condition codes */
6428 tcg_gen_ori_tl(cpu_T[0], cpu_T[0], 0x02);
6429 gen_op_mov_reg_T0(OT_BYTE, R_AH);
6430 break;
6431 case 0xf5: /* cmc */
6432 if (s->cc_op != CC_OP_DYNAMIC)
6433 gen_op_set_cc_op(s->cc_op);
6434 gen_compute_eflags(cpu_cc_src);
6435 tcg_gen_xori_tl(cpu_cc_src, cpu_cc_src, CC_C);
6436 s->cc_op = CC_OP_EFLAGS;
6437 break;
6438 case 0xf8: /* clc */
6439 if (s->cc_op != CC_OP_DYNAMIC)
6440 gen_op_set_cc_op(s->cc_op);
6441 gen_compute_eflags(cpu_cc_src);
6442 tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_C);
6443 s->cc_op = CC_OP_EFLAGS;
6444 break;
6445 case 0xf9: /* stc */
6446 if (s->cc_op != CC_OP_DYNAMIC)
6447 gen_op_set_cc_op(s->cc_op);
6448 gen_compute_eflags(cpu_cc_src);
6449 tcg_gen_ori_tl(cpu_cc_src, cpu_cc_src, CC_C);
6450 s->cc_op = CC_OP_EFLAGS;
6451 break;
6452 case 0xfc: /* cld */
6453 tcg_gen_movi_i32(cpu_tmp2_i32, 1);
6454 tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUState, df));
6455 break;
6456 case 0xfd: /* std */
6457 tcg_gen_movi_i32(cpu_tmp2_i32, -1);
6458 tcg_gen_st_i32(cpu_tmp2_i32, cpu_env, offsetof(CPUState, df));
6459 break;
6460
6461 /************************/
6462 /* bit operations */
6463 case 0x1ba: /* bt/bts/btr/btc Gv, im */
6464 ot = dflag + OT_WORD;
6465 modrm = ldub_code(s->pc++);
6466 op = (modrm >> 3) & 7;
6467 mod = (modrm >> 6) & 3;
6468 rm = (modrm & 7) | REX_B(s);
6469 if (mod != 3) {
6470 s->rip_offset = 1;
6471 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6472 gen_op_ld_T0_A0(ot + s->mem_index);
6473 } else {
6474 gen_op_mov_TN_reg(ot, 0, rm);
6475 }
6476 /* load shift */
6477 val = ldub_code(s->pc++);
6478 gen_op_movl_T1_im(val);
6479 if (op < 4)
6480 goto illegal_op;
6481 op -= 4;
6482 goto bt_op;
6483 case 0x1a3: /* bt Gv, Ev */
6484 op = 0;
6485 goto do_btx;
6486 case 0x1ab: /* bts */
6487 op = 1;
6488 goto do_btx;
6489 case 0x1b3: /* btr */
6490 op = 2;
6491 goto do_btx;
6492 case 0x1bb: /* btc */
6493 op = 3;
6494 do_btx:
6495 ot = dflag + OT_WORD;
6496 modrm = ldub_code(s->pc++);
6497 reg = ((modrm >> 3) & 7) | rex_r;
6498 mod = (modrm >> 6) & 3;
6499 rm = (modrm & 7) | REX_B(s);
6500 gen_op_mov_TN_reg(OT_LONG, 1, reg);
6501 if (mod != 3) {
6502 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6503 /* specific case: we need to add a displacement */
6504 gen_exts(ot, cpu_T[1]);
6505 tcg_gen_sari_tl(cpu_tmp0, cpu_T[1], 3 + ot);
6506 tcg_gen_shli_tl(cpu_tmp0, cpu_tmp0, ot);
6507 tcg_gen_add_tl(cpu_A0, cpu_A0, cpu_tmp0);
6508 gen_op_ld_T0_A0(ot + s->mem_index);
6509 } else {
6510 gen_op_mov_TN_reg(ot, 0, rm);
6511 }
6512 bt_op:
6513 tcg_gen_andi_tl(cpu_T[1], cpu_T[1], (1 << (3 + ot)) - 1);
6514 switch(op) {
6515 case 0:
6516 tcg_gen_shr_tl(cpu_cc_src, cpu_T[0], cpu_T[1]);
6517 tcg_gen_movi_tl(cpu_cc_dst, 0);
6518 break;
6519 case 1:
6520 tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
6521 tcg_gen_movi_tl(cpu_tmp0, 1);
6522 tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
6523 tcg_gen_or_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
6524 break;
6525 case 2:
6526 tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
6527 tcg_gen_movi_tl(cpu_tmp0, 1);
6528 tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
6529 tcg_gen_not_tl(cpu_tmp0, cpu_tmp0);
6530 tcg_gen_and_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
6531 break;
6532 default:
6533 case 3:
6534 tcg_gen_shr_tl(cpu_tmp4, cpu_T[0], cpu_T[1]);
6535 tcg_gen_movi_tl(cpu_tmp0, 1);
6536 tcg_gen_shl_tl(cpu_tmp0, cpu_tmp0, cpu_T[1]);
6537 tcg_gen_xor_tl(cpu_T[0], cpu_T[0], cpu_tmp0);
6538 break;
6539 }
6540 s->cc_op = CC_OP_SARB + ot;
6541 if (op != 0) {
6542 if (mod != 3)
6543 gen_op_st_T0_A0(ot + s->mem_index);
6544 else
6545 gen_op_mov_reg_T0(ot, rm);
6546 tcg_gen_mov_tl(cpu_cc_src, cpu_tmp4);
6547 tcg_gen_movi_tl(cpu_cc_dst, 0);
6548 }
6549 break;
6550 case 0x1bc: /* bsf */
6551 case 0x1bd: /* bsr */
6552 {
6553 int label1;
6554 TCGv t0;
6555
6556 ot = dflag + OT_WORD;
6557 modrm = ldub_code(s->pc++);
6558 reg = ((modrm >> 3) & 7) | rex_r;
6559 gen_ldst_modrm(s,modrm, ot, OR_TMP0, 0);
6560 gen_extu(ot, cpu_T[0]);
6561 t0 = tcg_temp_local_new();
6562 tcg_gen_mov_tl(t0, cpu_T[0]);
6563 if ((b & 1) && (prefixes & PREFIX_REPZ) &&
6564 (s->cpuid_ext3_features & CPUID_EXT3_ABM)) {
6565 switch(ot) {
6566 case OT_WORD: gen_helper_lzcnt(cpu_T[0], t0,
6567 tcg_const_i32(16)); break;
6568 case OT_LONG: gen_helper_lzcnt(cpu_T[0], t0,
6569 tcg_const_i32(32)); break;
6570 case OT_QUAD: gen_helper_lzcnt(cpu_T[0], t0,
6571 tcg_const_i32(64)); break;
6572 }
6573 gen_op_mov_reg_T0(ot, reg);
6574 } else {
6575 label1 = gen_new_label();
6576 tcg_gen_movi_tl(cpu_cc_dst, 0);
6577 tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, label1);
6578 if (b & 1) {
6579 gen_helper_bsr(cpu_T[0], t0);
6580 } else {
6581 gen_helper_bsf(cpu_T[0], t0);
6582 }
6583 gen_op_mov_reg_T0(ot, reg);
6584 tcg_gen_movi_tl(cpu_cc_dst, 1);
6585 gen_set_label(label1);
6586 tcg_gen_discard_tl(cpu_cc_src);
6587 s->cc_op = CC_OP_LOGICB + ot;
6588 }
6589 tcg_temp_free(t0);
6590 }
6591 break;
6592 /************************/
6593 /* bcd */
6594 case 0x27: /* daa */
6595 if (CODE64(s))
6596 goto illegal_op;
6597 if (s->cc_op != CC_OP_DYNAMIC)
6598 gen_op_set_cc_op(s->cc_op);
6599 gen_helper_daa();
6600 s->cc_op = CC_OP_EFLAGS;
6601 break;
6602 case 0x2f: /* das */
6603 if (CODE64(s))
6604 goto illegal_op;
6605 if (s->cc_op != CC_OP_DYNAMIC)
6606 gen_op_set_cc_op(s->cc_op);
6607 gen_helper_das();
6608 s->cc_op = CC_OP_EFLAGS;
6609 break;
6610 case 0x37: /* aaa */
6611 if (CODE64(s))
6612 goto illegal_op;
6613 if (s->cc_op != CC_OP_DYNAMIC)
6614 gen_op_set_cc_op(s->cc_op);
6615 gen_helper_aaa();
6616 s->cc_op = CC_OP_EFLAGS;
6617 break;
6618 case 0x3f: /* aas */
6619 if (CODE64(s))
6620 goto illegal_op;
6621 if (s->cc_op != CC_OP_DYNAMIC)
6622 gen_op_set_cc_op(s->cc_op);
6623 gen_helper_aas();
6624 s->cc_op = CC_OP_EFLAGS;
6625 break;
6626 case 0xd4: /* aam */
6627 if (CODE64(s))
6628 goto illegal_op;
6629 val = ldub_code(s->pc++);
6630 if (val == 0) {
6631 gen_exception(s, EXCP00_DIVZ, pc_start - s->cs_base);
6632 } else {
6633 gen_helper_aam(tcg_const_i32(val));
6634 s->cc_op = CC_OP_LOGICB;
6635 }
6636 break;
6637 case 0xd5: /* aad */
6638 if (CODE64(s))
6639 goto illegal_op;
6640 val = ldub_code(s->pc++);
6641 gen_helper_aad(tcg_const_i32(val));
6642 s->cc_op = CC_OP_LOGICB;
6643 break;
6644 /************************/
6645 /* misc */
6646 case 0x90: /* nop */
6647 /* XXX: correct lock test for all insn */
6648 if (prefixes & PREFIX_LOCK) {
6649 goto illegal_op;
6650 }
6651 /* If REX_B is set, then this is xchg eax, r8d, not a nop. */
6652 if (REX_B(s)) {
6653 goto do_xchg_reg_eax;
6654 }
6655 if (prefixes & PREFIX_REPZ) {
6656 gen_svm_check_intercept(s, pc_start, SVM_EXIT_PAUSE);
6657 }
6658 break;
6659 case 0x9b: /* fwait */
6660 if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
6661 (HF_MP_MASK | HF_TS_MASK)) {
6662 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
6663 } else {
6664 if (s->cc_op != CC_OP_DYNAMIC)
6665 gen_op_set_cc_op(s->cc_op);
6666 gen_jmp_im(pc_start - s->cs_base);
6667 gen_helper_fwait();
6668 }
6669 break;
6670 case 0xcc: /* int3 */
6671 gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
6672 break;
6673 case 0xcd: /* int N */
6674 val = ldub_code(s->pc++);
6675 if (s->vm86 && s->iopl != 3) {
6676 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6677 } else {
6678 gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base);
6679 }
6680 break;
6681 case 0xce: /* into */
6682 if (CODE64(s))
6683 goto illegal_op;
6684 if (s->cc_op != CC_OP_DYNAMIC)
6685 gen_op_set_cc_op(s->cc_op);
6686 gen_jmp_im(pc_start - s->cs_base);
6687 gen_helper_into(tcg_const_i32(s->pc - pc_start));
6688 break;
6689 #ifdef WANT_ICEBP
6690 case 0xf1: /* icebp (undocumented, exits to external debugger) */
6691 gen_svm_check_intercept(s, pc_start, SVM_EXIT_ICEBP);
6692 #if 1
6693 gen_debug(s, pc_start - s->cs_base);
6694 #else
6695 /* start debug */
6696 tb_flush(cpu_single_env);
6697 cpu_set_log(CPU_LOG_INT | CPU_LOG_TB_IN_ASM);
6698 #endif
6699 break;
6700 #endif
6701 case 0xfa: /* cli */
6702 if (!s->vm86) {
6703 if (s->cpl <= s->iopl) {
6704 gen_helper_cli();
6705 } else {
6706 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6707 }
6708 } else {
6709 if (s->iopl == 3) {
6710 gen_helper_cli();
6711 } else {
6712 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6713 }
6714 }
6715 break;
6716 case 0xfb: /* sti */
6717 if (!s->vm86) {
6718 if (s->cpl <= s->iopl) {
6719 gen_sti:
6720 gen_helper_sti();
6721 /* interruptions are enabled only the first insn after sti */
6722 /* If several instructions disable interrupts, only the
6723 _first_ does it */
6724 if (!(s->tb->flags & HF_INHIBIT_IRQ_MASK))
6725 gen_helper_set_inhibit_irq();
6726 /* give a chance to handle pending irqs */
6727 gen_jmp_im(s->pc - s->cs_base);
6728 gen_eob(s);
6729 } else {
6730 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6731 }
6732 } else {
6733 if (s->iopl == 3) {
6734 goto gen_sti;
6735 } else {
6736 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6737 }
6738 }
6739 break;
6740 case 0x62: /* bound */
6741 if (CODE64(s))
6742 goto illegal_op;
6743 ot = dflag ? OT_LONG : OT_WORD;
6744 modrm = ldub_code(s->pc++);
6745 reg = (modrm >> 3) & 7;
6746 mod = (modrm >> 6) & 3;
6747 if (mod == 3)
6748 goto illegal_op;
6749 gen_op_mov_TN_reg(ot, 0, reg);
6750 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
6751 gen_jmp_im(pc_start - s->cs_base);
6752 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6753 if (ot == OT_WORD)
6754 gen_helper_boundw(cpu_A0, cpu_tmp2_i32);
6755 else
6756 gen_helper_boundl(cpu_A0, cpu_tmp2_i32);
6757 break;
6758 case 0x1c8 ... 0x1cf: /* bswap reg */
6759 reg = (b & 7) | REX_B(s);
6760 #ifdef TARGET_X86_64
6761 if (dflag == 2) {
6762 gen_op_mov_TN_reg(OT_QUAD, 0, reg);
6763 tcg_gen_bswap64_i64(cpu_T[0], cpu_T[0]);
6764 gen_op_mov_reg_T0(OT_QUAD, reg);
6765 } else
6766 #endif
6767 {
6768 gen_op_mov_TN_reg(OT_LONG, 0, reg);
6769 tcg_gen_ext32u_tl(cpu_T[0], cpu_T[0]);
6770 tcg_gen_bswap32_tl(cpu_T[0], cpu_T[0]);
6771 gen_op_mov_reg_T0(OT_LONG, reg);
6772 }
6773 break;
6774 case 0xd6: /* salc */
6775 if (CODE64(s))
6776 goto illegal_op;
6777 if (s->cc_op != CC_OP_DYNAMIC)
6778 gen_op_set_cc_op(s->cc_op);
6779 gen_compute_eflags_c(cpu_T[0]);
6780 tcg_gen_neg_tl(cpu_T[0], cpu_T[0]);
6781 gen_op_mov_reg_T0(OT_BYTE, R_EAX);
6782 break;
6783 case 0xe0: /* loopnz */
6784 case 0xe1: /* loopz */
6785 case 0xe2: /* loop */
6786 case 0xe3: /* jecxz */
6787 {
6788 int l1, l2, l3;
6789
6790 tval = (int8_t)insn_get(s, OT_BYTE);
6791 next_eip = s->pc - s->cs_base;
6792 tval += next_eip;
6793 if (s->dflag == 0)
6794 tval &= 0xffff;
6795
6796 l1 = gen_new_label();
6797 l2 = gen_new_label();
6798 l3 = gen_new_label();
6799 b &= 3;
6800 switch(b) {
6801 case 0: /* loopnz */
6802 case 1: /* loopz */
6803 if (s->cc_op != CC_OP_DYNAMIC)
6804 gen_op_set_cc_op(s->cc_op);
6805 gen_op_add_reg_im(s->aflag, R_ECX, -1);
6806 gen_op_jz_ecx(s->aflag, l3);
6807 gen_compute_eflags(cpu_tmp0);
6808 tcg_gen_andi_tl(cpu_tmp0, cpu_tmp0, CC_Z);
6809 if (b == 0) {
6810 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, l1);
6811 } else {
6812 tcg_gen_brcondi_tl(TCG_COND_NE, cpu_tmp0, 0, l1);
6813 }
6814 break;
6815 case 2: /* loop */
6816 gen_op_add_reg_im(s->aflag, R_ECX, -1);
6817 gen_op_jnz_ecx(s->aflag, l1);
6818 break;
6819 default:
6820 case 3: /* jcxz */
6821 gen_op_jz_ecx(s->aflag, l1);
6822 break;
6823 }
6824
6825 gen_set_label(l3);
6826 gen_jmp_im(next_eip);
6827 tcg_gen_br(l2);
6828
6829 gen_set_label(l1);
6830 gen_jmp_im(tval);
6831 gen_set_label(l2);
6832 gen_eob(s);
6833 }
6834 break;
6835 case 0x130: /* wrmsr */
6836 case 0x132: /* rdmsr */
6837 if (s->cpl != 0) {
6838 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6839 } else {
6840 if (s->cc_op != CC_OP_DYNAMIC)
6841 gen_op_set_cc_op(s->cc_op);
6842 gen_jmp_im(pc_start - s->cs_base);
6843 if (b & 2) {
6844 gen_helper_rdmsr();
6845 } else {
6846 gen_helper_wrmsr();
6847 }
6848 }
6849 break;
6850 case 0x131: /* rdtsc */
6851 if (s->cc_op != CC_OP_DYNAMIC)
6852 gen_op_set_cc_op(s->cc_op);
6853 gen_jmp_im(pc_start - s->cs_base);
6854 if (use_icount)
6855 gen_io_start();
6856 gen_helper_rdtsc();
6857 if (use_icount) {
6858 gen_io_end();
6859 gen_jmp(s, s->pc - s->cs_base);
6860 }
6861 break;
6862 case 0x133: /* rdpmc */
6863 if (s->cc_op != CC_OP_DYNAMIC)
6864 gen_op_set_cc_op(s->cc_op);
6865 gen_jmp_im(pc_start - s->cs_base);
6866 gen_helper_rdpmc();
6867 break;
6868 case 0x134: /* sysenter */
6869 /* For Intel SYSENTER is valid on 64-bit */
6870 if (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
6871 goto illegal_op;
6872 if (!s->pe) {
6873 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6874 } else {
6875 gen_update_cc_op(s);
6876 gen_jmp_im(pc_start - s->cs_base);
6877 gen_helper_sysenter();
6878 gen_eob(s);
6879 }
6880 break;
6881 case 0x135: /* sysexit */
6882 /* For Intel SYSEXIT is valid on 64-bit */
6883 if (CODE64(s) && cpu_single_env->cpuid_vendor1 != CPUID_VENDOR_INTEL_1)
6884 goto illegal_op;
6885 if (!s->pe) {
6886 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6887 } else {
6888 gen_update_cc_op(s);
6889 gen_jmp_im(pc_start - s->cs_base);
6890 gen_helper_sysexit(tcg_const_i32(dflag));
6891 gen_eob(s);
6892 }
6893 break;
6894 #ifdef TARGET_X86_64
6895 case 0x105: /* syscall */
6896 /* XXX: is it usable in real mode ? */
6897 gen_update_cc_op(s);
6898 gen_jmp_im(pc_start - s->cs_base);
6899 gen_helper_syscall(tcg_const_i32(s->pc - pc_start));
6900 gen_eob(s);
6901 break;
6902 case 0x107: /* sysret */
6903 if (!s->pe) {
6904 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6905 } else {
6906 gen_update_cc_op(s);
6907 gen_jmp_im(pc_start - s->cs_base);
6908 gen_helper_sysret(tcg_const_i32(s->dflag));
6909 /* condition codes are modified only in long mode */
6910 if (s->lma)
6911 s->cc_op = CC_OP_EFLAGS;
6912 gen_eob(s);
6913 }
6914 break;
6915 #endif
6916 case 0x1a2: /* cpuid */
6917 if (s->cc_op != CC_OP_DYNAMIC)
6918 gen_op_set_cc_op(s->cc_op);
6919 gen_jmp_im(pc_start - s->cs_base);
6920 gen_helper_cpuid();
6921 break;
6922 case 0xf4: /* hlt */
6923 if (s->cpl != 0) {
6924 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6925 } else {
6926 if (s->cc_op != CC_OP_DYNAMIC)
6927 gen_op_set_cc_op(s->cc_op);
6928 gen_jmp_im(pc_start - s->cs_base);
6929 gen_helper_hlt(tcg_const_i32(s->pc - pc_start));
6930 s->is_jmp = DISAS_TB_JUMP;
6931 }
6932 break;
6933 case 0x100:
6934 modrm = ldub_code(s->pc++);
6935 mod = (modrm >> 6) & 3;
6936 op = (modrm >> 3) & 7;
6937 switch(op) {
6938 case 0: /* sldt */
6939 if (!s->pe || s->vm86)
6940 goto illegal_op;
6941 gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_READ);
6942 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,ldt.selector));
6943 ot = OT_WORD;
6944 if (mod == 3)
6945 ot += s->dflag;
6946 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
6947 break;
6948 case 2: /* lldt */
6949 if (!s->pe || s->vm86)
6950 goto illegal_op;
6951 if (s->cpl != 0) {
6952 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6953 } else {
6954 gen_svm_check_intercept(s, pc_start, SVM_EXIT_LDTR_WRITE);
6955 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
6956 gen_jmp_im(pc_start - s->cs_base);
6957 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6958 gen_helper_lldt(cpu_tmp2_i32);
6959 }
6960 break;
6961 case 1: /* str */
6962 if (!s->pe || s->vm86)
6963 goto illegal_op;
6964 gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_READ);
6965 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,tr.selector));
6966 ot = OT_WORD;
6967 if (mod == 3)
6968 ot += s->dflag;
6969 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
6970 break;
6971 case 3: /* ltr */
6972 if (!s->pe || s->vm86)
6973 goto illegal_op;
6974 if (s->cpl != 0) {
6975 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
6976 } else {
6977 gen_svm_check_intercept(s, pc_start, SVM_EXIT_TR_WRITE);
6978 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
6979 gen_jmp_im(pc_start - s->cs_base);
6980 tcg_gen_trunc_tl_i32(cpu_tmp2_i32, cpu_T[0]);
6981 gen_helper_ltr(cpu_tmp2_i32);
6982 }
6983 break;
6984 case 4: /* verr */
6985 case 5: /* verw */
6986 if (!s->pe || s->vm86)
6987 goto illegal_op;
6988 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
6989 if (s->cc_op != CC_OP_DYNAMIC)
6990 gen_op_set_cc_op(s->cc_op);
6991 if (op == 4)
6992 gen_helper_verr(cpu_T[0]);
6993 else
6994 gen_helper_verw(cpu_T[0]);
6995 s->cc_op = CC_OP_EFLAGS;
6996 break;
6997 default:
6998 goto illegal_op;
6999 }
7000 break;
7001 case 0x101:
7002 modrm = ldub_code(s->pc++);
7003 mod = (modrm >> 6) & 3;
7004 op = (modrm >> 3) & 7;
7005 rm = modrm & 7;
7006 switch(op) {
7007 case 0: /* sgdt */
7008 if (mod == 3)
7009 goto illegal_op;
7010 gen_svm_check_intercept(s, pc_start, SVM_EXIT_GDTR_READ);
7011 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7012 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.limit));
7013 gen_op_st_T0_A0(OT_WORD + s->mem_index);
7014 gen_add_A0_im(s, 2);
7015 tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, gdt.base));
7016 if (!s->dflag)
7017 gen_op_andl_T0_im(0xffffff);
7018 gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
7019 break;
7020 case 1:
7021 if (mod == 3) {
7022 switch (rm) {
7023 case 0: /* monitor */
7024 if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
7025 s->cpl != 0)
7026 goto illegal_op;
7027 if (s->cc_op != CC_OP_DYNAMIC)
7028 gen_op_set_cc_op(s->cc_op);
7029 gen_jmp_im(pc_start - s->cs_base);
7030 #ifdef TARGET_X86_64
7031 if (s->aflag == 2) {
7032 gen_op_movq_A0_reg(R_EAX);
7033 } else
7034 #endif
7035 {
7036 gen_op_movl_A0_reg(R_EAX);
7037 if (s->aflag == 0)
7038 gen_op_andl_A0_ffff();
7039 }
7040 gen_add_A0_ds_seg(s);
7041 gen_helper_monitor(cpu_A0);
7042 break;
7043 case 1: /* mwait */
7044 if (!(s->cpuid_ext_features & CPUID_EXT_MONITOR) ||
7045 s->cpl != 0)
7046 goto illegal_op;
7047 gen_update_cc_op(s);
7048 gen_jmp_im(pc_start - s->cs_base);
7049 gen_helper_mwait(tcg_const_i32(s->pc - pc_start));
7050 gen_eob(s);
7051 break;
7052 default:
7053 goto illegal_op;
7054 }
7055 } else { /* sidt */
7056 gen_svm_check_intercept(s, pc_start, SVM_EXIT_IDTR_READ);
7057 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7058 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.limit));
7059 gen_op_st_T0_A0(OT_WORD + s->mem_index);
7060 gen_add_A0_im(s, 2);
7061 tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, idt.base));
7062 if (!s->dflag)
7063 gen_op_andl_T0_im(0xffffff);
7064 gen_op_st_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
7065 }
7066 break;
7067 case 2: /* lgdt */
7068 case 3: /* lidt */
7069 if (mod == 3) {
7070 if (s->cc_op != CC_OP_DYNAMIC)
7071 gen_op_set_cc_op(s->cc_op);
7072 gen_jmp_im(pc_start - s->cs_base);
7073 switch(rm) {
7074 case 0: /* VMRUN */
7075 if (!(s->flags & HF_SVME_MASK) || !s->pe)
7076 goto illegal_op;
7077 if (s->cpl != 0) {
7078 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7079 break;
7080 } else {
7081 gen_helper_vmrun(tcg_const_i32(s->aflag),
7082 tcg_const_i32(s->pc - pc_start));
7083 tcg_gen_exit_tb(0);
7084 s->is_jmp = DISAS_TB_JUMP;
7085 }
7086 break;
7087 case 1: /* VMMCALL */
7088 if (!(s->flags & HF_SVME_MASK))
7089 goto illegal_op;
7090 gen_helper_vmmcall();
7091 break;
7092 case 2: /* VMLOAD */
7093 if (!(s->flags & HF_SVME_MASK) || !s->pe)
7094 goto illegal_op;
7095 if (s->cpl != 0) {
7096 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7097 break;
7098 } else {
7099 gen_helper_vmload(tcg_const_i32(s->aflag));
7100 }
7101 break;
7102 case 3: /* VMSAVE */
7103 if (!(s->flags & HF_SVME_MASK) || !s->pe)
7104 goto illegal_op;
7105 if (s->cpl != 0) {
7106 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7107 break;
7108 } else {
7109 gen_helper_vmsave(tcg_const_i32(s->aflag));
7110 }
7111 break;
7112 case 4: /* STGI */
7113 if ((!(s->flags & HF_SVME_MASK) &&
7114 !(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
7115 !s->pe)
7116 goto illegal_op;
7117 if (s->cpl != 0) {
7118 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7119 break;
7120 } else {
7121 gen_helper_stgi();
7122 }
7123 break;
7124 case 5: /* CLGI */
7125 if (!(s->flags & HF_SVME_MASK) || !s->pe)
7126 goto illegal_op;
7127 if (s->cpl != 0) {
7128 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7129 break;
7130 } else {
7131 gen_helper_clgi();
7132 }
7133 break;
7134 case 6: /* SKINIT */
7135 if ((!(s->flags & HF_SVME_MASK) &&
7136 !(s->cpuid_ext3_features & CPUID_EXT3_SKINIT)) ||
7137 !s->pe)
7138 goto illegal_op;
7139 gen_helper_skinit();
7140 break;
7141 case 7: /* INVLPGA */
7142 if (!(s->flags & HF_SVME_MASK) || !s->pe)
7143 goto illegal_op;
7144 if (s->cpl != 0) {
7145 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7146 break;
7147 } else {
7148 gen_helper_invlpga(tcg_const_i32(s->aflag));
7149 }
7150 break;
7151 default:
7152 goto illegal_op;
7153 }
7154 } else if (s->cpl != 0) {
7155 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7156 } else {
7157 gen_svm_check_intercept(s, pc_start,
7158 op==2 ? SVM_EXIT_GDTR_WRITE : SVM_EXIT_IDTR_WRITE);
7159 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7160 gen_op_ld_T1_A0(OT_WORD + s->mem_index);
7161 gen_add_A0_im(s, 2);
7162 gen_op_ld_T0_A0(CODE64(s) + OT_LONG + s->mem_index);
7163 if (!s->dflag)
7164 gen_op_andl_T0_im(0xffffff);
7165 if (op == 2) {
7166 tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,gdt.base));
7167 tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,gdt.limit));
7168 } else {
7169 tcg_gen_st_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,idt.base));
7170 tcg_gen_st32_tl(cpu_T[1], cpu_env, offsetof(CPUX86State,idt.limit));
7171 }
7172 }
7173 break;
7174 case 4: /* smsw */
7175 gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_CR0);
7176 #if defined TARGET_X86_64 && defined HOST_WORDS_BIGENDIAN
7177 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]) + 4);
7178 #else
7179 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,cr[0]));
7180 #endif
7181 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 1);
7182 break;
7183 case 6: /* lmsw */
7184 if (s->cpl != 0) {
7185 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7186 } else {
7187 gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
7188 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
7189 gen_helper_lmsw(cpu_T[0]);
7190 gen_jmp_im(s->pc - s->cs_base);
7191 gen_eob(s);
7192 }
7193 break;
7194 case 7:
7195 if (mod != 3) { /* invlpg */
7196 if (s->cpl != 0) {
7197 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7198 } else {
7199 if (s->cc_op != CC_OP_DYNAMIC)
7200 gen_op_set_cc_op(s->cc_op);
7201 gen_jmp_im(pc_start - s->cs_base);
7202 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7203 gen_helper_invlpg(cpu_A0);
7204 gen_jmp_im(s->pc - s->cs_base);
7205 gen_eob(s);
7206 }
7207 } else {
7208 switch (rm) {
7209 case 0: /* swapgs */
7210 #ifdef TARGET_X86_64
7211 if (CODE64(s)) {
7212 if (s->cpl != 0) {
7213 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7214 } else {
7215 tcg_gen_ld_tl(cpu_T[0], cpu_env,
7216 offsetof(CPUX86State,segs[R_GS].base));
7217 tcg_gen_ld_tl(cpu_T[1], cpu_env,
7218 offsetof(CPUX86State,kernelgsbase));
7219 tcg_gen_st_tl(cpu_T[1], cpu_env,
7220 offsetof(CPUX86State,segs[R_GS].base));
7221 tcg_gen_st_tl(cpu_T[0], cpu_env,
7222 offsetof(CPUX86State,kernelgsbase));
7223 }
7224 } else
7225 #endif
7226 {
7227 goto illegal_op;
7228 }
7229 break;
7230 case 1: /* rdtscp */
7231 if (!(s->cpuid_ext2_features & CPUID_EXT2_RDTSCP))
7232 goto illegal_op;
7233 if (s->cc_op != CC_OP_DYNAMIC)
7234 gen_op_set_cc_op(s->cc_op);
7235 gen_jmp_im(pc_start - s->cs_base);
7236 if (use_icount)
7237 gen_io_start();
7238 gen_helper_rdtscp();
7239 if (use_icount) {
7240 gen_io_end();
7241 gen_jmp(s, s->pc - s->cs_base);
7242 }
7243 break;
7244 default:
7245 goto illegal_op;
7246 }
7247 }
7248 break;
7249 default:
7250 goto illegal_op;
7251 }
7252 break;
7253 case 0x108: /* invd */
7254 case 0x109: /* wbinvd */
7255 if (s->cpl != 0) {
7256 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7257 } else {
7258 gen_svm_check_intercept(s, pc_start, (b & 2) ? SVM_EXIT_INVD : SVM_EXIT_WBINVD);
7259 /* nothing to do */
7260 }
7261 break;
7262 case 0x63: /* arpl or movslS (x86_64) */
7263 #ifdef TARGET_X86_64
7264 if (CODE64(s)) {
7265 int d_ot;
7266 /* d_ot is the size of destination */
7267 d_ot = dflag + OT_WORD;
7268
7269 modrm = ldub_code(s->pc++);
7270 reg = ((modrm >> 3) & 7) | rex_r;
7271 mod = (modrm >> 6) & 3;
7272 rm = (modrm & 7) | REX_B(s);
7273
7274 if (mod == 3) {
7275 gen_op_mov_TN_reg(OT_LONG, 0, rm);
7276 /* sign extend */
7277 if (d_ot == OT_QUAD)
7278 tcg_gen_ext32s_tl(cpu_T[0], cpu_T[0]);
7279 gen_op_mov_reg_T0(d_ot, reg);
7280 } else {
7281 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7282 if (d_ot == OT_QUAD) {
7283 gen_op_lds_T0_A0(OT_LONG + s->mem_index);
7284 } else {
7285 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
7286 }
7287 gen_op_mov_reg_T0(d_ot, reg);
7288 }
7289 } else
7290 #endif
7291 {
7292 int label1;
7293 TCGv t0, t1, t2, a0;
7294
7295 if (!s->pe || s->vm86)
7296 goto illegal_op;
7297 t0 = tcg_temp_local_new();
7298 t1 = tcg_temp_local_new();
7299 t2 = tcg_temp_local_new();
7300 ot = OT_WORD;
7301 modrm = ldub_code(s->pc++);
7302 reg = (modrm >> 3) & 7;
7303 mod = (modrm >> 6) & 3;
7304 rm = modrm & 7;
7305 if (mod != 3) {
7306 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7307 gen_op_ld_v(ot + s->mem_index, t0, cpu_A0);
7308 a0 = tcg_temp_local_new();
7309 tcg_gen_mov_tl(a0, cpu_A0);
7310 } else {
7311 gen_op_mov_v_reg(ot, t0, rm);
7312 TCGV_UNUSED(a0);
7313 }
7314 gen_op_mov_v_reg(ot, t1, reg);
7315 tcg_gen_andi_tl(cpu_tmp0, t0, 3);
7316 tcg_gen_andi_tl(t1, t1, 3);
7317 tcg_gen_movi_tl(t2, 0);
7318 label1 = gen_new_label();
7319 tcg_gen_brcond_tl(TCG_COND_GE, cpu_tmp0, t1, label1);
7320 tcg_gen_andi_tl(t0, t0, ~3);
7321 tcg_gen_or_tl(t0, t0, t1);
7322 tcg_gen_movi_tl(t2, CC_Z);
7323 gen_set_label(label1);
7324 if (mod != 3) {
7325 gen_op_st_v(ot + s->mem_index, t0, a0);
7326 tcg_temp_free(a0);
7327 } else {
7328 gen_op_mov_reg_v(ot, rm, t0);
7329 }
7330 if (s->cc_op != CC_OP_DYNAMIC)
7331 gen_op_set_cc_op(s->cc_op);
7332 gen_compute_eflags(cpu_cc_src);
7333 tcg_gen_andi_tl(cpu_cc_src, cpu_cc_src, ~CC_Z);
7334 tcg_gen_or_tl(cpu_cc_src, cpu_cc_src, t2);
7335 s->cc_op = CC_OP_EFLAGS;
7336 tcg_temp_free(t0);
7337 tcg_temp_free(t1);
7338 tcg_temp_free(t2);
7339 }
7340 break;
7341 case 0x102: /* lar */
7342 case 0x103: /* lsl */
7343 {
7344 int label1;
7345 TCGv t0;
7346 if (!s->pe || s->vm86)
7347 goto illegal_op;
7348 ot = dflag ? OT_LONG : OT_WORD;
7349 modrm = ldub_code(s->pc++);
7350 reg = ((modrm >> 3) & 7) | rex_r;
7351 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
7352 t0 = tcg_temp_local_new();
7353 if (s->cc_op != CC_OP_DYNAMIC)
7354 gen_op_set_cc_op(s->cc_op);
7355 if (b == 0x102)
7356 gen_helper_lar(t0, cpu_T[0]);
7357 else
7358 gen_helper_lsl(t0, cpu_T[0]);
7359 tcg_gen_andi_tl(cpu_tmp0, cpu_cc_src, CC_Z);
7360 label1 = gen_new_label();
7361 tcg_gen_brcondi_tl(TCG_COND_EQ, cpu_tmp0, 0, label1);
7362 gen_op_mov_reg_v(ot, reg, t0);
7363 gen_set_label(label1);
7364 s->cc_op = CC_OP_EFLAGS;
7365 tcg_temp_free(t0);
7366 }
7367 break;
7368 case 0x118:
7369 modrm = ldub_code(s->pc++);
7370 mod = (modrm >> 6) & 3;
7371 op = (modrm >> 3) & 7;
7372 switch(op) {
7373 case 0: /* prefetchnta */
7374 case 1: /* prefetchnt0 */
7375 case 2: /* prefetchnt0 */
7376 case 3: /* prefetchnt0 */
7377 if (mod == 3)
7378 goto illegal_op;
7379 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7380 /* nothing more to do */
7381 break;
7382 default: /* nop (multi byte) */
7383 gen_nop_modrm(s, modrm);
7384 break;
7385 }
7386 break;
7387 case 0x119 ... 0x11f: /* nop (multi byte) */
7388 modrm = ldub_code(s->pc++);
7389 gen_nop_modrm(s, modrm);
7390 break;
7391 case 0x120: /* mov reg, crN */
7392 case 0x122: /* mov crN, reg */
7393 if (s->cpl != 0) {
7394 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7395 } else {
7396 modrm = ldub_code(s->pc++);
7397 if ((modrm & 0xc0) != 0xc0)
7398 goto illegal_op;
7399 rm = (modrm & 7) | REX_B(s);
7400 reg = ((modrm >> 3) & 7) | rex_r;
7401 if (CODE64(s))
7402 ot = OT_QUAD;
7403 else
7404 ot = OT_LONG;
7405 if ((prefixes & PREFIX_LOCK) && (reg == 0) &&
7406 (s->cpuid_ext3_features & CPUID_EXT3_CR8LEG)) {
7407 reg = 8;
7408 }
7409 switch(reg) {
7410 case 0:
7411 case 2:
7412 case 3:
7413 case 4:
7414 case 8:
7415 if (s->cc_op != CC_OP_DYNAMIC)
7416 gen_op_set_cc_op(s->cc_op);
7417 gen_jmp_im(pc_start - s->cs_base);
7418 if (b & 2) {
7419 gen_op_mov_TN_reg(ot, 0, rm);
7420 gen_helper_write_crN(tcg_const_i32(reg), cpu_T[0]);
7421 gen_jmp_im(s->pc - s->cs_base);
7422 gen_eob(s);
7423 } else {
7424 gen_helper_read_crN(cpu_T[0], tcg_const_i32(reg));
7425 gen_op_mov_reg_T0(ot, rm);
7426 }
7427 break;
7428 default:
7429 goto illegal_op;
7430 }
7431 }
7432 break;
7433 case 0x121: /* mov reg, drN */
7434 case 0x123: /* mov drN, reg */
7435 if (s->cpl != 0) {
7436 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7437 } else {
7438 modrm = ldub_code(s->pc++);
7439 if ((modrm & 0xc0) != 0xc0)
7440 goto illegal_op;
7441 rm = (modrm & 7) | REX_B(s);
7442 reg = ((modrm >> 3) & 7) | rex_r;
7443 if (CODE64(s))
7444 ot = OT_QUAD;
7445 else
7446 ot = OT_LONG;
7447 /* XXX: do it dynamically with CR4.DE bit */
7448 if (reg == 4 || reg == 5 || reg >= 8)
7449 goto illegal_op;
7450 if (b & 2) {
7451 gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_DR0 + reg);
7452 gen_op_mov_TN_reg(ot, 0, rm);
7453 gen_helper_movl_drN_T0(tcg_const_i32(reg), cpu_T[0]);
7454 gen_jmp_im(s->pc - s->cs_base);
7455 gen_eob(s);
7456 } else {
7457 gen_svm_check_intercept(s, pc_start, SVM_EXIT_READ_DR0 + reg);
7458 tcg_gen_ld_tl(cpu_T[0], cpu_env, offsetof(CPUX86State,dr[reg]));
7459 gen_op_mov_reg_T0(ot, rm);
7460 }
7461 }
7462 break;
7463 case 0x106: /* clts */
7464 if (s->cpl != 0) {
7465 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
7466 } else {
7467 gen_svm_check_intercept(s, pc_start, SVM_EXIT_WRITE_CR0);
7468 gen_helper_clts();
7469 /* abort block because static cpu state changed */
7470 gen_jmp_im(s->pc - s->cs_base);
7471 gen_eob(s);
7472 }
7473 break;
7474 /* MMX/3DNow!/SSE/SSE2/SSE3/SSSE3/SSE4 support */
7475 case 0x1c3: /* MOVNTI reg, mem */
7476 if (!(s->cpuid_features & CPUID_SSE2))
7477 goto illegal_op;
7478 ot = s->dflag == 2 ? OT_QUAD : OT_LONG;
7479 modrm = ldub_code(s->pc++);
7480 mod = (modrm >> 6) & 3;
7481 if (mod == 3)
7482 goto illegal_op;
7483 reg = ((modrm >> 3) & 7) | rex_r;
7484 /* generate a generic store */
7485 gen_ldst_modrm(s, modrm, ot, reg, 1);
7486 break;
7487 case 0x1ae:
7488 modrm = ldub_code(s->pc++);
7489 mod = (modrm >> 6) & 3;
7490 op = (modrm >> 3) & 7;
7491 switch(op) {
7492 case 0: /* fxsave */
7493 if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
7494 (s->prefix & PREFIX_LOCK))
7495 goto illegal_op;
7496 if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
7497 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
7498 break;
7499 }
7500 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7501 if (s->cc_op != CC_OP_DYNAMIC)
7502 gen_op_set_cc_op(s->cc_op);
7503 gen_jmp_im(pc_start - s->cs_base);
7504 gen_helper_fxsave(cpu_A0, tcg_const_i32((s->dflag == 2)));
7505 break;
7506 case 1: /* fxrstor */
7507 if (mod == 3 || !(s->cpuid_features & CPUID_FXSR) ||
7508 (s->prefix & PREFIX_LOCK))
7509 goto illegal_op;
7510 if ((s->flags & HF_EM_MASK) || (s->flags & HF_TS_MASK)) {
7511 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
7512 break;
7513 }
7514 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7515 if (s->cc_op != CC_OP_DYNAMIC)
7516 gen_op_set_cc_op(s->cc_op);
7517 gen_jmp_im(pc_start - s->cs_base);
7518 gen_helper_fxrstor(cpu_A0, tcg_const_i32((s->dflag == 2)));
7519 break;
7520 case 2: /* ldmxcsr */
7521 case 3: /* stmxcsr */
7522 if (s->flags & HF_TS_MASK) {
7523 gen_exception(s, EXCP07_PREX, pc_start - s->cs_base);
7524 break;
7525 }
7526 if ((s->flags & HF_EM_MASK) || !(s->flags & HF_OSFXSR_MASK) ||
7527 mod == 3)
7528 goto illegal_op;
7529 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7530 if (op == 2) {
7531 gen_op_ld_T0_A0(OT_LONG + s->mem_index);
7532 tcg_gen_st32_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, mxcsr));
7533 } else {
7534 tcg_gen_ld32u_tl(cpu_T[0], cpu_env, offsetof(CPUX86State, mxcsr));
7535 gen_op_st_T0_A0(OT_LONG + s->mem_index);
7536 }
7537 break;
7538 case 5: /* lfence */
7539 case 6: /* mfence */
7540 if ((modrm & 0xc7) != 0xc0 || !(s->cpuid_features & CPUID_SSE2))
7541 goto illegal_op;
7542 break;
7543 case 7: /* sfence / clflush */
7544 if ((modrm & 0xc7) == 0xc0) {
7545 /* sfence */
7546 /* XXX: also check for cpuid_ext2_features & CPUID_EXT2_EMMX */
7547 if (!(s->cpuid_features & CPUID_SSE))
7548 goto illegal_op;
7549 } else {
7550 /* clflush */
7551 if (!(s->cpuid_features & CPUID_CLFLUSH))
7552 goto illegal_op;
7553 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7554 }
7555 break;
7556 default:
7557 goto illegal_op;
7558 }
7559 break;
7560 case 0x10d: /* 3DNow! prefetch(w) */
7561 modrm = ldub_code(s->pc++);
7562 mod = (modrm >> 6) & 3;
7563 if (mod == 3)
7564 goto illegal_op;
7565 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
7566 /* ignore for now */
7567 break;
7568 case 0x1aa: /* rsm */
7569 gen_svm_check_intercept(s, pc_start, SVM_EXIT_RSM);
7570 if (!(s->flags & HF_SMM_MASK))
7571 goto illegal_op;
7572 gen_update_cc_op(s);
7573 gen_jmp_im(s->pc - s->cs_base);
7574 gen_helper_rsm();
7575 gen_eob(s);
7576 break;
7577 case 0x1b8: /* SSE4.2 popcnt */
7578 if ((prefixes & (PREFIX_REPZ | PREFIX_LOCK | PREFIX_REPNZ)) !=
7579 PREFIX_REPZ)
7580 goto illegal_op;
7581 if (!(s->cpuid_ext_features & CPUID_EXT_POPCNT))
7582 goto illegal_op;
7583
7584 modrm = ldub_code(s->pc++);
7585 reg = ((modrm >> 3) & 7);
7586
7587 if (s->prefix & PREFIX_DATA)
7588 ot = OT_WORD;
7589 else if (s->dflag != 2)
7590 ot = OT_LONG;
7591 else
7592 ot = OT_QUAD;
7593
7594 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
7595 gen_helper_popcnt(cpu_T[0], cpu_T[0], tcg_const_i32(ot));
7596 gen_op_mov_reg_T0(ot, reg);
7597
7598 s->cc_op = CC_OP_EFLAGS;
7599 break;
7600 case 0x10e ... 0x10f:
7601 /* 3DNow! instructions, ignore prefixes */
7602 s->prefix &= ~(PREFIX_REPZ | PREFIX_REPNZ | PREFIX_DATA);
7603 case 0x110 ... 0x117:
7604 case 0x128 ... 0x12f:
7605 case 0x138 ... 0x13a:
7606 case 0x150 ... 0x179:
7607 case 0x17c ... 0x17f:
7608 case 0x1c2:
7609 case 0x1c4 ... 0x1c6:
7610 case 0x1d0 ... 0x1fe:
7611 gen_sse(s, b, pc_start, rex_r);
7612 break;
7613 default:
7614 goto illegal_op;
7615 }
7616 /* lock generation */
7617 if (s->prefix & PREFIX_LOCK)
7618 gen_helper_unlock();
7619 return s->pc;
7620 illegal_op:
7621 if (s->prefix & PREFIX_LOCK)
7622 gen_helper_unlock();
7623 /* XXX: ensure that no lock was generated */
7624 gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
7625 return s->pc;
7626 }
7627
7628 void optimize_flags_init(void)
7629 {
7630 #if TCG_TARGET_REG_BITS == 32
7631 assert(sizeof(CCTable) == (1 << 3));
7632 #else
7633 assert(sizeof(CCTable) == (1 << 4));
7634 #endif
7635 cpu_env = tcg_global_reg_new_ptr(TCG_AREG0, "env");
7636 cpu_cc_op = tcg_global_mem_new_i32(TCG_AREG0,
7637 offsetof(CPUState, cc_op), "cc_op");
7638 cpu_cc_src = tcg_global_mem_new(TCG_AREG0, offsetof(CPUState, cc_src),
7639 "cc_src");
7640 cpu_cc_dst = tcg_global_mem_new(TCG_AREG0, offsetof(CPUState, cc_dst),
7641 "cc_dst");
7642 cpu_cc_tmp = tcg_global_mem_new(TCG_AREG0, offsetof(CPUState, cc_tmp),
7643 "cc_tmp");
7644
7645 #ifdef TARGET_X86_64
7646 cpu_regs[R_EAX] = tcg_global_mem_new_i64(TCG_AREG0,
7647 offsetof(CPUState, regs[R_EAX]), "rax");
7648 cpu_regs[R_ECX] = tcg_global_mem_new_i64(TCG_AREG0,
7649 offsetof(CPUState, regs[R_ECX]), "rcx");
7650 cpu_regs[R_EDX] = tcg_global_mem_new_i64(TCG_AREG0,
7651 offsetof(CPUState, regs[R_EDX]), "rdx");
7652 cpu_regs[R_EBX] = tcg_global_mem_new_i64(TCG_AREG0,
7653 offsetof(CPUState, regs[R_EBX]), "rbx");
7654 cpu_regs[R_ESP] = tcg_global_mem_new_i64(TCG_AREG0,
7655 offsetof(CPUState, regs[R_ESP]), "rsp");
7656 cpu_regs[R_EBP] = tcg_global_mem_new_i64(TCG_AREG0,
7657 offsetof(CPUState, regs[R_EBP]), "rbp");
7658 cpu_regs[R_ESI] = tcg_global_mem_new_i64(TCG_AREG0,
7659 offsetof(CPUState, regs[R_ESI]), "rsi");
7660 cpu_regs[R_EDI] = tcg_global_mem_new_i64(TCG_AREG0,
7661 offsetof(CPUState, regs[R_EDI]), "rdi");
7662 cpu_regs[8] = tcg_global_mem_new_i64(TCG_AREG0,
7663 offsetof(CPUState, regs[8]), "r8");
7664 cpu_regs[9] = tcg_global_mem_new_i64(TCG_AREG0,
7665 offsetof(CPUState, regs[9]), "r9");
7666 cpu_regs[10] = tcg_global_mem_new_i64(TCG_AREG0,
7667 offsetof(CPUState, regs[10]), "r10");
7668 cpu_regs[11] = tcg_global_mem_new_i64(TCG_AREG0,
7669 offsetof(CPUState, regs[11]), "r11");
7670 cpu_regs[12] = tcg_global_mem_new_i64(TCG_AREG0,
7671 offsetof(CPUState, regs[12]), "r12");
7672 cpu_regs[13] = tcg_global_mem_new_i64(TCG_AREG0,
7673 offsetof(CPUState, regs[13]), "r13");
7674 cpu_regs[14] = tcg_global_mem_new_i64(TCG_AREG0,
7675 offsetof(CPUState, regs[14]), "r14");
7676 cpu_regs[15] = tcg_global_mem_new_i64(TCG_AREG0,
7677 offsetof(CPUState, regs[15]), "r15");
7678 #else
7679 cpu_regs[R_EAX] = tcg_global_mem_new_i32(TCG_AREG0,
7680 offsetof(CPUState, regs[R_EAX]), "eax");
7681 cpu_regs[R_ECX] = tcg_global_mem_new_i32(TCG_AREG0,
7682 offsetof(CPUState, regs[R_ECX]), "ecx");
7683 cpu_regs[R_EDX] = tcg_global_mem_new_i32(TCG_AREG0,
7684 offsetof(CPUState, regs[R_EDX]), "edx");
7685 cpu_regs[R_EBX] = tcg_global_mem_new_i32(TCG_AREG0,
7686 offsetof(CPUState, regs[R_EBX]), "ebx");
7687 cpu_regs[R_ESP] = tcg_global_mem_new_i32(TCG_AREG0,
7688 offsetof(CPUState, regs[R_ESP]), "esp");
7689 cpu_regs[R_EBP] = tcg_global_mem_new_i32(TCG_AREG0,
7690 offsetof(CPUState, regs[R_EBP]), "ebp");
7691 cpu_regs[R_ESI] = tcg_global_mem_new_i32(TCG_AREG0,
7692 offsetof(CPUState, regs[R_ESI]), "esi");
7693 cpu_regs[R_EDI] = tcg_global_mem_new_i32(TCG_AREG0,
7694 offsetof(CPUState, regs[R_EDI]), "edi");
7695 #endif
7696
7697 /* register helpers */
7698 #define GEN_HELPER 2
7699 #include "helper.h"
7700 }
7701
7702 /* generate intermediate code in gen_opc_buf and gen_opparam_buf for
7703 basic block 'tb'. If search_pc is TRUE, also generate PC
7704 information for each intermediate instruction. */
7705 static inline void gen_intermediate_code_internal(CPUState *env,
7706 TranslationBlock *tb,
7707 int search_pc)
7708 {
7709 DisasContext dc1, *dc = &dc1;
7710 target_ulong pc_ptr;
7711 uint16_t *gen_opc_end;
7712 CPUBreakpoint *bp;
7713 int j, lj;
7714 uint64_t flags;
7715 target_ulong pc_start;
7716 target_ulong cs_base;
7717 int num_insns;
7718 int max_insns;
7719
7720 /* generate intermediate code */
7721 pc_start = tb->pc;
7722 cs_base = tb->cs_base;
7723 flags = tb->flags;
7724
7725 dc->pe = (flags >> HF_PE_SHIFT) & 1;
7726 dc->code32 = (flags >> HF_CS32_SHIFT) & 1;
7727 dc->ss32 = (flags >> HF_SS32_SHIFT) & 1;
7728 dc->addseg = (flags >> HF_ADDSEG_SHIFT) & 1;
7729 dc->f_st = 0;
7730 dc->vm86 = (flags >> VM_SHIFT) & 1;
7731 dc->cpl = (flags >> HF_CPL_SHIFT) & 3;
7732 dc->iopl = (flags >> IOPL_SHIFT) & 3;
7733 dc->tf = (flags >> TF_SHIFT) & 1;
7734 dc->singlestep_enabled = env->singlestep_enabled;
7735 dc->cc_op = CC_OP_DYNAMIC;
7736 dc->cs_base = cs_base;
7737 dc->tb = tb;
7738 dc->popl_esp_hack = 0;
7739 /* select memory access functions */
7740 dc->mem_index = 0;
7741 if (flags & HF_SOFTMMU_MASK) {
7742 if (dc->cpl == 3)
7743 dc->mem_index = 2 * 4;
7744 else
7745 dc->mem_index = 1 * 4;
7746 }
7747 dc->cpuid_features = env->cpuid_features;
7748 dc->cpuid_ext_features = env->cpuid_ext_features;
7749 dc->cpuid_ext2_features = env->cpuid_ext2_features;
7750 dc->cpuid_ext3_features = env->cpuid_ext3_features;
7751 #ifdef TARGET_X86_64
7752 dc->lma = (flags >> HF_LMA_SHIFT) & 1;
7753 dc->code64 = (flags >> HF_CS64_SHIFT) & 1;
7754 #endif
7755 dc->flags = flags;
7756 dc->jmp_opt = !(dc->tf || env->singlestep_enabled ||
7757 (flags & HF_INHIBIT_IRQ_MASK)
7758 #ifndef CONFIG_SOFTMMU
7759 || (flags & HF_SOFTMMU_MASK)
7760 #endif
7761 );
7762 #if 0
7763 /* check addseg logic */
7764 if (!dc->addseg && (dc->vm86 || !dc->pe || !dc->code32))
7765 printf("ERROR addseg\n");
7766 #endif
7767
7768 cpu_T[0] = tcg_temp_new();
7769 cpu_T[1] = tcg_temp_new();
7770 cpu_A0 = tcg_temp_new();
7771 cpu_T3 = tcg_temp_new();
7772
7773 cpu_tmp0 = tcg_temp_new();
7774 cpu_tmp1_i64 = tcg_temp_new_i64();
7775 cpu_tmp2_i32 = tcg_temp_new_i32();
7776 cpu_tmp3_i32 = tcg_temp_new_i32();
7777 cpu_tmp4 = tcg_temp_new();
7778 cpu_tmp5 = tcg_temp_new();
7779 cpu_ptr0 = tcg_temp_new_ptr();
7780 cpu_ptr1 = tcg_temp_new_ptr();
7781
7782 gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
7783
7784 dc->is_jmp = DISAS_NEXT;
7785 pc_ptr = pc_start;
7786 lj = -1;
7787 num_insns = 0;
7788 max_insns = tb->cflags & CF_COUNT_MASK;
7789 if (max_insns == 0)
7790 max_insns = CF_COUNT_MASK;
7791
7792 gen_icount_start();
7793 for(;;) {
7794 if (unlikely(!QTAILQ_EMPTY(&env->breakpoints))) {
7795 QTAILQ_FOREACH(bp, &env->breakpoints, entry) {
7796 if (bp->pc == pc_ptr &&
7797 !((bp->flags & BP_CPU) && (tb->flags & HF_RF_MASK))) {
7798 gen_debug(dc, pc_ptr - dc->cs_base);
7799 break;
7800 }
7801 }
7802 }
7803 if (search_pc) {
7804 j = gen_opc_ptr - gen_opc_buf;
7805 if (lj < j) {
7806 lj++;
7807 while (lj < j)
7808 gen_opc_instr_start[lj++] = 0;
7809 }
7810 gen_opc_pc[lj] = pc_ptr;
7811 gen_opc_cc_op[lj] = dc->cc_op;
7812 gen_opc_instr_start[lj] = 1;
7813 gen_opc_icount[lj] = num_insns;
7814 }
7815 if (num_insns + 1 == max_insns && (tb->cflags & CF_LAST_IO))
7816 gen_io_start();
7817
7818 pc_ptr = disas_insn(dc, pc_ptr);
7819 num_insns++;
7820 /* stop translation if indicated */
7821 if (dc->is_jmp)
7822 break;
7823 /* if single step mode, we generate only one instruction and
7824 generate an exception */
7825 /* if irq were inhibited with HF_INHIBIT_IRQ_MASK, we clear
7826 the flag and abort the translation to give the irqs a
7827 change to be happen */
7828 if (dc->tf || dc->singlestep_enabled ||
7829 (flags & HF_INHIBIT_IRQ_MASK)) {
7830 gen_jmp_im(pc_ptr - dc->cs_base);
7831 gen_eob(dc);
7832 break;
7833 }
7834 /* if too long translation, stop generation too */
7835 if (gen_opc_ptr >= gen_opc_end ||
7836 (pc_ptr - pc_start) >= (TARGET_PAGE_SIZE - 32) ||
7837 num_insns >= max_insns) {
7838 gen_jmp_im(pc_ptr - dc->cs_base);
7839 gen_eob(dc);
7840 break;
7841 }
7842 if (singlestep) {
7843 gen_jmp_im(pc_ptr - dc->cs_base);
7844 gen_eob(dc);
7845 break;
7846 }
7847 }
7848 if (tb->cflags & CF_LAST_IO)
7849 gen_io_end();
7850 gen_icount_end(tb, num_insns);
7851 *gen_opc_ptr = INDEX_op_end;
7852 /* we don't forget to fill the last values */
7853 if (search_pc) {
7854 j = gen_opc_ptr - gen_opc_buf;
7855 lj++;
7856 while (lj <= j)
7857 gen_opc_instr_start[lj++] = 0;
7858 }
7859
7860 #ifdef DEBUG_DISAS
7861 if (qemu_loglevel_mask(CPU_LOG_TB_IN_ASM)) {
7862 int disas_flags;
7863 qemu_log("----------------\n");
7864 qemu_log("IN: %s\n", lookup_symbol(pc_start));
7865 #ifdef TARGET_X86_64
7866 if (dc->code64)
7867 disas_flags = 2;
7868 else
7869 #endif
7870 disas_flags = !dc->code32;
7871 log_target_disas(pc_start, pc_ptr - pc_start, disas_flags);
7872 qemu_log("\n");
7873 }
7874 #endif
7875
7876 if (!search_pc) {
7877 tb->size = pc_ptr - pc_start;
7878 tb->icount = num_insns;
7879 }
7880 }
7881
7882 void gen_intermediate_code(CPUState *env, TranslationBlock *tb)
7883 {
7884 gen_intermediate_code_internal(env, tb, 0);
7885 }
7886
7887 void gen_intermediate_code_pc(CPUState *env, TranslationBlock *tb)
7888 {
7889 gen_intermediate_code_internal(env, tb, 1);
7890 }
7891
7892 void restore_state_to_opc(CPUState *env, TranslationBlock *tb, int pc_pos)
7893 {
7894 int cc_op;
7895 #ifdef DEBUG_DISAS
7896 if (qemu_loglevel_mask(CPU_LOG_TB_OP)) {
7897 int i;
7898 qemu_log("RESTORE:\n");
7899 for(i = 0;i <= pc_pos; i++) {
7900 if (gen_opc_instr_start[i]) {
7901 qemu_log("0x%04x: " TARGET_FMT_lx "\n", i, gen_opc_pc[i]);
7902 }
7903 }
7904 qemu_log("pc_pos=0x%x eip=" TARGET_FMT_lx " cs_base=%x\n",
7905 pc_pos, gen_opc_pc[pc_pos] - tb->cs_base,
7906 (uint32_t)tb->cs_base);
7907 }
7908 #endif
7909 env->eip = gen_opc_pc[pc_pos] - tb->cs_base;
7910 cc_op = gen_opc_cc_op[pc_pos];
7911 if (cc_op != CC_OP_DYNAMIC)
7912 env->cc_op = cc_op;
7913 }
Anthony Liguori's QEMU tree