Return to threaded.h CVS log

Up to [gforth] / gforth / engine

Annotation of gforth/engine/threaded.h, revision 1.13

1.1       anton       1: /* This file defines a number of threading schemes.
                      2: 
1.6       anton       3:   Copyright (C) 1995, 1996,1997,1999 Free Software Foundation, Inc.
1.1       anton       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
1.7       anton      19:   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA.
1.1       anton      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: 
1.5       anton      94: /* CFA_NEXT: if NEXT uses cfa, you have to #define CFA_NEXT, to get
                     95:  * cfa declared in engine.
                     96:  */
1.1       anton      97: 
                     98: #ifdef DOUBLY_INDIRECT
1.4       jwilke     99: #  define CFA_NEXT
1.1       anton     100: #  define NEXT_P0      ({cfa=*ip;})
                    101: #  define IP           (ip)
1.3       anton     102: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     103: #  define NEXT_INST    (cfa)
                    104: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    105: #  define DEF_CA       Label ca;
1.13    ! anton     106: #  define NEXT_P1      ({\
        !           107:   if (cfa<=vm_prims+DOESJUMP || cfa>=vm_prims+sizeof(routines)) \
        !           108:     fprintf(stderr,"NEXT encountered prim %p at ip=%p\n", cfa, ip); \
        !           109:   ip++; ca=**cfa;})
1.1       anton     110: #  define NEXT_P2      ({goto *ca;})
1.13    ! anton     111: #  define EXEC(XT)     ({DEF_CA cfa=(XT);\
        !           112:   if (cfa>vm_prims+DOESJUMP && cfa<vm_prims+sizeof(routines)) \
        !           113:     fprintf(stderr,"EXEC encountered xt %p at ip=%p\n", cfa, ip); \
        !           114:  ca=**cfa; goto *ca;})
1.1       anton     115: 
                    116: #else /* !defined(DOUBLY_INDIRECT) */
                    117: 
1.3       anton     118: #if defined(DIRECT_THREADED)
                    119: 
                    120: /* note that the "cfa dead" versions only work if GETCFA exists and works */
                    121: 
                    122: #if THREADING_SCHEME==1
                    123: #warning direct threading scheme 1: autoinc, long latency, cfa live
1.4       jwilke    124: #  define CFA_NEXT
1.1       anton     125: #  define NEXT_P0      ({cfa=*ip++;})
                    126: #  define IP           (ip-1)
1.3       anton     127: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     128: #  define NEXT_INST    (cfa)
                    129: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    130: #  define DEF_CA
                    131: #  define NEXT_P1
                    132: #  define NEXT_P2      ({goto *cfa;})
                    133: #  define EXEC(XT)     ({cfa=(XT); goto *cfa;})
                    134: #endif
                    135: 
1.3       anton     136: #if THREADING_SCHEME==2
                    137: #warning direct threading scheme 2: autoinc, long latency, cfa dead
1.4       jwilke    138: #ifndef GETCFA
                    139: #error GETCFA must be defined for cfa dead threading
                    140: #endif
1.1       anton     141: #  define NEXT_P0      (ip++)
                    142: #  define IP           (ip-1)
1.3       anton     143: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     144: #  define NEXT_INST    (*(ip-1))
                    145: #  define INC_IP(const_inc)    ({ ip+=(const_inc);})
                    146: #  define DEF_CA
                    147: #  define NEXT_P1
                    148: #  define NEXT_P2      ({goto **(ip-1);})
                    149: #  define EXEC(XT)     ({goto *(XT);})
                    150: #endif
                    151: 
                    152: 
1.3       anton     153: #if THREADING_SCHEME==3
                    154: #warning direct threading scheme 3: autoinc, low latency, cfa live
1.4       jwilke    155: #  define CFA_NEXT
1.1       anton     156: #  define NEXT_P0
                    157: #  define IP           (ip)
1.3       anton     158: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     159: #  define NEXT_INST    (*ip)
                    160: #  define INC_IP(const_inc)    ({ip+=(const_inc);})
                    161: #  define DEF_CA
                    162: #  define NEXT_P1      ({cfa=*ip++;})
                    163: #  define NEXT_P2      ({goto *cfa;})
                    164: #  define EXEC(XT)     ({cfa=(XT); goto *cfa;})
                    165: #endif
                    166: 
