ViewVC Help
View File | Revision Log | Show Annotations | Revision Graph | Root Listing
root/cebix/BasiliskII/src/uae_cpu/compiler/compemu.h
Revision: 1.12
Committed: 2005-01-30T21:42:16Z (19 years, 9 months ago) by gbeauche
Content type: text/plain
Branch: MAIN
CVS Tags: nigel-build-17
Changes since 1.11: +2 -2 lines
Log Message:
Happy New Year!

File Contents

# Content
1 /*
2 * compiler/compemu.h - Public interface and definitions
3 *
4 * Original 68040 JIT compiler for UAE, copyright 2000-2002 Bernd Meyer
5 *
6 * Adaptation for Basilisk II and improvements, copyright 2000-2005
7 * Gwenole Beauchesne
8 *
9 * Basilisk II (C) 1997-2005 Christian Bauer
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24 */
25
26 #ifndef COMPEMU_H
27 #define COMPEMU_H
28
29 #include "newcpu.h"
30
31 #if USE_JIT
32
33 #if JIT_DEBUG
34 /* dump some information (m68k block, x86 block addresses) about the compiler state */
35 extern void compiler_dumpstate(void);
36 #endif
37
38 /* Now that we do block chaining, and also have linked lists on each tag,
39 TAGMASK can be much smaller and still do its job. Saves several megs
40 of memory! */
41 #define TAGMASK 0x0000ffff
42 #define TAGSIZE (TAGMASK+1)
43 #define MAXRUN 1024
44 #define cacheline(x) (((uintptr)x)&TAGMASK)
45
46 extern uae_u8* start_pc_p;
47 extern uae_u32 start_pc;
48
49 struct blockinfo_t;
50
51 struct cpu_history {
52 uae_u16 * location;
53 };
54
55 union cacheline {
56 cpuop_func * handler;
57 blockinfo_t * bi;
58 };
59
60 /* Use new spill/reload strategy when calling external functions */
61 #define USE_OPTIMIZED_CALLS 0
62 #if USE_OPTIMIZED_CALLS
63 #error implementation in progress
64 #endif
65
66 /* (gb) When on, this option can save save up to 30% compilation time
67 * when many lazy flushes occur (e.g. apps in MacOS 8.x).
68 */
69 #define USE_SEPARATE_BIA 1
70
71 /* Use chain of checksum_info_t to compute the block checksum */
72 #define USE_CHECKSUM_INFO 1
73
74 /* Use code inlining, aka follow-up of constant jumps */
75 #define USE_INLINING 1
76
77 /* Inlining requires the chained checksuming information */
78 #if USE_INLINING
79 #undef USE_CHECKSUM_INFO
80 #define USE_CHECKSUM_INFO 1
81 #endif
82
83 /* Does flush_icache_range() only check for blocks falling in the requested range? */
84 #define LAZY_FLUSH_ICACHE_RANGE 0
85
86 #define USE_F_ALIAS 1
87 #define USE_OFFSET 1
88 #define COMP_DEBUG 1
89
90 #if COMP_DEBUG
91 #define Dif(x) if (x)
92 #else
93 #define Dif(x) if (0)
94 #endif
95
96 #define SCALE 2
97
98 #define BYTES_PER_INST 10240 /* paranoid ;-) */
99 #define LONGEST_68K_INST 16 /* The number of bytes the longest possible
100 68k instruction takes */
101 #define MAX_CHECKSUM_LEN 2048 /* The maximum size we calculate checksums
102 for. Anything larger will be flushed
103 unconditionally even with SOFT_FLUSH */
104 #define MAX_HOLD_BI 3 /* One for the current block, and up to two
105 for jump targets */
106
107 #define INDIVIDUAL_INST 0
108 #if 1
109 // gb-- my format from readcpu.cpp is not the same
110 #define FLAG_X 0x0010
111 #define FLAG_N 0x0008
112 #define FLAG_Z 0x0004
113 #define FLAG_V 0x0002
114 #define FLAG_C 0x0001
115 #else
116 #define FLAG_C 0x0010
117 #define FLAG_V 0x0008
118 #define FLAG_Z 0x0004
119 #define FLAG_N 0x0002
120 #define FLAG_X 0x0001
121 #endif
122 #define FLAG_CZNV (FLAG_C | FLAG_Z | FLAG_N | FLAG_V)
123 #define FLAG_ZNV (FLAG_Z | FLAG_N | FLAG_V)
124
125 #define KILLTHERAT 1 /* Set to 1 to avoid some partial_rat_stalls */
126
127 /* Whether to preserve registers across calls to JIT compiled routines */
128 #if defined(X86_ASSEMBLY) || defined(X86_64_ASSEMBLY)
129 #define USE_PUSH_POP 0
130 #else
131 #define USE_PUSH_POP 1
132 #endif
133
134 #if defined(__x86_64__)
135 #define N_REGS 16 /* really only 15, but they are numbered 0-3,5-15 */
136 #else
137 #define N_REGS 8 /* really only 7, but they are numbered 0,1,2,3,5,6,7 */
138 #endif
139 #define N_FREGS 6 /* That leaves us two positions on the stack to play with */
140
141 /* Functions exposed to newcpu, or to what was moved from newcpu.c to
142 * compemu_support.c */
143 extern void compiler_init(void);
144 extern void compiler_exit(void);
145 extern bool compiler_use_jit(void);
146 extern void init_comp(void);
147 extern void flush(int save_regs);
148 extern void small_flush(int save_regs);
149 extern void set_target(uae_u8* t);
150 extern uae_u8* get_target(void);
151 extern void freescratch(void);
152 extern void build_comp(void);
153 extern void set_cache_state(int enabled);
154 extern int get_cache_state(void);
155 extern uae_u32 get_jitted_size(void);
156 extern void (*flush_icache)(int n);
157 extern void alloc_cache(void);
158 extern int check_for_cache_miss(void);
159
160 /* JIT FPU compilation */
161 extern void comp_fpp_opp (uae_u32 opcode, uae_u16 extra);
162 extern void comp_fbcc_opp (uae_u32 opcode);
163 extern void comp_fscc_opp (uae_u32 opcode, uae_u16 extra);
164
165 extern uae_u32 needed_flags;
166 extern cacheline cache_tags[];
167 extern uae_u8* comp_pc_p;
168 extern void* pushall_call_handler;
169
170 #define VREGS 32
171 #define VFREGS 16
172
173 #define INMEM 1
174 #define CLEAN 2
175 #define DIRTY 3
176 #define UNDEF 4
177 #define ISCONST 5
178
179 typedef struct {
180 uae_u32* mem;
181 uae_u32 val;
182 uae_u8 is_swapped;
183 uae_u8 status;
184 uae_s8 realreg; /* gb-- realreg can hold -1 */
185 uae_u8 realind; /* The index in the holds[] array */
186 uae_u8 needflush;
187 uae_u8 validsize;
188 uae_u8 dirtysize;
189 uae_u8 dummy;
190 } reg_status;
191
192 typedef struct {
193 uae_u32* mem;
194 double val;
195 uae_u8 status;
196 uae_s8 realreg; /* gb-- realreg can hold -1 */
197 uae_u8 realind;
198 uae_u8 needflush;
199 } freg_status;
200
201 #define PC_P 16
202 #define FLAGX 17
203 #define FLAGTMP 18
204 #define NEXT_HANDLER 19
205 #define S1 20
206 #define S2 21
207 #define S3 22
208 #define S4 23
209 #define S5 24
210 #define S6 25
211 #define S7 26
212 #define S8 27
213 #define S9 28
214 #define S10 29
215 #define S11 30
216 #define S12 31
217
218 #define FP_RESULT 8
219 #define FS1 9
220 #define FS2 10
221 #define FS3 11
222
223 typedef struct {
224 uae_u32 touched;
225 uae_s8 holds[VREGS];
226 uae_u8 nholds;
227 uae_u8 canbyte;
228 uae_u8 canword;
229 uae_u8 locked;
230 } n_status;
231
232 typedef struct {
233 uae_u32 touched;
234 uae_s8 holds[VFREGS];
235 uae_u8 nholds;
236 uae_u8 locked;
237 } fn_status;
238
239 /* For flag handling */
240 #define NADA 1
241 #define TRASH 2
242 #define VALID 3
243
244 /* needflush values */
245 #define NF_SCRATCH 0
246 #define NF_TOMEM 1
247 #define NF_HANDLER 2
248
249 typedef struct {
250 /* Integer part */
251 reg_status state[VREGS];
252 n_status nat[N_REGS];
253 uae_u32 flags_on_stack;
254 uae_u32 flags_in_flags;
255 uae_u32 flags_are_important;
256 /* FPU part */
257 freg_status fate[VFREGS];
258 fn_status fat[N_FREGS];
259
260 /* x86 FPU part */
261 uae_s8 spos[N_FREGS];
262 uae_s8 onstack[6];
263 uae_s8 tos;
264 } bigstate;
265
266 typedef struct {
267 /* Integer part */
268 char virt[VREGS];
269 char nat[N_REGS];
270 } smallstate;
271
272 extern bigstate live;
273 extern int touchcnt;
274
275
276 #define IMM uae_s32
277 #define R1 uae_u32
278 #define R2 uae_u32
279 #define R4 uae_u32
280 #define W1 uae_u32
281 #define W2 uae_u32
282 #define W4 uae_u32
283 #define RW1 uae_u32
284 #define RW2 uae_u32
285 #define RW4 uae_u32
286 #define MEMR uae_u32
287 #define MEMW uae_u32
288 #define MEMRW uae_u32
289
290 #define FW uae_u32
291 #define FR uae_u32
292 #define FRW uae_u32
293
294 #define MIDFUNC(nargs,func,args) void func args
295 #define MENDFUNC(nargs,func,args)
296 #define COMPCALL(func) func
297
298 #define LOWFUNC(flags,mem,nargs,func,args) static __inline__ void func args
299 #define LENDFUNC(flags,mem,nargs,func,args)
300
301 /* What we expose to the outside */
302 #define DECLARE_MIDFUNC(func) extern void func
303 DECLARE_MIDFUNC(bt_l_ri(R4 r, IMM i));
304 DECLARE_MIDFUNC(bt_l_rr(R4 r, R4 b));
305 DECLARE_MIDFUNC(btc_l_ri(RW4 r, IMM i));
306 DECLARE_MIDFUNC(btc_l_rr(RW4 r, R4 b));
307 DECLARE_MIDFUNC(bts_l_ri(RW4 r, IMM i));
308 DECLARE_MIDFUNC(bts_l_rr(RW4 r, R4 b));
309 DECLARE_MIDFUNC(btr_l_ri(RW4 r, IMM i));
310 DECLARE_MIDFUNC(btr_l_rr(RW4 r, R4 b));
311 DECLARE_MIDFUNC(mov_l_rm(W4 d, IMM s));
312 DECLARE_MIDFUNC(call_r(R4 r));
313 DECLARE_MIDFUNC(sub_l_mi(IMM d, IMM s));
314 DECLARE_MIDFUNC(mov_l_mi(IMM d, IMM s));
315 DECLARE_MIDFUNC(mov_w_mi(IMM d, IMM s));
316 DECLARE_MIDFUNC(mov_b_mi(IMM d, IMM s));
317 DECLARE_MIDFUNC(rol_b_ri(RW1 r, IMM i));
318 DECLARE_MIDFUNC(rol_w_ri(RW2 r, IMM i));
319 DECLARE_MIDFUNC(rol_l_ri(RW4 r, IMM i));
320 DECLARE_MIDFUNC(rol_l_rr(RW4 d, R1 r));
321 DECLARE_MIDFUNC(rol_w_rr(RW2 d, R1 r));
322 DECLARE_MIDFUNC(rol_b_rr(RW1 d, R1 r));
323 DECLARE_MIDFUNC(shll_l_rr(RW4 d, R1 r));
324 DECLARE_MIDFUNC(shll_w_rr(RW2 d, R1 r));
325 DECLARE_MIDFUNC(shll_b_rr(RW1 d, R1 r));
326 DECLARE_MIDFUNC(ror_b_ri(R1 r, IMM i));
327 DECLARE_MIDFUNC(ror_w_ri(R2 r, IMM i));
328 DECLARE_MIDFUNC(ror_l_ri(R4 r, IMM i));
329 DECLARE_MIDFUNC(ror_l_rr(R4 d, R1 r));
330 DECLARE_MIDFUNC(ror_w_rr(R2 d, R1 r));
331 DECLARE_MIDFUNC(ror_b_rr(R1 d, R1 r));
332 DECLARE_MIDFUNC(shrl_l_rr(RW4 d, R1 r));
333 DECLARE_MIDFUNC(shrl_w_rr(RW2 d, R1 r));
334 DECLARE_MIDFUNC(shrl_b_rr(RW1 d, R1 r));
335 DECLARE_MIDFUNC(shra_l_rr(RW4 d, R1 r));
336 DECLARE_MIDFUNC(shra_w_rr(RW2 d, R1 r));
337 DECLARE_MIDFUNC(shra_b_rr(RW1 d, R1 r));
338 DECLARE_MIDFUNC(shll_l_ri(RW4 r, IMM i));
339 DECLARE_MIDFUNC(shll_w_ri(RW2 r, IMM i));
340 DECLARE_MIDFUNC(shll_b_ri(RW1 r, IMM i));
341 DECLARE_MIDFUNC(shrl_l_ri(RW4 r, IMM i));
342 DECLARE_MIDFUNC(shrl_w_ri(RW2 r, IMM i));
343 DECLARE_MIDFUNC(shrl_b_ri(RW1 r, IMM i));
344 DECLARE_MIDFUNC(shra_l_ri(RW4 r, IMM i));
345 DECLARE_MIDFUNC(shra_w_ri(RW2 r, IMM i));
346 DECLARE_MIDFUNC(shra_b_ri(RW1 r, IMM i));
347 DECLARE_MIDFUNC(setcc(W1 d, IMM cc));
348 DECLARE_MIDFUNC(setcc_m(IMM d, IMM cc));
349 DECLARE_MIDFUNC(cmov_l_rr(RW4 d, R4 s, IMM cc));
350 DECLARE_MIDFUNC(cmov_l_rm(RW4 d, IMM s, IMM cc));
351 DECLARE_MIDFUNC(bsf_l_rr(W4 d, R4 s));
352 DECLARE_MIDFUNC(pop_m(IMM d));
353 DECLARE_MIDFUNC(push_m(IMM d));
354 DECLARE_MIDFUNC(pop_l(W4 d));
355 DECLARE_MIDFUNC(push_l_i(IMM i));
356 DECLARE_MIDFUNC(push_l(R4 s));
357 DECLARE_MIDFUNC(clear_16(RW4 r));
358 DECLARE_MIDFUNC(clear_8(RW4 r));
359 DECLARE_MIDFUNC(sign_extend_16_rr(W4 d, R2 s));
360 DECLARE_MIDFUNC(sign_extend_8_rr(W4 d, R1 s));
361 DECLARE_MIDFUNC(zero_extend_16_rr(W4 d, R2 s));
362 DECLARE_MIDFUNC(zero_extend_8_rr(W4 d, R1 s));
363 DECLARE_MIDFUNC(imul_64_32(RW4 d, RW4 s));
364 DECLARE_MIDFUNC(mul_64_32(RW4 d, RW4 s));
365 DECLARE_MIDFUNC(imul_32_32(RW4 d, R4 s));
366 DECLARE_MIDFUNC(mul_32_32(RW4 d, R4 s));
367 DECLARE_MIDFUNC(mov_b_rr(W1 d, R1 s));
368 DECLARE_MIDFUNC(mov_w_rr(W2 d, R2 s));
369 DECLARE_MIDFUNC(mov_l_rrm_indexed(W4 d,R4 baser, R4 index, IMM factor));
370 DECLARE_MIDFUNC(mov_w_rrm_indexed(W2 d, R4 baser, R4 index, IMM factor));
371 DECLARE_MIDFUNC(mov_b_rrm_indexed(W1 d, R4 baser, R4 index, IMM factor));
372 DECLARE_MIDFUNC(mov_l_mrr_indexed(R4 baser, R4 index, IMM factor, R4 s));
373 DECLARE_MIDFUNC(mov_w_mrr_indexed(R4 baser, R4 index, IMM factor, R2 s));
374 DECLARE_MIDFUNC(mov_b_mrr_indexed(R4 baser, R4 index, IMM factor, R1 s));
375 DECLARE_MIDFUNC(mov_l_bmrr_indexed(IMM base, R4 baser, R4 index, IMM factor, R4 s));
376 DECLARE_MIDFUNC(mov_w_bmrr_indexed(IMM base, R4 baser, R4 index, IMM factor, R2 s));
377 DECLARE_MIDFUNC(mov_b_bmrr_indexed(IMM base, R4 baser, R4 index, IMM factor, R1 s));
378 DECLARE_MIDFUNC(mov_l_brrm_indexed(W4 d, IMM base, R4 baser, R4 index, IMM factor));
379 DECLARE_MIDFUNC(mov_w_brrm_indexed(W2 d, IMM base, R4 baser, R4 index, IMM factor));
380 DECLARE_MIDFUNC(mov_b_brrm_indexed(W1 d, IMM base, R4 baser, R4 index, IMM factor));
381 DECLARE_MIDFUNC(mov_l_rm_indexed(W4 d, IMM base, R4 index, IMM factor));
382 DECLARE_MIDFUNC(mov_l_rR(W4 d, R4 s, IMM offset));
383 DECLARE_MIDFUNC(mov_w_rR(W2 d, R4 s, IMM offset));
384 DECLARE_MIDFUNC(mov_b_rR(W1 d, R4 s, IMM offset));
385 DECLARE_MIDFUNC(mov_l_brR(W4 d, R4 s, IMM offset));
386 DECLARE_MIDFUNC(mov_w_brR(W2 d, R4 s, IMM offset));
387 DECLARE_MIDFUNC(mov_b_brR(W1 d, R4 s, IMM offset));
388 DECLARE_MIDFUNC(mov_l_Ri(R4 d, IMM i, IMM offset));
389 DECLARE_MIDFUNC(mov_w_Ri(R4 d, IMM i, IMM offset));
390 DECLARE_MIDFUNC(mov_b_Ri(R4 d, IMM i, IMM offset));
391 DECLARE_MIDFUNC(mov_l_Rr(R4 d, R4 s, IMM offset));
392 DECLARE_MIDFUNC(mov_w_Rr(R4 d, R2 s, IMM offset));
393 DECLARE_MIDFUNC(mov_b_Rr(R4 d, R1 s, IMM offset));
394 DECLARE_MIDFUNC(lea_l_brr(W4 d, R4 s, IMM offset));
395 DECLARE_MIDFUNC(lea_l_brr_indexed(W4 d, R4 s, R4 index, IMM factor, IMM offset));
396 DECLARE_MIDFUNC(lea_l_rr_indexed(W4 d, R4 s, R4 index, IMM factor));
397 DECLARE_MIDFUNC(mov_l_bRr(R4 d, R4 s, IMM offset));
398 DECLARE_MIDFUNC(mov_w_bRr(R4 d, R2 s, IMM offset));
399 DECLARE_MIDFUNC(mov_b_bRr(R4 d, R1 s, IMM offset));
400 DECLARE_MIDFUNC(bswap_32(RW4 r));
401 DECLARE_MIDFUNC(bswap_16(RW2 r));
402 DECLARE_MIDFUNC(mov_l_rr(W4 d, R4 s));
403 DECLARE_MIDFUNC(mov_l_mr(IMM d, R4 s));
404 DECLARE_MIDFUNC(mov_w_mr(IMM d, R2 s));
405 DECLARE_MIDFUNC(mov_w_rm(W2 d, IMM s));
406 DECLARE_MIDFUNC(mov_b_mr(IMM d, R1 s));
407 DECLARE_MIDFUNC(mov_b_rm(W1 d, IMM s));
408 DECLARE_MIDFUNC(mov_l_ri(W4 d, IMM s));
409 DECLARE_MIDFUNC(mov_w_ri(W2 d, IMM s));
410 DECLARE_MIDFUNC(mov_b_ri(W1 d, IMM s));
411 DECLARE_MIDFUNC(add_l_mi(IMM d, IMM s) );
412 DECLARE_MIDFUNC(add_w_mi(IMM d, IMM s) );
413 DECLARE_MIDFUNC(add_b_mi(IMM d, IMM s) );
414 DECLARE_MIDFUNC(test_l_ri(R4 d, IMM i));
415 DECLARE_MIDFUNC(test_l_rr(R4 d, R4 s));
416 DECLARE_MIDFUNC(test_w_rr(R2 d, R2 s));
417 DECLARE_MIDFUNC(test_b_rr(R1 d, R1 s));
418 DECLARE_MIDFUNC(and_l_ri(RW4 d, IMM i));
419 DECLARE_MIDFUNC(and_l(RW4 d, R4 s));
420 DECLARE_MIDFUNC(and_w(RW2 d, R2 s));
421 DECLARE_MIDFUNC(and_b(RW1 d, R1 s));
422 DECLARE_MIDFUNC(or_l_rm(RW4 d, IMM s));
423 DECLARE_MIDFUNC(or_l_ri(RW4 d, IMM i));
424 DECLARE_MIDFUNC(or_l(RW4 d, R4 s));
425 DECLARE_MIDFUNC(or_w(RW2 d, R2 s));
426 DECLARE_MIDFUNC(or_b(RW1 d, R1 s));
427 DECLARE_MIDFUNC(adc_l(RW4 d, R4 s));
428 DECLARE_MIDFUNC(adc_w(RW2 d, R2 s));
429 DECLARE_MIDFUNC(adc_b(RW1 d, R1 s));
430 DECLARE_MIDFUNC(add_l(RW4 d, R4 s));
431 DECLARE_MIDFUNC(add_w(RW2 d, R2 s));
432 DECLARE_MIDFUNC(add_b(RW1 d, R1 s));
433 DECLARE_MIDFUNC(sub_l_ri(RW4 d, IMM i));
434 DECLARE_MIDFUNC(sub_w_ri(RW2 d, IMM i));
435 DECLARE_MIDFUNC(sub_b_ri(RW1 d, IMM i));
436 DECLARE_MIDFUNC(add_l_ri(RW4 d, IMM i));
437 DECLARE_MIDFUNC(add_w_ri(RW2 d, IMM i));
438 DECLARE_MIDFUNC(add_b_ri(RW1 d, IMM i));
439 DECLARE_MIDFUNC(sbb_l(RW4 d, R4 s));
440 DECLARE_MIDFUNC(sbb_w(RW2 d, R2 s));
441 DECLARE_MIDFUNC(sbb_b(RW1 d, R1 s));
442 DECLARE_MIDFUNC(sub_l(RW4 d, R4 s));
443 DECLARE_MIDFUNC(sub_w(RW2 d, R2 s));
444 DECLARE_MIDFUNC(sub_b(RW1 d, R1 s));
445 DECLARE_MIDFUNC(cmp_l(R4 d, R4 s));
446 DECLARE_MIDFUNC(cmp_l_ri(R4 r, IMM i));
447 DECLARE_MIDFUNC(cmp_w(R2 d, R2 s));
448 DECLARE_MIDFUNC(cmp_b(R1 d, R1 s));
449 DECLARE_MIDFUNC(xor_l(RW4 d, R4 s));
450 DECLARE_MIDFUNC(xor_w(RW2 d, R2 s));
451 DECLARE_MIDFUNC(xor_b(RW1 d, R1 s));
452 DECLARE_MIDFUNC(live_flags(void));
453 DECLARE_MIDFUNC(dont_care_flags(void));
454 DECLARE_MIDFUNC(duplicate_carry(void));
455 DECLARE_MIDFUNC(restore_carry(void));
456 DECLARE_MIDFUNC(start_needflags(void));
457 DECLARE_MIDFUNC(end_needflags(void));
458 DECLARE_MIDFUNC(make_flags_live(void));
459 DECLARE_MIDFUNC(call_r_11(R4 r, W4 out1, R4 in1, IMM osize, IMM isize));
460 DECLARE_MIDFUNC(call_r_02(R4 r, R4 in1, R4 in2, IMM isize1, IMM isize2));
461 DECLARE_MIDFUNC(forget_about(W4 r));
462 DECLARE_MIDFUNC(nop(void));
463
464 DECLARE_MIDFUNC(f_forget_about(FW r));
465 DECLARE_MIDFUNC(fmov_pi(FW r));
466 DECLARE_MIDFUNC(fmov_log10_2(FW r));
467 DECLARE_MIDFUNC(fmov_log2_e(FW r));
468 DECLARE_MIDFUNC(fmov_loge_2(FW r));
469 DECLARE_MIDFUNC(fmov_1(FW r));
470 DECLARE_MIDFUNC(fmov_0(FW r));
471 DECLARE_MIDFUNC(fmov_rm(FW r, MEMR m));
472 DECLARE_MIDFUNC(fmovi_rm(FW r, MEMR m));
473 DECLARE_MIDFUNC(fmovi_mr(MEMW m, FR r));
474 DECLARE_MIDFUNC(fmovs_rm(FW r, MEMR m));
475 DECLARE_MIDFUNC(fmovs_mr(MEMW m, FR r));
476 DECLARE_MIDFUNC(fmov_mr(MEMW m, FR r));
477 DECLARE_MIDFUNC(fmov_ext_mr(MEMW m, FR r));
478 DECLARE_MIDFUNC(fmov_ext_rm(FW r, MEMR m));
479 DECLARE_MIDFUNC(fmov_rr(FW d, FR s));
480 DECLARE_MIDFUNC(fldcw_m_indexed(R4 index, IMM base));
481 DECLARE_MIDFUNC(ftst_r(FR r));
482 DECLARE_MIDFUNC(dont_care_fflags(void));
483 DECLARE_MIDFUNC(fsqrt_rr(FW d, FR s));
484 DECLARE_MIDFUNC(fabs_rr(FW d, FR s));
485 DECLARE_MIDFUNC(frndint_rr(FW d, FR s));
486 DECLARE_MIDFUNC(fsin_rr(FW d, FR s));
487 DECLARE_MIDFUNC(fcos_rr(FW d, FR s));
488 DECLARE_MIDFUNC(ftwotox_rr(FW d, FR s));
489 DECLARE_MIDFUNC(fetox_rr(FW d, FR s));
490 DECLARE_MIDFUNC(flog2_rr(FW d, FR s));
491 DECLARE_MIDFUNC(fneg_rr(FW d, FR s));
492 DECLARE_MIDFUNC(fadd_rr(FRW d, FR s));
493 DECLARE_MIDFUNC(fsub_rr(FRW d, FR s));
494 DECLARE_MIDFUNC(fmul_rr(FRW d, FR s));
495 DECLARE_MIDFUNC(frem_rr(FRW d, FR s));
496 DECLARE_MIDFUNC(frem1_rr(FRW d, FR s));
497 DECLARE_MIDFUNC(fdiv_rr(FRW d, FR s));
498 DECLARE_MIDFUNC(fcmp_rr(FR d, FR s));
499 DECLARE_MIDFUNC(fflags_into_flags(W2 tmp));
500 #undef DECLARE_MIDFUNC
501
502 extern int failure;
503 #define FAIL(x) do { failure|=x; } while (0)
504
505 /* Convenience functions exposed to gencomp */
506 extern uae_u32 m68k_pc_offset;
507 extern void readbyte(int address, int dest, int tmp);
508 extern void readword(int address, int dest, int tmp);
509 extern void readlong(int address, int dest, int tmp);
510 extern void writebyte(int address, int source, int tmp);
511 extern void writeword(int address, int source, int tmp);
512 extern void writelong(int address, int source, int tmp);
513 extern void writeword_clobber(int address, int source, int tmp);
514 extern void writelong_clobber(int address, int source, int tmp);
515 extern void get_n_addr(int address, int dest, int tmp);
516 extern void get_n_addr_jmp(int address, int dest, int tmp);
517 extern void calc_disp_ea_020(int base, uae_u32 dp, int target, int tmp);
518 /* Set native Z flag only if register is zero */
519 extern void set_zero(int r, int tmp);
520 extern int kill_rodent(int r);
521 extern void sync_m68k_pc(void);
522 extern uae_u32 get_const(int r);
523 extern int is_const(int r);
524 extern void register_branch(uae_u32 not_taken, uae_u32 taken, uae_u8 cond);
525
526 #define comp_get_ibyte(o) do_get_mem_byte((uae_u8 *)(comp_pc_p + (o) + 1))
527 #define comp_get_iword(o) do_get_mem_word((uae_u16 *)(comp_pc_p + (o)))
528 #define comp_get_ilong(o) do_get_mem_long((uae_u32 *)(comp_pc_p + (o)))
529
530 struct blockinfo_t;
531
532 typedef struct dep_t {
533 uae_u32* jmp_off;
534 struct blockinfo_t* target;
535 struct blockinfo_t* source;
536 struct dep_t** prev_p;
537 struct dep_t* next;
538 } dependency;
539
540 typedef struct checksum_info_t {
541 uae_u8 *start_p;
542 uae_u32 length;
543 struct checksum_info_t *next;
544 } checksum_info;
545
546 typedef struct blockinfo_t {
547 uae_s32 count;
548 cpuop_func* direct_handler_to_use;
549 cpuop_func* handler_to_use;
550 /* The direct handler does not check for the correct address */
551
552 cpuop_func* handler;
553 cpuop_func* direct_handler;
554
555 cpuop_func* direct_pen;
556 cpuop_func* direct_pcc;
557
558 uae_u8* pc_p;
559
560 uae_u32 c1;
561 uae_u32 c2;
562 #if USE_CHECKSUM_INFO
563 checksum_info *csi;
564 #else
565 uae_u32 len;
566 uae_u32 min_pcp;
567 #endif
568
569 struct blockinfo_t* next_same_cl;
570 struct blockinfo_t** prev_same_cl_p;
571 struct blockinfo_t* next;
572 struct blockinfo_t** prev_p;
573
574 uae_u8 optlevel;
575 uae_u8 needed_flags;
576 uae_u8 status;
577 uae_u8 havestate;
578
579 dependency dep[2]; /* Holds things we depend on */
580 dependency* deplist; /* List of things that depend on this */
581 smallstate env;
582
583 #if JIT_DEBUG
584 /* (gb) size of the compiled block (direct handler) */
585 uae_u32 direct_handler_size;
586 #endif
587 } blockinfo;
588
589 #define BI_INVALID 0
590 #define BI_ACTIVE 1
591 #define BI_NEED_RECOMP 2
592 #define BI_NEED_CHECK 3
593 #define BI_CHECKING 4
594 #define BI_COMPILING 5
595 #define BI_FINALIZING 6
596
597 void execute_normal(void);
598 void exec_nostats(void);
599 void do_nothing(void);
600
601 #else
602
603 static __inline__ void flush_icache(int) { }
604 static __inline__ void build_comp() { }
605
606 #endif /* !USE_JIT */
607
608 #endif /* COMPEMU_H */