]> git.proxmox.com Git - mirror_qemu.git/blame - target-i386/translate.c
projects / mirror_qemu.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
always completely redefine the TLB in case of MMU fault
[mirror_qemu.git] / target-i386 / translate.c
CommitLineData
2c0262af
FB		 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, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20#include <stdarg.h>
21#include <stdlib.h>
22#include <stdio.h>
23#include <string.h>
24#include <inttypes.h>
25#include <signal.h>
26#include <assert.h>
27#include <sys/mman.h>
28
29#include "cpu.h"
30#include "exec-all.h"
31#include "disas.h"
32
33/* XXX: move that elsewhere */
34static uint16_t *gen_opc_ptr;
35static uint32_t *gen_opparam_ptr;
36
37#define PREFIX_REPZ 0x01
38#define PREFIX_REPNZ 0x02
39#define PREFIX_LOCK 0x04
40#define PREFIX_DATA 0x08
41#define PREFIX_ADR 0x10
42
43typedef struct DisasContext {
44 /* current insn context */
45 int override; /* -1 if no override */
46 int prefix;
47 int aflag, dflag;
48 uint8_t *pc; /* pc = eip + cs_base */
49 int is_jmp; /* 1 = means jump (stop translation), 2 means CPU
50 static state change (stop translation) */
51 /* current block context */
52 uint8_t *cs_base; /* base of CS segment */
53 int pe; /* protected mode */
54 int code32; /* 32 bit code segment */
55 int ss32; /* 32 bit stack segment */
56 int cc_op; /* current CC operation */
57 int addseg; /* non zero if either DS/ES/SS have a non zero base */
58 int f_st; /* currently unused */
59 int vm86; /* vm86 mode */
60 int cpl;
61 int iopl;
62 int tf; /* TF cpu flag */
34865134 63 int singlestep_enabled; /* "hardware" single step enabled */
2c0262af
FB		 64 int jmp_opt; /* use direct block chaining for direct jumps */
65 int mem_index; /* select memory access functions */
66 struct TranslationBlock *tb;
67 int popl_esp_hack; /* for correct popl with esp base handling */
68} DisasContext;
69
70static void gen_eob(DisasContext *s);
71static void gen_jmp(DisasContext *s, unsigned int eip);
72
73/* i386 arith/logic operations */
74enum {
75 OP_ADDL,
76 OP_ORL,
77 OP_ADCL,
78 OP_SBBL,
79 OP_ANDL,
80 OP_SUBL,
81 OP_XORL,
82 OP_CMPL,
83};
84
85/* i386 shift ops */
86enum {
87 OP_ROL,
88 OP_ROR,
89 OP_RCL,
90 OP_RCR,
91 OP_SHL,
92 OP_SHR,
93 OP_SHL1, /* undocumented */
94 OP_SAR = 7,
95};
96
97enum {
98#define DEF(s, n, copy_size) INDEX_op_ ## s,
99#include "opc.h"
100#undef DEF
101 NB_OPS,
102};
103
104#include "gen-op.h"
105
106/* operand size */
107enum {
108 OT_BYTE = 0,
109 OT_WORD,
110 OT_LONG,
111 OT_QUAD,
112};
113
114enum {
115 /* I386 int registers */
116 OR_EAX, /* MUST be even numbered */
117 OR_ECX,
118 OR_EDX,
119 OR_EBX,
120 OR_ESP,
121 OR_EBP,
122 OR_ESI,
123 OR_EDI,
124 OR_TMP0, /* temporary operand register */
125 OR_TMP1,
126 OR_A0, /* temporary register used when doing address evaluation */
127 OR_ZERO, /* fixed zero register */
128 NB_OREGS,
129};
130
131typedef void (GenOpFunc)(void);
132typedef void (GenOpFunc1)(long);
133typedef void (GenOpFunc2)(long, long);
134typedef void (GenOpFunc3)(long, long, long);
135
136static GenOpFunc *gen_op_mov_reg_T0[3][8] = {
137 [OT_BYTE] = {
138 gen_op_movb_EAX_T0,
139 gen_op_movb_ECX_T0,
140 gen_op_movb_EDX_T0,
141 gen_op_movb_EBX_T0,
142 gen_op_movh_EAX_T0,
143 gen_op_movh_ECX_T0,
144 gen_op_movh_EDX_T0,
145 gen_op_movh_EBX_T0,
146 },
147 [OT_WORD] = {
148 gen_op_movw_EAX_T0,
149 gen_op_movw_ECX_T0,
150 gen_op_movw_EDX_T0,
151 gen_op_movw_EBX_T0,
152 gen_op_movw_ESP_T0,
153 gen_op_movw_EBP_T0,
154 gen_op_movw_ESI_T0,
155 gen_op_movw_EDI_T0,
156 },
157 [OT_LONG] = {
158 gen_op_movl_EAX_T0,
159 gen_op_movl_ECX_T0,
160 gen_op_movl_EDX_T0,
161 gen_op_movl_EBX_T0,
162 gen_op_movl_ESP_T0,
163 gen_op_movl_EBP_T0,
164 gen_op_movl_ESI_T0,
165 gen_op_movl_EDI_T0,
166 },
167};
168
169static GenOpFunc *gen_op_mov_reg_T1[3][8] = {
170 [OT_BYTE] = {
171 gen_op_movb_EAX_T1,
172 gen_op_movb_ECX_T1,
173 gen_op_movb_EDX_T1,
174 gen_op_movb_EBX_T1,
175 gen_op_movh_EAX_T1,
176 gen_op_movh_ECX_T1,
177 gen_op_movh_EDX_T1,
178 gen_op_movh_EBX_T1,
179 },
180 [OT_WORD] = {
181 gen_op_movw_EAX_T1,
182 gen_op_movw_ECX_T1,
183 gen_op_movw_EDX_T1,
184 gen_op_movw_EBX_T1,
185 gen_op_movw_ESP_T1,
186 gen_op_movw_EBP_T1,
187 gen_op_movw_ESI_T1,
188 gen_op_movw_EDI_T1,
189 },
190 [OT_LONG] = {
191 gen_op_movl_EAX_T1,
192 gen_op_movl_ECX_T1,
193 gen_op_movl_EDX_T1,
194 gen_op_movl_EBX_T1,
195 gen_op_movl_ESP_T1,
196 gen_op_movl_EBP_T1,
197 gen_op_movl_ESI_T1,
198 gen_op_movl_EDI_T1,
199 },
200};
201
202static GenOpFunc *gen_op_mov_reg_A0[2][8] = {
203 [0] = {
204 gen_op_movw_EAX_A0,
205 gen_op_movw_ECX_A0,
206 gen_op_movw_EDX_A0,
207 gen_op_movw_EBX_A0,
208 gen_op_movw_ESP_A0,
209 gen_op_movw_EBP_A0,
210 gen_op_movw_ESI_A0,
211 gen_op_movw_EDI_A0,
212 },
213 [1] = {
214 gen_op_movl_EAX_A0,
215 gen_op_movl_ECX_A0,
216 gen_op_movl_EDX_A0,
217 gen_op_movl_EBX_A0,
218 gen_op_movl_ESP_A0,
219 gen_op_movl_EBP_A0,
220 gen_op_movl_ESI_A0,
221 gen_op_movl_EDI_A0,
222 },
223};
224
225static GenOpFunc *gen_op_mov_TN_reg[3][2][8] =
226{
227 [OT_BYTE] = {
228 {
229 gen_op_movl_T0_EAX,
230 gen_op_movl_T0_ECX,
231 gen_op_movl_T0_EDX,
232 gen_op_movl_T0_EBX,
233 gen_op_movh_T0_EAX,
234 gen_op_movh_T0_ECX,
235 gen_op_movh_T0_EDX,
236 gen_op_movh_T0_EBX,
237 },
238 {
239 gen_op_movl_T1_EAX,
240 gen_op_movl_T1_ECX,
241 gen_op_movl_T1_EDX,
242 gen_op_movl_T1_EBX,
243 gen_op_movh_T1_EAX,
244 gen_op_movh_T1_ECX,
245 gen_op_movh_T1_EDX,
246 gen_op_movh_T1_EBX,
247 },
248 },
249 [OT_WORD] = {
250 {
251 gen_op_movl_T0_EAX,
252 gen_op_movl_T0_ECX,
253 gen_op_movl_T0_EDX,
254 gen_op_movl_T0_EBX,
255 gen_op_movl_T0_ESP,
256 gen_op_movl_T0_EBP,
257 gen_op_movl_T0_ESI,
258 gen_op_movl_T0_EDI,
259 },
260 {
261 gen_op_movl_T1_EAX,
262 gen_op_movl_T1_ECX,
263 gen_op_movl_T1_EDX,
264 gen_op_movl_T1_EBX,
265 gen_op_movl_T1_ESP,
266 gen_op_movl_T1_EBP,
267 gen_op_movl_T1_ESI,
268 gen_op_movl_T1_EDI,
269 },
270 },
271 [OT_LONG] = {
272 {
273 gen_op_movl_T0_EAX,
274 gen_op_movl_T0_ECX,
275 gen_op_movl_T0_EDX,
276 gen_op_movl_T0_EBX,
277 gen_op_movl_T0_ESP,
278 gen_op_movl_T0_EBP,
279 gen_op_movl_T0_ESI,
280 gen_op_movl_T0_EDI,
281 },
282 {
283 gen_op_movl_T1_EAX,
284 gen_op_movl_T1_ECX,
285 gen_op_movl_T1_EDX,
286 gen_op_movl_T1_EBX,
287 gen_op_movl_T1_ESP,
288 gen_op_movl_T1_EBP,
289 gen_op_movl_T1_ESI,
290 gen_op_movl_T1_EDI,
291 },
292 },
293};
294
295static GenOpFunc *gen_op_movl_A0_reg[8] = {
296 gen_op_movl_A0_EAX,
297 gen_op_movl_A0_ECX,
298 gen_op_movl_A0_EDX,
299 gen_op_movl_A0_EBX,
300 gen_op_movl_A0_ESP,
301 gen_op_movl_A0_EBP,
302 gen_op_movl_A0_ESI,
303 gen_op_movl_A0_EDI,
304};
305
306static GenOpFunc *gen_op_addl_A0_reg_sN[4][8] = {
307 [0] = {
308 gen_op_addl_A0_EAX,
309 gen_op_addl_A0_ECX,
310 gen_op_addl_A0_EDX,
311 gen_op_addl_A0_EBX,
312 gen_op_addl_A0_ESP,
313 gen_op_addl_A0_EBP,
314 gen_op_addl_A0_ESI,
315 gen_op_addl_A0_EDI,
316 },
317 [1] = {
318 gen_op_addl_A0_EAX_s1,
319 gen_op_addl_A0_ECX_s1,
320 gen_op_addl_A0_EDX_s1,
321 gen_op_addl_A0_EBX_s1,
322 gen_op_addl_A0_ESP_s1,
323 gen_op_addl_A0_EBP_s1,
324 gen_op_addl_A0_ESI_s1,
325 gen_op_addl_A0_EDI_s1,
326 },
327 [2] = {
328 gen_op_addl_A0_EAX_s2,
329 gen_op_addl_A0_ECX_s2,
330 gen_op_addl_A0_EDX_s2,
331 gen_op_addl_A0_EBX_s2,
332 gen_op_addl_A0_ESP_s2,
333 gen_op_addl_A0_EBP_s2,
334 gen_op_addl_A0_ESI_s2,
335 gen_op_addl_A0_EDI_s2,
336 },
337 [3] = {
338 gen_op_addl_A0_EAX_s3,
339 gen_op_addl_A0_ECX_s3,
340 gen_op_addl_A0_EDX_s3,
341 gen_op_addl_A0_EBX_s3,
342 gen_op_addl_A0_ESP_s3,
343 gen_op_addl_A0_EBP_s3,
344 gen_op_addl_A0_ESI_s3,
345 gen_op_addl_A0_EDI_s3,
346 },
347};
348
349static GenOpFunc *gen_op_cmov_reg_T1_T0[2][8] = {
350 [0] = {
351 gen_op_cmovw_EAX_T1_T0,
352 gen_op_cmovw_ECX_T1_T0,
353 gen_op_cmovw_EDX_T1_T0,
354 gen_op_cmovw_EBX_T1_T0,
355 gen_op_cmovw_ESP_T1_T0,
356 gen_op_cmovw_EBP_T1_T0,
357 gen_op_cmovw_ESI_T1_T0,
358 gen_op_cmovw_EDI_T1_T0,
359 },
360 [1] = {
361 gen_op_cmovl_EAX_T1_T0,
362 gen_op_cmovl_ECX_T1_T0,
363 gen_op_cmovl_EDX_T1_T0,
364 gen_op_cmovl_EBX_T1_T0,
365 gen_op_cmovl_ESP_T1_T0,
366 gen_op_cmovl_EBP_T1_T0,
367 gen_op_cmovl_ESI_T1_T0,
368 gen_op_cmovl_EDI_T1_T0,
369 },
370};
371
372static GenOpFunc *gen_op_arith_T0_T1_cc[8] = {
373 NULL,
374 gen_op_orl_T0_T1,
375 NULL,
376 NULL,
377 gen_op_andl_T0_T1,
378 NULL,
379 gen_op_xorl_T0_T1,
380 NULL,
381};
382
383static GenOpFunc *gen_op_arithc_T0_T1_cc[3][2] = {
384 [OT_BYTE] = {
385 gen_op_adcb_T0_T1_cc,
386 gen_op_sbbb_T0_T1_cc,
387 },
388 [OT_WORD] = {
389 gen_op_adcw_T0_T1_cc,
390 gen_op_sbbw_T0_T1_cc,
391 },
392 [OT_LONG] = {
393 gen_op_adcl_T0_T1_cc,
394 gen_op_sbbl_T0_T1_cc,
395 },
396};
397
398static GenOpFunc *gen_op_arithc_mem_T0_T1_cc[3][2] = {
399 [OT_BYTE] = {
400 gen_op_adcb_mem_T0_T1_cc,
401 gen_op_sbbb_mem_T0_T1_cc,
402 },
403 [OT_WORD] = {
404 gen_op_adcw_mem_T0_T1_cc,
405 gen_op_sbbw_mem_T0_T1_cc,
406 },
407 [OT_LONG] = {
408 gen_op_adcl_mem_T0_T1_cc,
409 gen_op_sbbl_mem_T0_T1_cc,
410 },
411};
412
413static const int cc_op_arithb[8] = {
414 CC_OP_ADDB,
415 CC_OP_LOGICB,
416 CC_OP_ADDB,
417 CC_OP_SUBB,
418 CC_OP_LOGICB,
419 CC_OP_SUBB,
420 CC_OP_LOGICB,
421 CC_OP_SUBB,
422};
423
424static GenOpFunc *gen_op_cmpxchg_T0_T1_EAX_cc[3] = {
425 gen_op_cmpxchgb_T0_T1_EAX_cc,
426 gen_op_cmpxchgw_T0_T1_EAX_cc,
427 gen_op_cmpxchgl_T0_T1_EAX_cc,
428};
429
430static GenOpFunc *gen_op_cmpxchg_mem_T0_T1_EAX_cc[3] = {
431 gen_op_cmpxchgb_mem_T0_T1_EAX_cc,
432 gen_op_cmpxchgw_mem_T0_T1_EAX_cc,
433 gen_op_cmpxchgl_mem_T0_T1_EAX_cc,
434};
435
436static GenOpFunc *gen_op_shift_T0_T1_cc[3][8] = {
437 [OT_BYTE] = {
438 gen_op_rolb_T0_T1_cc,
439 gen_op_rorb_T0_T1_cc,
440 gen_op_rclb_T0_T1_cc,
441 gen_op_rcrb_T0_T1_cc,
442 gen_op_shlb_T0_T1_cc,
443 gen_op_shrb_T0_T1_cc,
444 gen_op_shlb_T0_T1_cc,
445 gen_op_sarb_T0_T1_cc,
446 },
447 [OT_WORD] = {
448 gen_op_rolw_T0_T1_cc,
449 gen_op_rorw_T0_T1_cc,
450 gen_op_rclw_T0_T1_cc,
451 gen_op_rcrw_T0_T1_cc,
452 gen_op_shlw_T0_T1_cc,
453 gen_op_shrw_T0_T1_cc,
454 gen_op_shlw_T0_T1_cc,
455 gen_op_sarw_T0_T1_cc,
456 },
457 [OT_LONG] = {
458 gen_op_roll_T0_T1_cc,
459 gen_op_rorl_T0_T1_cc,
460 gen_op_rcll_T0_T1_cc,
461 gen_op_rcrl_T0_T1_cc,
462 gen_op_shll_T0_T1_cc,
463 gen_op_shrl_T0_T1_cc,
464 gen_op_shll_T0_T1_cc,
465 gen_op_sarl_T0_T1_cc,
466 },
467};
468
469static GenOpFunc *gen_op_shift_mem_T0_T1_cc[3][8] = {
470 [OT_BYTE] = {
471 gen_op_rolb_mem_T0_T1_cc,
472 gen_op_rorb_mem_T0_T1_cc,
473 gen_op_rclb_mem_T0_T1_cc,
474 gen_op_rcrb_mem_T0_T1_cc,
475 gen_op_shlb_mem_T0_T1_cc,
476 gen_op_shrb_mem_T0_T1_cc,
477 gen_op_shlb_mem_T0_T1_cc,
478 gen_op_sarb_mem_T0_T1_cc,
479 },
480 [OT_WORD] = {
481 gen_op_rolw_mem_T0_T1_cc,
482 gen_op_rorw_mem_T0_T1_cc,
483 gen_op_rclw_mem_T0_T1_cc,
484 gen_op_rcrw_mem_T0_T1_cc,
485 gen_op_shlw_mem_T0_T1_cc,
486 gen_op_shrw_mem_T0_T1_cc,
487 gen_op_shlw_mem_T0_T1_cc,
488 gen_op_sarw_mem_T0_T1_cc,
489 },
490 [OT_LONG] = {
491 gen_op_roll_mem_T0_T1_cc,
492 gen_op_rorl_mem_T0_T1_cc,
493 gen_op_rcll_mem_T0_T1_cc,
494 gen_op_rcrl_mem_T0_T1_cc,
495 gen_op_shll_mem_T0_T1_cc,
496 gen_op_shrl_mem_T0_T1_cc,
497 gen_op_shll_mem_T0_T1_cc,
498 gen_op_sarl_mem_T0_T1_cc,
499 },
500};
501
502static GenOpFunc1 *gen_op_shiftd_T0_T1_im_cc[2][2] = {
503 [0] = {
504 gen_op_shldw_T0_T1_im_cc,
505 gen_op_shrdw_T0_T1_im_cc,
506 },
507 [1] = {
508 gen_op_shldl_T0_T1_im_cc,
509 gen_op_shrdl_T0_T1_im_cc,
510 },
511};
512
513static GenOpFunc *gen_op_shiftd_T0_T1_ECX_cc[2][2] = {
514 [0] = {
515 gen_op_shldw_T0_T1_ECX_cc,
516 gen_op_shrdw_T0_T1_ECX_cc,
517 },
518 [1] = {
519 gen_op_shldl_T0_T1_ECX_cc,
520 gen_op_shrdl_T0_T1_ECX_cc,
521 },
522};
523
524static GenOpFunc1 *gen_op_shiftd_mem_T0_T1_im_cc[2][2] = {
525 [0] = {
526 gen_op_shldw_mem_T0_T1_im_cc,
527 gen_op_shrdw_mem_T0_T1_im_cc,
528 },
529 [1] = {
530 gen_op_shldl_mem_T0_T1_im_cc,
531 gen_op_shrdl_mem_T0_T1_im_cc,
532 },
533};
534
535static GenOpFunc *gen_op_shiftd_mem_T0_T1_ECX_cc[2][2] = {
536 [0] = {
537 gen_op_shldw_mem_T0_T1_ECX_cc,
538 gen_op_shrdw_mem_T0_T1_ECX_cc,
539 },
540 [1] = {
541 gen_op_shldl_mem_T0_T1_ECX_cc,
542 gen_op_shrdl_mem_T0_T1_ECX_cc,
543 },
544};
545
546static GenOpFunc *gen_op_btx_T0_T1_cc[2][4] = {
547 [0] = {
548 gen_op_btw_T0_T1_cc,
549 gen_op_btsw_T0_T1_cc,
550 gen_op_btrw_T0_T1_cc,
551 gen_op_btcw_T0_T1_cc,
552 },
553 [1] = {
554 gen_op_btl_T0_T1_cc,
555 gen_op_btsl_T0_T1_cc,
556 gen_op_btrl_T0_T1_cc,
557 gen_op_btcl_T0_T1_cc,
558 },
559};
560
561static GenOpFunc *gen_op_bsx_T0_cc[2][2] = {
562 [0] = {
563 gen_op_bsfw_T0_cc,
564 gen_op_bsrw_T0_cc,
565 },
566 [1] = {
567 gen_op_bsfl_T0_cc,
568 gen_op_bsrl_T0_cc,
569 },
570};
571
572static GenOpFunc *gen_op_lds_T0_A0[3 * 3] = {
61382a50
FB		 573 gen_op_ldsb_raw_T0_A0,
574 gen_op_ldsw_raw_T0_A0,
2c0262af 575 NULL,
61382a50 576#ifndef CONFIG_USER_ONLY
2c0262af
FB		 577 gen_op_ldsb_kernel_T0_A0,
578 gen_op_ldsw_kernel_T0_A0,
579 NULL,
580
581 gen_op_ldsb_user_T0_A0,
582 gen_op_ldsw_user_T0_A0,
583 NULL,
61382a50 584#endif
2c0262af
FB		 585};
586
587static GenOpFunc *gen_op_ldu_T0_A0[3 * 3] = {
61382a50
FB		 588 gen_op_ldub_raw_T0_A0,
589 gen_op_lduw_raw_T0_A0,
2c0262af
FB		 590 NULL,
591
61382a50 592#ifndef CONFIG_USER_ONLY
2c0262af
FB		 593 gen_op_ldub_kernel_T0_A0,
594 gen_op_lduw_kernel_T0_A0,
595 NULL,
596
597 gen_op_ldub_user_T0_A0,
598 gen_op_lduw_user_T0_A0,
599 NULL,
61382a50 600#endif
2c0262af
FB		 601};
602
603/* sign does not matter, except for lidt/lgdt call (TODO: fix it) */
604static GenOpFunc *gen_op_ld_T0_A0[3 * 3] = {
61382a50
FB		 605 gen_op_ldub_raw_T0_A0,
606 gen_op_lduw_raw_T0_A0,
607 gen_op_ldl_raw_T0_A0,
2c0262af 608
61382a50 609#ifndef CONFIG_USER_ONLY
2c0262af
FB		 610 gen_op_ldub_kernel_T0_A0,
611 gen_op_lduw_kernel_T0_A0,
612 gen_op_ldl_kernel_T0_A0,
613
614 gen_op_ldub_user_T0_A0,
615 gen_op_lduw_user_T0_A0,
616 gen_op_ldl_user_T0_A0,
61382a50 617#endif
2c0262af
FB		 618};
619
620static GenOpFunc *gen_op_ld_T1_A0[3 * 3] = {
61382a50
FB		 621 gen_op_ldub_raw_T1_A0,
622 gen_op_lduw_raw_T1_A0,
623 gen_op_ldl_raw_T1_A0,
2c0262af 624
61382a50 625#ifndef CONFIG_USER_ONLY
2c0262af
FB		 626 gen_op_ldub_kernel_T1_A0,
627 gen_op_lduw_kernel_T1_A0,
628 gen_op_ldl_kernel_T1_A0,
629
630 gen_op_ldub_user_T1_A0,
631 gen_op_lduw_user_T1_A0,
632 gen_op_ldl_user_T1_A0,
61382a50 633#endif
2c0262af
FB		 634};
635
636static GenOpFunc *gen_op_st_T0_A0[3 * 3] = {
61382a50
FB		 637 gen_op_stb_raw_T0_A0,
638 gen_op_stw_raw_T0_A0,
639 gen_op_stl_raw_T0_A0,
2c0262af 640
61382a50 641#ifndef CONFIG_USER_ONLY
2c0262af
FB		 642 gen_op_stb_kernel_T0_A0,
643 gen_op_stw_kernel_T0_A0,
644 gen_op_stl_kernel_T0_A0,
645
646 gen_op_stb_user_T0_A0,
647 gen_op_stw_user_T0_A0,
648 gen_op_stl_user_T0_A0,
61382a50 649#endif
2c0262af
FB		 650};
651
652static inline void gen_string_movl_A0_ESI(DisasContext *s)
653{
654 int override;
655
656 override = s->override;
657 if (s->aflag) {
658 /* 32 bit address */
659 if (s->addseg && override < 0)
660 override = R_DS;
661 if (override >= 0) {
662 gen_op_movl_A0_seg(offsetof(CPUX86State,segs[override].base));
663 gen_op_addl_A0_reg_sN[0][R_ESI]();
664 } else {
665 gen_op_movl_A0_reg[R_ESI]();
666 }
667 } else {
668 /* 16 address, always override */
669 if (override < 0)
670 override = R_DS;
671 gen_op_movl_A0_reg[R_ESI]();
672 gen_op_andl_A0_ffff();
673 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
674 }
675}
676
677static inline void gen_string_movl_A0_EDI(DisasContext *s)
678{
679 if (s->aflag) {
680 if (s->addseg) {
681 gen_op_movl_A0_seg(offsetof(CPUX86State,segs[R_ES].base));
682 gen_op_addl_A0_reg_sN[0][R_EDI]();
683 } else {
684 gen_op_movl_A0_reg[R_EDI]();
685 }
686 } else {
687 gen_op_movl_A0_reg[R_EDI]();
688 gen_op_andl_A0_ffff();
689 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_ES].base));
690 }
691}
692
693static GenOpFunc *gen_op_movl_T0_Dshift[3] = {
694 gen_op_movl_T0_Dshiftb,
695 gen_op_movl_T0_Dshiftw,
696 gen_op_movl_T0_Dshiftl,
697};
698
699static GenOpFunc2 *gen_op_jz_ecx[2] = {
700 gen_op_jz_ecxw,
701 gen_op_jz_ecxl,
702};
703
704static GenOpFunc1 *gen_op_jz_ecx_im[2] = {
705 gen_op_jz_ecxw_im,
706 gen_op_jz_ecxl_im,
707};
708
709static GenOpFunc *gen_op_dec_ECX[2] = {
710 gen_op_decw_ECX,
711 gen_op_decl_ECX,
712};
713
714static GenOpFunc1 *gen_op_string_jnz_sub[2][3] = {
715 {
716 gen_op_string_jnz_subb,
717 gen_op_string_jnz_subw,
718 gen_op_string_jnz_subl,
719 },
720 {
721 gen_op_string_jz_subb,
722 gen_op_string_jz_subw,
723 gen_op_string_jz_subl,
724 },
725};
726
727static GenOpFunc1 *gen_op_string_jnz_sub_im[2][3] = {
728 {
729 gen_op_string_jnz_subb_im,
730 gen_op_string_jnz_subw_im,
731 gen_op_string_jnz_subl_im,
732 },
733 {
734 gen_op_string_jz_subb_im,
735 gen_op_string_jz_subw_im,
736 gen_op_string_jz_subl_im,
737 },
738};
739
740static GenOpFunc *gen_op_in_DX_T0[3] = {
741 gen_op_inb_DX_T0,
742 gen_op_inw_DX_T0,
743 gen_op_inl_DX_T0,
744};
745
746static GenOpFunc *gen_op_out_DX_T0[3] = {
747 gen_op_outb_DX_T0,
748 gen_op_outw_DX_T0,
749 gen_op_outl_DX_T0,
750};
751
f115e911
FB		 752static GenOpFunc *gen_op_in[3] = {
753 gen_op_inb_T0_T1,
754 gen_op_inw_T0_T1,
755 gen_op_inl_T0_T1,
756};
757
758static GenOpFunc *gen_op_out[3] = {
759 gen_op_outb_T0_T1,
760 gen_op_outw_T0_T1,
761 gen_op_outl_T0_T1,
762};
763
764static GenOpFunc *gen_check_io_T0[3] = {
765 gen_op_check_iob_T0,
766 gen_op_check_iow_T0,
767 gen_op_check_iol_T0,
768};
769
770static GenOpFunc *gen_check_io_DX[3] = {
771 gen_op_check_iob_DX,
772 gen_op_check_iow_DX,
773 gen_op_check_iol_DX,
774};
775
776static void gen_check_io(DisasContext *s, int ot, int use_dx, int cur_eip)
777{
778 if (s->pe && (s->cpl > s->iopl || s->vm86)) {
779 if (s->cc_op != CC_OP_DYNAMIC)
780 gen_op_set_cc_op(s->cc_op);
781 gen_op_jmp_im(cur_eip);
782 if (use_dx)
783 gen_check_io_DX[ot]();
784 else
785 gen_check_io_T0[ot]();
786 }
787}
788
2c0262af
FB		 789static inline void gen_movs(DisasContext *s, int ot)
790{
791 gen_string_movl_A0_ESI(s);
792 gen_op_ld_T0_A0[ot + s->mem_index]();
793 gen_string_movl_A0_EDI(s);
794 gen_op_st_T0_A0[ot + s->mem_index]();
795 gen_op_movl_T0_Dshift[ot]();
796 if (s->aflag) {
797 gen_op_addl_ESI_T0();
798 gen_op_addl_EDI_T0();
799 } else {
800 gen_op_addw_ESI_T0();
801 gen_op_addw_EDI_T0();
802 }
803}
804
805static inline void gen_update_cc_op(DisasContext *s)
806{
807 if (s->cc_op != CC_OP_DYNAMIC) {
808 gen_op_set_cc_op(s->cc_op);
809 s->cc_op = CC_OP_DYNAMIC;
810 }
811}
812
813static inline void gen_jz_ecx_string(DisasContext *s, unsigned int next_eip)
814{
815 if (s->jmp_opt) {
816 gen_op_jz_ecx[s->aflag]((long)s->tb, next_eip);
817 } else {
818 /* XXX: does not work with gdbstub "ice" single step - not a
819 serious problem */
820 gen_op_jz_ecx_im[s->aflag](next_eip);
821 }
822}
823
824static inline void gen_stos(DisasContext *s, int ot)
825{
826 gen_op_mov_TN_reg[OT_LONG][0][R_EAX]();
827 gen_string_movl_A0_EDI(s);
828 gen_op_st_T0_A0[ot + s->mem_index]();
829 gen_op_movl_T0_Dshift[ot]();
830 if (s->aflag) {
831 gen_op_addl_EDI_T0();
832 } else {
833 gen_op_addw_EDI_T0();
834 }
835}
836
837static inline void gen_lods(DisasContext *s, int ot)
838{
839 gen_string_movl_A0_ESI(s);
840 gen_op_ld_T0_A0[ot + s->mem_index]();
841 gen_op_mov_reg_T0[ot][R_EAX]();
842 gen_op_movl_T0_Dshift[ot]();
843 if (s->aflag) {
844 gen_op_addl_ESI_T0();
845 } else {
846 gen_op_addw_ESI_T0();
847 }
848}
849
850static inline void gen_scas(DisasContext *s, int ot)
851{
852 gen_op_mov_TN_reg[OT_LONG][0][R_EAX]();
853 gen_string_movl_A0_EDI(s);
854 gen_op_ld_T1_A0[ot + s->mem_index]();
855 gen_op_cmpl_T0_T1_cc();
856 gen_op_movl_T0_Dshift[ot]();
857 if (s->aflag) {
858 gen_op_addl_EDI_T0();
859 } else {
860 gen_op_addw_EDI_T0();
861 }
862}
863
864static inline void gen_cmps(DisasContext *s, int ot)
865{
866 gen_string_movl_A0_ESI(s);
867 gen_op_ld_T0_A0[ot + s->mem_index]();
868 gen_string_movl_A0_EDI(s);
869 gen_op_ld_T1_A0[ot + s->mem_index]();
870 gen_op_cmpl_T0_T1_cc();
871 gen_op_movl_T0_Dshift[ot]();
872 if (s->aflag) {
873 gen_op_addl_ESI_T0();
874 gen_op_addl_EDI_T0();
875 } else {
876 gen_op_addw_ESI_T0();
877 gen_op_addw_EDI_T0();
878 }
879}
880
881static inline void gen_ins(DisasContext *s, int ot)
882{
883 gen_op_in_DX_T0[ot]();
884 gen_string_movl_A0_EDI(s);
885 gen_op_st_T0_A0[ot + s->mem_index]();
886 gen_op_movl_T0_Dshift[ot]();
887 if (s->aflag) {
888 gen_op_addl_EDI_T0();
889 } else {
890 gen_op_addw_EDI_T0();
891 }
892}
893
894static inline void gen_outs(DisasContext *s, int ot)
895{
896 gen_string_movl_A0_ESI(s);
897 gen_op_ld_T0_A0[ot + s->mem_index]();
898 gen_op_out_DX_T0[ot]();
899 gen_op_movl_T0_Dshift[ot]();
900 if (s->aflag) {
901 gen_op_addl_ESI_T0();
902 } else {
903 gen_op_addw_ESI_T0();
904 }
905}
906
907/* same method as Valgrind : we generate jumps to current or next
908 instruction */
909#define GEN_REPZ(op) \
910static inline void gen_repz_ ## op(DisasContext *s, int ot, \
911 unsigned int cur_eip, unsigned int next_eip) \
912{ \
913 gen_update_cc_op(s); \
914 gen_jz_ecx_string(s, next_eip); \
915 gen_ ## op(s, ot); \
916 gen_op_dec_ECX[s->aflag](); \
917 /* a loop would cause two single step exceptions if ECX = 1 \
918 before rep string_insn */ \
919 if (!s->jmp_opt) \
920 gen_op_jz_ecx_im[s->aflag](next_eip); \
921 gen_jmp(s, cur_eip); \
922}
923
924#define GEN_REPZ2(op) \
925static inline void gen_repz_ ## op(DisasContext *s, int ot, \
926 unsigned int cur_eip, \
927 unsigned int next_eip, \
928 int nz) \
929{ \
930 gen_update_cc_op(s); \
931 gen_jz_ecx_string(s, next_eip); \
932 gen_ ## op(s, ot); \
933 gen_op_dec_ECX[s->aflag](); \
934 gen_op_set_cc_op(CC_OP_SUBB + ot); \
935 if (!s->jmp_opt) \
936 gen_op_string_jnz_sub_im[nz][ot](next_eip); \
937 else \
938 gen_op_string_jnz_sub[nz][ot]((long)s->tb); \
939 if (!s->jmp_opt) \
940 gen_op_jz_ecx_im[s->aflag](next_eip); \
941 gen_jmp(s, cur_eip); \
942}
943
944GEN_REPZ(movs)
945GEN_REPZ(stos)
946GEN_REPZ(lods)
947GEN_REPZ(ins)
948GEN_REPZ(outs)
949GEN_REPZ2(scas)
950GEN_REPZ2(cmps)
951
2c0262af
FB		 952enum {
953 JCC_O,
954 JCC_B,
955 JCC_Z,
956 JCC_BE,
957 JCC_S,
958 JCC_P,
959 JCC_L,
960 JCC_LE,
961};
962
963static GenOpFunc3 *gen_jcc_sub[3][8] = {
964 [OT_BYTE] = {
965 NULL,
966 gen_op_jb_subb,
967 gen_op_jz_subb,
968 gen_op_jbe_subb,
969 gen_op_js_subb,
970 NULL,
971 gen_op_jl_subb,
972 gen_op_jle_subb,
973 },
974 [OT_WORD] = {
975 NULL,
976 gen_op_jb_subw,
977 gen_op_jz_subw,
978 gen_op_jbe_subw,
979 gen_op_js_subw,
980 NULL,
981 gen_op_jl_subw,
982 gen_op_jle_subw,
983 },
984 [OT_LONG] = {
985 NULL,
986 gen_op_jb_subl,
987 gen_op_jz_subl,
988 gen_op_jbe_subl,
989 gen_op_js_subl,
990 NULL,
991 gen_op_jl_subl,
992 gen_op_jle_subl,
993 },
994};
995static GenOpFunc2 *gen_op_loop[2][4] = {
996 [0] = {
997 gen_op_loopnzw,
998 gen_op_loopzw,
999 gen_op_loopw,
1000 gen_op_jecxzw,
1001 },
1002 [1] = {
1003 gen_op_loopnzl,
1004 gen_op_loopzl,
1005 gen_op_loopl,
1006 gen_op_jecxzl,
1007 },
1008};
1009
1010static GenOpFunc *gen_setcc_slow[8] = {
1011 gen_op_seto_T0_cc,
1012 gen_op_setb_T0_cc,
1013 gen_op_setz_T0_cc,
1014 gen_op_setbe_T0_cc,
1015 gen_op_sets_T0_cc,
1016 gen_op_setp_T0_cc,
1017 gen_op_setl_T0_cc,
1018 gen_op_setle_T0_cc,
1019};
1020
1021static GenOpFunc *gen_setcc_sub[3][8] = {
1022 [OT_BYTE] = {
1023 NULL,
1024 gen_op_setb_T0_subb,
1025 gen_op_setz_T0_subb,
1026 gen_op_setbe_T0_subb,
1027 gen_op_sets_T0_subb,
1028 NULL,
1029 gen_op_setl_T0_subb,
1030 gen_op_setle_T0_subb,
1031 },
1032 [OT_WORD] = {
1033 NULL,
1034 gen_op_setb_T0_subw,
1035 gen_op_setz_T0_subw,
1036 gen_op_setbe_T0_subw,
1037 gen_op_sets_T0_subw,
1038 NULL,
1039 gen_op_setl_T0_subw,
1040 gen_op_setle_T0_subw,
1041 },
1042 [OT_LONG] = {
1043 NULL,
1044 gen_op_setb_T0_subl,
1045 gen_op_setz_T0_subl,
1046 gen_op_setbe_T0_subl,
1047 gen_op_sets_T0_subl,
1048 NULL,
1049 gen_op_setl_T0_subl,
1050 gen_op_setle_T0_subl,
1051 },
1052};
1053
1054static GenOpFunc *gen_op_fp_arith_ST0_FT0[8] = {
1055 gen_op_fadd_ST0_FT0,
1056 gen_op_fmul_ST0_FT0,
1057 gen_op_fcom_ST0_FT0,
1058 gen_op_fcom_ST0_FT0,
1059 gen_op_fsub_ST0_FT0,
1060 gen_op_fsubr_ST0_FT0,
1061 gen_op_fdiv_ST0_FT0,
1062 gen_op_fdivr_ST0_FT0,
1063};
1064
1065/* NOTE the exception in "r" op ordering */
1066static GenOpFunc1 *gen_op_fp_arith_STN_ST0[8] = {
1067 gen_op_fadd_STN_ST0,
1068 gen_op_fmul_STN_ST0,
1069 NULL,
1070 NULL,
1071 gen_op_fsubr_STN_ST0,
1072 gen_op_fsub_STN_ST0,
1073 gen_op_fdivr_STN_ST0,
1074 gen_op_fdiv_STN_ST0,
1075};
1076
1077/* if d == OR_TMP0, it means memory operand (address in A0) */
1078static void gen_op(DisasContext *s1, int op, int ot, int d)
1079{
1080 GenOpFunc *gen_update_cc;
1081
1082 if (d != OR_TMP0) {
1083 gen_op_mov_TN_reg[ot][0][d]();
1084 } else {
1085 gen_op_ld_T0_A0[ot + s1->mem_index]();
1086 }
1087 switch(op) {
1088 case OP_ADCL:
1089 case OP_SBBL:
1090 if (s1->cc_op != CC_OP_DYNAMIC)
1091 gen_op_set_cc_op(s1->cc_op);
1092 if (d != OR_TMP0) {
1093 gen_op_arithc_T0_T1_cc[ot][op - OP_ADCL]();
1094 gen_op_mov_reg_T0[ot][d]();
1095 } else {
1096 gen_op_arithc_mem_T0_T1_cc[ot][op - OP_ADCL]();
1097 }
1098 s1->cc_op = CC_OP_DYNAMIC;
1099 goto the_end;
1100 case OP_ADDL:
1101 gen_op_addl_T0_T1();
1102 s1->cc_op = CC_OP_ADDB + ot;
1103 gen_update_cc = gen_op_update2_cc;
1104 break;
1105 case OP_SUBL:
1106 gen_op_subl_T0_T1();
1107 s1->cc_op = CC_OP_SUBB + ot;
1108 gen_update_cc = gen_op_update2_cc;
1109 break;
1110 default:
1111 case OP_ANDL:
1112 case OP_ORL:
1113 case OP_XORL:
1114 gen_op_arith_T0_T1_cc[op]();
1115 s1->cc_op = CC_OP_LOGICB + ot;
1116 gen_update_cc = gen_op_update1_cc;
1117 break;
1118 case OP_CMPL:
1119 gen_op_cmpl_T0_T1_cc();
1120 s1->cc_op = CC_OP_SUBB + ot;
1121 gen_update_cc = NULL;
1122 break;
1123 }
1124 if (op != OP_CMPL) {
1125 if (d != OR_TMP0)
1126 gen_op_mov_reg_T0[ot][d]();
1127 else
1128 gen_op_st_T0_A0[ot + s1->mem_index]();
1129 }
1130 /* the flags update must happen after the memory write (precise
1131 exception support) */
1132 if (gen_update_cc)
1133 gen_update_cc();
1134 the_end: ;
1135}
1136
1137/* if d == OR_TMP0, it means memory operand (address in A0) */
1138static void gen_inc(DisasContext *s1, int ot, int d, int c)
1139{
1140 if (d != OR_TMP0)
1141 gen_op_mov_TN_reg[ot][0][d]();
1142 else
1143 gen_op_ld_T0_A0[ot + s1->mem_index]();
1144 if (s1->cc_op != CC_OP_DYNAMIC)
1145 gen_op_set_cc_op(s1->cc_op);
1146 if (c > 0) {
1147 gen_op_incl_T0();
1148 s1->cc_op = CC_OP_INCB + ot;
1149 } else {
1150 gen_op_decl_T0();
1151 s1->cc_op = CC_OP_DECB + ot;
1152 }
1153 if (d != OR_TMP0)
1154 gen_op_mov_reg_T0[ot][d]();
1155 else
1156 gen_op_st_T0_A0[ot + s1->mem_index]();
1157 gen_op_update_inc_cc();
1158}
1159
1160static void gen_shift(DisasContext *s1, int op, int ot, int d, int s)
1161{
1162 if (d != OR_TMP0)
1163 gen_op_mov_TN_reg[ot][0][d]();
1164 else
1165 gen_op_ld_T0_A0[ot + s1->mem_index]();
1166 if (s != OR_TMP1)
1167 gen_op_mov_TN_reg[ot][1][s]();
1168 /* for zero counts, flags are not updated, so must do it dynamically */
1169 if (s1->cc_op != CC_OP_DYNAMIC)
1170 gen_op_set_cc_op(s1->cc_op);
1171
1172 if (d != OR_TMP0)
1173 gen_op_shift_T0_T1_cc[ot][op]();
1174 else
1175 gen_op_shift_mem_T0_T1_cc[ot][op]();
1176 if (d != OR_TMP0)
1177 gen_op_mov_reg_T0[ot][d]();
1178 s1->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
1179}
1180
1181static void gen_shifti(DisasContext *s1, int op, int ot, int d, int c)
1182{
1183 /* currently not optimized */
1184 gen_op_movl_T1_im(c);
1185 gen_shift(s1, op, ot, d, OR_TMP1);
1186}
1187
1188static void gen_lea_modrm(DisasContext *s, int modrm, int *reg_ptr, int *offset_ptr)
1189{
1190 int havesib;
1191 int base, disp;
1192 int index;
1193 int scale;
1194 int opreg;
1195 int mod, rm, code, override, must_add_seg;
1196
1197 override = s->override;
1198 must_add_seg = s->addseg;
1199 if (override >= 0)
1200 must_add_seg = 1;
1201 mod = (modrm >> 6) & 3;
1202 rm = modrm & 7;
1203
1204 if (s->aflag) {
1205
1206 havesib = 0;
1207 base = rm;
1208 index = 0;
1209 scale = 0;
1210
1211 if (base == 4) {
1212 havesib = 1;
61382a50 1213 code = ldub_code(s->pc++);
2c0262af
FB		 1214 scale = (code >> 6) & 3;
1215 index = (code >> 3) & 7;
1216 base = code & 7;
1217 }
1218
1219 switch (mod) {
1220 case 0:
1221 if (base == 5) {
1222 base = -1;
61382a50 1223 disp = ldl_code(s->pc);
2c0262af
FB		 1224 s->pc += 4;
1225 } else {
1226 disp = 0;
1227 }
1228 break;
1229 case 1:
61382a50 1230 disp = (int8_t)ldub_code(s->pc++);
2c0262af
FB		 1231 break;
1232 default:
1233 case 2:
61382a50 1234 disp = ldl_code(s->pc);
2c0262af
FB		 1235 s->pc += 4;
1236 break;
1237 }
1238
1239 if (base >= 0) {
1240 /* for correct popl handling with esp */
1241 if (base == 4 && s->popl_esp_hack)
1242 disp += s->popl_esp_hack;
1243 gen_op_movl_A0_reg[base]();
1244 if (disp != 0)
1245 gen_op_addl_A0_im(disp);
1246 } else {
1247 gen_op_movl_A0_im(disp);
1248 }
1249 /* XXX: index == 4 is always invalid */
1250 if (havesib && (index != 4 || scale != 0)) {
1251 gen_op_addl_A0_reg_sN[scale][index]();
1252 }
1253 if (must_add_seg) {
1254 if (override < 0) {
1255 if (base == R_EBP || base == R_ESP)
1256 override = R_SS;
1257 else
1258 override = R_DS;
1259 }
1260 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
1261 }
1262 } else {
1263 switch (mod) {
1264 case 0:
1265 if (rm == 6) {
61382a50 1266 disp = lduw_code(s->pc);
2c0262af
FB		 1267 s->pc += 2;
1268 gen_op_movl_A0_im(disp);
1269 rm = 0; /* avoid SS override */
1270 goto no_rm;
1271 } else {
1272 disp = 0;
1273 }
1274 break;
1275 case 1:
61382a50 1276 disp = (int8_t)ldub_code(s->pc++);
2c0262af
FB		 1277 break;
1278 default:
1279 case 2:
61382a50 1280 disp = lduw_code(s->pc);
2c0262af
FB		 1281 s->pc += 2;
1282 break;
1283 }
1284 switch(rm) {
1285 case 0:
1286 gen_op_movl_A0_reg[R_EBX]();
1287 gen_op_addl_A0_reg_sN[0][R_ESI]();
1288 break;
1289 case 1:
1290 gen_op_movl_A0_reg[R_EBX]();
1291 gen_op_addl_A0_reg_sN[0][R_EDI]();
1292 break;
1293 case 2:
1294 gen_op_movl_A0_reg[R_EBP]();
1295 gen_op_addl_A0_reg_sN[0][R_ESI]();
1296 break;
1297 case 3:
1298 gen_op_movl_A0_reg[R_EBP]();
1299 gen_op_addl_A0_reg_sN[0][R_EDI]();
1300 break;
1301 case 4:
1302 gen_op_movl_A0_reg[R_ESI]();
1303 break;
1304 case 5:
1305 gen_op_movl_A0_reg[R_EDI]();
1306 break;
1307 case 6:
1308 gen_op_movl_A0_reg[R_EBP]();
1309 break;
1310 default:
1311 case 7:
1312 gen_op_movl_A0_reg[R_EBX]();
1313 break;
1314 }
1315 if (disp != 0)
1316 gen_op_addl_A0_im(disp);
1317 gen_op_andl_A0_ffff();
1318 no_rm:
1319 if (must_add_seg) {
1320 if (override < 0) {
1321 if (rm == 2 || rm == 3 || rm == 6)
1322 override = R_SS;
1323 else
1324 override = R_DS;
1325 }
1326 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
1327 }
1328 }
1329
1330 opreg = OR_A0;
1331 disp = 0;
1332 *reg_ptr = opreg;
1333 *offset_ptr = disp;
1334}
1335
1336/* generate modrm memory load or store of 'reg'. TMP0 is used if reg !=
1337 OR_TMP0 */
1338static void gen_ldst_modrm(DisasContext *s, int modrm, int ot, int reg, int is_store)
1339{
1340 int mod, rm, opreg, disp;
1341
1342 mod = (modrm >> 6) & 3;
1343 rm = modrm & 7;
1344 if (mod == 3) {
1345 if (is_store) {
1346 if (reg != OR_TMP0)
1347 gen_op_mov_TN_reg[ot][0][reg]();
1348 gen_op_mov_reg_T0[ot][rm]();
1349 } else {
1350 gen_op_mov_TN_reg[ot][0][rm]();
1351 if (reg != OR_TMP0)
1352 gen_op_mov_reg_T0[ot][reg]();
1353 }
1354 } else {
1355 gen_lea_modrm(s, modrm, &opreg, &disp);
1356 if (is_store) {
1357 if (reg != OR_TMP0)
1358 gen_op_mov_TN_reg[ot][0][reg]();
1359 gen_op_st_T0_A0[ot + s->mem_index]();
1360 } else {
1361 gen_op_ld_T0_A0[ot + s->mem_index]();
1362 if (reg != OR_TMP0)
1363 gen_op_mov_reg_T0[ot][reg]();
1364 }
1365 }
1366}
1367
1368static inline uint32_t insn_get(DisasContext *s, int ot)
1369{
1370 uint32_t ret;
1371
1372 switch(ot) {
1373 case OT_BYTE:
61382a50 1374 ret = ldub_code(s->pc);
2c0262af
FB		 1375 s->pc++;
1376 break;
1377 case OT_WORD:
61382a50 1378 ret = lduw_code(s->pc);
2c0262af
FB		 1379 s->pc += 2;
1380 break;
1381 default:
1382 case OT_LONG:
61382a50 1383 ret = ldl_code(s->pc);
2c0262af
FB		 1384 s->pc += 4;
1385 break;
1386 }
1387 return ret;
1388}
1389
1390static inline void gen_jcc(DisasContext *s, int b, int val, int next_eip)
1391{
1392 TranslationBlock *tb;
1393 int inv, jcc_op;
1394 GenOpFunc3 *func;
1395
1396 inv = b & 1;
1397 jcc_op = (b >> 1) & 7;
1398
1399 if (s->jmp_opt) {
1400 switch(s->cc_op) {
1401 /* we optimize the cmp/jcc case */
1402 case CC_OP_SUBB:
1403 case CC_OP_SUBW:
1404 case CC_OP_SUBL:
1405 func = gen_jcc_sub[s->cc_op - CC_OP_SUBB][jcc_op];
1406 break;
1407
1408 /* some jumps are easy to compute */
1409 case CC_OP_ADDB:
1410 case CC_OP_ADDW:
1411 case CC_OP_ADDL:
1412 case CC_OP_ADCB:
1413 case CC_OP_ADCW:
1414 case CC_OP_ADCL:
1415 case CC_OP_SBBB:
1416 case CC_OP_SBBW:
1417 case CC_OP_SBBL:
1418 case CC_OP_LOGICB:
1419 case CC_OP_LOGICW:
1420 case CC_OP_LOGICL:
1421 case CC_OP_INCB:
1422 case CC_OP_INCW:
1423 case CC_OP_INCL:
1424 case CC_OP_DECB:
1425 case CC_OP_DECW:
1426 case CC_OP_DECL:
1427 case CC_OP_SHLB:
1428 case CC_OP_SHLW:
1429 case CC_OP_SHLL:
1430 case CC_OP_SARB:
1431 case CC_OP_SARW:
1432 case CC_OP_SARL:
1433 switch(jcc_op) {
1434 case JCC_Z:
1435 func = gen_jcc_sub[(s->cc_op - CC_OP_ADDB) % 3][jcc_op];
1436 break;
1437 case JCC_S:
1438 func = gen_jcc_sub[(s->cc_op - CC_OP_ADDB) % 3][jcc_op];
1439 break;
1440 default:
1441 func = NULL;
1442 break;
1443 }
1444 break;
1445 default:
1446 func = NULL;
1447 break;
1448 }
1449
1450 if (s->cc_op != CC_OP_DYNAMIC)
1451 gen_op_set_cc_op(s->cc_op);
1452
1453 if (!func) {
1454 gen_setcc_slow[jcc_op]();
1455 func = gen_op_jcc;
1456 }
1457
1458 tb = s->tb;
1459 if (!inv) {
1460 func((long)tb, val, next_eip);
1461 } else {
1462 func((long)tb, next_eip, val);
1463 }
1464 s->is_jmp = 3;
1465 } else {
1466 if (s->cc_op != CC_OP_DYNAMIC) {
1467 gen_op_set_cc_op(s->cc_op);
1468 s->cc_op = CC_OP_DYNAMIC;
1469 }
1470 gen_setcc_slow[jcc_op]();
1471 if (!inv) {
1472 gen_op_jcc_im(val, next_eip);
1473 } else {
1474 gen_op_jcc_im(next_eip, val);
1475 }
1476 gen_eob(s);
1477 }
1478}
1479
1480static void gen_setcc(DisasContext *s, int b)
1481{
1482 int inv, jcc_op;
1483 GenOpFunc *func;
1484
1485 inv = b & 1;
1486 jcc_op = (b >> 1) & 7;
1487 switch(s->cc_op) {
1488 /* we optimize the cmp/jcc case */
1489 case CC_OP_SUBB:
1490 case CC_OP_SUBW:
1491 case CC_OP_SUBL:
1492 func = gen_setcc_sub[s->cc_op - CC_OP_SUBB][jcc_op];
1493 if (!func)
1494 goto slow_jcc;
1495 break;
1496
1497 /* some jumps are easy to compute */
1498 case CC_OP_ADDB:
1499 case CC_OP_ADDW:
1500 case CC_OP_ADDL:
1501 case CC_OP_LOGICB:
1502 case CC_OP_LOGICW:
1503 case CC_OP_LOGICL:
1504 case CC_OP_INCB:
1505 case CC_OP_INCW:
1506 case CC_OP_INCL:
1507 case CC_OP_DECB:
1508 case CC_OP_DECW:
1509 case CC_OP_DECL:
1510 case CC_OP_SHLB:
1511 case CC_OP_SHLW:
1512 case CC_OP_SHLL:
1513 switch(jcc_op) {
1514 case JCC_Z:
1515 func = gen_setcc_sub[(s->cc_op - CC_OP_ADDB) % 3][jcc_op];
1516 break;
1517 case JCC_S:
1518 func = gen_setcc_sub[(s->cc_op - CC_OP_ADDB) % 3][jcc_op];
1519 break;
1520 default:
1521 goto slow_jcc;
1522 }
1523 break;
1524 default:
1525 slow_jcc:
1526 if (s->cc_op != CC_OP_DYNAMIC)
1527 gen_op_set_cc_op(s->cc_op);
1528 func = gen_setcc_slow[jcc_op];
1529 break;
1530 }
1531 func();
1532 if (inv) {
1533 gen_op_xor_T0_1();
1534 }
1535}
1536
1537/* move T0 to seg_reg and compute if the CPU state may change. Never
1538 call this function with seg_reg == R_CS */
1539static void gen_movl_seg_T0(DisasContext *s, int seg_reg, unsigned int cur_eip)
1540{
1541 if (s->pe && !s->vm86)
1542 gen_op_movl_seg_T0(seg_reg, cur_eip);
1543 else
1544 gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[seg_reg]));
1545 /* abort translation because the register may have a non zero base
1546 or because ss32 may change. For R_SS, translation must always
1547 stop as a special handling must be done to disable hardware
1548 interrupts for the next instruction */
1549 if (seg_reg == R_SS || (!s->addseg && seg_reg < R_FS))
1550 s->is_jmp = 3;
1551}
1552
1553/* generate a push. It depends on ss32, addseg and dflag */
1554static void gen_push_T0(DisasContext *s)
1555{
1556 if (s->ss32) {
1557 if (!s->addseg) {
1558 if (s->dflag)
1559 gen_op_pushl_T0();
1560 else
1561 gen_op_pushw_T0();
1562 } else {
1563 if (s->dflag)
1564 gen_op_pushl_ss32_T0();
1565 else
1566 gen_op_pushw_ss32_T0();
1567 }
1568 } else {
1569 if (s->dflag)
1570 gen_op_pushl_ss16_T0();
1571 else
1572 gen_op_pushw_ss16_T0();
1573 }
1574}
1575
1576/* two step pop is necessary for precise exceptions */
1577static void gen_pop_T0(DisasContext *s)
1578{
1579 if (s->ss32) {
1580 if (!s->addseg) {
1581 if (s->dflag)
1582 gen_op_popl_T0();
1583 else
1584 gen_op_popw_T0();
1585 } else {
1586 if (s->dflag)
1587 gen_op_popl_ss32_T0();
1588 else
1589 gen_op_popw_ss32_T0();
1590 }
1591 } else {
1592 if (s->dflag)
1593 gen_op_popl_ss16_T0();
1594 else
1595 gen_op_popw_ss16_T0();
1596 }
1597}
1598
1599static inline void gen_stack_update(DisasContext *s, int addend)
1600{
1601 if (s->ss32) {
1602 if (addend == 2)
1603 gen_op_addl_ESP_2();
1604 else if (addend == 4)
1605 gen_op_addl_ESP_4();
1606 else
1607 gen_op_addl_ESP_im(addend);
1608 } else {
1609 if (addend == 2)
1610 gen_op_addw_ESP_2();
1611 else if (addend == 4)
1612 gen_op_addw_ESP_4();
1613 else
1614 gen_op_addw_ESP_im(addend);
1615 }
1616}
1617
1618static void gen_pop_update(DisasContext *s)
1619{
1620 gen_stack_update(s, 2 << s->dflag);
1621}
1622
1623static void gen_stack_A0(DisasContext *s)
1624{
1625 gen_op_movl_A0_ESP();
1626 if (!s->ss32)
1627 gen_op_andl_A0_ffff();
1628 gen_op_movl_T1_A0();
1629 if (s->addseg)
1630 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_SS].base));
1631}
1632
1633/* NOTE: wrap around in 16 bit not fully handled */
1634static void gen_pusha(DisasContext *s)
1635{
1636 int i;
1637 gen_op_movl_A0_ESP();
1638 gen_op_addl_A0_im(-16 << s->dflag);
1639 if (!s->ss32)
1640 gen_op_andl_A0_ffff();
1641 gen_op_movl_T1_A0();
1642 if (s->addseg)
1643 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_SS].base));
1644 for(i = 0;i < 8; i++) {
1645 gen_op_mov_TN_reg[OT_LONG][0][7 - i]();
1646 gen_op_st_T0_A0[OT_WORD + s->dflag + s->mem_index]();
1647 gen_op_addl_A0_im(2 << s->dflag);
1648 }
1649 gen_op_mov_reg_T1[OT_WORD + s->dflag][R_ESP]();
1650}
1651
1652/* NOTE: wrap around in 16 bit not fully handled */
1653static void gen_popa(DisasContext *s)
1654{
1655 int i;
1656 gen_op_movl_A0_ESP();
1657 if (!s->ss32)
1658 gen_op_andl_A0_ffff();
1659 gen_op_movl_T1_A0();
1660 gen_op_addl_T1_im(16 << s->dflag);
1661 if (s->addseg)
1662 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_SS].base));
1663 for(i = 0;i < 8; i++) {
1664 /* ESP is not reloaded */
1665 if (i != 3) {
1666 gen_op_ld_T0_A0[OT_WORD + s->dflag + s->mem_index]();
1667 gen_op_mov_reg_T0[OT_WORD + s->dflag][7 - i]();
1668 }
1669 gen_op_addl_A0_im(2 << s->dflag);
1670 }
1671 gen_op_mov_reg_T1[OT_WORD + s->dflag][R_ESP]();
1672}
1673
1674/* NOTE: wrap around in 16 bit not fully handled */
1675/* XXX: check this */
1676static void gen_enter(DisasContext *s, int esp_addend, int level)
1677{
1678 int ot, level1, addend, opsize;
1679
1680 ot = s->dflag + OT_WORD;
1681 level &= 0x1f;
1682 level1 = level;
1683 opsize = 2 << s->dflag;
1684
1685 gen_op_movl_A0_ESP();
1686 gen_op_addl_A0_im(-opsize);
1687 if (!s->ss32)
1688 gen_op_andl_A0_ffff();
1689 gen_op_movl_T1_A0();
1690 if (s->addseg)
1691 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[R_SS].base));
1692 /* push bp */
1693 gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
1694 gen_op_st_T0_A0[ot + s->mem_index]();
1695 if (level) {
1696 while (level--) {
1697 gen_op_addl_A0_im(-opsize);
1698 gen_op_addl_T0_im(-opsize);
1699 gen_op_st_T0_A0[ot + s->mem_index]();
1700 }
1701 gen_op_addl_A0_im(-opsize);
1702 /* XXX: add st_T1_A0 ? */
1703 gen_op_movl_T0_T1();
1704 gen_op_st_T0_A0[ot + s->mem_index]();
1705 }
1706 gen_op_mov_reg_T1[ot][R_EBP]();
1707 addend = -esp_addend;
1708 if (level1)
1709 addend -= opsize * (level1 + 1);
1710 gen_op_addl_T1_im(addend);
1711 gen_op_mov_reg_T1[ot][R_ESP]();
1712}
1713
1714static void gen_exception(DisasContext *s, int trapno, unsigned int cur_eip)
1715{
1716 if (s->cc_op != CC_OP_DYNAMIC)
1717 gen_op_set_cc_op(s->cc_op);
1718 gen_op_jmp_im(cur_eip);
1719 gen_op_raise_exception(trapno);
1720 s->is_jmp = 3;
1721}
1722
1723/* an interrupt is different from an exception because of the
1724 priviledge checks */
1725static void gen_interrupt(DisasContext *s, int intno,
1726 unsigned int cur_eip, unsigned int next_eip)
1727{
1728 if (s->cc_op != CC_OP_DYNAMIC)
1729 gen_op_set_cc_op(s->cc_op);
1730 gen_op_jmp_im(cur_eip);
1731 gen_op_raise_interrupt(intno, next_eip);
1732 s->is_jmp = 3;
1733}
1734
1735static void gen_debug(DisasContext *s, unsigned int cur_eip)
1736{
1737 if (s->cc_op != CC_OP_DYNAMIC)
1738 gen_op_set_cc_op(s->cc_op);
1739 gen_op_jmp_im(cur_eip);
1740 gen_op_debug();
1741 s->is_jmp = 3;
1742}
1743
1744/* generate a generic end of block. Trace exception is also generated
1745 if needed */
1746static void gen_eob(DisasContext *s)
1747{
1748 if (s->cc_op != CC_OP_DYNAMIC)
1749 gen_op_set_cc_op(s->cc_op);
34865134
FB		 1750 if (s->singlestep_enabled) {
1751 gen_op_debug();
1752 } else if (s->tf) {
2c0262af
FB		 1753 gen_op_raise_exception(EXCP01_SSTP);
1754 } else {
1755 gen_op_movl_T0_0();
1756 gen_op_exit_tb();
1757 }
1758 s->is_jmp = 3;
1759}
1760
1761/* generate a jump to eip. No segment change must happen before as a
1762 direct call to the next block may occur */
1763static void gen_jmp(DisasContext *s, unsigned int eip)
1764{
1765 TranslationBlock *tb = s->tb;
1766
1767 if (s->jmp_opt) {
1768 if (s->cc_op != CC_OP_DYNAMIC)
1769 gen_op_set_cc_op(s->cc_op);
1770 gen_op_jmp((long)tb, eip);
1771 s->is_jmp = 3;
1772 } else {
1773 gen_op_jmp_im(eip);
1774 gen_eob(s);
1775 }
1776}
1777
1778/* convert one instruction. s->is_jmp is set if the translation must
1779 be stopped. Return the next pc value */
1780static uint8_t *disas_insn(DisasContext *s, uint8_t *pc_start)
1781{
1782 int b, prefixes, aflag, dflag;
1783 int shift, ot;
1784 int modrm, reg, rm, mod, reg_addr, op, opreg, offset_addr, val;
1785 unsigned int next_eip;
1786
1787 s->pc = pc_start;
1788 prefixes = 0;
1789 aflag = s->code32;
1790 dflag = s->code32;
1791 s->override = -1;
1792 next_byte:
61382a50 1793 b = ldub_code(s->pc);
2c0262af
FB		 1794 s->pc++;
1795 /* check prefixes */
1796 switch (b) {
1797 case 0xf3:
1798 prefixes |= PREFIX_REPZ;
1799 goto next_byte;
1800 case 0xf2:
1801 prefixes |= PREFIX_REPNZ;
1802 goto next_byte;
1803 case 0xf0:
1804 prefixes |= PREFIX_LOCK;
1805 goto next_byte;
1806 case 0x2e:
1807 s->override = R_CS;
1808 goto next_byte;
1809 case 0x36:
1810 s->override = R_SS;
1811 goto next_byte;
1812 case 0x3e:
1813 s->override = R_DS;
1814 goto next_byte;
1815 case 0x26:
1816 s->override = R_ES;
1817 goto next_byte;
1818 case 0x64:
1819 s->override = R_FS;
1820 goto next_byte;
1821 case 0x65:
1822 s->override = R_GS;
1823 goto next_byte;
1824 case 0x66:
1825 prefixes |= PREFIX_DATA;
1826 goto next_byte;
1827 case 0x67:
1828 prefixes |= PREFIX_ADR;
1829 goto next_byte;
1830 }
1831
1832 if (prefixes & PREFIX_DATA)
1833 dflag ^= 1;
1834 if (prefixes & PREFIX_ADR)
1835 aflag ^= 1;
1836
1837 s->prefix = prefixes;
1838 s->aflag = aflag;
1839 s->dflag = dflag;
1840
1841 /* lock generation */
1842 if (prefixes & PREFIX_LOCK)
1843 gen_op_lock();
1844
1845 /* now check op code */
1846 reswitch:
1847 switch(b) {
1848 case 0x0f:
1849 /**************************/
1850 /* extended op code */
61382a50 1851 b = ldub_code(s->pc++) | 0x100;
2c0262af
FB		 1852 goto reswitch;
1853
1854 /**************************/
1855 /* arith & logic */
1856 case 0x00 ... 0x05:
1857 case 0x08 ... 0x0d:
1858 case 0x10 ... 0x15:
1859 case 0x18 ... 0x1d:
1860 case 0x20 ... 0x25:
1861 case 0x28 ... 0x2d:
1862 case 0x30 ... 0x35:
1863 case 0x38 ... 0x3d:
1864 {
1865 int op, f, val;
1866 op = (b >> 3) & 7;
1867 f = (b >> 1) & 3;
1868
1869 if ((b & 1) == 0)
1870 ot = OT_BYTE;
1871 else
1872 ot = dflag ? OT_LONG : OT_WORD;
1873
1874 switch(f) {
1875 case 0: /* OP Ev, Gv */
61382a50 1876 modrm = ldub_code(s->pc++);
2c0262af
FB		 1877 reg = ((modrm >> 3) & 7);
1878 mod = (modrm >> 6) & 3;
1879 rm = modrm & 7;
1880 if (mod != 3) {
1881 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
1882 opreg = OR_TMP0;
1883 } else if (op == OP_XORL && rm == reg) {
1884 xor_zero:
1885 /* xor reg, reg optimisation */
1886 gen_op_movl_T0_0();
1887 s->cc_op = CC_OP_LOGICB + ot;
1888 gen_op_mov_reg_T0[ot][reg]();
1889 gen_op_update1_cc();
1890 break;
1891 } else {
1892 opreg = rm;
1893 }
1894 gen_op_mov_TN_reg[ot][1][reg]();
1895 gen_op(s, op, ot, opreg);
1896 break;
1897 case 1: /* OP Gv, Ev */
61382a50 1898 modrm = ldub_code(s->pc++);
2c0262af
FB		 1899 mod = (modrm >> 6) & 3;
1900 reg = ((modrm >> 3) & 7);
1901 rm = modrm & 7;
1902 if (mod != 3) {
1903 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
1904 gen_op_ld_T1_A0[ot + s->mem_index]();
1905 } else if (op == OP_XORL && rm == reg) {
1906 goto xor_zero;
1907 } else {
1908 gen_op_mov_TN_reg[ot][1][rm]();
1909 }
1910 gen_op(s, op, ot, reg);
1911 break;
1912 case 2: /* OP A, Iv */
1913 val = insn_get(s, ot);
1914 gen_op_movl_T1_im(val);
1915 gen_op(s, op, ot, OR_EAX);
1916 break;
1917 }
1918 }
1919 break;
1920
1921 case 0x80: /* GRP1 */
1922 case 0x81:
1923 case 0x83:
1924 {
1925 int val;
1926
1927 if ((b & 1) == 0)
1928 ot = OT_BYTE;
1929 else
1930 ot = dflag ? OT_LONG : OT_WORD;
1931
61382a50 1932 modrm = ldub_code(s->pc++);
2c0262af
FB		 1933 mod = (modrm >> 6) & 3;
1934 rm = modrm & 7;
1935 op = (modrm >> 3) & 7;
1936
1937 if (mod != 3) {
1938 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
1939 opreg = OR_TMP0;
1940 } else {
1941 opreg = rm + OR_EAX;
1942 }
1943
1944 switch(b) {
1945 default:
1946 case 0x80:
1947 case 0x81:
1948 val = insn_get(s, ot);
1949 break;
1950 case 0x83:
1951 val = (int8_t)insn_get(s, OT_BYTE);
1952 break;
1953 }
1954 gen_op_movl_T1_im(val);
1955 gen_op(s, op, ot, opreg);
1956 }
1957 break;
1958
1959 /**************************/
1960 /* inc, dec, and other misc arith */
1961 case 0x40 ... 0x47: /* inc Gv */
1962 ot = dflag ? OT_LONG : OT_WORD;
1963 gen_inc(s, ot, OR_EAX + (b & 7), 1);
1964 break;
1965 case 0x48 ... 0x4f: /* dec Gv */
1966 ot = dflag ? OT_LONG : OT_WORD;
1967 gen_inc(s, ot, OR_EAX + (b & 7), -1);
1968 break;
1969 case 0xf6: /* GRP3 */
1970 case 0xf7:
1971 if ((b & 1) == 0)
1972 ot = OT_BYTE;
1973 else
1974 ot = dflag ? OT_LONG : OT_WORD;
1975
61382a50 1976 modrm = ldub_code(s->pc++);
2c0262af
FB		 1977 mod = (modrm >> 6) & 3;
1978 rm = modrm & 7;
1979 op = (modrm >> 3) & 7;
1980 if (mod != 3) {
1981 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
1982 gen_op_ld_T0_A0[ot + s->mem_index]();
1983 } else {
1984 gen_op_mov_TN_reg[ot][0][rm]();
1985 }
1986
1987 switch(op) {
1988 case 0: /* test */
1989 val = insn_get(s, ot);
1990 gen_op_movl_T1_im(val);
1991 gen_op_testl_T0_T1_cc();
1992 s->cc_op = CC_OP_LOGICB + ot;
1993 break;
1994 case 2: /* not */
1995 gen_op_notl_T0();
1996 if (mod != 3) {
1997 gen_op_st_T0_A0[ot + s->mem_index]();
1998 } else {
1999 gen_op_mov_reg_T0[ot][rm]();
2000 }
2001 break;
2002 case 3: /* neg */
2003 gen_op_negl_T0();
2004 if (mod != 3) {
2005 gen_op_st_T0_A0[ot + s->mem_index]();
2006 } else {
2007 gen_op_mov_reg_T0[ot][rm]();
2008 }
2009 gen_op_update_neg_cc();
2010 s->cc_op = CC_OP_SUBB + ot;
2011 break;
2012 case 4: /* mul */
2013 switch(ot) {
2014 case OT_BYTE:
2015 gen_op_mulb_AL_T0();
2016 break;
2017 case OT_WORD:
2018 gen_op_mulw_AX_T0();
2019 break;
2020 default:
2021 case OT_LONG:
2022 gen_op_mull_EAX_T0();
2023 break;
2024 }
2025 s->cc_op = CC_OP_MUL;
2026 break;
2027 case 5: /* imul */
2028 switch(ot) {
2029 case OT_BYTE:
2030 gen_op_imulb_AL_T0();
2031 break;
2032 case OT_WORD:
2033 gen_op_imulw_AX_T0();
2034 break;
2035 default:
2036 case OT_LONG:
2037 gen_op_imull_EAX_T0();
2038 break;
2039 }
2040 s->cc_op = CC_OP_MUL;
2041 break;
2042 case 6: /* div */
2043 switch(ot) {
2044 case OT_BYTE:
2045 gen_op_divb_AL_T0(pc_start - s->cs_base);
2046 break;
2047 case OT_WORD:
2048 gen_op_divw_AX_T0(pc_start - s->cs_base);
2049 break;
2050 default:
2051 case OT_LONG:
2052 gen_op_divl_EAX_T0(pc_start - s->cs_base);
2053 break;
2054 }
2055 break;
2056 case 7: /* idiv */
2057 switch(ot) {
2058 case OT_BYTE:
2059 gen_op_idivb_AL_T0(pc_start - s->cs_base);
2060 break;
2061 case OT_WORD:
2062 gen_op_idivw_AX_T0(pc_start - s->cs_base);
2063 break;
2064 default:
2065 case OT_LONG:
2066 gen_op_idivl_EAX_T0(pc_start - s->cs_base);
2067 break;
2068 }
2069 break;
2070 default:
2071 goto illegal_op;
2072 }
2073 break;
2074
2075 case 0xfe: /* GRP4 */
2076 case 0xff: /* GRP5 */
2077 if ((b & 1) == 0)
2078 ot = OT_BYTE;
2079 else
2080 ot = dflag ? OT_LONG : OT_WORD;
2081
61382a50 2082 modrm = ldub_code(s->pc++);
2c0262af
FB		 2083 mod = (modrm >> 6) & 3;
2084 rm = modrm & 7;
2085 op = (modrm >> 3) & 7;
2086 if (op >= 2 && b == 0xfe) {
2087 goto illegal_op;
2088 }
2089 if (mod != 3) {
2090 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2091 if (op >= 2 && op != 3 && op != 5)
2092 gen_op_ld_T0_A0[ot + s->mem_index]();
2093 } else {
2094 gen_op_mov_TN_reg[ot][0][rm]();
2095 }
2096
2097 switch(op) {
2098 case 0: /* inc Ev */
2099 if (mod != 3)
2100 opreg = OR_TMP0;
2101 else
2102 opreg = rm;
2103 gen_inc(s, ot, opreg, 1);
2104 break;
2105 case 1: /* dec Ev */
2106 if (mod != 3)
2107 opreg = OR_TMP0;
2108 else
2109 opreg = rm;
2110 gen_inc(s, ot, opreg, -1);
2111 break;
2112 case 2: /* call Ev */
2113 /* XXX: optimize if memory (no and is necessary) */
2114 if (s->dflag == 0)
2115 gen_op_andl_T0_ffff();
2116 gen_op_jmp_T0();
2117 next_eip = s->pc - s->cs_base;
2118 gen_op_movl_T0_im(next_eip);
2119 gen_push_T0(s);
2120 gen_eob(s);
2121 break;
61382a50 2122 case 3: /* lcall Ev */
2c0262af
FB		 2123 gen_op_ld_T1_A0[ot + s->mem_index]();
2124 gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
61382a50 2125 gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
2c0262af
FB		 2126 do_lcall:
2127 if (s->pe && !s->vm86) {
2128 if (s->cc_op != CC_OP_DYNAMIC)
2129 gen_op_set_cc_op(s->cc_op);
2130 gen_op_jmp_im(pc_start - s->cs_base);
2131 gen_op_lcall_protected_T0_T1(dflag, s->pc - s->cs_base);
2132 } else {
2133 gen_op_lcall_real_T0_T1(dflag, s->pc - s->cs_base);
2134 }
2135 gen_eob(s);
2136 break;
2137 case 4: /* jmp Ev */
2138 if (s->dflag == 0)
2139 gen_op_andl_T0_ffff();
2140 gen_op_jmp_T0();
2141 gen_eob(s);
2142 break;
2143 case 5: /* ljmp Ev */
2144 gen_op_ld_T1_A0[ot + s->mem_index]();
2145 gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
61382a50 2146 gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
2c0262af
FB		 2147 do_ljmp:
2148 if (s->pe && !s->vm86) {
2149 if (s->cc_op != CC_OP_DYNAMIC)
2150 gen_op_set_cc_op(s->cc_op);
2151 gen_op_jmp_im(pc_start - s->cs_base);
2152 gen_op_ljmp_protected_T0_T1();
2153 } else {
2154 gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
2155 gen_op_movl_T0_T1();
2156 gen_op_jmp_T0();
2157 }
2158 gen_eob(s);
2159 break;
2160 case 6: /* push Ev */
2161 gen_push_T0(s);
2162 break;
2163 default:
2164 goto illegal_op;
2165 }
2166 break;
2167
2168 case 0x84: /* test Ev, Gv */
2169 case 0x85:
2170 if ((b & 1) == 0)
2171 ot = OT_BYTE;
2172 else
2173 ot = dflag ? OT_LONG : OT_WORD;
2174
61382a50 2175 modrm = ldub_code(s->pc++);
2c0262af
FB		 2176 mod = (modrm >> 6) & 3;
2177 rm = modrm & 7;
2178 reg = (modrm >> 3) & 7;
2179
2180 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
2181 gen_op_mov_TN_reg[ot][1][reg + OR_EAX]();
2182 gen_op_testl_T0_T1_cc();
2183 s->cc_op = CC_OP_LOGICB + ot;
2184 break;
2185
2186 case 0xa8: /* test eAX, Iv */
2187 case 0xa9:
2188 if ((b & 1) == 0)
2189 ot = OT_BYTE;
2190 else
2191 ot = dflag ? OT_LONG : OT_WORD;
2192 val = insn_get(s, ot);
2193
2194 gen_op_mov_TN_reg[ot][0][OR_EAX]();
2195 gen_op_movl_T1_im(val);
2196 gen_op_testl_T0_T1_cc();
2197 s->cc_op = CC_OP_LOGICB + ot;
2198 break;
2199
2200 case 0x98: /* CWDE/CBW */
2201 if (dflag)
2202 gen_op_movswl_EAX_AX();
2203 else
2204 gen_op_movsbw_AX_AL();
2205 break;
2206 case 0x99: /* CDQ/CWD */
2207 if (dflag)
2208 gen_op_movslq_EDX_EAX();
2209 else
2210 gen_op_movswl_DX_AX();
2211 break;
2212 case 0x1af: /* imul Gv, Ev */
2213 case 0x69: /* imul Gv, Ev, I */
2214 case 0x6b:
2215 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2216 modrm = ldub_code(s->pc++);
2c0262af
FB		 2217 reg = ((modrm >> 3) & 7) + OR_EAX;
2218 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
2219 if (b == 0x69) {
2220 val = insn_get(s, ot);
2221 gen_op_movl_T1_im(val);
2222 } else if (b == 0x6b) {
2223 val = insn_get(s, OT_BYTE);
2224 gen_op_movl_T1_im(val);
2225 } else {
2226 gen_op_mov_TN_reg[ot][1][reg]();
2227 }
2228
2229 if (ot == OT_LONG) {
2230 gen_op_imull_T0_T1();
2231 } else {
2232 gen_op_imulw_T0_T1();
2233 }
2234 gen_op_mov_reg_T0[ot][reg]();
2235 s->cc_op = CC_OP_MUL;
2236 break;
2237 case 0x1c0:
2238 case 0x1c1: /* xadd Ev, Gv */
2239 if ((b & 1) == 0)
2240 ot = OT_BYTE;
2241 else
2242 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2243 modrm = ldub_code(s->pc++);
2c0262af
FB		 2244 reg = (modrm >> 3) & 7;
2245 mod = (modrm >> 6) & 3;
2246 if (mod == 3) {
2247 rm = modrm & 7;
2248 gen_op_mov_TN_reg[ot][0][reg]();
2249 gen_op_mov_TN_reg[ot][1][rm]();
2250 gen_op_addl_T0_T1();
2251 gen_op_mov_reg_T0[ot][rm]();
2252 gen_op_mov_reg_T1[ot][reg]();
2253 } else {
2254 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2255 gen_op_mov_TN_reg[ot][0][reg]();
2256 gen_op_ld_T1_A0[ot + s->mem_index]();
2257 gen_op_addl_T0_T1();
2258 gen_op_st_T0_A0[ot + s->mem_index]();
2259 gen_op_mov_reg_T1[ot][reg]();
2260 }
2261 gen_op_update2_cc();
2262 s->cc_op = CC_OP_ADDB + ot;
2263 break;
2264 case 0x1b0:
2265 case 0x1b1: /* cmpxchg Ev, Gv */
2266 if ((b & 1) == 0)
2267 ot = OT_BYTE;
2268 else
2269 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2270 modrm = ldub_code(s->pc++);
2c0262af
FB		 2271 reg = (modrm >> 3) & 7;
2272 mod = (modrm >> 6) & 3;
2273 gen_op_mov_TN_reg[ot][1][reg]();
2274 if (mod == 3) {
2275 rm = modrm & 7;
2276 gen_op_mov_TN_reg[ot][0][rm]();
2277 gen_op_cmpxchg_T0_T1_EAX_cc[ot]();
2278 gen_op_mov_reg_T0[ot][rm]();
2279 } else {
2280 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2281 gen_op_ld_T0_A0[ot + s->mem_index]();
2282 gen_op_cmpxchg_mem_T0_T1_EAX_cc[ot]();
2283 }
2284 s->cc_op = CC_OP_SUBB + ot;
2285 break;
2286 case 0x1c7: /* cmpxchg8b */
61382a50 2287 modrm = ldub_code(s->pc++);
2c0262af
FB		 2288 mod = (modrm >> 6) & 3;
2289 if (mod == 3)
2290 goto illegal_op;
2291 if (s->cc_op != CC_OP_DYNAMIC)
2292 gen_op_set_cc_op(s->cc_op);
2293 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2294 gen_op_cmpxchg8b();
2295 s->cc_op = CC_OP_EFLAGS;
2296 break;
2297
2298 /**************************/
2299 /* push/pop */
2300 case 0x50 ... 0x57: /* push */
2301 gen_op_mov_TN_reg[OT_LONG][0][b & 7]();
2302 gen_push_T0(s);
2303 break;
2304 case 0x58 ... 0x5f: /* pop */
2305 ot = dflag ? OT_LONG : OT_WORD;
2306 gen_pop_T0(s);
77729c24 2307 /* NOTE: order is important for pop %sp */
2c0262af 2308 gen_pop_update(s);
77729c24 2309 gen_op_mov_reg_T0[ot][b & 7]();
2c0262af
FB		 2310 break;
2311 case 0x60: /* pusha */
2312 gen_pusha(s);
2313 break;
2314 case 0x61: /* popa */
2315 gen_popa(s);
2316 break;
2317 case 0x68: /* push Iv */
2318 case 0x6a:
2319 ot = dflag ? OT_LONG : OT_WORD;
2320 if (b == 0x68)
2321 val = insn_get(s, ot);
2322 else
2323 val = (int8_t)insn_get(s, OT_BYTE);
2324 gen_op_movl_T0_im(val);
2325 gen_push_T0(s);
2326 break;
2327 case 0x8f: /* pop Ev */
2328 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2329 modrm = ldub_code(s->pc++);
77729c24 2330 mod = (modrm >> 6) & 3;
2c0262af 2331 gen_pop_T0(s);
77729c24
FB		 2332 if (mod == 3) {
2333 /* NOTE: order is important for pop %sp */
2334 gen_pop_update(s);
2335 rm = modrm & 7;
2336 gen_op_mov_reg_T0[ot][rm]();
2337 } else {
2338 /* NOTE: order is important too for MMU exceptions */
2339 s->popl_esp_hack = 2 << dflag;
2340 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
2341 s->popl_esp_hack = 0;
2342 gen_pop_update(s);
2343 }
2c0262af
FB		 2344 break;
2345 case 0xc8: /* enter */
2346 {
2347 int level;
61382a50 2348 val = lduw_code(s->pc);
2c0262af 2349 s->pc += 2;
61382a50 2350 level = ldub_code(s->pc++);
2c0262af
FB		 2351 gen_enter(s, val, level);
2352 }
2353 break;
2354 case 0xc9: /* leave */
2355 /* XXX: exception not precise (ESP is updated before potential exception) */
2356 if (s->ss32) {
2357 gen_op_mov_TN_reg[OT_LONG][0][R_EBP]();
2358 gen_op_mov_reg_T0[OT_LONG][R_ESP]();
2359 } else {
2360 gen_op_mov_TN_reg[OT_WORD][0][R_EBP]();
2361 gen_op_mov_reg_T0[OT_WORD][R_ESP]();
2362 }
2363 gen_pop_T0(s);
2364 ot = dflag ? OT_LONG : OT_WORD;
2365 gen_op_mov_reg_T0[ot][R_EBP]();
2366 gen_pop_update(s);
2367 break;
2368 case 0x06: /* push es */
2369 case 0x0e: /* push cs */
2370 case 0x16: /* push ss */
2371 case 0x1e: /* push ds */
2372 gen_op_movl_T0_seg(b >> 3);
2373 gen_push_T0(s);
2374 break;
2375 case 0x1a0: /* push fs */
2376 case 0x1a8: /* push gs */
2377 gen_op_movl_T0_seg((b >> 3) & 7);
2378 gen_push_T0(s);
2379 break;
2380 case 0x07: /* pop es */
2381 case 0x17: /* pop ss */
2382 case 0x1f: /* pop ds */
2383 reg = b >> 3;
2384 gen_pop_T0(s);
2385 gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
2386 gen_pop_update(s);
2387 if (reg == R_SS) {
2388 /* if reg == SS, inhibit interrupts/trace */
2389 gen_op_set_inhibit_irq();
2390 s->tf = 0;
2391 }
2392 if (s->is_jmp) {
2393 gen_op_jmp_im(s->pc - s->cs_base);
2394 gen_eob(s);
2395 }
2396 break;
2397 case 0x1a1: /* pop fs */
2398 case 0x1a9: /* pop gs */
2399 gen_pop_T0(s);
2400 gen_movl_seg_T0(s, (b >> 3) & 7, pc_start - s->cs_base);
2401 gen_pop_update(s);
2402 if (s->is_jmp) {
2403 gen_op_jmp_im(s->pc - s->cs_base);
2404 gen_eob(s);
2405 }
2406 break;
2407
2408 /**************************/
2409 /* mov */
2410 case 0x88:
2411 case 0x89: /* mov Gv, Ev */
2412 if ((b & 1) == 0)
2413 ot = OT_BYTE;
2414 else
2415 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2416 modrm = ldub_code(s->pc++);
2c0262af
FB		 2417 reg = (modrm >> 3) & 7;
2418
2419 /* generate a generic store */
2420 gen_ldst_modrm(s, modrm, ot, OR_EAX + reg, 1);
2421 break;
2422 case 0xc6:
2423 case 0xc7: /* mov Ev, Iv */
2424 if ((b & 1) == 0)
2425 ot = OT_BYTE;
2426 else
2427 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2428 modrm = ldub_code(s->pc++);
2c0262af
FB		 2429 mod = (modrm >> 6) & 3;
2430 if (mod != 3)
2431 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2432 val = insn_get(s, ot);
2433 gen_op_movl_T0_im(val);
2434 if (mod != 3)
2435 gen_op_st_T0_A0[ot + s->mem_index]();
2436 else
2437 gen_op_mov_reg_T0[ot][modrm & 7]();
2438 break;
2439 case 0x8a:
2440 case 0x8b: /* mov Ev, Gv */
2441 if ((b & 1) == 0)
2442 ot = OT_BYTE;
2443 else
2444 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2445 modrm = ldub_code(s->pc++);
2c0262af
FB		 2446 reg = (modrm >> 3) & 7;
2447
2448 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
2449 gen_op_mov_reg_T0[ot][reg]();
2450 break;
2451 case 0x8e: /* mov seg, Gv */
61382a50 2452 modrm = ldub_code(s->pc++);
2c0262af
FB		 2453 reg = (modrm >> 3) & 7;
2454 if (reg >= 6 || reg == R_CS)
2455 goto illegal_op;
2456 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
2457 gen_movl_seg_T0(s, reg, pc_start - s->cs_base);
2458 if (reg == R_SS) {
2459 /* if reg == SS, inhibit interrupts/trace */
2460 gen_op_set_inhibit_irq();
2461 s->tf = 0;
2462 }
2463 if (s->is_jmp) {
2464 gen_op_jmp_im(s->pc - s->cs_base);
2465 gen_eob(s);
2466 }
2467 break;
2468 case 0x8c: /* mov Gv, seg */
61382a50 2469 modrm = ldub_code(s->pc++);
2c0262af
FB		 2470 reg = (modrm >> 3) & 7;
2471 mod = (modrm >> 6) & 3;
2472 if (reg >= 6)
2473 goto illegal_op;
2474 gen_op_movl_T0_seg(reg);
2475 ot = OT_WORD;
2476 if (mod == 3 && dflag)
2477 ot = OT_LONG;
2478 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
2479 break;
2480
2481 case 0x1b6: /* movzbS Gv, Eb */
2482 case 0x1b7: /* movzwS Gv, Eb */
2483 case 0x1be: /* movsbS Gv, Eb */
2484 case 0x1bf: /* movswS Gv, Eb */
2485 {
2486 int d_ot;
2487 /* d_ot is the size of destination */
2488 d_ot = dflag + OT_WORD;
2489 /* ot is the size of source */
2490 ot = (b & 1) + OT_BYTE;
61382a50 2491 modrm = ldub_code(s->pc++);
2c0262af
FB		 2492 reg = ((modrm >> 3) & 7) + OR_EAX;
2493 mod = (modrm >> 6) & 3;
2494 rm = modrm & 7;
2495
2496 if (mod == 3) {
2497 gen_op_mov_TN_reg[ot][0][rm]();
2498 switch(ot | (b & 8)) {
2499 case OT_BYTE:
2500 gen_op_movzbl_T0_T0();
2501 break;
2502 case OT_BYTE | 8:
2503 gen_op_movsbl_T0_T0();
2504 break;
2505 case OT_WORD:
2506 gen_op_movzwl_T0_T0();
2507 break;
2508 default:
2509 case OT_WORD | 8:
2510 gen_op_movswl_T0_T0();
2511 break;
2512 }
2513 gen_op_mov_reg_T0[d_ot][reg]();
2514 } else {
2515 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2516 if (b & 8) {
2517 gen_op_lds_T0_A0[ot + s->mem_index]();
2518 } else {
2519 gen_op_ldu_T0_A0[ot + s->mem_index]();
2520 }
2521 gen_op_mov_reg_T0[d_ot][reg]();
2522 }
2523 }
2524 break;
2525
2526 case 0x8d: /* lea */
2527 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2528 modrm = ldub_code(s->pc++);
2c0262af
FB		 2529 reg = (modrm >> 3) & 7;
2530 /* we must ensure that no segment is added */
2531 s->override = -1;
2532 val = s->addseg;
2533 s->addseg = 0;
2534 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2535 s->addseg = val;
2536 gen_op_mov_reg_A0[ot - OT_WORD][reg]();
2537 break;
2538
2539 case 0xa0: /* mov EAX, Ov */
2540 case 0xa1:
2541 case 0xa2: /* mov Ov, EAX */
2542 case 0xa3:
2543 if ((b & 1) == 0)
2544 ot = OT_BYTE;
2545 else
2546 ot = dflag ? OT_LONG : OT_WORD;
2547 if (s->aflag)
2548 offset_addr = insn_get(s, OT_LONG);
2549 else
2550 offset_addr = insn_get(s, OT_WORD);
2551 gen_op_movl_A0_im(offset_addr);
2552 /* handle override */
2553 {
2554 int override, must_add_seg;
2555 must_add_seg = s->addseg;
2556 if (s->override >= 0) {
2557 override = s->override;
2558 must_add_seg = 1;
2559 } else {
2560 override = R_DS;
2561 }
2562 if (must_add_seg) {
2563 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
2564 }
2565 }
2566 if ((b & 2) == 0) {
2567 gen_op_ld_T0_A0[ot + s->mem_index]();
2568 gen_op_mov_reg_T0[ot][R_EAX]();
2569 } else {
2570 gen_op_mov_TN_reg[ot][0][R_EAX]();
2571 gen_op_st_T0_A0[ot + s->mem_index]();
2572 }
2573 break;
2574 case 0xd7: /* xlat */
2575 gen_op_movl_A0_reg[R_EBX]();
2576 gen_op_addl_A0_AL();
2577 if (s->aflag == 0)
2578 gen_op_andl_A0_ffff();
2579 /* handle override */
2580 {
2581 int override, must_add_seg;
2582 must_add_seg = s->addseg;
2583 override = R_DS;
2584 if (s->override >= 0) {
2585 override = s->override;
2586 must_add_seg = 1;
2587 } else {
2588 override = R_DS;
2589 }
2590 if (must_add_seg) {
2591 gen_op_addl_A0_seg(offsetof(CPUX86State,segs[override].base));
2592 }
2593 }
2594 gen_op_ldu_T0_A0[OT_BYTE + s->mem_index]();
2595 gen_op_mov_reg_T0[OT_BYTE][R_EAX]();
2596 break;
2597 case 0xb0 ... 0xb7: /* mov R, Ib */
2598 val = insn_get(s, OT_BYTE);
2599 gen_op_movl_T0_im(val);
2600 gen_op_mov_reg_T0[OT_BYTE][b & 7]();
2601 break;
2602 case 0xb8 ... 0xbf: /* mov R, Iv */
2603 ot = dflag ? OT_LONG : OT_WORD;
2604 val = insn_get(s, ot);
2605 reg = OR_EAX + (b & 7);
2606 gen_op_movl_T0_im(val);
2607 gen_op_mov_reg_T0[ot][reg]();
2608 break;
2609
2610 case 0x91 ... 0x97: /* xchg R, EAX */
2611 ot = dflag ? OT_LONG : OT_WORD;
2612 reg = b & 7;
2613 rm = R_EAX;
2614 goto do_xchg_reg;
2615 case 0x86:
2616 case 0x87: /* xchg Ev, Gv */
2617 if ((b & 1) == 0)
2618 ot = OT_BYTE;
2619 else
2620 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2621 modrm = ldub_code(s->pc++);
2c0262af
FB		 2622 reg = (modrm >> 3) & 7;
2623 mod = (modrm >> 6) & 3;
2624 if (mod == 3) {
2625 rm = modrm & 7;
2626 do_xchg_reg:
2627 gen_op_mov_TN_reg[ot][0][reg]();
2628 gen_op_mov_TN_reg[ot][1][rm]();
2629 gen_op_mov_reg_T0[ot][rm]();
2630 gen_op_mov_reg_T1[ot][reg]();
2631 } else {
2632 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2633 gen_op_mov_TN_reg[ot][0][reg]();
2634 /* for xchg, lock is implicit */
2635 if (!(prefixes & PREFIX_LOCK))
2636 gen_op_lock();
2637 gen_op_ld_T1_A0[ot + s->mem_index]();
2638 gen_op_st_T0_A0[ot + s->mem_index]();
2639 if (!(prefixes & PREFIX_LOCK))
2640 gen_op_unlock();
2641 gen_op_mov_reg_T1[ot][reg]();
2642 }
2643 break;
2644 case 0xc4: /* les Gv */
2645 op = R_ES;
2646 goto do_lxx;
2647 case 0xc5: /* lds Gv */
2648 op = R_DS;
2649 goto do_lxx;
2650 case 0x1b2: /* lss Gv */
2651 op = R_SS;
2652 goto do_lxx;
2653 case 0x1b4: /* lfs Gv */
2654 op = R_FS;
2655 goto do_lxx;
2656 case 0x1b5: /* lgs Gv */
2657 op = R_GS;
2658 do_lxx:
2659 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2660 modrm = ldub_code(s->pc++);
2c0262af
FB		 2661 reg = (modrm >> 3) & 7;
2662 mod = (modrm >> 6) & 3;
2663 if (mod == 3)
2664 goto illegal_op;
2665 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2666 gen_op_ld_T1_A0[ot + s->mem_index]();
2667 gen_op_addl_A0_im(1 << (ot - OT_WORD + 1));
2668 /* load the segment first to handle exceptions properly */
61382a50 2669 gen_op_ldu_T0_A0[OT_WORD + s->mem_index]();
2c0262af
FB		 2670 gen_movl_seg_T0(s, op, pc_start - s->cs_base);
2671 /* then put the data */
2672 gen_op_mov_reg_T1[ot][reg]();
2673 if (s->is_jmp) {
2674 gen_op_jmp_im(s->pc - s->cs_base);
2675 gen_eob(s);
2676 }
2677 break;
2678
2679 /************************/
2680 /* shifts */
2681 case 0xc0:
2682 case 0xc1:
2683 /* shift Ev,Ib */
2684 shift = 2;
2685 grp2:
2686 {
2687 if ((b & 1) == 0)
2688 ot = OT_BYTE;
2689 else
2690 ot = dflag ? OT_LONG : OT_WORD;
2691
61382a50 2692 modrm = ldub_code(s->pc++);
2c0262af
FB		 2693 mod = (modrm >> 6) & 3;
2694 rm = modrm & 7;
2695 op = (modrm >> 3) & 7;
2696
2697 if (mod != 3) {
2698 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2699 opreg = OR_TMP0;
2700 } else {
2701 opreg = rm + OR_EAX;
2702 }
2703
2704 /* simpler op */
2705 if (shift == 0) {
2706 gen_shift(s, op, ot, opreg, OR_ECX);
2707 } else {
2708 if (shift == 2) {
61382a50 2709 shift = ldub_code(s->pc++);
2c0262af
FB		 2710 }
2711 gen_shifti(s, op, ot, opreg, shift);
2712 }
2713 }
2714 break;
2715 case 0xd0:
2716 case 0xd1:
2717 /* shift Ev,1 */
2718 shift = 1;
2719 goto grp2;
2720 case 0xd2:
2721 case 0xd3:
2722 /* shift Ev,cl */
2723 shift = 0;
2724 goto grp2;
2725
2726 case 0x1a4: /* shld imm */
2727 op = 0;
2728 shift = 1;
2729 goto do_shiftd;
2730 case 0x1a5: /* shld cl */
2731 op = 0;
2732 shift = 0;
2733 goto do_shiftd;
2734 case 0x1ac: /* shrd imm */
2735 op = 1;
2736 shift = 1;
2737 goto do_shiftd;
2738 case 0x1ad: /* shrd cl */
2739 op = 1;
2740 shift = 0;
2741 do_shiftd:
2742 ot = dflag ? OT_LONG : OT_WORD;
61382a50 2743 modrm = ldub_code(s->pc++);
2c0262af
FB		 2744 mod = (modrm >> 6) & 3;
2745 rm = modrm & 7;
2746 reg = (modrm >> 3) & 7;
2747
2748 if (mod != 3) {
2749 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2750 gen_op_ld_T0_A0[ot + s->mem_index]();
2751 } else {
2752 gen_op_mov_TN_reg[ot][0][rm]();
2753 }
2754 gen_op_mov_TN_reg[ot][1][reg]();
2755
2756 if (shift) {
61382a50 2757 val = ldub_code(s->pc++);
2c0262af
FB		 2758 val &= 0x1f;
2759 if (val) {
2760 if (mod == 3)
2761 gen_op_shiftd_T0_T1_im_cc[ot - OT_WORD][op](val);
2762 else
2763 gen_op_shiftd_mem_T0_T1_im_cc[ot - OT_WORD][op](val);
2764 if (op == 0 && ot != OT_WORD)
2765 s->cc_op = CC_OP_SHLB + ot;
2766 else
2767 s->cc_op = CC_OP_SARB + ot;
2768 }
2769 } else {
2770 if (s->cc_op != CC_OP_DYNAMIC)
2771 gen_op_set_cc_op(s->cc_op);
2772 if (mod == 3)
2773 gen_op_shiftd_T0_T1_ECX_cc[ot - OT_WORD][op]();
2774 else
2775 gen_op_shiftd_mem_T0_T1_ECX_cc[ot - OT_WORD][op]();
2776 s->cc_op = CC_OP_DYNAMIC; /* cannot predict flags after */
2777 }
2778 if (mod == 3) {
2779 gen_op_mov_reg_T0[ot][rm]();
2780 }
2781 break;
2782
2783 /************************/
2784 /* floats */
2785 case 0xd8 ... 0xdf:
61382a50 2786 modrm = ldub_code(s->pc++);
2c0262af
FB		 2787 mod = (modrm >> 6) & 3;
2788 rm = modrm & 7;
2789 op = ((b & 7) << 3) | ((modrm >> 3) & 7);
2790
2791 if (mod != 3) {
2792 /* memory op */
2793 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
2794 switch(op) {
2795 case 0x00 ... 0x07: /* fxxxs */
2796 case 0x10 ... 0x17: /* fixxxl */
2797 case 0x20 ... 0x27: /* fxxxl */
2798 case 0x30 ... 0x37: /* fixxx */
2799 {
2800 int op1;
2801 op1 = op & 7;
2802
2803 switch(op >> 4) {
2804 case 0:
2805 gen_op_flds_FT0_A0();
2806 break;
2807 case 1:
2808 gen_op_fildl_FT0_A0();
2809 break;
2810 case 2:
2811 gen_op_fldl_FT0_A0();
2812 break;
2813 case 3:
2814 default:
2815 gen_op_fild_FT0_A0();
2816 break;
2817 }
2818
2819 gen_op_fp_arith_ST0_FT0[op1]();
2820 if (op1 == 3) {
2821 /* fcomp needs pop */
2822 gen_op_fpop();
2823 }
2824 }
2825 break;
2826 case 0x08: /* flds */
2827 case 0x0a: /* fsts */
2828 case 0x0b: /* fstps */
2829 case 0x18: /* fildl */
2830 case 0x1a: /* fistl */
2831 case 0x1b: /* fistpl */
2832 case 0x28: /* fldl */
2833 case 0x2a: /* fstl */
2834 case 0x2b: /* fstpl */
2835 case 0x38: /* filds */
2836 case 0x3a: /* fists */
2837 case 0x3b: /* fistps */
2838
2839 switch(op & 7) {
2840 case 0:
2841 switch(op >> 4) {
2842 case 0:
2843 gen_op_flds_ST0_A0();
2844 break;
2845 case 1:
2846 gen_op_fildl_ST0_A0();
2847 break;
2848 case 2:
2849 gen_op_fldl_ST0_A0();
2850 break;
2851 case 3:
2852 default:
2853 gen_op_fild_ST0_A0();
2854 break;
2855 }
2856 break;
2857 default:
2858 switch(op >> 4) {
2859 case 0:
2860 gen_op_fsts_ST0_A0();
2861 break;
2862 case 1:
2863 gen_op_fistl_ST0_A0();
2864 break;
2865 case 2:
2866 gen_op_fstl_ST0_A0();
2867 break;
2868 case 3:
2869 default:
2870 gen_op_fist_ST0_A0();
2871 break;
2872 }
2873 if ((op & 7) == 3)
2874 gen_op_fpop();
2875 break;
2876 }
2877 break;
2878 case 0x0c: /* fldenv mem */
2879 gen_op_fldenv_A0(s->dflag);
2880 break;
2881 case 0x0d: /* fldcw mem */
2882 gen_op_fldcw_A0();
2883 break;
2884 case 0x0e: /* fnstenv mem */
2885 gen_op_fnstenv_A0(s->dflag);
2886 break;
2887 case 0x0f: /* fnstcw mem */
2888 gen_op_fnstcw_A0();
2889 break;
2890 case 0x1d: /* fldt mem */
2891 gen_op_fldt_ST0_A0();
2892 break;
2893 case 0x1f: /* fstpt mem */
2894 gen_op_fstt_ST0_A0();
2895 gen_op_fpop();
2896 break;
2897 case 0x2c: /* frstor mem */
2898 gen_op_frstor_A0(s->dflag);
2899 break;
2900 case 0x2e: /* fnsave mem */
2901 gen_op_fnsave_A0(s->dflag);
2902 break;
2903 case 0x2f: /* fnstsw mem */
2904 gen_op_fnstsw_A0();
2905 break;
2906 case 0x3c: /* fbld */
2907 gen_op_fbld_ST0_A0();
2908 break;
2909 case 0x3e: /* fbstp */
2910 gen_op_fbst_ST0_A0();
2911 gen_op_fpop();
2912 break;
2913 case 0x3d: /* fildll */
2914 gen_op_fildll_ST0_A0();
2915 break;
2916 case 0x3f: /* fistpll */
2917 gen_op_fistll_ST0_A0();
2918 gen_op_fpop();
2919 break;
2920 default:
2921 goto illegal_op;
2922 }
2923 } else {
2924 /* register float ops */
2925 opreg = rm;
2926
2927 switch(op) {
2928 case 0x08: /* fld sti */
2929 gen_op_fpush();
2930 gen_op_fmov_ST0_STN((opreg + 1) & 7);
2931 break;
2932 case 0x09: /* fxchg sti */
2933 gen_op_fxchg_ST0_STN(opreg);
2934 break;
2935 case 0x0a: /* grp d9/2 */
2936 switch(rm) {
2937 case 0: /* fnop */
2938 break;
2939 default:
2940 goto illegal_op;
2941 }
2942 break;
2943 case 0x0c: /* grp d9/4 */
2944 switch(rm) {
2945 case 0: /* fchs */
2946 gen_op_fchs_ST0();
2947 break;
2948 case 1: /* fabs */
2949 gen_op_fabs_ST0();
2950 break;
2951 case 4: /* ftst */
2952 gen_op_fldz_FT0();
2953 gen_op_fcom_ST0_FT0();
2954 break;
2955 case 5: /* fxam */
2956 gen_op_fxam_ST0();
2957 break;
2958 default:
2959 goto illegal_op;
2960 }
2961 break;
2962 case 0x0d: /* grp d9/5 */
2963 {
2964 switch(rm) {
2965 case 0:
2966 gen_op_fpush();
2967 gen_op_fld1_ST0();
2968 break;
2969 case 1:
2970 gen_op_fpush();
2971 gen_op_fldl2t_ST0();
2972 break;
2973 case 2:
2974 gen_op_fpush();
2975 gen_op_fldl2e_ST0();
2976 break;
2977 case 3:
2978 gen_op_fpush();
2979 gen_op_fldpi_ST0();
2980 break;
2981 case 4:
2982 gen_op_fpush();
2983 gen_op_fldlg2_ST0();
2984 break;
2985 case 5:
2986 gen_op_fpush();
2987 gen_op_fldln2_ST0();
2988 break;
2989 case 6:
2990 gen_op_fpush();
2991 gen_op_fldz_ST0();
2992 break;
2993 default:
2994 goto illegal_op;
2995 }
2996 }
2997 break;
2998 case 0x0e: /* grp d9/6 */
2999 switch(rm) {
3000 case 0: /* f2xm1 */
3001 gen_op_f2xm1();
3002 break;
3003 case 1: /* fyl2x */
3004 gen_op_fyl2x();
3005 break;
3006 case 2: /* fptan */
3007 gen_op_fptan();
3008 break;
3009 case 3: /* fpatan */
3010 gen_op_fpatan();
3011 break;
3012 case 4: /* fxtract */
3013 gen_op_fxtract();
3014 break;
3015 case 5: /* fprem1 */
3016 gen_op_fprem1();
3017 break;
3018 case 6: /* fdecstp */
3019 gen_op_fdecstp();
3020 break;
3021 default:
3022 case 7: /* fincstp */
3023 gen_op_fincstp();
3024 break;
3025 }
3026 break;
3027 case 0x0f: /* grp d9/7 */
3028 switch(rm) {
3029 case 0: /* fprem */
3030 gen_op_fprem();
3031 break;
3032 case 1: /* fyl2xp1 */
3033 gen_op_fyl2xp1();
3034 break;
3035 case 2: /* fsqrt */
3036 gen_op_fsqrt();
3037 break;
3038 case 3: /* fsincos */
3039 gen_op_fsincos();
3040 break;
3041 case 5: /* fscale */
3042 gen_op_fscale();
3043 break;
3044 case 4: /* frndint */
3045 gen_op_frndint();
3046 break;
3047 case 6: /* fsin */
3048 gen_op_fsin();
3049 break;
3050 default:
3051 case 7: /* fcos */
3052 gen_op_fcos();
3053 break;
3054 }
3055 break;
3056 case 0x00: case 0x01: case 0x04 ... 0x07: /* fxxx st, sti */
3057 case 0x20: case 0x21: case 0x24 ... 0x27: /* fxxx sti, st */
3058 case 0x30: case 0x31: case 0x34 ... 0x37: /* fxxxp sti, st */
3059 {
3060 int op1;
3061
3062 op1 = op & 7;
3063 if (op >= 0x20) {
3064 gen_op_fp_arith_STN_ST0[op1](opreg);
3065 if (op >= 0x30)
3066 gen_op_fpop();
3067 } else {
3068 gen_op_fmov_FT0_STN(opreg);
3069 gen_op_fp_arith_ST0_FT0[op1]();
3070 }
3071 }
3072 break;
3073 case 0x02: /* fcom */
3074 gen_op_fmov_FT0_STN(opreg);
3075 gen_op_fcom_ST0_FT0();
3076 break;
3077 case 0x03: /* fcomp */
3078 gen_op_fmov_FT0_STN(opreg);
3079 gen_op_fcom_ST0_FT0();
3080 gen_op_fpop();
3081 break;
3082 case 0x15: /* da/5 */
3083 switch(rm) {
3084 case 1: /* fucompp */
3085 gen_op_fmov_FT0_STN(1);
3086 gen_op_fucom_ST0_FT0();
3087 gen_op_fpop();
3088 gen_op_fpop();
3089 break;
3090 default:
3091 goto illegal_op;
3092 }
3093 break;
3094 case 0x1c:
3095 switch(rm) {
3096 case 0: /* feni (287 only, just do nop here) */
3097 break;
3098 case 1: /* fdisi (287 only, just do nop here) */
3099 break;
3100 case 2: /* fclex */
3101 gen_op_fclex();
3102 break;
3103 case 3: /* fninit */
3104 gen_op_fninit();
3105 break;
3106 case 4: /* fsetpm (287 only, just do nop here) */
3107 break;
3108 default:
3109 goto illegal_op;
3110 }
3111 break;
3112 case 0x1d: /* fucomi */
3113 if (s->cc_op != CC_OP_DYNAMIC)
3114 gen_op_set_cc_op(s->cc_op);
3115 gen_op_fmov_FT0_STN(opreg);
3116 gen_op_fucomi_ST0_FT0();
3117 s->cc_op = CC_OP_EFLAGS;
3118 break;
3119 case 0x1e: /* fcomi */
3120 if (s->cc_op != CC_OP_DYNAMIC)
3121 gen_op_set_cc_op(s->cc_op);
3122 gen_op_fmov_FT0_STN(opreg);
3123 gen_op_fcomi_ST0_FT0();
3124 s->cc_op = CC_OP_EFLAGS;
3125 break;
3126 case 0x2a: /* fst sti */
3127 gen_op_fmov_STN_ST0(opreg);
3128 break;
3129 case 0x2b: /* fstp sti */
3130 gen_op_fmov_STN_ST0(opreg);
3131 gen_op_fpop();
3132 break;
3133 case 0x2c: /* fucom st(i) */
3134 gen_op_fmov_FT0_STN(opreg);
3135 gen_op_fucom_ST0_FT0();
3136 break;
3137 case 0x2d: /* fucomp st(i) */
3138 gen_op_fmov_FT0_STN(opreg);
3139 gen_op_fucom_ST0_FT0();
3140 gen_op_fpop();
3141 break;
3142 case 0x33: /* de/3 */
3143 switch(rm) {
3144 case 1: /* fcompp */
3145 gen_op_fmov_FT0_STN(1);
3146 gen_op_fcom_ST0_FT0();
3147 gen_op_fpop();
3148 gen_op_fpop();
3149 break;
3150 default:
3151 goto illegal_op;
3152 }
3153 break;
3154 case 0x3c: /* df/4 */
3155 switch(rm) {
3156 case 0:
3157 gen_op_fnstsw_EAX();
3158 break;
3159 default:
3160 goto illegal_op;
3161 }
3162 break;
3163 case 0x3d: /* fucomip */
3164 if (s->cc_op != CC_OP_DYNAMIC)
3165 gen_op_set_cc_op(s->cc_op);
3166 gen_op_fmov_FT0_STN(opreg);
3167 gen_op_fucomi_ST0_FT0();
3168 gen_op_fpop();
3169 s->cc_op = CC_OP_EFLAGS;
3170 break;
3171 case 0x3e: /* fcomip */
3172 if (s->cc_op != CC_OP_DYNAMIC)
3173 gen_op_set_cc_op(s->cc_op);
3174 gen_op_fmov_FT0_STN(opreg);
3175 gen_op_fcomi_ST0_FT0();
3176 gen_op_fpop();
3177 s->cc_op = CC_OP_EFLAGS;
3178 break;
3179 default:
3180 goto illegal_op;
3181 }
3182 }
3183 break;
3184 /************************/
3185 /* string ops */
3186
3187 case 0xa4: /* movsS */
3188 case 0xa5:
3189 if ((b & 1) == 0)
3190 ot = OT_BYTE;
3191 else
3192 ot = dflag ? OT_LONG : OT_WORD;
3193
3194 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
3195 gen_repz_movs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
3196 } else {
3197 gen_movs(s, ot);
3198 }
3199 break;
3200
3201 case 0xaa: /* stosS */
3202 case 0xab:
3203 if ((b & 1) == 0)
3204 ot = OT_BYTE;
3205 else
3206 ot = dflag ? OT_LONG : OT_WORD;
3207
3208 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
3209 gen_repz_stos(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
3210 } else {
3211 gen_stos(s, ot);
3212 }
3213 break;
3214 case 0xac: /* lodsS */
3215 case 0xad:
3216 if ((b & 1) == 0)
3217 ot = OT_BYTE;
3218 else
3219 ot = dflag ? OT_LONG : OT_WORD;
3220 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
3221 gen_repz_lods(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
3222 } else {
3223 gen_lods(s, ot);
3224 }
3225 break;
3226 case 0xae: /* scasS */
3227 case 0xaf:
3228 if ((b & 1) == 0)
3229 ot = OT_BYTE;
3230 else
3231 ot = dflag ? OT_LONG : OT_WORD;
3232 if (prefixes & PREFIX_REPNZ) {
3233 gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
3234 } else if (prefixes & PREFIX_REPZ) {
3235 gen_repz_scas(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
3236 } else {
3237 gen_scas(s, ot);
3238 s->cc_op = CC_OP_SUBB + ot;
3239 }
3240 break;
3241
3242 case 0xa6: /* cmpsS */
3243 case 0xa7:
3244 if ((b & 1) == 0)
3245 ot = OT_BYTE;
3246 else
3247 ot = dflag ? OT_LONG : OT_WORD;
3248 if (prefixes & PREFIX_REPNZ) {
3249 gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 1);
3250 } else if (prefixes & PREFIX_REPZ) {
3251 gen_repz_cmps(s, ot, pc_start - s->cs_base, s->pc - s->cs_base, 0);
3252 } else {
3253 gen_cmps(s, ot);
3254 s->cc_op = CC_OP_SUBB + ot;
3255 }
3256 break;
3257 case 0x6c: /* insS */
3258 case 0x6d:
f115e911
FB		 3259 if ((b & 1) == 0)
3260 ot = OT_BYTE;
3261 else
3262 ot = dflag ? OT_LONG : OT_WORD;
3263 gen_check_io(s, ot, 1, pc_start - s->cs_base);
3264 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
3265 gen_repz_ins(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
2c0262af 3266 } else {
f115e911 3267 gen_ins(s, ot);
2c0262af
FB		 3268 }
3269 break;
3270 case 0x6e: /* outsS */
3271 case 0x6f:
f115e911
FB		 3272 if ((b & 1) == 0)
3273 ot = OT_BYTE;
3274 else
3275 ot = dflag ? OT_LONG : OT_WORD;
3276 gen_check_io(s, ot, 1, pc_start - s->cs_base);
3277 if (prefixes & (PREFIX_REPZ | PREFIX_REPNZ)) {
3278 gen_repz_outs(s, ot, pc_start - s->cs_base, s->pc - s->cs_base);
2c0262af 3279 } else {
f115e911 3280 gen_outs(s, ot);
2c0262af
FB		 3281 }
3282 break;
3283
3284 /************************/
3285 /* port I/O */
3286 case 0xe4:
3287 case 0xe5:
f115e911
FB		 3288 if ((b & 1) == 0)
3289 ot = OT_BYTE;
3290 else
3291 ot = dflag ? OT_LONG : OT_WORD;
3292 val = ldub_code(s->pc++);
3293 gen_op_movl_T0_im(val);
3294 gen_check_io(s, ot, 0, pc_start - s->cs_base);
3295 gen_op_in[ot]();
3296 gen_op_mov_reg_T1[ot][R_EAX]();
2c0262af
FB		 3297 break;
3298 case 0xe6:
3299 case 0xe7:
f115e911
FB		 3300 if ((b & 1) == 0)
3301 ot = OT_BYTE;
3302 else
3303 ot = dflag ? OT_LONG : OT_WORD;
3304 val = ldub_code(s->pc++);
3305 gen_op_movl_T0_im(val);
3306 gen_check_io(s, ot, 0, pc_start - s->cs_base);
3307 gen_op_mov_TN_reg[ot][1][R_EAX]();
3308 gen_op_out[ot]();
2c0262af
FB		 3309 break;
3310 case 0xec:
3311 case 0xed:
f115e911
FB		 3312 if ((b & 1) == 0)
3313 ot = OT_BYTE;
3314 else
3315 ot = dflag ? OT_LONG : OT_WORD;
3316 gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
3317 gen_check_io(s, ot, 0, pc_start - s->cs_base);
3318 gen_op_in[ot]();
3319 gen_op_mov_reg_T1[ot][R_EAX]();
2c0262af
FB		 3320 break;
3321 case 0xee:
3322 case 0xef:
f115e911
FB		 3323 if ((b & 1) == 0)
3324 ot = OT_BYTE;
3325 else
3326 ot = dflag ? OT_LONG : OT_WORD;
3327 gen_op_mov_TN_reg[OT_WORD][0][R_EDX]();
3328 gen_check_io(s, ot, 0, pc_start - s->cs_base);
3329 gen_op_mov_TN_reg[ot][1][R_EAX]();
3330 gen_op_out[ot]();
2c0262af
FB		 3331 break;
3332
3333 /************************/
3334 /* control */
3335 case 0xc2: /* ret im */
61382a50 3336 val = ldsw_code(s->pc);
2c0262af
FB		 3337 s->pc += 2;
3338 gen_pop_T0(s);
3339 gen_stack_update(s, val + (2 << s->dflag));
3340 if (s->dflag == 0)
3341 gen_op_andl_T0_ffff();
3342 gen_op_jmp_T0();
3343 gen_eob(s);
3344 break;
3345 case 0xc3: /* ret */
3346 gen_pop_T0(s);
3347 gen_pop_update(s);
3348 if (s->dflag == 0)
3349 gen_op_andl_T0_ffff();
3350 gen_op_jmp_T0();
3351 gen_eob(s);
3352 break;
3353 case 0xca: /* lret im */
61382a50 3354 val = ldsw_code(s->pc);
2c0262af
FB		 3355 s->pc += 2;
3356 do_lret:
3357 if (s->pe && !s->vm86) {
3358 if (s->cc_op != CC_OP_DYNAMIC)
3359 gen_op_set_cc_op(s->cc_op);
3360 gen_op_jmp_im(pc_start - s->cs_base);
3361 gen_op_lret_protected(s->dflag, val);
3362 } else {
3363 gen_stack_A0(s);
3364 /* pop offset */
3365 gen_op_ld_T0_A0[1 + s->dflag + s->mem_index]();
3366 if (s->dflag == 0)
3367 gen_op_andl_T0_ffff();
3368 /* NOTE: keeping EIP updated is not a problem in case of
3369 exception */
3370 gen_op_jmp_T0();
3371 /* pop selector */
3372 gen_op_addl_A0_im(2 << s->dflag);
3373 gen_op_ld_T0_A0[1 + s->dflag + s->mem_index]();
3374 gen_op_movl_seg_T0_vm(offsetof(CPUX86State,segs[R_CS]));
3375 /* add stack offset */
3376 gen_stack_update(s, val + (4 << s->dflag));
3377 }
3378 gen_eob(s);
3379 break;
3380 case 0xcb: /* lret */
3381 val = 0;
3382 goto do_lret;
3383 case 0xcf: /* iret */
3384 if (!s->pe) {
3385 /* real mode */
3386 gen_op_iret_real(s->dflag);
3387 s->cc_op = CC_OP_EFLAGS;
f115e911
FB		 3388 } else if (s->vm86) {
3389 if (s->iopl != 3) {
3390 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3391 } else {
3392 gen_op_iret_real(s->dflag);
3393 s->cc_op = CC_OP_EFLAGS;
3394 }
2c0262af
FB		 3395 } else {
3396 if (s->cc_op != CC_OP_DYNAMIC)
3397 gen_op_set_cc_op(s->cc_op);
3398 gen_op_jmp_im(pc_start - s->cs_base);
3399 gen_op_iret_protected(s->dflag);
3400 s->cc_op = CC_OP_EFLAGS;
3401 }
3402 gen_eob(s);
3403 break;
3404 case 0xe8: /* call im */
3405 {
3406 unsigned int next_eip;
3407 ot = dflag ? OT_LONG : OT_WORD;
3408 val = insn_get(s, ot);
3409 next_eip = s->pc - s->cs_base;
3410 val += next_eip;
3411 if (s->dflag == 0)
3412 val &= 0xffff;
3413 gen_op_movl_T0_im(next_eip);
3414 gen_push_T0(s);
3415 gen_jmp(s, val);
3416 }
3417 break;
3418 case 0x9a: /* lcall im */
3419 {
3420 unsigned int selector, offset;
3421
3422 ot = dflag ? OT_LONG : OT_WORD;
3423 offset = insn_get(s, ot);
3424 selector = insn_get(s, OT_WORD);
3425
3426 gen_op_movl_T0_im(selector);
3427 gen_op_movl_T1_im(offset);
3428 }
3429 goto do_lcall;
3430 case 0xe9: /* jmp */
3431 ot = dflag ? OT_LONG : OT_WORD;
3432 val = insn_get(s, ot);
3433 val += s->pc - s->cs_base;
3434 if (s->dflag == 0)
3435 val = val & 0xffff;
3436 gen_jmp(s, val);
3437 break;
3438 case 0xea: /* ljmp im */
3439 {
3440 unsigned int selector, offset;
3441
3442 ot = dflag ? OT_LONG : OT_WORD;
3443 offset = insn_get(s, ot);
3444 selector = insn_get(s, OT_WORD);
3445
3446 gen_op_movl_T0_im(selector);
3447 gen_op_movl_T1_im(offset);
3448 }
3449 goto do_ljmp;
3450 case 0xeb: /* jmp Jb */
3451 val = (int8_t)insn_get(s, OT_BYTE);
3452 val += s->pc - s->cs_base;
3453 if (s->dflag == 0)
3454 val = val & 0xffff;
3455 gen_jmp(s, val);
3456 break;
3457 case 0x70 ... 0x7f: /* jcc Jb */
3458 val = (int8_t)insn_get(s, OT_BYTE);
3459 goto do_jcc;
3460 case 0x180 ... 0x18f: /* jcc Jv */
3461 if (dflag) {
3462 val = insn_get(s, OT_LONG);
3463 } else {
3464 val = (int16_t)insn_get(s, OT_WORD);
3465 }
3466 do_jcc:
3467 next_eip = s->pc - s->cs_base;
3468 val += next_eip;
3469 if (s->dflag == 0)
3470 val &= 0xffff;
3471 gen_jcc(s, b, val, next_eip);
3472 break;
3473
3474 case 0x190 ... 0x19f: /* setcc Gv */
61382a50 3475 modrm = ldub_code(s->pc++);
2c0262af
FB		 3476 gen_setcc(s, b);
3477 gen_ldst_modrm(s, modrm, OT_BYTE, OR_TMP0, 1);
3478 break;
3479 case 0x140 ... 0x14f: /* cmov Gv, Ev */
3480 ot = dflag ? OT_LONG : OT_WORD;
61382a50 3481 modrm = ldub_code(s->pc++);
2c0262af
FB		 3482 reg = (modrm >> 3) & 7;
3483 mod = (modrm >> 6) & 3;
3484 gen_setcc(s, b);
3485 if (mod != 3) {
3486 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3487 gen_op_ld_T1_A0[ot + s->mem_index]();
3488 } else {
3489 rm = modrm & 7;
3490 gen_op_mov_TN_reg[ot][1][rm]();
3491 }
3492 gen_op_cmov_reg_T1_T0[ot - OT_WORD][reg]();
3493 break;
3494
3495 /************************/
3496 /* flags */
3497 case 0x9c: /* pushf */
3498 if (s->vm86 && s->iopl != 3) {
3499 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3500 } else {
3501 if (s->cc_op != CC_OP_DYNAMIC)
3502 gen_op_set_cc_op(s->cc_op);
3503 gen_op_movl_T0_eflags();
3504 gen_push_T0(s);
3505 }
3506 break;
3507 case 0x9d: /* popf */
3508 if (s->vm86 && s->iopl != 3) {
3509 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3510 } else {
3511 gen_pop_T0(s);
3512 if (s->cpl == 0) {
3513 if (s->dflag) {
3514 gen_op_movl_eflags_T0_cpl0();
3515 } else {
3516 gen_op_movw_eflags_T0_cpl0();
3517 }
3518 } else {
3519 if (s->dflag) {
3520 gen_op_movl_eflags_T0();
3521 } else {
3522 gen_op_movw_eflags_T0();
3523 }
3524 }
3525 gen_pop_update(s);
3526 s->cc_op = CC_OP_EFLAGS;
3527 /* abort translation because TF flag may change */
3528 gen_op_jmp_im(s->pc - s->cs_base);
3529 gen_eob(s);
3530 }
3531 break;
3532 case 0x9e: /* sahf */
3533 gen_op_mov_TN_reg[OT_BYTE][0][R_AH]();
3534 if (s->cc_op != CC_OP_DYNAMIC)
3535 gen_op_set_cc_op(s->cc_op);
3536 gen_op_movb_eflags_T0();
3537 s->cc_op = CC_OP_EFLAGS;
3538 break;
3539 case 0x9f: /* lahf */
3540 if (s->cc_op != CC_OP_DYNAMIC)
3541 gen_op_set_cc_op(s->cc_op);
3542 gen_op_movl_T0_eflags();
3543 gen_op_mov_reg_T0[OT_BYTE][R_AH]();
3544 break;
3545 case 0xf5: /* cmc */
3546 if (s->cc_op != CC_OP_DYNAMIC)
3547 gen_op_set_cc_op(s->cc_op);
3548 gen_op_cmc();
3549 s->cc_op = CC_OP_EFLAGS;
3550 break;
3551 case 0xf8: /* clc */
3552 if (s->cc_op != CC_OP_DYNAMIC)
3553 gen_op_set_cc_op(s->cc_op);
3554 gen_op_clc();
3555 s->cc_op = CC_OP_EFLAGS;
3556 break;
3557 case 0xf9: /* stc */
3558 if (s->cc_op != CC_OP_DYNAMIC)
3559 gen_op_set_cc_op(s->cc_op);
3560 gen_op_stc();
3561 s->cc_op = CC_OP_EFLAGS;
3562 break;
3563 case 0xfc: /* cld */
3564 gen_op_cld();
3565 break;
3566 case 0xfd: /* std */
3567 gen_op_std();
3568 break;
3569
3570 /************************/
3571 /* bit operations */
3572 case 0x1ba: /* bt/bts/btr/btc Gv, im */
3573 ot = dflag ? OT_LONG : OT_WORD;
61382a50 3574 modrm = ldub_code(s->pc++);
2c0262af
FB		 3575 op = (modrm >> 3) & 7;
3576 mod = (modrm >> 6) & 3;
3577 rm = modrm & 7;
3578 if (mod != 3) {
3579 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3580 gen_op_ld_T0_A0[ot + s->mem_index]();
3581 } else {
3582 gen_op_mov_TN_reg[ot][0][rm]();
3583 }
3584 /* load shift */
61382a50 3585 val = ldub_code(s->pc++);
2c0262af
FB		 3586 gen_op_movl_T1_im(val);
3587 if (op < 4)
3588 goto illegal_op;
3589 op -= 4;
3590 gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
3591 s->cc_op = CC_OP_SARB + ot;
3592 if (op != 0) {
3593 if (mod != 3)
3594 gen_op_st_T0_A0[ot + s->mem_index]();
3595 else
3596 gen_op_mov_reg_T0[ot][rm]();
3597 gen_op_update_bt_cc();
3598 }
3599 break;
3600 case 0x1a3: /* bt Gv, Ev */
3601 op = 0;
3602 goto do_btx;
3603 case 0x1ab: /* bts */
3604 op = 1;
3605 goto do_btx;
3606 case 0x1b3: /* btr */
3607 op = 2;
3608 goto do_btx;
3609 case 0x1bb: /* btc */
3610 op = 3;
3611 do_btx:
3612 ot = dflag ? OT_LONG : OT_WORD;
61382a50 3613 modrm = ldub_code(s->pc++);
2c0262af
FB		 3614 reg = (modrm >> 3) & 7;
3615 mod = (modrm >> 6) & 3;
3616 rm = modrm & 7;
3617 gen_op_mov_TN_reg[OT_LONG][1][reg]();
3618 if (mod != 3) {
3619 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3620 /* specific case: we need to add a displacement */
3621 if (ot == OT_WORD)
3622 gen_op_add_bitw_A0_T1();
3623 else
3624 gen_op_add_bitl_A0_T1();
3625 gen_op_ld_T0_A0[ot + s->mem_index]();
3626 } else {
3627 gen_op_mov_TN_reg[ot][0][rm]();
3628 }
3629 gen_op_btx_T0_T1_cc[ot - OT_WORD][op]();
3630 s->cc_op = CC_OP_SARB + ot;
3631 if (op != 0) {
3632 if (mod != 3)
3633 gen_op_st_T0_A0[ot + s->mem_index]();
3634 else
3635 gen_op_mov_reg_T0[ot][rm]();
3636 gen_op_update_bt_cc();
3637 }
3638 break;
3639 case 0x1bc: /* bsf */
3640 case 0x1bd: /* bsr */
3641 ot = dflag ? OT_LONG : OT_WORD;
61382a50 3642 modrm = ldub_code(s->pc++);
2c0262af
FB		 3643 reg = (modrm >> 3) & 7;
3644 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
3645 gen_op_bsx_T0_cc[ot - OT_WORD][b & 1]();
3646 /* NOTE: we always write back the result. Intel doc says it is
3647 undefined if T0 == 0 */
3648 gen_op_mov_reg_T0[ot][reg]();
3649 s->cc_op = CC_OP_LOGICB + ot;
3650 break;
3651 /************************/
3652 /* bcd */
3653 case 0x27: /* daa */
3654 if (s->cc_op != CC_OP_DYNAMIC)
3655 gen_op_set_cc_op(s->cc_op);
3656 gen_op_daa();
3657 s->cc_op = CC_OP_EFLAGS;
3658 break;
3659 case 0x2f: /* das */
3660 if (s->cc_op != CC_OP_DYNAMIC)
3661 gen_op_set_cc_op(s->cc_op);
3662 gen_op_das();
3663 s->cc_op = CC_OP_EFLAGS;
3664 break;
3665 case 0x37: /* aaa */
3666 if (s->cc_op != CC_OP_DYNAMIC)
3667 gen_op_set_cc_op(s->cc_op);
3668 gen_op_aaa();
3669 s->cc_op = CC_OP_EFLAGS;
3670 break;
3671 case 0x3f: /* aas */
3672 if (s->cc_op != CC_OP_DYNAMIC)
3673 gen_op_set_cc_op(s->cc_op);
3674 gen_op_aas();
3675 s->cc_op = CC_OP_EFLAGS;
3676 break;
3677 case 0xd4: /* aam */
61382a50 3678 val = ldub_code(s->pc++);
2c0262af
FB		 3679 gen_op_aam(val);
3680 s->cc_op = CC_OP_LOGICB;
3681 break;
3682 case 0xd5: /* aad */
61382a50 3683 val = ldub_code(s->pc++);
2c0262af
FB		 3684 gen_op_aad(val);
3685 s->cc_op = CC_OP_LOGICB;
3686 break;
3687 /************************/
3688 /* misc */
3689 case 0x90: /* nop */
3690 break;
3691 case 0x9b: /* fwait */
3692 break;
3693 case 0xcc: /* int3 */
3694 gen_interrupt(s, EXCP03_INT3, pc_start - s->cs_base, s->pc - s->cs_base);
3695 break;
3696 case 0xcd: /* int N */
61382a50 3697 val = ldub_code(s->pc++);
f115e911 3698 if (s->vm86 && s->iopl != 3) {
2c0262af 3699 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
f115e911
FB		 3700 } else {
3701 gen_interrupt(s, val, pc_start - s->cs_base, s->pc - s->cs_base);
3702 }
2c0262af
FB		 3703 break;
3704 case 0xce: /* into */
3705 if (s->cc_op != CC_OP_DYNAMIC)
3706 gen_op_set_cc_op(s->cc_op);
3707 gen_op_into(s->pc - s->cs_base);
3708 break;
3709 case 0xf1: /* icebp (undocumented, exits to external debugger) */
3710 gen_debug(s, pc_start - s->cs_base);
3711 break;
3712 case 0xfa: /* cli */
3713 if (!s->vm86) {
3714 if (s->cpl <= s->iopl) {
3715 gen_op_cli();
3716 } else {
3717 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3718 }
3719 } else {
3720 if (s->iopl == 3) {
3721 gen_op_cli();
3722 } else {
3723 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3724 }
3725 }
3726 break;
3727 case 0xfb: /* sti */
3728 if (!s->vm86) {
3729 if (s->cpl <= s->iopl) {
3730 gen_sti:
3731 gen_op_sti();
3732 /* interruptions are enabled only the first insn after sti */
3733 gen_op_set_inhibit_irq();
3734 /* give a chance to handle pending irqs */
3735 gen_op_jmp_im(s->pc - s->cs_base);
3736 gen_eob(s);
3737 } else {
3738 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3739 }
3740 } else {
3741 if (s->iopl == 3) {
3742 goto gen_sti;
3743 } else {
3744 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3745 }
3746 }
3747 break;
3748 case 0x62: /* bound */
3749 ot = dflag ? OT_LONG : OT_WORD;
61382a50 3750 modrm = ldub_code(s->pc++);
2c0262af
FB		 3751 reg = (modrm >> 3) & 7;
3752 mod = (modrm >> 6) & 3;
3753 if (mod == 3)
3754 goto illegal_op;
3755 gen_op_mov_reg_T0[ot][reg]();
3756 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3757 if (ot == OT_WORD)
3758 gen_op_boundw(pc_start - s->cs_base);
3759 else
3760 gen_op_boundl(pc_start - s->cs_base);
3761 break;
3762 case 0x1c8 ... 0x1cf: /* bswap reg */
3763 reg = b & 7;
3764 gen_op_mov_TN_reg[OT_LONG][0][reg]();
3765 gen_op_bswapl_T0();
3766 gen_op_mov_reg_T0[OT_LONG][reg]();
3767 break;
3768 case 0xd6: /* salc */
3769 if (s->cc_op != CC_OP_DYNAMIC)
3770 gen_op_set_cc_op(s->cc_op);
3771 gen_op_salc();
3772 break;
3773 case 0xe0: /* loopnz */
3774 case 0xe1: /* loopz */
3775 if (s->cc_op != CC_OP_DYNAMIC)
3776 gen_op_set_cc_op(s->cc_op);
3777 /* FALL THRU */
3778 case 0xe2: /* loop */
3779 case 0xe3: /* jecxz */
3780 val = (int8_t)insn_get(s, OT_BYTE);
3781 next_eip = s->pc - s->cs_base;
3782 val += next_eip;
3783 if (s->dflag == 0)
3784 val &= 0xffff;
3785 gen_op_loop[s->aflag][b & 3](val, next_eip);
3786 gen_eob(s);
3787 break;
3788 case 0x130: /* wrmsr */
3789 case 0x132: /* rdmsr */
3790 if (s->cpl != 0) {
3791 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3792 } else {
3793 if (b & 2)
3794 gen_op_rdmsr();
3795 else
3796 gen_op_wrmsr();
3797 }
3798 break;
3799 case 0x131: /* rdtsc */
3800 gen_op_rdtsc();
3801 break;
3802 case 0x1a2: /* cpuid */
3803 gen_op_cpuid();
3804 break;
3805 case 0xf4: /* hlt */
3806 if (s->cpl != 0) {
3807 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3808 } else {
3809 if (s->cc_op != CC_OP_DYNAMIC)
3810 gen_op_set_cc_op(s->cc_op);
3811 gen_op_jmp_im(s->pc - s->cs_base);
3812 gen_op_hlt();
3813 s->is_jmp = 3;
3814 }
3815 break;
3816 case 0x100:
61382a50 3817 modrm = ldub_code(s->pc++);
2c0262af
FB		 3818 mod = (modrm >> 6) & 3;
3819 op = (modrm >> 3) & 7;
3820 switch(op) {
3821 case 0: /* sldt */
f115e911
FB		 3822 if (!s->pe || s->vm86)
3823 goto illegal_op;
2c0262af
FB		 3824 gen_op_movl_T0_env(offsetof(CPUX86State,ldt.selector));
3825 ot = OT_WORD;
3826 if (mod == 3)
3827 ot += s->dflag;
3828 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
3829 break;
3830 case 2: /* lldt */
f115e911
FB		 3831 if (!s->pe || s->vm86)
3832 goto illegal_op;
2c0262af
FB		 3833 if (s->cpl != 0) {
3834 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3835 } else {
3836 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
3837 gen_op_jmp_im(pc_start - s->cs_base);
3838 gen_op_lldt_T0();
3839 }
3840 break;
3841 case 1: /* str */
f115e911
FB		 3842 if (!s->pe || s->vm86)
3843 goto illegal_op;
2c0262af
FB		 3844 gen_op_movl_T0_env(offsetof(CPUX86State,tr.selector));
3845 ot = OT_WORD;
3846 if (mod == 3)
3847 ot += s->dflag;
3848 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 1);
3849 break;
3850 case 3: /* ltr */
f115e911
FB		 3851 if (!s->pe || s->vm86)
3852 goto illegal_op;
2c0262af
FB		 3853 if (s->cpl != 0) {
3854 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3855 } else {
3856 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
3857 gen_op_jmp_im(pc_start - s->cs_base);
3858 gen_op_ltr_T0();
3859 }
3860 break;
3861 case 4: /* verr */
3862 case 5: /* verw */
f115e911
FB		 3863 if (!s->pe || s->vm86)
3864 goto illegal_op;
3865 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
3866 if (s->cc_op != CC_OP_DYNAMIC)
3867 gen_op_set_cc_op(s->cc_op);
3868 if (op == 4)
3869 gen_op_verr();
3870 else
3871 gen_op_verw();
3872 s->cc_op = CC_OP_EFLAGS;
3873 break;
2c0262af
FB		 3874 default:
3875 goto illegal_op;
3876 }
3877 break;
3878 case 0x101:
61382a50 3879 modrm = ldub_code(s->pc++);
2c0262af
FB		 3880 mod = (modrm >> 6) & 3;
3881 op = (modrm >> 3) & 7;
3882 switch(op) {
3883 case 0: /* sgdt */
3884 case 1: /* sidt */
3885 if (mod == 3)
3886 goto illegal_op;
3887 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3888 if (op == 0)
3889 gen_op_movl_T0_env(offsetof(CPUX86State,gdt.limit));
3890 else
3891 gen_op_movl_T0_env(offsetof(CPUX86State,idt.limit));
3892 gen_op_st_T0_A0[OT_WORD + s->mem_index]();
3893 gen_op_addl_A0_im(2);
3894 if (op == 0)
3895 gen_op_movl_T0_env(offsetof(CPUX86State,gdt.base));
3896 else
3897 gen_op_movl_T0_env(offsetof(CPUX86State,idt.base));
3898 if (!s->dflag)
3899 gen_op_andl_T0_im(0xffffff);
3900 gen_op_st_T0_A0[OT_LONG + s->mem_index]();
3901 break;
3902 case 2: /* lgdt */
3903 case 3: /* lidt */
3904 if (mod == 3)
3905 goto illegal_op;
3906 if (s->cpl != 0) {
3907 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3908 } else {
3909 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3910 gen_op_ld_T1_A0[OT_WORD + s->mem_index]();
3911 gen_op_addl_A0_im(2);
3912 gen_op_ld_T0_A0[OT_LONG + s->mem_index]();
3913 if (!s->dflag)
3914 gen_op_andl_T0_im(0xffffff);
3915 if (op == 2) {
3916 gen_op_movl_env_T0(offsetof(CPUX86State,gdt.base));
3917 gen_op_movl_env_T1(offsetof(CPUX86State,gdt.limit));
3918 } else {
3919 gen_op_movl_env_T0(offsetof(CPUX86State,idt.base));
3920 gen_op_movl_env_T1(offsetof(CPUX86State,idt.limit));
3921 }
3922 }
3923 break;
3924 case 4: /* smsw */
3925 gen_op_movl_T0_env(offsetof(CPUX86State,cr[0]));
3926 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 1);
3927 break;
3928 case 6: /* lmsw */
3929 if (s->cpl != 0) {
3930 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3931 } else {
3932 gen_ldst_modrm(s, modrm, OT_WORD, OR_TMP0, 0);
3933 gen_op_lmsw_T0();
d71b9a8b
FB		 3934 gen_op_jmp_im(s->pc - s->cs_base);
3935 gen_eob(s);
2c0262af
FB		 3936 }
3937 break;
3938 case 7: /* invlpg */
3939 if (s->cpl != 0) {
3940 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
3941 } else {
3942 if (mod == 3)
3943 goto illegal_op;
3944 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3945 gen_op_invlpg_A0();
3946 }
3947 break;
3948 default:
3949 goto illegal_op;
3950 }
3951 break;
f115e911
FB		 3952 case 0x63: /* arpl */
3953 if (!s->pe || s->vm86)
3954 goto illegal_op;
3955 ot = dflag ? OT_LONG : OT_WORD;
3956 modrm = ldub_code(s->pc++);
3957 reg = (modrm >> 3) & 7;
3958 mod = (modrm >> 6) & 3;
3959 rm = modrm & 7;
3960 if (mod != 3) {
3961 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
3962 gen_op_ld_T0_A0[ot + s->mem_index]();
3963 } else {
3964 gen_op_mov_TN_reg[ot][0][rm]();
3965 }
3966 if (s->cc_op != CC_OP_DYNAMIC)
3967 gen_op_set_cc_op(s->cc_op);
3968 gen_op_arpl();
3969 s->cc_op = CC_OP_EFLAGS;
3970 if (mod != 3) {
3971 gen_op_st_T0_A0[ot + s->mem_index]();
3972 } else {
3973 gen_op_mov_reg_T0[ot][rm]();
3974 }
3975 gen_op_arpl_update();
3976 break;
2c0262af
FB		 3977 case 0x102: /* lar */
3978 case 0x103: /* lsl */
3979 if (!s->pe || s->vm86)
3980 goto illegal_op;
3981 ot = dflag ? OT_LONG : OT_WORD;
61382a50 3982 modrm = ldub_code(s->pc++);
2c0262af
FB		 3983 reg = (modrm >> 3) & 7;
3984 gen_ldst_modrm(s, modrm, ot, OR_TMP0, 0);
3985 gen_op_mov_TN_reg[ot][1][reg]();
3986 if (s->cc_op != CC_OP_DYNAMIC)
3987 gen_op_set_cc_op(s->cc_op);
3988 if (b == 0x102)
3989 gen_op_lar();
3990 else
3991 gen_op_lsl();
3992 s->cc_op = CC_OP_EFLAGS;
3993 gen_op_mov_reg_T1[ot][reg]();
3994 break;
3995 case 0x118:
61382a50 3996 modrm = ldub_code(s->pc++);
2c0262af
FB		 3997 mod = (modrm >> 6) & 3;
3998 op = (modrm >> 3) & 7;
3999 switch(op) {
4000 case 0: /* prefetchnta */
4001 case 1: /* prefetchnt0 */
4002 case 2: /* prefetchnt0 */
4003 case 3: /* prefetchnt0 */
4004 if (mod == 3)
4005 goto illegal_op;
4006 gen_lea_modrm(s, modrm, &reg_addr, &offset_addr);
4007 /* nothing more to do */
4008 break;
4009 default:
4010 goto illegal_op;
4011 }
4012 break;
4013 case 0x120: /* mov reg, crN */
4014 case 0x122: /* mov crN, reg */
4015 if (s->cpl != 0) {
4016 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
4017 } else {
61382a50 4018 modrm = ldub_code(s->pc++);
2c0262af
FB		 4019 if ((modrm & 0xc0) != 0xc0)
4020 goto illegal_op;
4021 rm = modrm & 7;
4022 reg = (modrm >> 3) & 7;
4023 switch(reg) {
4024 case 0:
4025 case 2:
4026 case 3:
4027 case 4:
4028 if (b & 2) {
4029 gen_op_mov_TN_reg[OT_LONG][0][rm]();
4030 gen_op_movl_crN_T0(reg);
4031 gen_op_jmp_im(s->pc - s->cs_base);
4032 gen_eob(s);
4033 } else {
4034 gen_op_movl_T0_env(offsetof(CPUX86State,cr[reg]));
4035 gen_op_mov_reg_T0[OT_LONG][rm]();
4036 }
4037 break;
4038 default:
4039 goto illegal_op;
4040 }
4041 }
4042 break;
4043 case 0x121: /* mov reg, drN */
4044 case 0x123: /* mov drN, reg */
4045 if (s->cpl != 0) {
4046 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
4047 } else {
61382a50 4048 modrm = ldub_code(s->pc++);
2c0262af
FB		 4049 if ((modrm & 0xc0) != 0xc0)
4050 goto illegal_op;
4051 rm = modrm & 7;
4052 reg = (modrm >> 3) & 7;
4053 /* XXX: do it dynamically with CR4.DE bit */
4054 if (reg == 4 || reg == 5)
4055 goto illegal_op;
4056 if (b & 2) {
4057 gen_op_mov_TN_reg[OT_LONG][0][rm]();
4058 gen_op_movl_drN_T0(reg);
4059 gen_op_jmp_im(s->pc - s->cs_base);
4060 gen_eob(s);
4061 } else {
4062 gen_op_movl_T0_env(offsetof(CPUX86State,dr[reg]));
4063 gen_op_mov_reg_T0[OT_LONG][rm]();
4064 }
4065 }
4066 break;
4067 case 0x106: /* clts */
4068 if (s->cpl != 0) {
4069 gen_exception(s, EXCP0D_GPF, pc_start - s->cs_base);
4070 } else {
4071 gen_op_clts();
4072 }
4073 break;
4074 default:
4075 goto illegal_op;
4076 }
4077 /* lock generation */
4078 if (s->prefix & PREFIX_LOCK)
4079 gen_op_unlock();
4080 return s->pc;
4081 illegal_op:
4082 /* XXX: ensure that no lock was generated */
4083 gen_exception(s, EXCP06_ILLOP, pc_start - s->cs_base);
4084 return s->pc;
4085}
4086
4087#define CC_OSZAPC (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C)
4088#define CC_OSZAP (CC_O | CC_S | CC_Z | CC_A | CC_P)
4089
4090/* flags read by an operation */
4091static uint16_t opc_read_flags[NB_OPS] = {
4092 [INDEX_op_aas] = CC_A,
4093 [INDEX_op_aaa] = CC_A,
4094 [INDEX_op_das] = CC_A | CC_C,
4095 [INDEX_op_daa] = CC_A | CC_C,
4096
4097 [INDEX_op_adcb_T0_T1_cc] = CC_C,
4098 [INDEX_op_adcw_T0_T1_cc] = CC_C,
4099 [INDEX_op_adcl_T0_T1_cc] = CC_C,
4100 [INDEX_op_sbbb_T0_T1_cc] = CC_C,
4101 [INDEX_op_sbbw_T0_T1_cc] = CC_C,
4102 [INDEX_op_sbbl_T0_T1_cc] = CC_C,
4103
4104 [INDEX_op_adcb_mem_T0_T1_cc] = CC_C,
4105 [INDEX_op_adcw_mem_T0_T1_cc] = CC_C,
4106 [INDEX_op_adcl_mem_T0_T1_cc] = CC_C,
4107 [INDEX_op_sbbb_mem_T0_T1_cc] = CC_C,
4108 [INDEX_op_sbbw_mem_T0_T1_cc] = CC_C,
4109 [INDEX_op_sbbl_mem_T0_T1_cc] = CC_C,
4110
4111 /* subtle: due to the incl/decl implementation, C is used */
4112 [INDEX_op_update_inc_cc] = CC_C,
4113
4114 [INDEX_op_into] = CC_O,
4115
4116 [INDEX_op_jb_subb] = CC_C,
4117 [INDEX_op_jb_subw] = CC_C,
4118 [INDEX_op_jb_subl] = CC_C,
4119
4120 [INDEX_op_jz_subb] = CC_Z,
4121 [INDEX_op_jz_subw] = CC_Z,
4122 [INDEX_op_jz_subl] = CC_Z,
4123
4124 [INDEX_op_jbe_subb] = CC_Z | CC_C,
4125 [INDEX_op_jbe_subw] = CC_Z | CC_C,
4126 [INDEX_op_jbe_subl] = CC_Z | CC_C,
4127
4128 [INDEX_op_js_subb] = CC_S,
4129 [INDEX_op_js_subw] = CC_S,
4130 [INDEX_op_js_subl] = CC_S,
4131
4132 [INDEX_op_jl_subb] = CC_O | CC_S,
4133 [INDEX_op_jl_subw] = CC_O | CC_S,
4134 [INDEX_op_jl_subl] = CC_O | CC_S,
4135
4136 [INDEX_op_jle_subb] = CC_O | CC_S | CC_Z,
4137 [INDEX_op_jle_subw] = CC_O | CC_S | CC_Z,
4138 [INDEX_op_jle_subl] = CC_O | CC_S | CC_Z,
4139
4140 [INDEX_op_loopnzw] = CC_Z,
4141 [INDEX_op_loopnzl] = CC_Z,
4142 [INDEX_op_loopzw] = CC_Z,
4143 [INDEX_op_loopzl] = CC_Z,
4144
4145 [INDEX_op_seto_T0_cc] = CC_O,
4146 [INDEX_op_setb_T0_cc] = CC_C,
4147 [INDEX_op_setz_T0_cc] = CC_Z,
4148 [INDEX_op_setbe_T0_cc] = CC_Z | CC_C,
4149 [INDEX_op_sets_T0_cc] = CC_S,
4150 [INDEX_op_setp_T0_cc] = CC_P,
4151 [INDEX_op_setl_T0_cc] = CC_O | CC_S,
4152 [INDEX_op_setle_T0_cc] = CC_O | CC_S | CC_Z,
4153
4154 [INDEX_op_setb_T0_subb] = CC_C,
4155 [INDEX_op_setb_T0_subw] = CC_C,
4156 [INDEX_op_setb_T0_subl] = CC_C,
4157
4158 [INDEX_op_setz_T0_subb] = CC_Z,
4159 [INDEX_op_setz_T0_subw] = CC_Z,
4160 [INDEX_op_setz_T0_subl] = CC_Z,
4161
4162 [INDEX_op_setbe_T0_subb] = CC_Z | CC_C,
4163 [INDEX_op_setbe_T0_subw] = CC_Z | CC_C,
4164 [INDEX_op_setbe_T0_subl] = CC_Z | CC_C,
4165
4166 [INDEX_op_sets_T0_subb] = CC_S,
4167 [INDEX_op_sets_T0_subw] = CC_S,
4168 [INDEX_op_sets_T0_subl] = CC_S,
4169
4170 [INDEX_op_setl_T0_subb] = CC_O | CC_S,
4171 [INDEX_op_setl_T0_subw] = CC_O | CC_S,
4172 [INDEX_op_setl_T0_subl] = CC_O | CC_S,
4173
4174 [INDEX_op_setle_T0_subb] = CC_O | CC_S | CC_Z,
4175 [INDEX_op_setle_T0_subw] = CC_O | CC_S | CC_Z,
4176 [INDEX_op_setle_T0_subl] = CC_O | CC_S | CC_Z,
4177
4178 [INDEX_op_movl_T0_eflags] = CC_OSZAPC,
4179 [INDEX_op_cmc] = CC_C,
4180 [INDEX_op_salc] = CC_C,
4181
4182 [INDEX_op_rclb_T0_T1_cc] = CC_C,
4183 [INDEX_op_rclw_T0_T1_cc] = CC_C,
4184 [INDEX_op_rcll_T0_T1_cc] = CC_C,
4185 [INDEX_op_rcrb_T0_T1_cc] = CC_C,
4186 [INDEX_op_rcrw_T0_T1_cc] = CC_C,
4187 [INDEX_op_rcrl_T0_T1_cc] = CC_C,
4188
4189 [INDEX_op_rclb_mem_T0_T1_cc] = CC_C,
4190 [INDEX_op_rclw_mem_T0_T1_cc] = CC_C,
4191 [INDEX_op_rcll_mem_T0_T1_cc] = CC_C,
4192 [INDEX_op_rcrb_mem_T0_T1_cc] = CC_C,
4193 [INDEX_op_rcrw_mem_T0_T1_cc] = CC_C,
4194 [INDEX_op_rcrl_mem_T0_T1_cc] = CC_C,
4195};
4196
4197/* flags written by an operation */
4198static uint16_t opc_write_flags[NB_OPS] = {
4199 [INDEX_op_update2_cc] = CC_OSZAPC,
4200 [INDEX_op_update1_cc] = CC_OSZAPC,
4201 [INDEX_op_cmpl_T0_T1_cc] = CC_OSZAPC,
4202 [INDEX_op_update_neg_cc] = CC_OSZAPC,
4203 /* subtle: due to the incl/decl implementation, C is used */
4204 [INDEX_op_update_inc_cc] = CC_OSZAPC,
4205 [INDEX_op_testl_T0_T1_cc] = CC_OSZAPC,
4206
4207 [INDEX_op_adcb_T0_T1_cc] = CC_OSZAPC,
4208 [INDEX_op_adcw_T0_T1_cc] = CC_OSZAPC,
4209 [INDEX_op_adcl_T0_T1_cc] = CC_OSZAPC,
4210 [INDEX_op_sbbb_T0_T1_cc] = CC_OSZAPC,
4211 [INDEX_op_sbbw_T0_T1_cc] = CC_OSZAPC,
4212 [INDEX_op_sbbl_T0_T1_cc] = CC_OSZAPC,
4213
4214 [INDEX_op_adcb_mem_T0_T1_cc] = CC_OSZAPC,
4215 [INDEX_op_adcw_mem_T0_T1_cc] = CC_OSZAPC,
4216 [INDEX_op_adcl_mem_T0_T1_cc] = CC_OSZAPC,
4217 [INDEX_op_sbbb_mem_T0_T1_cc] = CC_OSZAPC,
4218 [INDEX_op_sbbw_mem_T0_T1_cc] = CC_OSZAPC,
4219 [INDEX_op_sbbl_mem_T0_T1_cc] = CC_OSZAPC,
4220
4221 [INDEX_op_mulb_AL_T0] = CC_OSZAPC,
4222 [INDEX_op_imulb_AL_T0] = CC_OSZAPC,
4223 [INDEX_op_mulw_AX_T0] = CC_OSZAPC,
4224 [INDEX_op_imulw_AX_T0] = CC_OSZAPC,
4225 [INDEX_op_mull_EAX_T0] = CC_OSZAPC,
4226 [INDEX_op_imull_EAX_T0] = CC_OSZAPC,
4227 [INDEX_op_imulw_T0_T1] = CC_OSZAPC,
4228 [INDEX_op_imull_T0_T1] = CC_OSZAPC,
4229
4230 /* bcd */
4231 [INDEX_op_aam] = CC_OSZAPC,
4232 [INDEX_op_aad] = CC_OSZAPC,
4233 [INDEX_op_aas] = CC_OSZAPC,
4234 [INDEX_op_aaa] = CC_OSZAPC,
4235 [INDEX_op_das] = CC_OSZAPC,
4236 [INDEX_op_daa] = CC_OSZAPC,
4237
4238 [INDEX_op_movb_eflags_T0] = CC_S | CC_Z | CC_A | CC_P | CC_C,
4239 [INDEX_op_movw_eflags_T0] = CC_OSZAPC,
4240 [INDEX_op_movl_eflags_T0] = CC_OSZAPC,
4241 [INDEX_op_clc] = CC_C,
4242 [INDEX_op_stc] = CC_C,
4243 [INDEX_op_cmc] = CC_C,
4244
4245 [INDEX_op_rolb_T0_T1_cc] = CC_O | CC_C,
4246 [INDEX_op_rolw_T0_T1_cc] = CC_O | CC_C,
4247 [INDEX_op_roll_T0_T1_cc] = CC_O | CC_C,
4248 [INDEX_op_rorb_T0_T1_cc] = CC_O | CC_C,
4249 [INDEX_op_rorw_T0_T1_cc] = CC_O | CC_C,
4250 [INDEX_op_rorl_T0_T1_cc] = CC_O | CC_C,
4251
4252 [INDEX_op_rclb_T0_T1_cc] = CC_O | CC_C,
4253 [INDEX_op_rclw_T0_T1_cc] = CC_O | CC_C,
4254 [INDEX_op_rcll_T0_T1_cc] = CC_O | CC_C,
4255 [INDEX_op_rcrb_T0_T1_cc] = CC_O | CC_C,
4256 [INDEX_op_rcrw_T0_T1_cc] = CC_O | CC_C,
4257 [INDEX_op_rcrl_T0_T1_cc] = CC_O | CC_C,
4258
4259 [INDEX_op_shlb_T0_T1_cc] = CC_OSZAPC,
4260 [INDEX_op_shlw_T0_T1_cc] = CC_OSZAPC,
4261 [INDEX_op_shll_T0_T1_cc] = CC_OSZAPC,
4262
4263 [INDEX_op_shrb_T0_T1_cc] = CC_OSZAPC,
4264 [INDEX_op_shrw_T0_T1_cc] = CC_OSZAPC,
4265 [INDEX_op_shrl_T0_T1_cc] = CC_OSZAPC,
4266
4267 [INDEX_op_sarb_T0_T1_cc] = CC_OSZAPC,
4268 [INDEX_op_sarw_T0_T1_cc] = CC_OSZAPC,
4269 [INDEX_op_sarl_T0_T1_cc] = CC_OSZAPC,
4270
4271 [INDEX_op_shldw_T0_T1_ECX_cc] = CC_OSZAPC,
4272 [INDEX_op_shldl_T0_T1_ECX_cc] = CC_OSZAPC,
4273 [INDEX_op_shldw_T0_T1_im_cc] = CC_OSZAPC,
4274 [INDEX_op_shldl_T0_T1_im_cc] = CC_OSZAPC,
4275
4276 [INDEX_op_shrdw_T0_T1_ECX_cc] = CC_OSZAPC,
4277 [INDEX_op_shrdl_T0_T1_ECX_cc] = CC_OSZAPC,
4278 [INDEX_op_shrdw_T0_T1_im_cc] = CC_OSZAPC,
4279 [INDEX_op_shrdl_T0_T1_im_cc] = CC_OSZAPC,
4280
4281 [INDEX_op_rolb_mem_T0_T1_cc] = CC_O | CC_C,
4282 [INDEX_op_rolw_mem_T0_T1_cc] = CC_O | CC_C,
4283 [INDEX_op_roll_mem_T0_T1_cc] = CC_O | CC_C,
4284 [INDEX_op_rorb_mem_T0_T1_cc] = CC_O | CC_C,
4285 [INDEX_op_rorw_mem_T0_T1_cc] = CC_O | CC_C,
4286 [INDEX_op_rorl_mem_T0_T1_cc] = CC_O | CC_C,
4287
4288 [INDEX_op_rclb_mem_T0_T1_cc] = CC_O | CC_C,
4289 [INDEX_op_rclw_mem_T0_T1_cc] = CC_O | CC_C,
4290 [INDEX_op_rcll_mem_T0_T1_cc] = CC_O | CC_C,
4291 [INDEX_op_rcrb_mem_T0_T1_cc] = CC_O | CC_C,
4292 [INDEX_op_rcrw_mem_T0_T1_cc] = CC_O | CC_C,
4293 [INDEX_op_rcrl_mem_T0_T1_cc] = CC_O | CC_C,
4294
4295 [INDEX_op_shlb_mem_T0_T1_cc] = CC_OSZAPC,
4296 [INDEX_op_shlw_mem_T0_T1_cc] = CC_OSZAPC,
4297 [INDEX_op_shll_mem_T0_T1_cc] = CC_OSZAPC,
4298
4299 [INDEX_op_shrb_mem_T0_T1_cc] = CC_OSZAPC,
4300 [INDEX_op_shrw_mem_T0_T1_cc] = CC_OSZAPC,
4301 [INDEX_op_shrl_mem_T0_T1_cc] = CC_OSZAPC,
4302
4303 [INDEX_op_sarb_mem_T0_T1_cc] = CC_OSZAPC,
4304 [INDEX_op_sarw_mem_T0_T1_cc] = CC_OSZAPC,
4305 [INDEX_op_sarl_mem_T0_T1_cc] = CC_OSZAPC,
4306
4307 [INDEX_op_shldw_mem_T0_T1_ECX_cc] = CC_OSZAPC,
4308 [INDEX_op_shldl_mem_T0_T1_ECX_cc] = CC_OSZAPC,
4309 [INDEX_op_shldw_mem_T0_T1_im_cc] = CC_OSZAPC,
4310 [INDEX_op_shldl_mem_T0_T1_im_cc] = CC_OSZAPC,
4311
4312 [INDEX_op_shrdw_mem_T0_T1_ECX_cc] = CC_OSZAPC,
4313 [INDEX_op_shrdl_mem_T0_T1_ECX_cc] = CC_OSZAPC,
4314 [INDEX_op_shrdw_mem_T0_T1_im_cc] = CC_OSZAPC,
4315 [INDEX_op_shrdl_mem_T0_T1_im_cc] = CC_OSZAPC,
4316
4317 [INDEX_op_btw_T0_T1_cc] = CC_OSZAPC,
4318 [INDEX_op_btl_T0_T1_cc] = CC_OSZAPC,
4319 [INDEX_op_btsw_T0_T1_cc] = CC_OSZAPC,
4320 [INDEX_op_btsl_T0_T1_cc] = CC_OSZAPC,
4321 [INDEX_op_btrw_T0_T1_cc] = CC_OSZAPC,
4322 [INDEX_op_btrl_T0_T1_cc] = CC_OSZAPC,
4323 [INDEX_op_btcw_T0_T1_cc] = CC_OSZAPC,
4324 [INDEX_op_btcl_T0_T1_cc] = CC_OSZAPC,
4325
4326 [INDEX_op_bsfw_T0_cc] = CC_OSZAPC,
4327 [INDEX_op_bsfl_T0_cc] = CC_OSZAPC,
4328 [INDEX_op_bsrw_T0_cc] = CC_OSZAPC,
4329 [INDEX_op_bsrl_T0_cc] = CC_OSZAPC,
4330
4331 [INDEX_op_cmpxchgb_T0_T1_EAX_cc] = CC_OSZAPC,
4332 [INDEX_op_cmpxchgw_T0_T1_EAX_cc] = CC_OSZAPC,
4333 [INDEX_op_cmpxchgl_T0_T1_EAX_cc] = CC_OSZAPC,
4334
4335 [INDEX_op_cmpxchgb_mem_T0_T1_EAX_cc] = CC_OSZAPC,
4336 [INDEX_op_cmpxchgw_mem_T0_T1_EAX_cc] = CC_OSZAPC,
4337 [INDEX_op_cmpxchgl_mem_T0_T1_EAX_cc] = CC_OSZAPC,
4338
4339 [INDEX_op_cmpxchg8b] = CC_Z,
4340 [INDEX_op_lar] = CC_Z,
4341 [INDEX_op_lsl] = CC_Z,
4342 [INDEX_op_fcomi_ST0_FT0] = CC_Z | CC_P | CC_C,
4343 [INDEX_op_fucomi_ST0_FT0] = CC_Z | CC_P | CC_C,
4344};
4345
4346/* simpler form of an operation if no flags need to be generated */
4347static uint16_t opc_simpler[NB_OPS] = {
4348 [INDEX_op_update2_cc] = INDEX_op_nop,
4349 [INDEX_op_update1_cc] = INDEX_op_nop,
4350 [INDEX_op_update_neg_cc] = INDEX_op_nop,
4351#if 0
4352 /* broken: CC_OP logic must be rewritten */
4353 [INDEX_op_update_inc_cc] = INDEX_op_nop,
4354#endif
4355 [INDEX_op_rolb_T0_T1_cc] = INDEX_op_rolb_T0_T1,
4356 [INDEX_op_rolw_T0_T1_cc] = INDEX_op_rolw_T0_T1,
4357 [INDEX_op_roll_T0_T1_cc] = INDEX_op_roll_T0_T1,
4358
4359 [INDEX_op_rorb_T0_T1_cc] = INDEX_op_rorb_T0_T1,
4360 [INDEX_op_rorw_T0_T1_cc] = INDEX_op_rorw_T0_T1,
4361 [INDEX_op_rorl_T0_T1_cc] = INDEX_op_rorl_T0_T1,
4362
4363 [INDEX_op_rolb_mem_T0_T1_cc] = INDEX_op_rolb_mem_T0_T1,
4364 [INDEX_op_rolw_mem_T0_T1_cc] = INDEX_op_rolw_mem_T0_T1,
4365 [INDEX_op_roll_mem_T0_T1_cc] = INDEX_op_roll_mem_T0_T1,
4366
4367 [INDEX_op_rorb_mem_T0_T1_cc] = INDEX_op_rorb_mem_T0_T1,
4368 [INDEX_op_rorw_mem_T0_T1_cc] = INDEX_op_rorw_mem_T0_T1,
4369 [INDEX_op_rorl_mem_T0_T1_cc] = INDEX_op_rorl_mem_T0_T1,
4370
4371 [INDEX_op_shlb_T0_T1_cc] = INDEX_op_shlb_T0_T1,
4372 [INDEX_op_shlw_T0_T1_cc] = INDEX_op_shlw_T0_T1,
4373 [INDEX_op_shll_T0_T1_cc] = INDEX_op_shll_T0_T1,
4374
4375 [INDEX_op_shrb_T0_T1_cc] = INDEX_op_shrb_T0_T1,
4376 [INDEX_op_shrw_T0_T1_cc] = INDEX_op_shrw_T0_T1,
4377 [INDEX_op_shrl_T0_T1_cc] = INDEX_op_shrl_T0_T1,
4378
4379 [INDEX_op_sarb_T0_T1_cc] = INDEX_op_sarb_T0_T1,
4380 [INDEX_op_sarw_T0_T1_cc] = INDEX_op_sarw_T0_T1,
4381 [INDEX_op_sarl_T0_T1_cc] = INDEX_op_sarl_T0_T1,
4382};
4383
4384void optimize_flags_init(void)
4385{
4386 int i;
4387 /* put default values in arrays */
4388 for(i = 0; i < NB_OPS; i++) {
4389 if (opc_simpler[i] == 0)
4390 opc_simpler[i] = i;
4391 }
4392}
4393
4394/* CPU flags computation optimization: we move backward thru the
4395 generated code to see which flags are needed. The operation is
4396 modified if suitable */
4397static void optimize_flags(uint16_t *opc_buf, int opc_buf_len)
4398{
4399 uint16_t *opc_ptr;
4400 int live_flags, write_flags, op;
4401
4402 opc_ptr = opc_buf + opc_buf_len;
4403 /* live_flags contains the flags needed by the next instructions
4404 in the code. At the end of the bloc, we consider that all the
4405 flags are live. */
4406 live_flags = CC_OSZAPC;
4407 while (opc_ptr > opc_buf) {
4408 op = *--opc_ptr;
4409 /* if none of the flags written by the instruction is used,
4410 then we can try to find a simpler instruction */
4411 write_flags = opc_write_flags[op];
4412 if ((live_flags & write_flags) == 0) {
4413 *opc_ptr = opc_simpler[op];
4414 }
4415 /* compute the live flags before the instruction */
4416 live_flags &= ~write_flags;
4417 live_flags |= opc_read_flags[op];
4418 }
4419}
4420
4421/* generate intermediate code in gen_opc_buf and gen_opparam_buf for
4422 basic block 'tb'. If search_pc is TRUE, also generate PC
4423 information for each intermediate instruction. */
4424static inline int gen_intermediate_code_internal(CPUState *env,
4425 TranslationBlock *tb,
4426 int search_pc)
4427{
4428 DisasContext dc1, *dc = &dc1;
4429 uint8_t *pc_ptr;
4430 uint16_t *gen_opc_end;
4431 int flags, j, lj;
4432 uint8_t *pc_start;
4433 uint8_t *cs_base;
4434
4435 /* generate intermediate code */
4436 pc_start = (uint8_t *)tb->pc;
4437 cs_base = (uint8_t *)tb->cs_base;
4438 flags = tb->flags;
4439
4440 dc->pe = env->cr[0] & CR0_PE_MASK;
4441 dc->code32 = (flags >> HF_CS32_SHIFT) & 1;
4442 dc->ss32 = (flags >> HF_SS32_SHIFT) & 1;
4443 dc->addseg = (flags >> HF_ADDSEG_SHIFT) & 1;
4444 dc->f_st = 0;
4445 dc->vm86 = (flags >> VM_SHIFT) & 1;
4446 dc->cpl = (flags >> HF_CPL_SHIFT) & 3;
4447 dc->iopl = (flags >> IOPL_SHIFT) & 3;
4448 dc->tf = (flags >> TF_SHIFT) & 1;
34865134 4449 dc->singlestep_enabled = env->singlestep_enabled;
2c0262af
FB		 4450 dc->cc_op = CC_OP_DYNAMIC;
4451 dc->cs_base = cs_base;
4452 dc->tb = tb;
4453 dc->popl_esp_hack = 0;
4454 /* select memory access functions */
4455 dc->mem_index = 0;
4456 if (flags & HF_SOFTMMU_MASK) {
4457 if (dc->cpl == 3)
4458 dc->mem_index = 6;
4459 else
4460 dc->mem_index = 3;
4461 }
4462 dc->jmp_opt = !(dc->tf || env->singlestep_enabled
415fa2ea 4463#ifndef CONFIG_SOFTMMU
2c0262af
FB		 4464 || (flags & HF_SOFTMMU_MASK)
4465#endif
4466 );
4467 gen_opc_ptr = gen_opc_buf;
4468 gen_opc_end = gen_opc_buf + OPC_MAX_SIZE;
4469 gen_opparam_ptr = gen_opparam_buf;
4470
4471 dc->is_jmp = DISAS_NEXT;
4472 pc_ptr = pc_start;
4473 lj = -1;
4474
4475 /* if irq were inhibited for the next instruction, we can disable
4476 them here as it is simpler (otherwise jumps would have to
4477 handled as special case) */
4478 if (flags & HF_INHIBIT_IRQ_MASK) {
4479 gen_op_reset_inhibit_irq();
4480 }
4481 for(;;) {
4482 if (env->nb_breakpoints > 0) {
4483 for(j = 0; j < env->nb_breakpoints; j++) {
4484 if (env->breakpoints[j] == (unsigned long)pc_ptr) {
4485 gen_debug(dc, pc_ptr - dc->cs_base);
4486 break;
4487 }
4488 }
4489 }
4490 if (search_pc) {
4491 j = gen_opc_ptr - gen_opc_buf;
4492 if (lj < j) {
4493 lj++;
4494 while (lj < j)
4495 gen_opc_instr_start[lj++] = 0;
4496 }
4497 gen_opc_pc[lj] = (uint32_t)pc_ptr;
4498 gen_opc_cc_op[lj] = dc->cc_op;
4499 gen_opc_instr_start[lj] = 1;
4500 }
4501 pc_ptr = disas_insn(dc, pc_ptr);
4502 /* stop translation if indicated */
4503 if (dc->is_jmp)
4504 break;
4505 /* if single step mode, we generate only one instruction and
4506 generate an exception */
34865134 4507 if (dc->tf || dc->singlestep_enabled) {
2c0262af
FB		 4508 gen_op_jmp_im(pc_ptr - dc->cs_base);
4509 gen_eob(dc);
4510 break;
4511 }
4512 /* if too long translation, stop generation too */
4513 if (gen_opc_ptr >= gen_opc_end ||
4514 (pc_ptr - pc_start) >= (TARGET_PAGE_SIZE - 32)) {
4515 gen_op_jmp_im(pc_ptr - dc->cs_base);
4516 gen_eob(dc);
4517 break;
4518 }
4519 }
4520 *gen_opc_ptr = INDEX_op_end;
4521 /* we don't forget to fill the last values */
4522 if (search_pc) {
4523 j = gen_opc_ptr - gen_opc_buf;
4524 lj++;
4525 while (lj <= j)
4526 gen_opc_instr_start[lj++] = 0;
4527 }
4528
4529#ifdef DEBUG_DISAS
4530 if (loglevel) {
4531 fprintf(logfile, "----------------\n");
4532 fprintf(logfile, "IN: %s\n", lookup_symbol(pc_start));
4533 disas(logfile, pc_start, pc_ptr - pc_start, 0, !dc->code32);
4534 fprintf(logfile, "\n");
4535
4536 fprintf(logfile, "OP:\n");
4537 dump_ops(gen_opc_buf, gen_opparam_buf);
4538 fprintf(logfile, "\n");
4539 }
4540#endif
4541
4542 /* optimize flag computations */
4543 optimize_flags(gen_opc_buf, gen_opc_ptr - gen_opc_buf);
4544
4545#ifdef DEBUG_DISAS
4546 if (loglevel) {
4547 fprintf(logfile, "AFTER FLAGS OPT:\n");
4548 dump_ops(gen_opc_buf, gen_opparam_buf);
4549 fprintf(logfile, "\n");
4550 }
4551#endif
4552 if (!search_pc)
4553 tb->size = pc_ptr - pc_start;
4554 return 0;
4555}
4556
4557int gen_intermediate_code(CPUState *env, TranslationBlock *tb)
4558{
4559 return gen_intermediate_code_internal(env, tb, 0);
4560}
4561
4562int gen_intermediate_code_pc(CPUState *env, TranslationBlock *tb)
4563{
4564 return gen_intermediate_code_internal(env, tb, 1);
4565}
4566
QEMU mirror