1.3       anton     167: #if THREADING_SCHEME==4
                    168: #warning direct threading scheme 4: autoinc, low latency, cfa dead
1.4       jwilke    169: #ifndef GETCFA
                    170: #error GETCFA must be defined for cfa dead threading
                    171: #endif
1.1       anton     172: #  define NEXT_P0
                    173: #  define IP           (ip)
1.3       anton     174: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     175: #  define NEXT_INST    (*ip)
                    176: #  define INC_IP(const_inc)    ({ ip+=(const_inc);})
                    177: #  define DEF_CA
                    178: #  define NEXT_P1
                    179: #  define NEXT_P2      ({goto **(ip++);})
                    180: #  define EXEC(XT)     ({goto *(XT);})
                    181: #endif
                    182: 
1.3       anton     183: #if THREADING_SCHEME==5
                    184: #warning direct threading scheme 5: long latency, cfa live
1.4       jwilke    185: #  define CFA_NEXT
1.1       anton     186: #  define NEXT_P0      ({cfa=*ip;})
                    187: #  define IP           (ip)
1.3       anton     188: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     189: #  define NEXT_INST    (cfa)
                    190: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    191: #  define DEF_CA
                    192: #  define NEXT_P1      (ip++)
                    193: #  define NEXT_P2      ({goto *cfa;})
                    194: #  define EXEC(XT)     ({cfa=(XT); goto *cfa;})
                    195: #endif
                    196: 
1.3       anton     197: #if THREADING_SCHEME==6
                    198: #warning direct threading scheme 6: long latency, cfa dead
1.4       jwilke    199: #ifndef GETCFA
                    200: #error GETCFA must be defined for cfa dead threading
                    201: #endif
1.1       anton     202: #  define NEXT_P0
                    203: #  define IP           (ip)
1.3       anton     204: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     205: #  define NEXT_INST    (*ip)
                    206: #  define INC_IP(const_inc)    ({ip+=(const_inc);})
                    207: #  define DEF_CA
                    208: #  define NEXT_P1      (ip++)
                    209: #  define NEXT_P2      ({goto **(ip-1);})
                    210: #  define EXEC(XT)     ({goto *(XT);})
                    211: #endif
                    212: 
                    213: 
1.3       anton     214: #if THREADING_SCHEME==7
                    215: #warning direct threading scheme 7: low latency, cfa live
1.4       jwilke    216: #  define CFA_NEXT
1.1       anton     217: #  define NEXT_P0
                    218: #  define IP           (ip)
1.3       anton     219: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     220: #  define NEXT_INST    (*ip)
                    221: #  define INC_IP(const_inc)    ({ip+=(const_inc);})
                    222: #  define DEF_CA
                    223: #  define NEXT_P1      ({cfa=*ip++;})
                    224: #  define NEXT_P2      ({goto *cfa;})
                    225: #  define EXEC(XT)     ({cfa=(XT); goto *cfa;})
                    226: #endif
                    227: 
1.3       anton     228: #if THREADING_SCHEME==8
                    229: #warning direct threading scheme 8: cfa dead, i386 hack
1.4       jwilke    230: #ifndef GETCFA
                    231: #error GETCFA must be defined for cfa dead threading
                    232: #endif
1.1       anton     233: #  define NEXT_P0
                    234: #  define IP           (ip)
1.3       anton     235: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     236: #  define NEXT_INST    (*IP)
                    237: #  define INC_IP(const_inc)    ({ ip+=(const_inc);})
                    238: #  define DEF_CA
                    239: #  define NEXT_P1      (ip++)
                    240: #  define NEXT_P2      ({goto **(ip-1);})
                    241: #  define EXEC(XT)     ({goto *(XT);})
                    242: #endif
                    243: 
