![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to compemu_optimizer_x86.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [HATARI the Atari ST Emulator] / hatari / src / cpu / jit|
Return to compemu_optimizer_x86.c CVS log | Up to [HATARI the Atari ST Emulator] / hatari / src / cpu / jit |
1.1 root 1: #if USE_LOW_OPTIMIZER
2: /* Welcome to the magical world of cpp ;-) */
3:
4: /* This was broken by the advent of FPU emulation. It also didn't
5: provide any useful speedup while it worked. *Sigh* Someone fix my
6: software, please ;-) */
7:
8: #define MAXLOPTINST 100
9:
10: #define LDECISION currprefs.comp_lowopt
11:
12: #define lopt_op0(dummy) lopt_store_op0(
13: #define lopt_op1(a1) lopt_store_op1(LOPT_##a1,
14: #define lopt_op2(a1,a2) lopt_store_op2(LOPT_##a1,LOPT_##a2,
15: #define lopt_op3(a1,a2,a3) lopt_store_op3(LOPT_##a1,LOPT_##a2,LOPT_##a3,
16: #define lopt_op4(a1,a2,a3,a4) lopt_store_op4(LOPT_##a1,LOPT_##a2,LOPT_##a3,LOPT_##a4,
17: #define lopt_op5(a1,a2,a3,a4,a5) lopt_store_op5(LOPT_##a1,LOPT_##a2,LOPT_##a3,LOPT_##a4,LOPT_##a5,
18:
19: #define ldirect0(dummy) ()
20: #define ldirect1(a1) (LDIR_##a1)
21: #define ldirect2(a1,a2) (LDIR_##a1,LDIR_##a2)
22: #define ldirect3(a1,a2,a3) (LDIR_##a1,LDIR_##a2,LDIR_##a3)
23: #define ldirect4(a1,a2,a3,a4) (LDIR_##a1,LDIR_##a2,LDIR_##a3,LDIR_##a4)
24: #define ldirect5(a1,a2,a3,a4,a5) (LDIR_##a1,LDIR_##a2,LDIR_##a3,LDIR_##a4,LDIR_##a5)
25:
26: #define NONE 0
27: #define READ 1
28: #define WRITE 2
29: #define RMW (READ|WRITE)
30:
31: #define SIZE1 4
32: #define SIZE2 8
33: #define SIZE4 12
34: #define FLOAT 16
35: #define SIZEMASK 12
36:
37: #define LIMM NONE
38: #define LR1 (READ | SIZE1)
39: #define LR2 (READ | SIZE2)
40: #define LR4 (READ | SIZE4)
41: #define LW1 (WRITE | SIZE1)
42: #define LW2 (WRITE | SIZE2)
43: #define LW4 (WRITE | SIZE4)
44: #define LRW1 (RMW | SIZE1)
45: #define LRW2 (RMW | SIZE2)
46: #define LRW4 (RMW | SIZE4)
47: #define LFW (READ | FLOAT)
48: #define LFR (WRITE | FLOAT)
49: #define LFRW (RMW | FLOAT)
50: #define LMEMR NONE
51: #define LMEMW NONE
52: #define LMEMRW NONE
53:
54: #define LOPT_IMM LIMM,
55: #define LOPT_R1 LR1 ,
56: #define LOPT_R2 LR2 ,
57: #define LOPT_R4 LR4 ,
58: #define LOPT_W1 LW1 ,
59: #define LOPT_W2 LW2 ,
60: #define LOPT_W4 LW4 ,
61: #define LOPT_RW1 LRW1,
62: #define LOPT_RW2 LRW2,
63: #define LOPT_RW4 LRW4,
64: #define LOPT_FR LFR,
65: #define LOPT_FW LFW,
66: #define LOPT_FRW LFRW,
67: #define LOPT_MEMR LMEMR,
68: #define LOPT_MEMW LMEMW,
69: #define LOPT_MEMRW LMEMRW,
70:
71: #define LDIR_IMM
72: #define LDIR_R1
73: #define LDIR_R2
74: #define LDIR_R4
75: #define LDIR_W1
76: #define LDIR_W2
77: #define LDIR_W4
78: #define LDIR_RW1
79: #define LDIR_RW2
80: #define LDIR_RW4
81: #define LDIR_FW
82: #define LDIR_FR
83: #define LDIR_FRW
84: #define LDIR_MEMR
85: #define LDIR_MEMW
86: #define LDIR_MEMRW
87:
88:
89: #undef LOWFUNC
90: #undef LENDFUNC
91:
92: #define LOWFUNC(flags,mem,nargs,func,args) \
93: STATIC_INLINE void do_##func args
94:
95: #define LENDFUNC(flags,mem,nargs,func,args) \
96: STATIC_INLINE void func args \
97: { \
98: if (LDECISION) { \
99: lopt_op##nargs##args do_##func, mem, flags); \
100: } else { \
101: do_##func ldirect##nargs##args; \
102: } \
103: }
104:
105: typedef struct lopt_inst_rec {
106: void* func;
107: uae_u32 args[5];
108: uae_u8 argtype[5];
109: uae_s8 nargs;
110: uae_u8 mem;
111: uae_u8 flags;
112: } lopt_inst;
113:
114:
115:
116: static lopt_inst linst[MAXLOPTINST];
117: static int lopt_index=0;
118:
119: STATIC_INLINE int argsize(int type)
120: {
121: return type&SIZEMASK;
122: }
123:
124: STATIC_INLINE int reads_mem(int i) {
125: return linst[i].mem & READ;
126: }
127:
128:
129: STATIC_INLINE int access_reg(int i, int r, int mode)
130: {
131: int k;
132: for (k=0;k<linst[i].nargs;k++)
133: if (linst[i].args[k]==r &&
134: (linst[i].argtype[k]&mode) &&
135: !(linst[i].argtype[k]&FLOAT))
136: return 1;
137: return 0;
138: }
139:
140: STATIC_INLINE_ int writes_reg(int i, int r)
141: {
142: return access_reg(i,r,WRITE);
143: }
144:
145: STATIC_INLINE int reads_reg(int i, int r)
146: {
147: return access_reg(i,r,READ);
148: }
149:
150: STATIC_INLINE int uses_reg(int i, int r)
151: {
152: return access_reg(i,r,RMW);
153: }
154:
155:
156: STATIC_INLINE int writes_mem(int i) {
157: return linst[i].mem & WRITE;
158: }
159:
160: STATIC_INLINE int uses_mem(int i)
161: {
162: return linst[i].mem & RMW;
163: }
164:
165: STATIC_INLINE int reads_flags(int i) {
166: return linst[i].flags & READ;
167: }
168:
169: STATIC_INLINE int writes_flags(int i) {
170: return linst[i].flags & WRITE;
171: }
172:
173: STATIC_INLINE int uses_flags(int i)
174: {
175: return linst[i].flags & RMW;
176: }
177:
178: static void do_raw_mov_l_rm(W4,MEMR);
179: static void do_raw_fflags_save(void);
180:
181:
182: /* Whether i depends on j */
183: STATIC_INLINE int depends_on(int i, int j)
184: {
185: int n;
186:
187: /* First, check memory */
188: if (writes_mem(i) && uses_mem(j))
189: return 1;
190: if (reads_mem(i) && writes_mem(j))
191: return 1;
192:
193: /* Next, check flags */
194: if (writes_flags(i) && uses_flags(j))
195: return 1;
196: if (reads_flags(i) && writes_flags(j))
197: return 1;
198:
199: for (n=0;n<linst[i].nargs;n++) {
200: if (linst[i].argtype[n] & FLOAT)
201: return 1;
202: }
203: for (n=0;n<linst[j].nargs;n++) {
204: if (linst[j].argtype[n] & FLOAT)
205: return 1;
206: }
207:
208: for (n=0;n<linst[i].nargs;n++) {
209: if ((linst[i].argtype[n] & WRITE) &&
210: !(linst[i].argtype[n] & FLOAT)) {
211: if (uses_reg(j,linst[i].args[n]))
212: return 1;
213: }
214: else if ((linst[i].argtype[n] & READ) &&
215: !(linst[i].argtype[n] & FLOAT)) {
216: if (writes_reg(j,linst[i].args[n]))
217: return 1;
218: }
219: }
220:
221: /* The need for this indicates a problem somewhere in the
222: LOWFUNC definitions --- I think. FIXME! */
223:
224: if (uses_flags(j) && uses_flags(i))
225: return 1;
226: if (linst[i].func==do_raw_fflags_save)
227: return 1;
228: if (linst[j].func==do_raw_fflags_save)
229: return 1;
230:
231: return 0;
232: }
233:
234: static void do_raw_mov_l_rm(W4 d, MEMR s);
235:
236: STATIC_INLINE void low_peephole(void)
237: {
238: int i;
239:
240: for (i=0;i<lopt_index;i++) {
241: if (uses_mem(i)) {
242: int j=i-1;
243:
244: while (j>=i-4 && j>=0 && !depends_on(i,j)) {
245: j--;
246: }
247: if (j!=i-1) {
248: lopt_inst x=linst[i];
249: int k=i;
250:
251: j++;
252: while (k>j) {
253: linst[k]=linst[k-1];
254: k--;
255: }
256: linst[j]=x;
257: }
258: }
259: }
260: }
261:
262:
263: typedef void lopt_handler0(void);
264: typedef void lopt_handler1(uae_u32);
265: typedef void lopt_handler2(uae_u32,uae_u32);
266: typedef void lopt_handler3(uae_u32,uae_u32,uae_u32);
267: typedef void lopt_handler4(uae_u32,uae_u32,uae_u32,uae_u32);
268: typedef void lopt_handler5(uae_u32,uae_u32,uae_u32,uae_u32,uae_u32);
269:
270: static void lopt_emit_all(void)
271: {
272: int i;
273: lopt_inst* x;
274: static int inemit=0;
275:
276: if (inemit) {
277: printf("WARNING: lopt_emit is not reentrant!\n");
278: }
279: inemit=1;
280:
281: low_peephole();
282:
283: for (i=0;i<lopt_index;i++) {
284: x=linst+i;
285: switch(x->nargs) {
286: case 0: ((lopt_handler0*)x->func)(); break;
287: case 1: ((lopt_handler1*)x->func)(x->args[0]); break;
288: case 2: ((lopt_handler2*)x->func)(x->args[0],x->args[1]); break;
289: case 3: ((lopt_handler3*)x->func)(x->args[0],x->args[1],x->args[2]); break;
290: case 4: ((lopt_handler4*)x->func)(x->args[0],x->args[1],x->args[2],
291: x->args[3]); break;
292: case 5: ((lopt_handler5*)x->func)(x->args[0],x->args[1],x->args[2],
293: x->args[3],x->args[4]); break;
294: default: abort();
295: }
296: }
297: lopt_index=0;
298: inemit=0;
299: }
300:
301: STATIC_INLINE void low_advance(void)
302: {
303: lopt_index++;
304: if (lopt_index==MAXLOPTINST)
305: lopt_emit_all();
306: }
307:
308: STATIC_INLINE void lopt_store_op0(void* lfuncptr, uae_u32 lmem,
309: uae_u32 lflags)
310: {
311: linst[lopt_index].func=lfuncptr;
312: linst[lopt_index].mem=lmem;
313: linst[lopt_index].flags=lflags;
314: linst[lopt_index].nargs=0;
315: low_advance();
316: }
317:
318: STATIC_INLINE void lopt_store_op1(uae_u8 t1, uae_u32 a1,
319: void* lfuncptr, uae_u32 lmem,
320: uae_u32 lflags)
321: {
322: linst[lopt_index].func=lfuncptr;
323: linst[lopt_index].mem=lmem;
324: linst[lopt_index].flags=lflags;
325: linst[lopt_index].nargs=1;
326: linst[lopt_index].argtype[0]=t1;
327: linst[lopt_index].args[0]=a1;
328: low_advance();
329: }
330:
331: STATIC_INLINE void lopt_store_op2(uae_u8 t1, uae_u32 a1,
332: uae_u8 t2, uae_u32 a2,
333: void* lfuncptr, uae_u32 lmem,
334: uae_u32 lflags)
335: {
336: linst[lopt_index].func=lfuncptr;
337: linst[lopt_index].mem=lmem;
338: linst[lopt_index].flags=lflags;
339: linst[lopt_index].nargs=2;
340: linst[lopt_index].argtype[0]=t1;
341: linst[lopt_index].args[0]=a1;
342: linst[lopt_index].argtype[1]=t2;
343: linst[lopt_index].args[1]=a2;
344: low_advance();
345: }
346:
347: STATIC_INLINE void lopt_store_op3(uae_u8 t1, uae_u32 a1,
348: uae_u8 t2, uae_u32 a2,
349: uae_u8 t3, uae_u32 a3,
350: void* lfuncptr, uae_u32 lmem,
351: uae_u32 lflags)
352: {
353: linst[lopt_index].func=lfuncptr;
354: linst[lopt_index].mem=lmem;
355: linst[lopt_index].flags=lflags;
356: linst[lopt_index].nargs=3;
357: linst[lopt_index].argtype[0]=t1;
358: linst[lopt_index].args[0]=a1;
359: linst[lopt_index].argtype[1]=t2;
360: linst[lopt_index].args[1]=a2;
361: linst[lopt_index].argtype[2]=t3;
362: linst[lopt_index].args[2]=a3;
363: low_advance();
364: }
365:
366: STATIC_INLINE void lopt_store_op4(uae_u8 t1, uae_u32 a1,
367: uae_u8 t2, uae_u32 a2,
368: uae_u8 t3, uae_u32 a3,
369: uae_u8 t4, uae_u32 a4,
370: void* lfuncptr, uae_u32 lmem,
371: uae_u32 lflags)
372: {
373: linst[lopt_index].func=lfuncptr;
374: linst[lopt_index].mem=lmem;
375: linst[lopt_index].flags=lflags;
376: linst[lopt_index].nargs=4;
377: linst[lopt_index].argtype[0]=t1;
378: linst[lopt_index].args[0]=a1;
379: linst[lopt_index].argtype[1]=t2;
380: linst[lopt_index].args[1]=a2;
381: linst[lopt_index].argtype[2]=t3;
382: linst[lopt_index].args[2]=a3;
383: linst[lopt_index].argtype[3]=t4;
384: linst[lopt_index].args[3]=a4;
385: low_advance();
386: }
387:
388: STATIC_INLINE void lopt_store_op5(uae_u8 t1, uae_u32 a1,
389: uae_u8 t2, uae_u32 a2,
390: uae_u8 t3, uae_u32 a3,
391: uae_u8 t4, uae_u32 a4,
392: uae_u8 t5, uae_u32 a5,
393: void* lfuncptr, uae_u32 lmem,
394: uae_u32 lflags)
395: {
396: linst[lopt_index].func=lfuncptr;
397: linst[lopt_index].mem=lmem;
398: linst[lopt_index].flags=lflags;
399: linst[lopt_index].nargs=5;
400: linst[lopt_index].argtype[0]=t1;
401: linst[lopt_index].args[0]=a1;
402: linst[lopt_index].argtype[1]=t2;
403: linst[lopt_index].args[1]=a2;
404: linst[lopt_index].argtype[2]=t3;
405: linst[lopt_index].args[2]=a3;
406: linst[lopt_index].argtype[3]=t4;
407: linst[lopt_index].args[3]=a4;
408: linst[lopt_index].argtype[4]=t5;
409: linst[lopt_index].args[4]=a5;
410: low_advance();
411: }
412:
413: STATIC_INLINE void empty_low_optimizer(void)
414: {
415: lopt_emit_all();
416: }
417:
418: #else
419: #define lopt_emit_all()
420: #define empty_low_optimizer()
421: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.