]>
Commit | Line | Data |
---|---|---|
7d13299d FB |
1 | /* |
2 | * i386 emulator main execution loop | |
3 | * | |
4 | * Copyright (c) 2003 Fabrice Bellard | |
5 | * | |
6 | * This program is free software; you can redistribute it and/or modify | |
7 | * it under the terms of the GNU General Public License as published by | |
8 | * the Free Software Foundation; either version 2 of the License, or | |
9 | * (at your option) any later version. | |
10 | * | |
11 | * This program 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 | |
14 | * GNU General Public License for more details. | |
15 | * | |
16 | * You should have received a copy of the GNU General Public License | |
17 | * along with this program; if not, write to the Free Software | |
18 | * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. | |
19 | */ | |
20 | #include "exec-i386.h" | |
21 | ||
dc99065b | 22 | //#define DEBUG_EXEC |
7d13299d FB |
23 | #define DEBUG_FLUSH |
24 | ||
25 | /* main execution loop */ | |
26 | ||
27 | /* maximum total translate dcode allocated */ | |
28 | #define CODE_GEN_BUFFER_SIZE (2048 * 1024) | |
29 | //#define CODE_GEN_BUFFER_SIZE (128 * 1024) | |
30 | #define CODE_GEN_MAX_SIZE 65536 | |
31 | #define CODE_GEN_ALIGN 16 /* must be >= of the size of a icache line */ | |
32 | ||
33 | /* threshold to flush the translated code buffer */ | |
34 | #define CODE_GEN_BUFFER_MAX_SIZE (CODE_GEN_BUFFER_SIZE - CODE_GEN_MAX_SIZE) | |
35 | ||
36 | #define CODE_GEN_MAX_BLOCKS (CODE_GEN_BUFFER_SIZE / 64) | |
37 | #define CODE_GEN_HASH_BITS 15 | |
38 | #define CODE_GEN_HASH_SIZE (1 << CODE_GEN_HASH_BITS) | |
6dbad63e | 39 | |
7d13299d | 40 | typedef struct TranslationBlock { |
dab2ed99 FB |
41 | unsigned long pc; /* simulated PC corresponding to this block (EIP + CS base) */ |
42 | unsigned long cs_base; /* CS base for this block */ | |
6dbad63e | 43 | unsigned int flags; /* flags defining in which context the code was generated */ |
7d13299d FB |
44 | uint8_t *tc_ptr; /* pointer to the translated code */ |
45 | struct TranslationBlock *hash_next; /* next matching block */ | |
46 | } TranslationBlock; | |
47 | ||
48 | TranslationBlock tbs[CODE_GEN_MAX_BLOCKS]; | |
49 | TranslationBlock *tb_hash[CODE_GEN_HASH_SIZE]; | |
50 | int nb_tbs; | |
51 | ||
52 | uint8_t code_gen_buffer[CODE_GEN_BUFFER_SIZE]; | |
53 | uint8_t *code_gen_ptr; | |
54 | ||
55 | #ifdef DEBUG_EXEC | |
56 | static const char *cc_op_str[] = { | |
57 | "DYNAMIC", | |
58 | "EFLAGS", | |
59 | "MUL", | |
60 | "ADDB", | |
61 | "ADDW", | |
62 | "ADDL", | |
63 | "ADCB", | |
64 | "ADCW", | |
65 | "ADCL", | |
66 | "SUBB", | |
67 | "SUBW", | |
68 | "SUBL", | |
69 | "SBBB", | |
70 | "SBBW", | |
71 | "SBBL", | |
72 | "LOGICB", | |
73 | "LOGICW", | |
74 | "LOGICL", | |
75 | "INCB", | |
76 | "INCW", | |
77 | "INCL", | |
78 | "DECB", | |
79 | "DECW", | |
80 | "DECL", | |
81 | "SHLB", | |
82 | "SHLW", | |
83 | "SHLL", | |
84 | "SARB", | |
85 | "SARW", | |
86 | "SARL", | |
87 | }; | |
88 | ||
89 | static void cpu_x86_dump_state(void) | |
90 | { | |
91 | int eflags; | |
92 | eflags = cc_table[CC_OP].compute_all(); | |
93 | eflags |= (DF & DIRECTION_FLAG); | |
94 | fprintf(logfile, | |
95 | "EAX=%08x EBX=%08X ECX=%08x EDX=%08x\n" | |
96 | "ESI=%08x EDI=%08X EBP=%08x ESP=%08x\n" | |
97 | "CCS=%08x CCD=%08x CCO=%-8s EFL=%c%c%c%c%c%c%c\n", | |
98 | env->regs[R_EAX], env->regs[R_EBX], env->regs[R_ECX], env->regs[R_EDX], | |
99 | env->regs[R_ESI], env->regs[R_EDI], env->regs[R_EBP], env->regs[R_ESP], | |
100 | env->cc_src, env->cc_dst, cc_op_str[env->cc_op], | |
101 | eflags & DIRECTION_FLAG ? 'D' : '-', | |
102 | eflags & CC_O ? 'O' : '-', | |
103 | eflags & CC_S ? 'S' : '-', | |
104 | eflags & CC_Z ? 'Z' : '-', | |
105 | eflags & CC_A ? 'A' : '-', | |
106 | eflags & CC_P ? 'P' : '-', | |
107 | eflags & CC_C ? 'C' : '-' | |
108 | ); | |
109 | #if 1 | |
110 | fprintf(logfile, "ST0=%f ST1=%f ST2=%f ST3=%f\n", | |
111 | (double)ST0, (double)ST1, (double)ST(2), (double)ST(3)); | |
112 | #endif | |
113 | } | |
114 | ||
115 | #endif | |
116 | ||
117 | void cpu_x86_tblocks_init(void) | |
118 | { | |
119 | if (!code_gen_ptr) { | |
120 | code_gen_ptr = code_gen_buffer; | |
121 | } | |
122 | } | |
123 | ||
124 | /* flush all the translation blocks */ | |
125 | static void tb_flush(void) | |
126 | { | |
127 | int i; | |
128 | #ifdef DEBUG_FLUSH | |
129 | printf("gemu: flush code_size=%d nb_tbs=%d avg_tb_size=%d\n", | |
130 | code_gen_ptr - code_gen_buffer, | |
131 | nb_tbs, | |
132 | (code_gen_ptr - code_gen_buffer) / nb_tbs); | |
133 | #endif | |
134 | nb_tbs = 0; | |
135 | for(i = 0;i < CODE_GEN_HASH_SIZE; i++) | |
136 | tb_hash[i] = NULL; | |
137 | code_gen_ptr = code_gen_buffer; | |
138 | /* XXX: flush processor icache at this point */ | |
139 | } | |
140 | ||
141 | /* find a translation block in the translation cache. If not found, | |
142 | allocate a new one */ | |
6dbad63e | 143 | static inline TranslationBlock *tb_find_and_alloc(unsigned long pc, |
dab2ed99 | 144 | unsigned long cs_base, |
6dbad63e | 145 | unsigned int flags) |
7d13299d FB |
146 | { |
147 | TranslationBlock **ptb, *tb; | |
148 | unsigned int h; | |
149 | ||
150 | h = pc & (CODE_GEN_HASH_SIZE - 1); | |
151 | ptb = &tb_hash[h]; | |
152 | for(;;) { | |
153 | tb = *ptb; | |
154 | if (!tb) | |
155 | break; | |
dab2ed99 | 156 | if (tb->pc == pc && tb->cs_base == cs_base && tb->flags == flags) |
7d13299d FB |
157 | return tb; |
158 | ptb = &tb->hash_next; | |
159 | } | |
160 | if (nb_tbs >= CODE_GEN_MAX_BLOCKS || | |
161 | (code_gen_ptr - code_gen_buffer) >= CODE_GEN_BUFFER_MAX_SIZE) | |
162 | tb_flush(); | |
163 | tb = &tbs[nb_tbs++]; | |
164 | *ptb = tb; | |
165 | tb->pc = pc; | |
dab2ed99 | 166 | tb->cs_base = cs_base; |
6dbad63e | 167 | tb->flags = flags; |
7d13299d FB |
168 | tb->tc_ptr = NULL; |
169 | tb->hash_next = NULL; | |
170 | return tb; | |
171 | } | |
172 | ||
173 | int cpu_x86_exec(CPUX86State *env1) | |
174 | { | |
175 | int saved_T0, saved_T1, saved_A0; | |
176 | CPUX86State *saved_env; | |
04369ff2 FB |
177 | #ifdef reg_EAX |
178 | int saved_EAX; | |
179 | #endif | |
180 | #ifdef reg_ECX | |
181 | int saved_ECX; | |
182 | #endif | |
183 | #ifdef reg_EDX | |
184 | int saved_EDX; | |
185 | #endif | |
186 | #ifdef reg_EBX | |
187 | int saved_EBX; | |
188 | #endif | |
189 | #ifdef reg_ESP | |
190 | int saved_ESP; | |
191 | #endif | |
192 | #ifdef reg_EBP | |
193 | int saved_EBP; | |
194 | #endif | |
195 | #ifdef reg_ESI | |
196 | int saved_ESI; | |
197 | #endif | |
198 | #ifdef reg_EDI | |
199 | int saved_EDI; | |
200 | #endif | |
7d13299d FB |
201 | int code_gen_size, ret; |
202 | void (*gen_func)(void); | |
203 | TranslationBlock *tb; | |
dab2ed99 | 204 | uint8_t *tc_ptr, *cs_base, *pc; |
6dbad63e FB |
205 | unsigned int flags; |
206 | ||
7d13299d FB |
207 | /* first we save global registers */ |
208 | saved_T0 = T0; | |
209 | saved_T1 = T1; | |
210 | saved_A0 = A0; | |
211 | saved_env = env; | |
212 | env = env1; | |
04369ff2 FB |
213 | #ifdef reg_EAX |
214 | saved_EAX = EAX; | |
215 | EAX = env->regs[R_EAX]; | |
216 | #endif | |
217 | #ifdef reg_ECX | |
218 | saved_ECX = ECX; | |
219 | ECX = env->regs[R_ECX]; | |
220 | #endif | |
221 | #ifdef reg_EDX | |
222 | saved_EDX = EDX; | |
223 | EDX = env->regs[R_EDX]; | |
224 | #endif | |
225 | #ifdef reg_EBX | |
226 | saved_EBX = EBX; | |
227 | EBX = env->regs[R_EBX]; | |
228 | #endif | |
229 | #ifdef reg_ESP | |
230 | saved_ESP = ESP; | |
231 | ESP = env->regs[R_ESP]; | |
232 | #endif | |
233 | #ifdef reg_EBP | |
234 | saved_EBP = EBP; | |
235 | EBP = env->regs[R_EBP]; | |
236 | #endif | |
237 | #ifdef reg_ESI | |
238 | saved_ESI = ESI; | |
239 | ESI = env->regs[R_ESI]; | |
240 | #endif | |
241 | #ifdef reg_EDI | |
242 | saved_EDI = EDI; | |
243 | EDI = env->regs[R_EDI]; | |
244 | #endif | |
7d13299d FB |
245 | |
246 | /* prepare setjmp context for exception handling */ | |
247 | if (setjmp(env->jmp_env) == 0) { | |
248 | for(;;) { | |
249 | #ifdef DEBUG_EXEC | |
250 | if (loglevel) { | |
251 | cpu_x86_dump_state(); | |
252 | } | |
253 | #endif | |
6dbad63e FB |
254 | /* we compute the CPU state. We assume it will not |
255 | change during the whole generated block. */ | |
256 | flags = env->seg_cache[R_CS].seg_32bit << GEN_FLAG_CODE32_SHIFT; | |
dab2ed99 | 257 | flags |= env->seg_cache[R_SS].seg_32bit << GEN_FLAG_SS32_SHIFT; |
6dbad63e FB |
258 | flags |= (((unsigned long)env->seg_cache[R_DS].base | |
259 | (unsigned long)env->seg_cache[R_ES].base | | |
260 | (unsigned long)env->seg_cache[R_SS].base) != 0) << | |
261 | GEN_FLAG_ADDSEG_SHIFT; | |
dab2ed99 FB |
262 | cs_base = env->seg_cache[R_CS].base; |
263 | pc = cs_base + env->eip; | |
264 | tb = tb_find_and_alloc((unsigned long)pc, (unsigned long)cs_base, | |
265 | flags); | |
7d13299d FB |
266 | tc_ptr = tb->tc_ptr; |
267 | if (!tb->tc_ptr) { | |
268 | /* if no translated code available, then translate it now */ | |
269 | tc_ptr = code_gen_ptr; | |
270 | cpu_x86_gen_code(code_gen_ptr, CODE_GEN_MAX_SIZE, | |
dab2ed99 | 271 | &code_gen_size, pc, cs_base, flags); |
7d13299d FB |
272 | tb->tc_ptr = tc_ptr; |
273 | code_gen_ptr = (void *)(((unsigned long)code_gen_ptr + code_gen_size + CODE_GEN_ALIGN - 1) & ~(CODE_GEN_ALIGN - 1)); | |
274 | } | |
275 | /* execute the generated code */ | |
276 | gen_func = (void *)tc_ptr; | |
277 | gen_func(); | |
278 | } | |
279 | } | |
280 | ret = env->exception_index; | |
281 | ||
282 | /* restore global registers */ | |
04369ff2 FB |
283 | #ifdef reg_EAX |
284 | EAX = saved_EAX; | |
285 | #endif | |
286 | #ifdef reg_ECX | |
287 | ECX = saved_ECX; | |
288 | #endif | |
289 | #ifdef reg_EDX | |
290 | EDX = saved_EDX; | |
291 | #endif | |
292 | #ifdef reg_EBX | |
293 | EBX = saved_EBX; | |
294 | #endif | |
295 | #ifdef reg_ESP | |
296 | ESP = saved_ESP; | |
297 | #endif | |
298 | #ifdef reg_EBP | |
299 | EBP = saved_EBP; | |
300 | #endif | |
301 | #ifdef reg_ESI | |
302 | ESI = saved_ESI; | |
303 | #endif | |
304 | #ifdef reg_EDI | |
305 | EDI = saved_EDI; | |
306 | #endif | |
7d13299d FB |
307 | T0 = saved_T0; |
308 | T1 = saved_T1; | |
309 | A0 = saved_A0; | |
310 | env = saved_env; | |
311 | return ret; | |
312 | } | |
6dbad63e FB |
313 | |
314 | void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector) | |
315 | { | |
316 | CPUX86State *saved_env; | |
317 | ||
318 | saved_env = env; | |
319 | env = s; | |
320 | load_seg(seg_reg, selector); | |
321 | env = saved_env; | |
322 | } |