1.3       anton     244: #if THREADING_SCHEME==9
                    245: #warning direct threading scheme 9: Power/PPC hack, long latency
                    246: /* Power uses a prepare-to-branch instruction, and the latency between
                    247:    this inst and the branch is 5 cycles on a PPC604; so we utilize this
                    248:    to do some prefetching in between */
1.4       jwilke    249: #  define CFA_NEXT
1.3       anton     250: #  define NEXT_P0
                    251: #  define IP           ip
                    252: #  define SET_IP(p)    ({ip=(p); next_cfa=*ip; NEXT_P0;})
                    253: #  define NEXT_INST    (next_cfa)
                    254: #  define INC_IP(const_inc)    ({next_cfa=IP[const_inc]; ip+=(const_inc);})
1.8       anton     255: #  define DEF_CA       
                    256: #  define NEXT_P1      ({cfa=next_cfa; ip++; next_cfa=*ip;})
                    257: #  define NEXT_P2      ({goto *cfa;})
1.3       anton     258: #  define EXEC(XT)     ({cfa=(XT); goto *cfa;})
                    259: #  define MORE_VARS    Xt next_cfa;
                    260: #endif
1.1       anton     261: 
1.3       anton     262: #if THREADING_SCHEME==10
                    263: #warning direct threading scheme 10: plain (no attempt at scheduling)
1.4       jwilke    264: #  define CFA_NEXT
1.3       anton     265: #  define NEXT_P0
                    266: #  define IP           (ip)
                    267: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
                    268: #  define NEXT_INST    (*ip)
                    269: #  define INC_IP(const_inc)    ({ip+=(const_inc);})
                    270: #  define DEF_CA
                    271: #  define NEXT_P1
                    272: #  define NEXT_P2      ({cfa=*ip++; goto *cfa;})
                    273: #  define EXEC(XT)     ({cfa=(XT); goto *cfa;})
                    274: #endif
1.1       anton     275: 
1.3       anton     276: /* direct threaded */
                    277: #else
1.1       anton     278: /* indirect THREADED  */
                    279: 
1.3       anton     280: #if THREADING_SCHEME==1
                    281: #warning indirect threading scheme 1: autoinc, long latency, cisc
1.4       jwilke    282: #  define CFA_NEXT
1.1       anton     283: #  define NEXT_P0      ({cfa=*ip++;})
                    284: #  define IP           (ip-1)
1.3       anton     285: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     286: #  define NEXT_INST    (cfa)
                    287: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    288: #  define DEF_CA
                    289: #  define NEXT_P1
                    290: #  define NEXT_P2      ({goto **cfa;})
                    291: #  define EXEC(XT)     ({cfa=(XT); goto **cfa;})
                    292: #endif
                    293: 
1.3       anton     294: #if THREADING_SCHEME==2
                    295: #warning indirect threading scheme 2: autoinc, long latency
1.4       jwilke    296: #  define CFA_NEXT
1.1       anton     297: #  define NEXT_P0      ({cfa=*ip++;})
                    298: #  define IP           (ip-1)
1.3       anton     299: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     300: #  define NEXT_INST    (cfa)
                    301: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    302: #  define DEF_CA       Label ca;
                    303: #  define NEXT_P1      ({ca=*cfa;})
                    304: #  define NEXT_P2      ({goto *ca;})
                    305: #  define EXEC(XT)     ({DEF_CA cfa=(XT); ca=*cfa; goto *ca;})
                    306: #endif
                    307: 
                    308: 
1.3       anton     309: #if THREADING_SCHEME==3
                    310: #warning indirect threading scheme 3: autoinc, low latency, cisc
1.4       jwilke    311: #  define CFA_NEXT
1.1       anton     312: #  define NEXT_P0
                    313: #  define IP           (ip)
1.3       anton     314: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     315: #  define NEXT_INST    (*ip)
                    316: #  define INC_IP(const_inc)    ({ip+=(const_inc);})
                    317: #  define DEF_CA
                    318: #  define NEXT_P1
                    319: #  define NEXT_P2      ({cfa=*ip++; goto **cfa;})
                    320: #  define EXEC(XT)     ({cfa=(XT); goto **cfa;})
                    321: #endif
                    322: 
