1: /* This file defines a number of threading schemes.
2:
3: Copyright (C) 1995, 1996,1997,1999,2003 Free Software Foundation, Inc.
4:
5: This file is part of Gforth.
6:
7: Gforth is free software; you can redistribute it and/or
8: modify it under the terms of the GNU General Public License
9: as published by the Free Software Foundation; either version 2
10: of the License, or (at your option) any later version.
11:
12: This program is distributed in the hope that it will be useful,
13: but WITHOUT ANY WARRANTY; without even the implied warranty of
14: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15: GNU General Public License for more details.
16:
17: You should have received a copy of the GNU General Public License
18: along with this program; if not, write to the Free Software
19: Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
20:
21:
22: This files defines macros for threading. Many sets of macros are
23: defined. Functionally they have only one difference: Some implement
24: direct threading, some indirect threading. The other differences are
25: just variations to help GCC generate faster code for various
26: machines.
27:
28: (Well, to tell the truth, there actually is another functional
29: difference in some pathological cases: e.g., a '!' stores into the
30: cell where the next executed word comes from; or, the next word
31: executed comes from the top-of-stack. These differences are one of
32: the reasons why GCC cannot produce the right variation by itself. We
33: chose disallowing such practices and using the added implementation
34: freedom to achieve a significant speedup, because these practices
35: are not common in Forth (I have never heard of or seen anyone using
36: them), and it is easy to circumvent problems: A control flow change
37: will flush any prefetched words; you may want to do a "0
38: drop" before that to write back the top-of-stack cache.)
39:
40: These macro sets are used in the following ways: After translation
41: to C a typical primitive looks like
42:
43: ...
44: {
45: DEF_CA
46: other declarations
47: NEXT_P0;
48: main part of the primitive
49: NEXT_P1;
50: store results to stack
51: NEXT_P2;
52: }
53:
54: DEF_CA and all the NEXT_P* together must implement NEXT; In the main
55: part the instruction pointer can be read with IP, changed with
56: INC_IP(const_inc), and the cell right behind the presently executing
57: word (i.e. the value of *IP) is accessed with NEXT_INST.
58:
59: If a primitive does not fall through the main part, it has to do the
60: rest by itself. If it changes ip, it has to redo NEXT_P0 (perhaps we
61: should define a macro SET_IP).
62:
63: Some primitives (execute, dodefer) do not end with NEXT, but with
64: EXEC(.). If NEXT_P0 has been called earlier, it has to perform
65: "ip=IP;" to ensure that ip has the right value (NEXT_P0 may change
66: it).
67:
68: Finally, there is NEXT1_P1 and NEXT1_P2, which are parts of EXEC
69: (EXEC(XT) could be defined as "cfa=XT; NEXT1_P1; NEXT1_P2;" (is this
70: true?)) and are used for making docol faster.
71:
72: We can define the ways in which these macros are used with a regular
73: expression:
74:
75: For a primitive
76:
77: DEF_CA NEXT_P0 ( IP | INC_IP | NEXT_INST | ip=...; NEXT_P0 ) * ( NEXT_P1 NEXT_P2 | EXEC(...) )
78:
79: For a run-time routine, e.g., docol:
80: PFA1(cfa) ( NEXT_P0 NEXT | cfa=...; NEXT1_P1; NEXT1_P2 | EXEC(...) )
81:
82: This comment does not yet describe all the dependences that the
83: macros have to satisfy.
84:
85: To organize the former ifdef chaos, each path is separated
86: This gives a quite impressive number of paths, but you clearly
87: find things that go together.
88:
89: It should be possible to organize the whole thing in a way that
90: contains less redundancy and allows a simpler description.
91:
92: */
93:
94: #ifdef DOUBLY_INDIRECT
95: # ifndef DEBUG_DITC
96: # define DEBUG_DITC 0
97: # endif
98: /* define to 1 if you want to check consistency */
99: # define NEXT_P0 ({cfa=*ip;})
100: # define IP (ip)
101: # define SET_IP(p) ({ip=(p); NEXT_P0;})
102: # define NEXT_INST (cfa)
103: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
104: # define DEF_CA Label ca;
105: # define NEXT_P1 ({\
106: if (DEBUG_DITC && (cfa<=vm_prims+DOESJUMP || cfa>=vm_prims+npriminfos)) \
107: fprintf(stderr,"NEXT encountered prim %p at ip=%p\n", cfa, ip); \
108: ip++;})
109: # define NEXT_P2 ({ca=**cfa; goto *ca;})
110: # define EXEC(XT) ({DEF_CA cfa=(XT);\
111: if (DEBUG_DITC && (cfa>vm_prims+DOESJUMP && cfa<vm_prims+npriminfos)) \
112: fprintf(stderr,"EXEC encountered xt %p at ip=%p, vm_prims=%p, xts=%p\n", cfa, ip, vm_prims, xts); \
113: ca=**cfa; goto *ca;})
114:
115: #elif defined(NO_IP)
116:
117: #define NEXT_P0
118: #define SET_IP(target) assert(0)
119: #define INC_IP(n) ((void)0)
120: #define DEF_CA
121: #define NEXT_P1
122: #define NEXT_P2 ({goto *next_code;})
123: /* set next_code to the return address before performing EXEC */
124: #define EXEC(XT) ({cfa=(XT); goto **cfa;})
125:
126: #else /* !defined(DOUBLY_INDIRECT) && !defined(NO_IP) */
127:
128: #if defined(DIRECT_THREADED)
129:
130: /* This lets the compiler know that cfa is dead before; we place it at
131: "goto *"s that perform direct threaded dispatch (i.e., not EXECUTE
132: etc.), and thus do not reach doers, which would use cfa; the only
133: way to a doer is through EXECUTE etc., which set the cfa
134: themselves.
135:
136: Some of these direct threaded schemes use "cfa" to hold the code
137: address in normal direct threaded code. Of course we cannot use
138: KILLS there.
139:
140: KILLS works by having an empty asm instruction, and claiming to the
141: compiler that it writes to cfa.
142:
143: KILLS is optional. You can write
144:
145: #define KILLS
146:
147: and lose just a little performance.
148: */
149: #define KILLS asm("":"=X"(cfa));
150:
151: #ifndef THREADING_SCHEME
152: #define THREADING_SCHEME 6
153: #endif
154:
155: #if THREADING_SCHEME==1
156: #warning direct threading scheme 1: autoinc, long latency, cfa live
157: # define NEXT_P0 ({cfa=*ip++;})
158: # define IP (ip-1)
159: # define SET_IP(p) ({ip=(p); NEXT_P0;})
160: # define NEXT_INST (cfa)
161: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
162: # define DEF_CA
163: # define NEXT_P1
164: # define NEXT_P2 ({goto *cfa;})
165: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
166: #endif
167:
168: #if THREADING_SCHEME==2
169: #warning direct threading scheme 2: autoinc, long latency, cfa dead
170: # define NEXT_P0 (ip++)
171: # define IP (ip-1)
172: # define SET_IP(p) ({ip=(p); NEXT_P0;})
173: # define NEXT_INST (*(ip-1))
174: # define INC_IP(const_inc) ({ ip+=(const_inc);})
175: # define DEF_CA
176: # define NEXT_P1
177: # define NEXT_P2 ({KILLS goto **(ip-1);})
178: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
179: #endif
180:
181:
182: #if THREADING_SCHEME==3
183: #warning direct threading scheme 3: autoinc, low latency, cfa live
184: # define NEXT_P0
185: # define IP (ip)
186: # define SET_IP(p) ({ip=(p); NEXT_P0;})
187: # define NEXT_INST (*ip)
188: # define INC_IP(const_inc) ({ip+=(const_inc);})
189: # define DEF_CA
190: # define NEXT_P1 ({cfa=*ip++;})
191: # define NEXT_P2 ({goto *cfa;})
192: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
193: #endif
194:
195: #if THREADING_SCHEME==4
196: #warning direct threading scheme 4: autoinc, low latency, cfa dead
197: # define NEXT_P0
198: # define IP (ip)
199: # define SET_IP(p) ({ip=(p); NEXT_P0;})
200: # define NEXT_INST (*ip)
201: # define INC_IP(const_inc) ({ ip+=(const_inc);})
202: # define DEF_CA
203: # define NEXT_P1
204: # define NEXT_P2 ({KILLS goto **(ip++);})
205: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
206: #endif
207:
208: #if THREADING_SCHEME==5
209: #warning direct threading scheme 5: long latency, cfa live
210: # define NEXT_P0 ({cfa=*ip;})
211: # define IP (ip)
212: # define SET_IP(p) ({ip=(p); NEXT_P0;})
213: # define NEXT_INST (cfa)
214: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
215: # define DEF_CA
216: # define NEXT_P1 (ip++)
217: # define NEXT_P2 ({goto *cfa;})
218: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
219: #endif
220:
221: #if THREADING_SCHEME==6
222: #warning direct threading scheme 6: long latency, cfa dead
223: # define NEXT_P0
224: # define IP (ip)
225: # define SET_IP(p) ({ip=(p); NEXT_P0;})
226: # define NEXT_INST (*ip)
227: # define INC_IP(const_inc) ({ip+=(const_inc);})
228: # define DEF_CA
229: # define NEXT_P1 (ip++)
230: # define NEXT_P2 ({KILLS goto **(ip-1);})
231: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
232: #endif
233:
234:
235: #if THREADING_SCHEME==7
236: #warning direct threading scheme 7: low latency, cfa live
237: # define NEXT_P0
238: # define IP (ip)
239: # define SET_IP(p) ({ip=(p); NEXT_P0;})
240: # define NEXT_INST (*ip)
241: # define INC_IP(const_inc) ({ip+=(const_inc);})
242: # define DEF_CA
243: # define NEXT_P1 ({cfa=*ip++;})
244: # define NEXT_P2 ({goto *cfa;})
245: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
246: #endif
247:
248: #if THREADING_SCHEME==8
249: #warning direct threading scheme 8: cfa dead, i386 hack
250: # define NEXT_P0
251: # define IP (ip)
252: # define SET_IP(p) ({ip=(p); NEXT_P0;})
253: # define NEXT_INST (*IP)
254: # define INC_IP(const_inc) ({ ip+=(const_inc);})
255: # define DEF_CA
256: # define NEXT_P1 (ip++)
257: # define NEXT_P2 ({KILLS goto **(ip-1);})
258: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
259: #endif
260:
261: #if THREADING_SCHEME==9
262: #warning direct threading scheme 9: Power/PPC hack, long latency
263: /* Power uses a prepare-to-branch instruction, and the latency between
264: this inst and the branch is 5 cycles on a PPC604; so we utilize this
265: to do some prefetching in between */
266: # define NEXT_P0
267: # define IP ip
268: # define SET_IP(p) ({ip=(p); next_cfa=*ip; NEXT_P0;})
269: # define NEXT_INST (next_cfa)
270: # define INC_IP(const_inc) ({next_cfa=IP[const_inc]; ip+=(const_inc);})
271: # define DEF_CA
272: # define NEXT_P1 ({cfa=next_cfa; ip++; next_cfa=*ip;})
273: # define NEXT_P2 ({goto *cfa;})
274: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
275: # define MORE_VARS Xt next_cfa;
276: #endif
277:
278: #if THREADING_SCHEME==10
279: #warning direct threading scheme 10: plain (no attempt at scheduling)
280: # define NEXT_P0
281: # define IP (ip)
282: # define SET_IP(p) ({ip=(p); NEXT_P0;})
283: # define NEXT_INST (*ip)
284: # define INC_IP(const_inc) ({ip+=(const_inc);})
285: # define DEF_CA
286: # define NEXT_P1
287: # define NEXT_P2 ({cfa=*ip++; goto *cfa;})
288: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
289: #endif
290:
291: /* direct threaded */
292: #else
293: /* indirect THREADED */
294:
295: #ifndef THREADING_SCHEME
296: #define THREADING_SCHEME 6
297: #endif
298:
299: #if THREADING_SCHEME==1
300: #warning indirect threading scheme 1: autoinc, long latency, cisc
301: # define NEXT_P0 ({cfa=*ip++;})
302: # define IP (ip-1)
303: # define SET_IP(p) ({ip=(p); NEXT_P0;})
304: # define NEXT_INST (cfa)
305: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
306: # define DEF_CA
307: # define NEXT_P1
308: # define NEXT_P2 ({goto **cfa;})
309: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
310: #endif
311:
312: #if THREADING_SCHEME==2
313: #warning indirect threading scheme 2: autoinc, long latency
314: # define NEXT_P0 ({cfa=*ip++;})
315: # define IP (ip-1)
316: # define SET_IP(p) ({ip=(p); NEXT_P0;})
317: # define NEXT_INST (cfa)
318: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
319: # define DEF_CA Label ca;
320: # define NEXT_P1 ({ca=*cfa;})
321: # define NEXT_P2 ({goto *ca;})
322: # define EXEC(XT) ({DEF_CA cfa=(XT); ca=*cfa; goto *ca;})
323: #endif
324:
325:
326: #if THREADING_SCHEME==3
327: #warning indirect threading scheme 3: autoinc, low latency, cisc
328: # define NEXT_P0
329: # define IP (ip)
330: # define SET_IP(p) ({ip=(p); NEXT_P0;})
331: # define NEXT_INST (*ip)
332: # define INC_IP(const_inc) ({ip+=(const_inc);})
333: # define DEF_CA
334: # define NEXT_P1
335: # define NEXT_P2 ({cfa=*ip++; goto **cfa;})
336: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
337: #endif
338:
339: #if THREADING_SCHEME==4
340: #warning indirect threading scheme 4: autoinc, low latency
341: # define NEXT_P0 ({cfa=*ip++;})
342: # define IP (ip-1)
343: # define SET_IP(p) ({ip=(p); NEXT_P0;})
344: # define NEXT_INST (cfa)
345: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
346: # define DEF_CA Label ca;
347: # define NEXT_P1 ({ca=*cfa;})
348: # define NEXT_P2 ({goto *ca;})
349: # define EXEC(XT) ({DEF_CA cfa=(XT); ca=*cfa; goto *ca;})
350: #endif
351:
352:
353: #if THREADING_SCHEME==5
354: #warning indirect threading scheme 5: long latency, cisc
355: # define NEXT_P0 ({cfa=*ip;})
356: # define IP (ip)
357: # define SET_IP(p) ({ip=(p); NEXT_P0;})
358: # define NEXT_INST (cfa)
359: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
360: # define DEF_CA
361: # define NEXT_P1 (ip++)
362: # define NEXT_P2 ({goto **cfa;})
363: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
364: #endif
365:
366: #if THREADING_SCHEME==6
367: #warning indirect threading scheme 6: long latency
368: # define NEXT_P0 ({cfa=*ip;})
369: # define IP (ip)
370: # define SET_IP(p) ({ip=(p); NEXT_P0;})
371: # define NEXT_INST (cfa)
372: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
373: # define DEF_CA Label ca;
374: # define NEXT_P1 ({ip++; ca=*cfa;})
375: # define NEXT_P2 ({goto *ca;})
376: # define EXEC(XT) ({DEF_CA cfa=(XT); ca=*cfa; goto *ca;})
377: #endif
378:
379: #if THREADING_SCHEME==7
380: #warning indirect threading scheme 7: low latency
381: # define NEXT_P0 ({cfa=*ip;})
382: # define IP (ip)
383: # define SET_IP(p) ({ip=(p); NEXT_P0;})
384: # define NEXT_INST (cfa)
385: # define INC_IP(const_inc) ({cfa=IP[const_inc]; ip+=(const_inc);})
386: # define DEF_CA Label ca;
387: # define NEXT_P1 ({ip++; ca=*cfa;})
388: # define NEXT_P2 ({goto *ca;})
389: # define EXEC(XT) ({DEF_CA cfa=(XT); ca=*cfa; goto *ca;})
390: #endif
391:
392: #if THREADING_SCHEME==8
393: #warning indirect threading scheme 8: low latency,cisc
394: # define NEXT_P0
395: # define IP (ip)
396: # define SET_IP(p) ({ip=(p); NEXT_P0;})
397: # define NEXT_INST (*ip)
398: # define INC_IP(const_inc) ({ip+=(const_inc);})
399: # define DEF_CA
400: # define NEXT_P1
401: # define NEXT_P2 ({cfa=*ip++; goto **cfa;})
402: # define EXEC(XT) ({cfa=(XT); goto **cfa;})
403: #endif
404:
405: /* indirect threaded */
406: #endif
407:
408: #endif /* !defined(DOUBLY_INDIRECT) && !defined(NO_IP) */
409:
410: #define NEXT ({DEF_CA NEXT_P1; NEXT_P2;})
411: #define IPTOS NEXT_INST
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>