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