1.3       anton     323: #if THREADING_SCHEME==4
                    324: #warning indirect threading scheme 4: autoinc, low latency
1.4       jwilke    325: #  define CFA_NEXT
1.1       anton     326: #  define NEXT_P0      ({cfa=*ip++;})
                    327: #  define IP           (ip-1)
1.3       anton     328: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     329: #  define NEXT_INST    (cfa)
                    330: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    331: #  define DEF_CA       Label ca;
                    332: #  define NEXT_P1      ({ca=*cfa;})
                    333: #  define NEXT_P2      ({goto *ca;})
                    334: #  define EXEC(XT)     ({DEF_CA cfa=(XT); ca=*cfa; goto *ca;})
                    335: #endif
                    336: 
                    337: 
1.3       anton     338: #if THREADING_SCHEME==5
                    339: #warning indirect threading scheme 5: long latency, cisc
1.4       jwilke    340: #  define CFA_NEXT
1.1       anton     341: #  define NEXT_P0      ({cfa=*ip;})
                    342: #  define IP           (ip)
1.3       anton     343: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     344: #  define NEXT_INST    (cfa)
                    345: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    346: #  define DEF_CA
                    347: #  define NEXT_P1      (ip++)
                    348: #  define NEXT_P2      ({goto **cfa;})
                    349: #  define EXEC(XT)     ({cfa=(XT); goto **cfa;})
                    350: #endif
                    351: 
1.3       anton     352: #if THREADING_SCHEME==6
                    353: #warning indirect threading scheme 6: long latency
1.4       jwilke    354: #  define CFA_NEXT
1.1       anton     355: #  define NEXT_P0      ({cfa=*ip;})
                    356: #  define IP           (ip)
1.3       anton     357: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     358: #  define NEXT_INST    (cfa)
                    359: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    360: #  define DEF_CA       Label ca;
                    361: #  define NEXT_P1      ({ip++; ca=*cfa;})
                    362: #  define NEXT_P2      ({goto *ca;})
                    363: #  define EXEC(XT)     ({DEF_CA cfa=(XT); ca=*cfa; goto *ca;})
                    364: #endif
                    365: 
1.3       anton     366: #if THREADING_SCHEME==7
                    367: #warning indirect threading scheme 7: low latency
1.4       jwilke    368: #  define CFA_NEXT
1.3       anton     369: #  define NEXT_P0      ({cfa=*ip;})
                    370: #  define IP           (ip)
                    371: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
                    372: #  define NEXT_INST    (cfa)
                    373: #  define INC_IP(const_inc)    ({cfa=IP[const_inc]; ip+=(const_inc);})
                    374: #  define DEF_CA       Label ca;
                    375: #  define NEXT_P1      ({ip++; ca=*cfa;})
                    376: #  define NEXT_P2      ({goto *ca;})
                    377: #  define EXEC(XT)     ({DEF_CA cfa=(XT); ca=*cfa; goto *ca;})
                    378: #endif
1.1       anton     379: 
1.3       anton     380: #if THREADING_SCHEME==8
                    381: #warning indirect threading scheme 8: low latency,cisc
1.4       jwilke    382: #  define CFA_NEXT
1.1       anton     383: #  define NEXT_P0
                    384: #  define IP           (ip)
1.3       anton     385: #  define SET_IP(p)    ({ip=(p); NEXT_P0;})
1.1       anton     386: #  define NEXT_INST    (*ip)
                    387: #  define INC_IP(const_inc)    ({ip+=(const_inc);})
                    388: #  define DEF_CA
                    389: #  define NEXT_P1
                    390: #  define NEXT_P2      ({cfa=*ip++; goto **cfa;})
                    391: #  define EXEC(XT)     ({cfa=(XT); goto **cfa;})
                    392: #endif
                    393: 
1.3       anton     394: /* indirect threaded */
1.1       anton     395: #endif
                    396: 
                    397: #endif /* !defined(DOUBLY_INDIRECT) */
                    398: 
                    399: #define NEXT ({DEF_CA NEXT_P1; NEXT_P2;})
1.10      anton     400: #define IPTOS NEXT_INST