gwj / at91sam9263 · Commits

Commit 838104f60845adfa3ff5ad30e7f3a28c76f42bea

Authored by bellard
1 parent abf28337

removed 


git-svn-id: svn://svn.savannah.nongnu.org/qemu/trunk@3550 c046a42c-6fe2-441c-8c8c-71466251a162
Inline Side-by-side
Showing 1 changed file with 0 additions and 1323 deletions
target-i386/translate-copy.c deleted 100644 → 0
  View file @abf2833
1   -/*
2   - * i386 on 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 "config.h"
21   -
22   -#include <stdarg.h>
23   -#include <stdlib.h>
24   -#include <stdio.h>
25   -#include <string.h>
26   -#include <inttypes.h>
27   -#include <assert.h>
28   -
29   -#include "cpu.h"
30   -#include "exec-all.h"
31   -#include "disas.h"
32   -
33   -#ifdef USE_CODE_COPY
34   -
35   -#include <signal.h>
36   -#include <sys/mman.h>
37   -#include <sys/ucontext.h>
38   -
39   -extern char exec_loop;
40   -
41   -/* operand size */
42   -enum {
43   - OT_BYTE = 0,
44   - OT_WORD,
45   - OT_LONG,
46   - OT_QUAD,
47   -};
48   -
49   -#define PREFIX_REPZ 0x01
50   -#define PREFIX_REPNZ 0x02
51   -#define PREFIX_LOCK 0x04
52   -#define PREFIX_DATA 0x08
53   -#define PREFIX_ADR 0x10
54   -
55   -typedef struct DisasContext {
56   - /* current insn context */
57   - int override; /* -1 if no override */
58   - int prefix;
59   - int aflag, dflag;
60   - target_ulong pc; /* pc = eip + cs_base */
61   - int is_jmp; /* 1 = means jump (stop translation), 2 means CPU
62   - static state change (stop translation) */
63   - /* code output */
64   - uint8_t *gen_code_ptr;
65   - uint8_t *gen_code_start;
66   -
67   - /* current block context */
68   - target_ulong cs_base; /* base of CS segment */
69   - int pe; /* protected mode */
70   - int code32; /* 32 bit code segment */
71   - int f_st; /* currently unused */
72   - int vm86; /* vm86 mode */
73   - int cpl;
74   - int iopl;
75   - int flags;
76   - struct TranslationBlock *tb;
77   -} DisasContext;
78   -
79   -#define CPU_FIELD_OFFSET(field) offsetof(CPUState, field)
80   -
81   -#define CPU_SEG 0x64 /* fs override */
82   -
83   -static inline void gb(DisasContext *s, uint32_t val)
84   -{
85   - *s->gen_code_ptr++ = val;
86   -}
87   -
88   -static inline void gw(DisasContext *s, uint32_t val)
89   -{
90   - *s->gen_code_ptr++ = val;
91   - *s->gen_code_ptr++ = val >> 8;
92   -}
93   -
94   -static inline void gl(DisasContext *s, uint32_t val)
95   -{
96   - *s->gen_code_ptr++ = val;
97   - *s->gen_code_ptr++ = val >> 8;
98   - *s->gen_code_ptr++ = val >> 16;
99   - *s->gen_code_ptr++ = val >> 24;
100   -}
101   -
102   -static inline void gjmp(DisasContext *s, long val)
103   -{
104   - gb(s, 0xe9); /* jmp */
105   - gl(s, val - (long)(s->gen_code_ptr + 4));
106   -}
107   -
108   -static inline void gen_movl_addr_im(DisasContext *s,
109   - uint32_t addr, uint32_t val)
110   -{
111   - gb(s, CPU_SEG); /* seg movl im, addr */
112   - gb(s, 0xc7);
113   - gb(s, 0x05);
114   - gl(s, addr);
115   - gl(s, val);
116   -}
117   -
118   -static inline void gen_movw_addr_im(DisasContext *s,
119   - uint32_t addr, uint32_t val)
120   -{
121   - gb(s, CPU_SEG); /* seg movl im, addr */
122   - gb(s, 0x66);
123   - gb(s, 0xc7);
124   - gb(s, 0x05);
125   - gl(s, addr);
126   - gw(s, val);
127   -}
128   -
129   -
130   -static void gen_jmp(DisasContext *s, uint32_t target_eip)
131   -{
132   - TranslationBlock *tb = s->tb;
133   -
134   - gb(s, 0xe9); /* jmp */
135   - tb->tb_jmp_offset[0] = s->gen_code_ptr - s->gen_code_start;
136   - gl(s, 0);
137   -
138   - tb->tb_next_offset[0] = s->gen_code_ptr - s->gen_code_start;
139   - gen_movl_addr_im(s, CPU_FIELD_OFFSET(eip), target_eip);
140   - gen_movl_addr_im(s, CPU_FIELD_OFFSET(tmp0), (uint32_t)tb);
141   - gjmp(s, (long)&exec_loop);
142   -
143   - s->is_jmp = 1;
144   -}
145   -
146   -static void gen_jcc(DisasContext *s, int op,
147   - uint32_t target_eip, uint32_t next_eip)
148   -{
149   - TranslationBlock *tb = s->tb;
150   -
151   - gb(s, 0x0f); /* jcc */
152   - gb(s, 0x80 + op);
153   - tb->tb_jmp_offset[0] = s->gen_code_ptr - s->gen_code_start;
154   - gl(s, 0);
155   - gb(s, 0xe9); /* jmp */
156   - tb->tb_jmp_offset[1] = s->gen_code_ptr - s->gen_code_start;
157   - gl(s, 0);
158   -
159   - tb->tb_next_offset[0] = s->gen_code_ptr - s->gen_code_start;
160   - gen_movl_addr_im(s, CPU_FIELD_OFFSET(eip), target_eip);
161   - gen_movl_addr_im(s, CPU_FIELD_OFFSET(tmp0), (uint32_t)tb);
162   - gjmp(s, (long)&exec_loop);
163   -
164   - tb->tb_next_offset[1] = s->gen_code_ptr - s->gen_code_start;
165   - gen_movl_addr_im(s, CPU_FIELD_OFFSET(eip), next_eip);
166   - gen_movl_addr_im(s, CPU_FIELD_OFFSET(tmp0), (uint32_t)tb | 1);
167   - gjmp(s, (long)&exec_loop);
168   -
169   - s->is_jmp = 1;
170   -}
171   -
172   -static void gen_eob(DisasContext *s)
173   -{
174   - gen_movl_addr_im(s, CPU_FIELD_OFFSET(tmp0), 0);
175   - gjmp(s, (long)&exec_loop);
176   -
177   - s->is_jmp = 1;
178   -}
179   -
180   -static inline void gen_lea_modrm(DisasContext *s, int modrm)
181   -{
182   - int havesib;
183   - int base, disp;
184   - int index;
185   - int scale;
186   - int mod, rm, code;
187   -
188   - mod = (modrm >> 6) & 3;
189   - rm = modrm & 7;
190   -
191   - if (s->aflag) {
192   -
193   - havesib = 0;
194   - base = rm;
195   - index = 0;
196   - scale = 0;
197   -
198   - if (base == 4) {
199   - havesib = 1;
200   - code = ldub_code(s->pc++);
201   - scale = (code >> 6) & 3;
202   - index = (code >> 3) & 7;
203   - base = code & 7;
204   - }
205   -
206   - switch (mod) {
207   - case 0:
208   - if (base == 5) {
209   - base = -1;
210   - disp = ldl_code(s->pc);
211   - s->pc += 4;
212   - } else {
213   - disp = 0;
214   - }
215   - break;
216   - case 1:
217   - disp = (int8_t)ldub_code(s->pc++);
218   - break;
219   - default:
220   - case 2:
221   - disp = ldl_code(s->pc);
222   - s->pc += 4;
223   - break;
224   - }
225   -
226   - } else {
227   - switch (mod) {
228   - case 0:
229   - if (rm == 6) {
230   - disp = lduw_code(s->pc);
231   - s->pc += 2;
232   - } else {
233   - disp = 0;
234   - }
235   - break;
236   - case 1:
237   - disp = (int8_t)ldub_code(s->pc++);
238   - break;
239   - default:
240   - case 2:
241   - disp = lduw_code(s->pc);
242   - s->pc += 2;
243   - break;
244   - }
245   - }
246   -}
247   -
248   -static inline void parse_modrm(DisasContext *s, int modrm)
249   -{
250   - if ((modrm & 0xc0) != 0xc0)
251   - gen_lea_modrm(s, modrm);
252   -}
253   -
254   -static inline uint32_t insn_get(DisasContext *s, int ot)
255   -{
256   - uint32_t ret;
257   -
258   - switch(ot) {
259   - case OT_BYTE:
260   - ret = ldub_code(s->pc);
261   - s->pc++;
262   - break;
263   - case OT_WORD:
264   - ret = lduw_code(s->pc);
265   - s->pc += 2;
266   - break;
267   - default:
268   - case OT_LONG:
269   - ret = ldl_code(s->pc);
270   - s->pc += 4;
271   - break;
272   - }
273   - return ret;
274   -}
275   -
276   -/* convert one instruction. s->is_jmp is set if the translation must
277   - be stopped. */
278   -static int disas_insn(DisasContext *s)
279   -{
280   - target_ulong pc_start, pc_tmp, pc_start_insn;
281   - int b, prefixes, aflag, dflag, next_eip, val;
282   - int ot;
283   - int modrm, mod, op, rm;
284   -
285   - pc_start = s->pc;
286   - prefixes = 0;
287   - aflag = s->code32;
288   - dflag = s->code32;
289   - s->override = -1;
290   - next_byte:
291   - b = ldub_code(s->pc);
292   - s->pc++;
293   - /* check prefixes */
294   - switch (b) {
295   - case 0xf3:
296   - prefixes |= PREFIX_REPZ;
297   - goto next_byte;
298   - case 0xf2:
299   - prefixes |= PREFIX_REPNZ;
300   - goto next_byte;
301   - case 0xf0:
302   - prefixes |= PREFIX_LOCK;
303   - goto next_byte;
304   - case 0x2e:
305   - s->override = R_CS;
306   - goto next_byte;
307   - case 0x36:
308   - s->override = R_SS;
309   - goto next_byte;
310   - case 0x3e:
311   - s->override = R_DS;
312   - goto next_byte;
313   - case 0x26:
314   - s->override = R_ES;
315   - goto next_byte;
316   - case 0x64:
317   - s->override = R_FS;
318   - goto next_byte;
319   - case 0x65:
320   - s->override = R_GS;
321   - goto next_byte;
322   - case 0x66:
323   - prefixes |= PREFIX_DATA;
324   - goto next_byte;
325   - case 0x67:
326   - prefixes |= PREFIX_ADR;
327   - goto next_byte;
328   - }
329   -
330   - if (prefixes & PREFIX_DATA)
331   - dflag ^= 1;
332   - if (prefixes & PREFIX_ADR)
333   - aflag ^= 1;
334   -
335   - s->prefix = prefixes;
336   - s->aflag = aflag;
337   - s->dflag = dflag;
338   -
339   - /* lock generation */
340   - if (prefixes & PREFIX_LOCK)
341   - goto unsupported_op;
342   - if (s->override == R_FS || s->override == R_GS || s->override == R_CS)
343   - goto unsupported_op;
344   -
345   - pc_start_insn = s->pc - 1;
346   - /* now check op code */
347   - reswitch:
348   - switch(b) {
349   - case 0x0f:
350   - /**************************/
351   - /* extended op code */
352   - b = ldub_code(s->pc++) | 0x100;
353   - goto reswitch;
354   -
355   - /**************************/
356   - /* arith & logic */
357   - case 0x00 ... 0x05:
358   - case 0x08 ... 0x0d:
359   - case 0x10 ... 0x15:
360   - case 0x18 ... 0x1d:
361   - case 0x20 ... 0x25:
362   - case 0x28 ... 0x2d:
363   - case 0x30 ... 0x35:
364   - case 0x38 ... 0x3d:
365   - {
366   - int f;
367   - f = (b >> 1) & 3;
368   -
369   - if ((b & 1) == 0)
370   - ot = OT_BYTE;
371   - else
372   - ot = dflag ? OT_LONG : OT_WORD;
373   -
374   - switch(f) {
375   - case 0: /* OP Ev, Gv */
376   - modrm = ldub_code(s->pc++);
377   - parse_modrm(s, modrm);
378   - break;
379   - case 1: /* OP Gv, Ev */
380   - modrm = ldub_code(s->pc++);
381   - parse_modrm(s, modrm);
382   - break;
383   - case 2: /* OP A, Iv */
384   - insn_get(s, ot);
385   - break;
386   - }
387   - }
388   - break;
389   -
390   - case 0x80: /* GRP1 */
391   - case 0x81:
392   - case 0x82:
393   - case 0x83:
394   - {
395   - if ((b & 1) == 0)
396   - ot = OT_BYTE;
397   - else
398   - ot = dflag ? OT_LONG : OT_WORD;
399   -
400   - modrm = ldub_code(s->pc++);
401   - parse_modrm(s, modrm);
402   -
403   - switch(b) {
404   - default:
405   - case 0x80:
406   - case 0x81:
407   - case 0x82:
408   - insn_get(s, ot);
409   - break;
410   - case 0x83:
411   - insn_get(s, OT_BYTE);
412   - break;
413   - }
414   - }
415   - break;
416   -
417   - /**************************/
418   - /* inc, dec, and other misc arith */
419   - case 0x40 ... 0x47: /* inc Gv */
420   - break;
421   - case 0x48 ... 0x4f: /* dec Gv */
422   - break;
423   - case 0xf6: /* GRP3 */
424   - case 0xf7:
425   - if ((b & 1) == 0)
426   - ot = OT_BYTE;
427   - else
428   - ot = dflag ? OT_LONG : OT_WORD;
429   -
430   - modrm = ldub_code(s->pc++);
431   - op = (modrm >> 3) & 7;
432   - parse_modrm(s, modrm);
433   -
434   - switch(op) {
435   - case 0: /* test */
436   - insn_get(s, ot);
437   - break;
438   - case 2: /* not */
439   - break;
440   - case 3: /* neg */
441   - break;
442   - case 4: /* mul */
443   - break;
444   - case 5: /* imul */
445   - break;
446   - case 6: /* div */
447   - break;
448   - case 7: /* idiv */
449   - break;
450   - default:
451   - goto illegal_op;
452   - }
453   - break;
454   -
455   - case 0xfe: /* GRP4 */
456   - case 0xff: /* GRP5 */
457   - if ((b & 1) == 0)
458   - ot = OT_BYTE;
459   - else
460   - ot = dflag ? OT_LONG : OT_WORD;
461   -
462   - modrm = ldub_code(s->pc++);
463   - mod = (modrm >> 6) & 3;
464   - op = (modrm >> 3) & 7;
465   - if (op >= 2 && b == 0xfe) {
466   - goto illegal_op;
467   - }
468   - pc_tmp = s->pc;
469   - parse_modrm(s, modrm);
470   -
471   - switch(op) {
472   - case 0: /* inc Ev */
473   - break;
474   - case 1: /* dec Ev */
475   - break;
476   - case 2: /* call Ev */
477   - /* XXX: optimize and handle MEM exceptions specifically
478   - fs movl %eax, regs[0]
479   - movl Ev, %eax
480   - pushl next_eip
481   - fs movl %eax, eip
482   - */
483   - goto unsupported_op;
484   - case 3: /* lcall Ev */
485   - goto unsupported_op;
486   - case 4: /* jmp Ev */
487   - /* XXX: optimize and handle MEM exceptions specifically
488   - fs movl %eax, regs[0]
489   - movl Ev, %eax
490   - fs movl %eax, eip
491   - */
492   - goto unsupported_op;
493   - case 5: /* ljmp Ev */
494   - goto unsupported_op;
495   - case 6: /* push Ev */
496   - break;
497   - default:
498   - goto illegal_op;
499   - }
500   - break;
501   - case 0xa8: /* test eAX, Iv */
502   - case 0xa9:
503   - if ((b & 1) == 0)
504   - ot = OT_BYTE;
505   - else
506   - ot = dflag ? OT_LONG : OT_WORD;
507   - insn_get(s, ot);
508   - break;
509   -
510   - case 0x98: /* CWDE/CBW */
511   - break;
512   - case 0x99: /* CDQ/CWD */
513   - break;
514   - case 0x1af: /* imul Gv, Ev */
515   - case 0x69: /* imul Gv, Ev, I */
516   - case 0x6b:
517   - ot = dflag ? OT_LONG : OT_WORD;
518   - modrm = ldub_code(s->pc++);
519   - parse_modrm(s, modrm);
520   - if (b == 0x69) {
521   - insn_get(s, ot);
522   - } else if (b == 0x6b) {
523   - insn_get(s, OT_BYTE);
524   - } else {
525   - }
526   - break;
527   -
528   - case 0x84: /* test Ev, Gv */
529   - case 0x85:
530   -
531   - case 0x1c0:
532   - case 0x1c1: /* xadd Ev, Gv */
533   -
534   - case 0x1b0:
535   - case 0x1b1: /* cmpxchg Ev, Gv */
536   -
537   - case 0x8f: /* pop Ev */
538   -
539   - case 0x88:
540   - case 0x89: /* mov Gv, Ev */
541   -
542   - case 0x8a:
543   - case 0x8b: /* mov Ev, Gv */
544   -
545   - case 0x1b6: /* movzbS Gv, Eb */
546   - case 0x1b7: /* movzwS Gv, Eb */
547   - case 0x1be: /* movsbS Gv, Eb */
548   - case 0x1bf: /* movswS Gv, Eb */
549   -
550   - case 0x86:
551   - case 0x87: /* xchg Ev, Gv */
552   -
553   - case 0xd0:
554   - case 0xd1: /* shift Ev,1 */
555   -
556   - case 0xd2:
557   - case 0xd3: /* shift Ev,cl */
558   -
559   - case 0x1a5: /* shld cl */
560   - case 0x1ad: /* shrd cl */
561   -
562   - case 0x190 ... 0x19f: /* setcc Gv */
563   -
564   - /* XXX: emulate cmov if not available ? */
565   - case 0x140 ... 0x14f: /* cmov Gv, Ev */
566   -
567   - case 0x1a3: /* bt Gv, Ev */
568   - case 0x1ab: /* bts */
569   - case 0x1b3: /* btr */
570   - case 0x1bb: /* btc */
571   -
572   - case 0x1bc: /* bsf */
573   - case 0x1bd: /* bsr */
574   -
575   - modrm = ldub_code(s->pc++);
576   - parse_modrm(s, modrm);
577   - break;
578   -
579   - case 0x1c7: /* cmpxchg8b */
580   - modrm = ldub_code(s->pc++);
581   - mod = (modrm >> 6) & 3;
582   - if (mod == 3)
583   - goto illegal_op;
584   - parse_modrm(s, modrm);
585   - break;
586   -
587   - /**************************/
588   - /* push/pop */
589   - case 0x50 ... 0x57: /* push */
590   - case 0x58 ... 0x5f: /* pop */
591   - case 0x60: /* pusha */
592   - case 0x61: /* popa */
593   - break;
594   -
595   - case 0x68: /* push Iv */
596   - case 0x6a:
597   - ot = dflag ? OT_LONG : OT_WORD;
598   - if (b == 0x68)
599   - insn_get(s, ot);
600   - else
601   - insn_get(s, OT_BYTE);
602   - break;
603   - case 0xc8: /* enter */
604   - lduw_code(s->pc);
605   - s->pc += 2;
606   - ldub_code(s->pc++);
607   - break;
608   - case 0xc9: /* leave */
609   - break;
610   -
611   - case 0x06: /* push es */
612   - case 0x0e: /* push cs */
613   - case 0x16: /* push ss */
614   - case 0x1e: /* push ds */
615   - /* XXX: optimize:
616   - push segs[n].selector
617   - */
618   - goto unsupported_op;
619   - case 0x1a0: /* push fs */
620   - case 0x1a8: /* push gs */
621   - goto unsupported_op;
622   - case 0x07: /* pop es */
623   - case 0x17: /* pop ss */
624   - case 0x1f: /* pop ds */
625   - goto unsupported_op;
626   - case 0x1a1: /* pop fs */
627   - case 0x1a9: /* pop gs */
628   - goto unsupported_op;
629   - case 0x8e: /* mov seg, Gv */
630   - /* XXX: optimize:
631   - fs movl r, regs[]
632   - movl segs[].selector, r
633   - mov r, Gv
634   - fs movl regs[], r
635   - */
636   - goto unsupported_op;
637   - case 0x8c: /* mov Gv, seg */
638   - goto unsupported_op;
639   - case 0xc4: /* les Gv */
640   - op = R_ES;
641   - goto do_lxx;
642   - case 0xc5: /* lds Gv */
643   - op = R_DS;
644   - goto do_lxx;
645   - case 0x1b2: /* lss Gv */
646   - op = R_SS;
647   - goto do_lxx;
648   - case 0x1b4: /* lfs Gv */
649   - op = R_FS;
650   - goto do_lxx;
651   - case 0x1b5: /* lgs Gv */
652   - op = R_GS;
653   - do_lxx:
654   - goto unsupported_op;
655   - /************************/
656   - /* floats */
657   - case 0xd8 ... 0xdf:
658   -#if 1
659   - /* currently not stable enough */
660   - goto unsupported_op;
661   -#else
662   - if (s->flags & (HF_EM_MASK | HF_TS_MASK))
663   - goto unsupported_op;
664   -#endif
665   -#if 0
666   - /* for testing FPU context switch */
667   - {
668   - static int count;
669   - count = (count + 1) % 3;
670   - if (count != 0)
671   - goto unsupported_op;
672   - }
673   -#endif
674   - modrm = ldub_code(s->pc++);
675   - mod = (modrm >> 6) & 3;
676   - rm = modrm & 7;
677   - op = ((b & 7) << 3) | ((modrm >> 3) & 7);
678   - if (mod != 3) {
679   - /* memory op */
680   - parse_modrm(s, modrm);
681   - switch(op) {
682   - case 0x00 ... 0x07: /* fxxxs */
683   - case 0x10 ... 0x17: /* fixxxl */
684   - case 0x20 ... 0x27: /* fxxxl */
685   - case 0x30 ... 0x37: /* fixxx */
686   - break;
687   - case 0x08: /* flds */
688   - case 0x0a: /* fsts */
689   - case 0x0b: /* fstps */
690   - case 0x18: /* fildl */
691   - case 0x1a: /* fistl */
692   - case 0x1b: /* fistpl */
693   - case 0x28: /* fldl */
694   - case 0x2a: /* fstl */
695   - case 0x2b: /* fstpl */
696   - case 0x38: /* filds */
697   - case 0x3a: /* fists */
698   - case 0x3b: /* fistps */
699   - case 0x0c: /* fldenv mem */
700   - case 0x0d: /* fldcw mem */
701   - case 0x0e: /* fnstenv mem */
702   - case 0x0f: /* fnstcw mem */
703   - case 0x1d: /* fldt mem */
704   - case 0x1f: /* fstpt mem */
705   - case 0x2c: /* frstor mem */
706   - case 0x2e: /* fnsave mem */
707   - case 0x2f: /* fnstsw mem */
708   - case 0x3c: /* fbld */
709   - case 0x3e: /* fbstp */
710   - case 0x3d: /* fildll */
711   - case 0x3f: /* fistpll */
712   - break;
713   - default:
714   - goto illegal_op;
715   - }
716   - } else {
717   - /* register float ops */
718   - switch(op) {
719   - case 0x08: /* fld sti */
720   - case 0x09: /* fxchg sti */
721   - break;
722   - case 0x0a: /* grp d9/2 */
723   - switch(rm) {
724   - case 0: /* fnop */
725   - break;
726   - default:
727   - goto illegal_op;
728   - }
729   - break;
730   - case 0x0c: /* grp d9/4 */
731   - switch(rm) {
732   - case 0: /* fchs */
733   - case 1: /* fabs */
734   - case 4: /* ftst */
735   - case 5: /* fxam */
736   - break;
737   - default:
738   - goto illegal_op;
739   - }
740   - break;
741   - case 0x0d: /* grp d9/5 */
742   - switch(rm) {
743   - case 0:
744   - case 1:
745   - case 2:
746   - case 3:
747   - case 4:
748   - case 5:
749   - case 6:
750   - break;
751   - default:
752   - goto illegal_op;
753   - }
754   - break;
755   - case 0x0e: /* grp d9/6 */
756   - break;
757   - case 0x0f: /* grp d9/7 */
758   - break;
759   - case 0x00: case 0x01: case 0x04 ... 0x07: /* fxxx st, sti */
760   - case 0x20: case 0x21: case 0x24 ... 0x27: /* fxxx sti, st */
761   - case 0x30: case 0x31: case 0x34 ... 0x37: /* fxxxp sti, st */
762   - break;
763   - case 0x02: /* fcom */
764   - break;
765   - case 0x03: /* fcomp */
766   - break;
767   - case 0x15: /* da/5 */
768   - switch(rm) {
769   - case 1: /* fucompp */
770   - break;
771   - default:
772   - goto illegal_op;
773   - }
774   - break;
775   - case 0x1c:
776   - switch(rm) {
777   - case 0: /* feni (287 only, just do nop here) */
778   - case 1: /* fdisi (287 only, just do nop here) */
779   - goto unsupported_op;
780   - case 2: /* fclex */
781   - case 3: /* fninit */
782   - case 4: /* fsetpm (287 only, just do nop here) */
783   - break;
784   - default:
785   - goto illegal_op;
786   - }
787   - break;
788   - case 0x1d: /* fucomi */
789   - break;
790   - case 0x1e: /* fcomi */
791   - break;
792   - case 0x28: /* ffree sti */
793   - break;
794   - case 0x2a: /* fst sti */
795   - break;
796   - case 0x2b: /* fstp sti */
797   - break;
798   - case 0x2c: /* fucom st(i) */
799   - break;
800   - case 0x2d: /* fucomp st(i) */
801   - break;
802   - case 0x33: /* de/3 */
803   - switch(rm) {
804   - case 1: /* fcompp */
805   - break;
806   - default:
807   - goto illegal_op;
808   - }
809   - break;
810   - case 0x3c: /* df/4 */
811   - switch(rm) {
812   - case 0:
813   - break;
814   - default:
815   - goto illegal_op;
816   - }
817   - break;
818   - case 0x3d: /* fucomip */
819   - break;
820   - case 0x3e: /* fcomip */
821   - break;
822   - case 0x10 ... 0x13: /* fcmovxx */
823   - case 0x18 ... 0x1b:
824   - break;
825   - default:
826   - goto illegal_op;
827   - }
828   - }
829   - s->tb->cflags |= CF_TB_FP_USED;
830   - break;
831   -
832   - /**************************/
833   - /* mov */
834   - case 0xc6:
835   - case 0xc7: /* mov Ev, Iv */
836   - if ((b & 1) == 0)
837   - ot = OT_BYTE;
838   - else
839   - ot = dflag ? OT_LONG : OT_WORD;
840   - modrm = ldub_code(s->pc++);
841   - parse_modrm(s, modrm);
842   - insn_get(s, ot);
843   - break;
844   -
845   - case 0x8d: /* lea */
846   - ot = dflag ? OT_LONG : OT_WORD;
847   - modrm = ldub_code(s->pc++);
848   - mod = (modrm >> 6) & 3;
849   - if (mod == 3)
850   - goto illegal_op;
851   - parse_modrm(s, modrm);
852   - break;
853   -
854   - case 0xa0: /* mov EAX, Ov */
855   - case 0xa1:
856   - case 0xa2: /* mov Ov, EAX */
857   - case 0xa3:
858   - if ((b & 1) == 0)
859   - ot = OT_BYTE;
860   - else
861   - ot = dflag ? OT_LONG : OT_WORD;
862   - if (s->aflag)
863   - insn_get(s, OT_LONG);
864   - else
865   - insn_get(s, OT_WORD);
866   - break;
867   - case 0xd7: /* xlat */
868   - break;
869   - case 0xb0 ... 0xb7: /* mov R, Ib */
870   - insn_get(s, OT_BYTE);
871   - break;
872   - case 0xb8 ... 0xbf: /* mov R, Iv */
873   - ot = dflag ? OT_LONG : OT_WORD;
874   - insn_get(s, ot);
875   - break;
876   -
877   - case 0x91 ... 0x97: /* xchg R, EAX */
878   - break;
879   -
880   - /************************/
881   - /* shifts */
882   - case 0xc0:
883   - case 0xc1: /* shift Ev,imm */
884   -
885   - case 0x1a4: /* shld imm */
886   - case 0x1ac: /* shrd imm */
887   - modrm = ldub_code(s->pc++);
888   - parse_modrm(s, modrm);
889   - ldub_code(s->pc++);
890   - break;
891   -
892   - /************************/
893   - /* string ops */
894   -
895   - case 0xa4: /* movsS */
896   - case 0xa5:
897   - break;
898   -
899   - case 0xaa: /* stosS */
900   - case 0xab:
901   - break;
902   -
903   - case 0xac: /* lodsS */
904   - case 0xad:
905   - break;
906   -
907   - case 0xae: /* scasS */
908   - case 0xaf:
909   - break;
910   -
911   - case 0xa6: /* cmpsS */
912   - case 0xa7:
913   - break;
914   -
915   - case 0x6c: /* insS */
916   - case 0x6d:
917   - goto unsupported_op;
918   -
919   - case 0x6e: /* outsS */
920   - case 0x6f:
921   - goto unsupported_op;
922   -
923   - /************************/
924   - /* port I/O */
925   - case 0xe4:
926   - case 0xe5:
927   - goto unsupported_op;
928   -
929   - case 0xe6:
930   - case 0xe7:
931   - goto unsupported_op;
932   -
933   - case 0xec:
934   - case 0xed:
935   - goto unsupported_op;
936   -
937   - case 0xee:
938   - case 0xef:
939   - goto unsupported_op;
940   -
941   - /************************/
942   - /* control */
943   -#if 0
944   - case 0xc2: /* ret im */
945   - val = ldsw_code(s->pc);
946   - s->pc += 2;
947   - gen_pop_T0(s);
948   - gen_stack_update(s, val + (2 << s->dflag));
949   - if (s->dflag == 0)
950   - gen_op_andl_T0_ffff();
951   - gen_op_jmp_T0();
952   - gen_eob(s);
953   - break;
954   -#endif
955   -
956   - case 0xc3: /* ret */
957   - gb(s, CPU_SEG);
958   - if (!s->dflag)
959   - gb(s, 0x66); /* d16 */
960   - gb(s, 0x8f); /* pop addr */
961   - gb(s, 0x05);
962   - gl(s, CPU_FIELD_OFFSET(eip));
963   - if (!s->dflag) {
964   - /* reset high bits of EIP */
965   - gen_movw_addr_im(s, CPU_FIELD_OFFSET(eip) + 2, 0);
966   - }
967   - gen_eob(s);
968   - goto no_copy;
969   - case 0xca: /* lret im */
970   - case 0xcb: /* lret */
971   - case 0xcf: /* iret */
972   - case 0x9a: /* lcall im */
973   - case 0xea: /* ljmp im */
974   - goto unsupported_op;
975   -
976   - case 0xe8: /* call im */
977   - ot = dflag ? OT_LONG : OT_WORD;
978   - val = insn_get(s, ot);
979   - next_eip = s->pc - s->cs_base;
980   - val += next_eip;
981   - if (s->dflag) {
982   - gb(s, 0x68); /* pushl imm */
983   - gl(s, next_eip);
984   - } else {
985   - gb(s, 0x66); /* pushw imm */
986   - gb(s, 0x68);
987   - gw(s, next_eip);
988   - val &= 0xffff;
989   - }
990   - gen_jmp(s, val);
991   - goto no_copy;
992   - case 0xe9: /* jmp */
993   - ot = dflag ? OT_LONG : OT_WORD;
994   - val = insn_get(s, ot);
995   - val += s->pc - s->cs_base;
996   - if (s->dflag == 0)
997   - val = val & 0xffff;
998   - gen_jmp(s, val);
999   - goto no_copy;
1000   - case 0xeb: /* jmp Jb */
1001   - val = (int8_t)insn_get(s, OT_BYTE);
1002   - val += s->pc - s->cs_base;
1003   - if (s->dflag == 0)
1004   - val = val & 0xffff;
1005   - gen_jmp(s, val);
1006   - goto no_copy;
1007   - case 0x70 ... 0x7f: /* jcc Jb */
1008   - val = (int8_t)insn_get(s, OT_BYTE);
1009   - goto do_jcc;
1010   - case 0x180 ... 0x18f: /* jcc Jv */
1011   - if (dflag) {
1012   - val = insn_get(s, OT_LONG);
1013   - } else {
1014   - val = (int16_t)insn_get(s, OT_WORD);
1015   - }
1016   - do_jcc:
1017   - next_eip = s->pc - s->cs_base;
1018   - val += next_eip;
1019   - if (s->dflag == 0)
1020   - val &= 0xffff;
1021   - gen_jcc(s, b & 0xf, val, next_eip);
1022   - goto no_copy;
1023   -
1024   - /************************/
1025   - /* flags */
1026   - case 0x9c: /* pushf */
1027   - /* XXX: put specific code ? */
1028   - goto unsupported_op;
1029   - case 0x9d: /* popf */
1030   - goto unsupported_op;
1031   -
1032   - case 0x9e: /* sahf */
1033   - case 0x9f: /* lahf */
1034   - case 0xf5: /* cmc */
1035   - case 0xf8: /* clc */
1036   - case 0xf9: /* stc */
1037   - case 0xfc: /* cld */
1038   - case 0xfd: /* std */
1039   - break;
1040   -
1041   - /************************/
1042   - /* bit operations */
1043   - case 0x1ba: /* bt/bts/btr/btc Gv, im */
1044   - ot = dflag ? OT_LONG : OT_WORD;
1045   - modrm = ldub_code(s->pc++);
1046   - op = (modrm >> 3) & 7;
1047   - parse_modrm(s, modrm);
1048   - /* load shift */
1049   - ldub_code(s->pc++);
1050   - if (op < 4)
1051   - goto illegal_op;
1052   - break;
1053   - /************************/
1054   - /* bcd */
1055   - case 0x27: /* daa */
1056   - break;
1057   - case 0x2f: /* das */
1058   - break;
1059   - case 0x37: /* aaa */
1060   - break;
1061   - case 0x3f: /* aas */
1062   - break;
1063   - case 0xd4: /* aam */
1064   - ldub_code(s->pc++);
1065   - break;
1066   - case 0xd5: /* aad */
1067   - ldub_code(s->pc++);
1068   - break;
1069   - /************************/
1070   - /* misc */
1071   - case 0x90: /* nop */
1072   - break;
1073   - case 0x9b: /* fwait */
1074   - if ((s->flags & (HF_MP_MASK | HF_TS_MASK)) ==
1075   - (HF_MP_MASK | HF_TS_MASK)) {
1076   - goto unsupported_op;
1077   - }
1078   - break;
1079   - case 0xcc: /* int3 */
1080   - goto unsupported_op;
1081   - case 0xcd: /* int N */
1082   - goto unsupported_op;
1083   - case 0xce: /* into */
1084   - goto unsupported_op;
1085   - case 0xf1: /* icebp (undocumented, exits to external debugger) */
1086   - goto unsupported_op;
1087   - case 0xfa: /* cli */
1088   - goto unsupported_op;
1089   - case 0xfb: /* sti */
1090   - goto unsupported_op;
1091   - case 0x62: /* bound */
1092   - modrm = ldub_code(s->pc++);
1093   - mod = (modrm >> 6) & 3;
1094   - if (mod == 3)
1095   - goto illegal_op;
1096   - parse_modrm(s, modrm);
1097   - break;
1098   - case 0x1c8 ... 0x1cf: /* bswap reg */
1099   - break;
1100   - case 0xd6: /* salc */
1101   - break;
1102   - case 0xe0: /* loopnz */
1103   - case 0xe1: /* loopz */
1104   - case 0xe2: /* loop */
1105   - case 0xe3: /* jecxz */
1106   - goto unsupported_op;
1107   -
1108   - case 0x130: /* wrmsr */
1109   - case 0x132: /* rdmsr */
1110   - goto unsupported_op;
1111   - case 0x131: /* rdtsc */
1112   - goto unsupported_op;
1113   - case 0x1a2: /* cpuid */
1114   - goto unsupported_op;
1115   - case 0xf4: /* hlt */
1116   - goto unsupported_op;
1117   - case 0x100:
1118   - goto unsupported_op;
1119   - case 0x101:
1120   - goto unsupported_op;
1121   - case 0x108: /* invd */
1122   - case 0x109: /* wbinvd */
1123   - goto unsupported_op;
1124   - case 0x63: /* arpl */
1125   - goto unsupported_op;
1126   - case 0x102: /* lar */
1127   - case 0x103: /* lsl */
1128   - goto unsupported_op;
1129   - case 0x118:
1130   - goto unsupported_op;
1131   - case 0x120: /* mov reg, crN */
1132   - case 0x122: /* mov crN, reg */
1133   - goto unsupported_op;
1134   - case 0x121: /* mov reg, drN */
1135   - case 0x123: /* mov drN, reg */
1136   - goto unsupported_op;
1137   - case 0x106: /* clts */
1138   - goto unsupported_op;
1139   - default:
1140   - goto illegal_op;
1141   - }
1142   -
1143   - /* just copy the code */
1144   -
1145   - /* no override yet */
1146   - if (!s->dflag)
1147   - gb(s, 0x66);
1148   - if (!s->aflag)
1149   - gb(s, 0x67);
1150   - if (prefixes & PREFIX_REPZ)
1151   - gb(s, 0xf3);
1152   - else if (prefixes & PREFIX_REPNZ)
1153   - gb(s, 0xf2);
1154   - {
1155   - int len, i;
1156   - len = s->pc - pc_start_insn;
1157   - for(i = 0; i < len; i++) {
1158   - *s->gen_code_ptr++ = ldub_code(pc_start_insn + i);
1159   - }
1160   - }
1161   - no_copy:
1162   - return 0;
1163   - illegal_op:
1164   - unsupported_op:
1165   - /* fall back to slower code gen necessary */
1166   - s->pc = pc_start;
1167   - return -1;
1168   -}
1169   -
1170   -#define GEN_CODE_MAX_SIZE 8192
1171   -#define GEN_CODE_MAX_INSN_SIZE 512
1172   -
1173   -static inline int gen_intermediate_code_internal(CPUState *env,
1174   - TranslationBlock *tb,
1175   - uint8_t *gen_code_ptr,
1176   - int *gen_code_size_ptr,
1177   - int search_pc,
1178   - uint8_t *tc_ptr)
1179   -{
1180   - DisasContext dc1, *dc = &dc1;
1181   - target_ulong pc_insn, pc_start, cs_base;
1182   - uint8_t *gen_code_end;
1183   - int flags, ret;
1184   -
1185   - if (env->nb_breakpoints > 0 ||
1186   - env->singlestep_enabled)
1187   - return -1;
1188   - flags = tb->flags;
1189   - if (flags & (HF_TF_MASK | HF_ADDSEG_MASK |
1190   - HF_SOFTMMU_MASK | HF_INHIBIT_IRQ_MASK))
1191   - return -1;
1192   - if (!(flags & HF_SS32_MASK))
1193   - return -1;
1194   - if (tb->cflags & CF_SINGLE_INSN)
1195   - return -1;
1196   - gen_code_end = gen_code_ptr +
1197   - GEN_CODE_MAX_SIZE - GEN_CODE_MAX_INSN_SIZE;
1198   - dc->gen_code_ptr = gen_code_ptr;
1199   - dc->gen_code_start = gen_code_ptr;
1200   -
1201   - /* generate intermediate code */
1202   - pc_start = tb->pc;
1203   - cs_base = tb->cs_base;
1204   - dc->pc = pc_start;
1205   - dc->cs_base = cs_base;
1206   - dc->pe = (flags >> HF_PE_SHIFT) & 1;
1207   - dc->code32 = (flags >> HF_CS32_SHIFT) & 1;
1208   - dc->f_st = 0;
1209   - dc->vm86 = (flags >> VM_SHIFT) & 1;
1210   - dc->cpl = (flags >> HF_CPL_SHIFT) & 3;
1211   - dc->iopl = (flags >> IOPL_SHIFT) & 3;
1212   - dc->tb = tb;
1213   - dc->flags = flags;
1214   -
1215   - dc->is_jmp = 0;
1216   -
1217   - for(;;) {
1218   - pc_insn = dc->pc;
1219   - ret = disas_insn(dc);
1220   - if (ret < 0) {
1221   - /* unsupported insn */
1222   - if (dc->pc == pc_start) {
1223   - /* if first instruction, signal that no copying was done */
1224   - return -1;
1225   - } else {
1226   - gen_jmp(dc, dc->pc - dc->cs_base);
1227   - dc->is_jmp = 1;
1228   - }
1229   - }
1230   - if (search_pc) {
1231   - /* search pc mode */
1232   - if (tc_ptr < dc->gen_code_ptr) {
1233   - env->eip = pc_insn - cs_base;
1234   - return 0;
1235   - }
1236   - }
1237   - /* stop translation if indicated */
1238   - if (dc->is_jmp)
1239   - break;
1240   - /* if too long translation, stop generation */
1241   - if (dc->gen_code_ptr >= gen_code_end ||
1242   - (dc->pc - pc_start) >= (TARGET_PAGE_SIZE - 32)) {
1243   - gen_jmp(dc, dc->pc - dc->cs_base);
1244   - break;
1245   - }
1246   - }
1247   -
1248   -#ifdef DEBUG_DISAS
1249   - if (loglevel & CPU_LOG_TB_IN_ASM) {
1250   - fprintf(logfile, "----------------\n");
1251   - fprintf(logfile, "IN: COPY: %s fpu=%d\n",
1252   - lookup_symbol(pc_start),
1253   - tb->cflags & CF_TB_FP_USED ? 1 : 0);
1254   - target_disas(logfile, pc_start, dc->pc - pc_start, !dc->code32);
1255   - fprintf(logfile, "\n");
1256   - }
1257   -#endif
1258   -
1259   - if (!search_pc) {
1260   - *gen_code_size_ptr = dc->gen_code_ptr - dc->gen_code_start;
1261   - tb->size = dc->pc - pc_start;
1262   - tb->cflags |= CF_CODE_COPY;
1263   - return 0;
1264   - } else {
1265   - return -1;
1266   - }
1267   -}
1268   -
1269   -/* generate code by just copying data. Return -1 if cannot generate
1270   - any code. Return 0 if code was generated */
1271   -int cpu_gen_code_copy(CPUState *env, TranslationBlock *tb,
1272   - int max_code_size, int *gen_code_size_ptr)
1273   -{
1274   - /* generate machine code */
1275   - tb->tb_next_offset[0] = 0xffff;
1276   - tb->tb_next_offset[1] = 0xffff;
1277   -#ifdef USE_DIRECT_JUMP
1278   - /* the following two entries are optional (only used for string ops) */
1279   - tb->tb_jmp_offset[2] = 0xffff;
1280   - tb->tb_jmp_offset[3] = 0xffff;
1281   -#endif
1282   - return gen_intermediate_code_internal(env, tb,
1283   - tb->tc_ptr, gen_code_size_ptr,
1284   - 0, NULL);
1285   -}
1286   -
1287   -static uint8_t dummy_gen_code_buf[GEN_CODE_MAX_SIZE];
1288   -
1289   -int cpu_restore_state_copy(TranslationBlock *tb,
1290   - CPUState *env, unsigned long searched_pc,
1291   - void *puc)
1292   -{
1293   - struct ucontext *uc = puc;
1294   - int ret, eflags;
1295   -
1296   - /* find opc index corresponding to search_pc */
1297   - if (searched_pc < (unsigned long)tb->tc_ptr)
1298   - return -1;
1299   - searched_pc = searched_pc - (long)tb->tc_ptr + (long)dummy_gen_code_buf;
1300   - ret = gen_intermediate_code_internal(env, tb,
1301   - dummy_gen_code_buf, NULL,
1302   - 1, (uint8_t *)searched_pc);
1303   - if (ret < 0)
1304   - return ret;
1305   - /* restore all the CPU state from the CPU context from the
1306   - signal. The FPU context stays in the host CPU. */
1307   -
1308   - env->regs[R_EAX] = uc->uc_mcontext.gregs[REG_EAX];
1309   - env->regs[R_ECX] = uc->uc_mcontext.gregs[REG_ECX];
1310   - env->regs[R_EDX] = uc->uc_mcontext.gregs[REG_EDX];
1311   - env->regs[R_EBX] = uc->uc_mcontext.gregs[REG_EBX];
1312   - env->regs[R_ESP] = uc->uc_mcontext.gregs[REG_ESP];
1313   - env->regs[R_EBP] = uc->uc_mcontext.gregs[REG_EBP];
1314   - env->regs[R_ESI] = uc->uc_mcontext.gregs[REG_ESI];
1315   - env->regs[R_EDI] = uc->uc_mcontext.gregs[REG_EDI];
1316   - eflags = uc->uc_mcontext.gregs[REG_EFL];
1317   - env->df = 1 - (2 * ((eflags >> 10) & 1));
1318   - env->cc_src = eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
1319   - env->cc_op = CC_OP_EFLAGS;
1320   - return 0;
1321   -}
1322   -
1323   -#endif /* USE_CODE_COPY */