better caching in #perform:withArguments:
authorClaus Gittinger <cg@exept.de>
Thu, 03 Aug 2000 13:15:05 +0200
changeset 5495 d42dbc9ac39d
parent 5494 35f624eaf060
child 5496 338c81a04468
better caching in #perform:withArguments:
Object.st
--- a/Object.st	Thu Aug 03 01:10:29 2000 +0200
+++ b/Object.st	Thu Aug 03 13:15:05 2000 +0200
@@ -4561,61 +4561,58 @@
 
 %{
     REGISTER OBJ sel = aSelector;
-    struct inlineCache *pIlc;
-    static struct inlineCache ilc_0 = __ILCPERF0(@line+14);
-    static struct inlineCache ilc_1 = __ILCPERF0(@line+17-1);
-    static struct inlineCache ilc_2 = __ILCPERF0(@line+20-2);
-    static struct inlineCache ilc_3 = __ILCPERF0(@line+23-3);
-    static struct inlineCache ilc_4 = __ILCPERF0(@line+26-4);
-    static OBJ last_0 = nil;
-    static OBJ last_1 = nil;
-    static OBJ last_2 = nil;
-    static OBJ last_3 = nil;
-    static OBJ last_4 = nil;
-    static flip = 0;
 
     if (InterruptPending == nil) {
+        struct inlineCache *pIlc;
+        static struct inlineCache ilc_0 = __ILCPERF0(@line);
+        static struct inlineCache ilc_1 = __ILCPERF0(@line);
+        static struct inlineCache ilc_2 = __ILCPERF0(@line);
+        static struct inlineCache ilc_3 = __ILCPERF0(@line);
+        static struct inlineCache ilc_4 = __ILCPERF0(@line);
+        static OBJ last_0 = nil;
+        static OBJ last_1 = nil;
+        static OBJ last_2 = nil;
+        static OBJ last_3 = nil;
+        static OBJ last_4 = nil;
+        static flip = 0;
+
         if (sel == last_0) {
-            RETURN ( (*(ilc_0.ilc_func))(self, sel, nil, &ilc_0) );
-        }
-        if (sel == last_1) {
-            RETURN ( (*(ilc_1.ilc_func))(self, sel, nil, &ilc_1) );
-        }
-        if (sel == last_2) {
-            RETURN ( (*(ilc_2.ilc_func))(self, sel, nil, &ilc_2) );
-        }
-        if (sel == last_3) {
-            RETURN ( (*(ilc_3.ilc_func))(self, sel, nil, &ilc_3) );
-        }
-        if (sel == last_4) {
-            RETURN ( (*(ilc_4.ilc_func))(self, sel, nil, &ilc_4) );
-        }
-        
-        if (flip == 0) {
             pIlc = &ilc_0;
-            flip = 1;
-            last_0 = sel;
-        } else if (flip == 1) {
+        } else if (sel == last_1) {
             pIlc = &ilc_1;
-            flip = 2;
-            last_1 = sel;
-        } else if (flip == 2) {
+        } else if (sel == last_2) {
             pIlc = &ilc_2;
-            flip = 3;
-            last_2 = sel;
-        } else if (flip == 3) {
+        } else if (sel == last_3) {
             pIlc = &ilc_3;
-            flip = 4;
-            last_3 = sel;
-        } else {
+        } else if (sel == last_4) {
             pIlc = &ilc_4;
-            flip = 0;
-            last_4 = sel;
-        }
-        pIlc->ilc_func = __SEND0ADDR__;
-        if (pIlc->ilc_poly) {
-            __flushPolyCache(pIlc->ilc_poly);
-            pIlc->ilc_poly = 0;
+        } else {
+            if (flip == 0) {
+                pIlc = &ilc_0;
+                flip = 1;
+                last_0 = sel;
+            } else if (flip == 1) {
+                pIlc = &ilc_1;
+                flip = 2;
+                last_1 = sel;
+            } else if (flip == 2) {
+                pIlc = &ilc_2;
+                flip = 3;
+                last_2 = sel;
+            } else if (flip == 3) {
+                pIlc = &ilc_3;
+                flip = 4;
+                last_3 = sel;
+            } else {
+                pIlc = &ilc_4;
+                flip = 0;
+                last_4 = sel;
+            }
+            pIlc->ilc_func = __SEND0ADDR__;
+            if (pIlc->ilc_poly) {
+                __flushPolyCache(pIlc->ilc_poly);
+                pIlc->ilc_poly = 0;
+            }
         }
         RETURN ( (*(pIlc->ilc_func))(self, sel, nil, pIlc) );
     } else {
@@ -4799,12 +4796,22 @@
         case 16:
             {
                 static struct inlineCache ilc16 = __DUMMYILCSELF16(@line+1);
-                RETURN ( _SEND15(self, aSelector, aClass, &ilc15,
+                RETURN ( _SEND16(self, aSelector, aClass, &ilc15,
                                  argP[0], argP[1], argP[2], argP[3], argP[4], argP[5],
                                  argP[6], argP[7], argP[8], argP[9], argP[10],
                                  argP[11], argP[12], argP[13], argP[14], argP[15]));
             }
 #endif
+#ifdef _SEND17
+        case 17:
+            {
+                static struct inlineCache ilc17 = __DUMMYILCSELF17(@line+1);
+                RETURN ( _SEND17(self, aSelector, aClass, &ilc15,
+                                 argP[0], argP[1], argP[2], argP[3], argP[4], argP[5],
+                                 argP[6], argP[7], argP[8], argP[9], argP[10],
+                                 argP[11], argP[12], argP[13], argP[14], argP[15], argP[16]));
+            }
+#endif
 
 
     }
@@ -4821,61 +4828,58 @@
 
 %{
     REGISTER OBJ sel = aSelector;
-    struct inlineCache *pIlc;
-    static struct inlineCache ilc_0 = __ILCPERF1(@line+14);
-    static struct inlineCache ilc_1 = __ILCPERF1(@line+14+3-1);
-    static struct inlineCache ilc_2 = __ILCPERF1(@line+14+6-2);
-    static struct inlineCache ilc_3 = __ILCPERF1(@line+14+9-3);
-    static struct inlineCache ilc_4 = __ILCPERF1(@line+14+12-4);
-    static OBJ last_0 = nil;
-    static OBJ last_1 = nil;
-    static OBJ last_2 = nil;
-    static OBJ last_3 = nil;
-    static OBJ last_4 = nil;
-    static flip = 0;
 
     if (InterruptPending == nil) {
+        struct inlineCache *pIlc;
+        static struct inlineCache ilc_0 = __ILCPERF1(@line);
+        static struct inlineCache ilc_1 = __ILCPERF1(@line);
+        static struct inlineCache ilc_2 = __ILCPERF1(@line);
+        static struct inlineCache ilc_3 = __ILCPERF1(@line);
+        static struct inlineCache ilc_4 = __ILCPERF1(@line);
+        static OBJ last_0 = nil;
+        static OBJ last_1 = nil;
+        static OBJ last_2 = nil;
+        static OBJ last_3 = nil;
+        static OBJ last_4 = nil;
+        static flip = 0;
+
         if (sel == last_0) {
-            RETURN ( (*(ilc_0.ilc_func))(self, sel, nil, &ilc_0, arg) );
-        }
-        if (sel == last_1) {
-            RETURN ( (*(ilc_1.ilc_func))(self, sel, nil, &ilc_1, arg) );
-        }
-        if (sel == last_2) {
-            RETURN ( (*(ilc_2.ilc_func))(self, sel, nil, &ilc_2, arg) );
-        }
-        if (sel == last_3) {
-            RETURN ( (*(ilc_3.ilc_func))(self, sel, nil, &ilc_3, arg) );
-        }
-        if (sel == last_4) {
-            RETURN ( (*(ilc_4.ilc_func))(self, sel, nil, &ilc_4, arg) );
-        }
-
-        if (flip == 0) {
             pIlc = &ilc_0;
-            flip = 1;
-            last_0 = sel;
-        } else if (flip == 1) {
+        } else if (sel == last_1) {
             pIlc = &ilc_1;
-            flip = 2;
-            last_1 = sel;
-        } else if (flip == 2) {
+        } else if (sel == last_2) {
             pIlc = &ilc_2;
-            flip = 3;
-            last_2 = sel;
-        } else if (flip == 3) {
+        } else if (sel == last_3) {
             pIlc = &ilc_3;
-            flip = 4;
-            last_3 = sel;
-        } else {
+        } else if (sel == last_4) {
             pIlc = &ilc_4;
-            flip = 0;
-            last_4 = sel;
-        }
-        pIlc->ilc_func = __SEND1ADDR__;
-        if (pIlc->ilc_poly) {
-            __flushPolyCache(pIlc->ilc_poly);
-            pIlc->ilc_poly = 0;
+        } else {
+            if (flip == 0) {
+                pIlc = &ilc_0;
+                flip = 1;
+                last_0 = sel;
+            } else if (flip == 1) {
+                pIlc = &ilc_1;
+                flip = 2;
+                last_1 = sel;
+            } else if (flip == 2) {
+                pIlc = &ilc_2;
+                flip = 3;
+                last_2 = sel;
+            } else if (flip == 3) {
+                pIlc = &ilc_3;
+                flip = 4;
+                last_3 = sel;
+            } else {
+                pIlc = &ilc_4;
+                flip = 0;
+                last_4 = sel;
+            }
+            pIlc->ilc_func = __SEND1ADDR__;
+            if (pIlc->ilc_poly) {
+                __flushPolyCache(pIlc->ilc_poly);
+                pIlc->ilc_poly = 0;
+            }
         }
         RETURN ( (*(pIlc->ilc_func))(self, sel, nil, pIlc, arg) );
     } else {
@@ -4892,34 +4896,33 @@
 
 %{
     struct inlineCache *pIlc;
-    static struct inlineCache ilc_0 = __ILCPERF2(@line+29);
-    static struct inlineCache ilc_1 = __ILCPERF2(@line+28);
-    static OBJ last_0 = nil;
-    static OBJ last_1 = nil;
-    static flip = 0;
 
     if (InterruptPending == nil) {
-        if (aSelector != last_0) {
-            if (aSelector != last_1) {
-                if (flip) {
-                    pIlc = &ilc_0;
-                    flip = 0;
-                    last_0 = aSelector;
-                } else {
-                    pIlc = &ilc_1;
-                    flip = 1;
-                    last_1 = aSelector;
-                }
-                pIlc->ilc_func = __SEND2ADDR__;
-                if (pIlc->ilc_poly) {
-                    __flushPolyCache(pIlc->ilc_poly);
-                    pIlc->ilc_poly = 0;
-                }
+        static struct inlineCache ilc_0 = __ILCPERF2(@line);
+        static struct inlineCache ilc_1 = __ILCPERF2(@line);
+        static OBJ last_0 = nil;
+        static OBJ last_1 = nil;
+        static flip = 0;
+
+        if (aSelector == last_0) {
+            pIlc = &ilc_0;
+        } else if (aSelector == last_1) {
+            pIlc = &ilc_1;
+        } else {
+            if (flip == 0) {
+                pIlc = &ilc_0;
+                flip = 1;
+                last_0 = aSelector;
             } else {
                 pIlc = &ilc_1;
+                flip = 0;
+                last_1 = aSelector;
             }
-        } else {
-            pIlc = &ilc_0;
+            pIlc->ilc_func = __SEND2ADDR__;
+            if (pIlc->ilc_poly) {
+                __flushPolyCache(pIlc->ilc_poly);
+                pIlc->ilc_poly = 0;
+            }
         }
         RETURN ( (*(pIlc->ilc_func))(self, aSelector, nil, pIlc, arg1, arg2) );
     } else {
@@ -4936,8 +4939,8 @@
 
 %{
     struct inlineCache *pIlc;
-    static struct inlineCache ilc_0 = __ILCPERF3(@line+29);
-    static struct inlineCache ilc_1 = __ILCPERF3(@line+28);
+    static struct inlineCache ilc_0 = __ILCPERF3(@line);
+    static struct inlineCache ilc_1 = __ILCPERF3(@line);
     static OBJ last_0 = nil;
     static OBJ last_1 = nil;
     static flip = 0;
@@ -4965,8 +4968,7 @@
         } else {
             pIlc = &ilc_0;
         }
-        RETURN ( (*(pIlc->ilc_func))(self, aSelector, nil, pIlc, 
-                                     arg1, arg2, arg3) );
+        RETURN ( (*(pIlc->ilc_func))(self, aSelector, nil, pIlc, arg1, arg2, arg3) );
     } else {
         static struct inlineCache ilc3 = __DUMMYILCSELF3(@line+1);
         RETURN (_SEND3(self, aSelector, nil, &ilc3, arg1, arg2, arg3));
@@ -4981,8 +4983,8 @@
 
 %{
     struct inlineCache *pIlc;
-    static struct inlineCache ilc_0 = __ILCPERF4(@line+29);
-    static struct inlineCache ilc_1 = __ILCPERF4(@line+28);
+    static struct inlineCache ilc_0 = __ILCPERF4(@line);
+    static struct inlineCache ilc_1 = __ILCPERF4(@line);
     static OBJ last_0 = nil;
     static OBJ last_1 = nil;
     static flip = 0;
@@ -5027,8 +5029,8 @@
 
 %{
     struct inlineCache *pIlc;
-    static struct inlineCache ilc_0 = __ILCPERF5(@line+29);
-    static struct inlineCache ilc_1 = __ILCPERF5(@line+28);
+    static struct inlineCache ilc_0 = __ILCPERF5(@line);
+    static struct inlineCache ilc_1 = __ILCPERF5(@line);
     static OBJ last_0 = nil;
     static OBJ last_1 = nil;
     static flip = 0;
@@ -5074,8 +5076,8 @@
 
 %{
     struct inlineCache *pIlc;
-    static struct inlineCache ilc_0 = __ILCPERF6(@line+29);
-    static struct inlineCache ilc_1 = __ILCPERF6(@line+28);
+    static struct inlineCache ilc_0 = __ILCPERF6(@line);
+    static struct inlineCache ilc_1 = __ILCPERF6(@line);
     static OBJ last_0 = nil;
     static OBJ last_1 = nil;
     static flip = 0;
@@ -5125,40 +5127,17 @@
 
 %{
     REGISTER OBJ *argP;
-    int nargs, i;
-    static struct inlineCache ilcSize = __ILC0(@line);
-    static OBJ last0 = nil; static struct inlineCache ilc0 = __ILCPERF0(@line);
-    static OBJ last1 = nil; static struct inlineCache ilc1 = __ILCPERF1(@line);
-    static OBJ last2 = nil; static struct inlineCache ilc2 = __ILCPERF2(@line);
-    static OBJ last3 = nil; static struct inlineCache ilc3 = __ILCPERF3(@line);
-    static OBJ last4 = nil; static struct inlineCache ilc4 = __ILCPERF4(@line);
-    static OBJ last5 = nil; static struct inlineCache ilc5 = __ILCPERF5(@line);
-    static OBJ last6 = nil; static struct inlineCache ilc6 = __ILCPERF6(@line);
-    static OBJ last7 = nil; static struct inlineCache ilc7 = __ILCPERF7(@line);
-    static OBJ last8 = nil; static struct inlineCache ilc8 = __ILCPERF8(@line);
-    static OBJ last9 = nil; static struct inlineCache ilc9 = __ILCPERF9(@line);
-    static OBJ last10 = nil; static struct inlineCache ilc10 = __ILCPERF10(@line);
-    static OBJ last11 = nil; static struct inlineCache ilc11 = __ILCPERF11(@line);
-    static OBJ last12 = nil; static struct inlineCache ilc12 = __ILCPERF12(@line);
-    static OBJ last13 = nil; static struct inlineCache ilc13 = __ILCPERF13(@line);
-    static OBJ last14 = nil; static struct inlineCache ilc14 = __ILCPERF14(@line);
-    static OBJ last15 = nil; static struct inlineCache ilc15 = __ILCPERF15(@line);
+    int nargs;
     OBJ l;
 
-#if defined(xxxTHIS_CONTEXT) /* not because this has a context */
-    /*
-     * must set lineno in sender by hand here ... (because of NOCONTEXT)
-     */
-    if ((l = __ILC_LNO_AS_OBJ(__pilc)) != __MKSMALLINT(0)) {
-        _ContextInstPtr(__thisContext)->c_lineno = l;
-    }
-#endif
-
     if (__isArray(argArray)) {
         nargs = __arraySize(argArray);
         argP = __ArrayInstPtr(argArray)->a_element;
     } else {
         if (__isNonNilObject(argArray)) {
+            static struct inlineCache ilcSize = __ILC0(@line);
+            int i;
+
             numberOfArgs = (*ilcSize.ilc_func)(argArray, @symbol(size), nil, &ilcSize); 
             if (!__isSmallInteger(numberOfArgs)) 
                 goto bad;
@@ -5174,261 +5153,380 @@
     }
     switch (nargs) {
         case 0:
-            if ((InterruptPending != nil) || (aSelector != last0)) {
-                ilc0.ilc_func = __SEND0ADDR__;
-                if (ilc0.ilc_poly) {
-                    __flushPolyCache(ilc0.ilc_poly);
-                    ilc0.ilc_poly = 0;
+            if (InterruptPending == nil) {
+                static OBJ last0_0 = nil; static struct inlineCache ilc0_0 = __ILCPERF0(@line);
+                static OBJ last0_1 = nil; static struct inlineCache ilc0_1 = __ILCPERF0(@line);
+                static OBJ last0_2 = nil; static struct inlineCache ilc0_2 = __ILCPERF0(@line);
+                static OBJ last0_3 = nil; static struct inlineCache ilc0_3 = __ILCPERF0(@line);
+                static int flip0 = 0;
+                struct inlineCache *pIlc;
+
+                if (aSelector == last0_0) {
+                    pIlc = &ilc0_0;
+                } else if (aSelector == last0_1) {
+                    pIlc = &ilc0_1;
+                } else if (aSelector == last0_2) {
+                    pIlc = &ilc0_2;
+                } else if (aSelector == last0_3) {
+                    pIlc = &ilc0_3;
+                } else {
+                    if (flip0 == 0) {
+                        pIlc = &ilc0_0;
+                        flip0 = 1;
+                        last0_0 = aSelector;
+                    } else if (flip0 == 1) {
+                        pIlc = &ilc0_1;
+                        flip0 = 2;
+                        last0_1 = aSelector;
+                    } else if (flip0 == 2) {
+                        pIlc = &ilc0_2;
+                        flip0 = 3;
+                        last0_2 = aSelector;
+                    } else {
+                        pIlc = &ilc0_3;
+                        flip0 = 0;
+                        last0_3 = aSelector;
+                    }
+
+                    pIlc->ilc_func = __SEND0ADDR__;
+                    if (pIlc->ilc_poly) {
+                        __flushPolyCache(pIlc->ilc_poly);
+                        pIlc->ilc_poly = 0;
+                    }
                 }
-                last0 = aSelector;
+                RETURN ((*pIlc->ilc_func)(self, aSelector, nil, pIlc));
+            } else {
+                static struct inlineCache ilc0 = __DUMMYILCSELF0(@line+1);
+                RETURN (_SEND0(self, aSelector, nil, &ilc0));
             }
-#ifdef xxTHIS_CONTEXT  /* not because this has a context */
-            ilc0.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ((*ilc0.ilc_func)(self, aSelector, nil, &ilc0));
 
         case 1: 
-            if ((InterruptPending != nil) || (aSelector != last1)) {
-                ilc1.ilc_func = __SEND1ADDR__;
-                if (ilc1.ilc_poly) {
-                    __flushPolyCache(ilc1.ilc_poly);
-                    ilc1.ilc_poly = 0;
+            if (InterruptPending == nil) {
+                static OBJ last1_0 = nil; static struct inlineCache ilc1_0 = __ILCPERF1(@line);
+                static OBJ last1_1 = nil; static struct inlineCache ilc1_1 = __ILCPERF1(@line);
+                static OBJ last1_2 = nil; static struct inlineCache ilc1_2 = __ILCPERF1(@line);
+                static OBJ last1_3 = nil; static struct inlineCache ilc1_3 = __ILCPERF1(@line);
+                static int flip1 = 0;
+                struct inlineCache *pIlc;
+
+                if (aSelector == last1_0) {
+                    pIlc = &ilc1_0;
+                } else if (aSelector == last1_1) {
+                    pIlc = &ilc1_1;
+                } else if (aSelector == last1_2) {
+                    pIlc = &ilc1_2;
+                } else if (aSelector == last1_3) {
+                    pIlc = &ilc1_3;
+                } else {
+                    if (flip1 == 0) {
+                        pIlc = &ilc1_0;
+                        flip1 = 1;
+                        last1_0 = aSelector;
+                    } else if (flip1 == 1) {
+                        pIlc = &ilc1_1;
+                        flip1 = 2;
+                        last1_1 = aSelector;
+                    } else if (flip1 == 2) {
+                        pIlc = &ilc1_2;
+                        flip1 = 3;
+                        last1_2 = aSelector;
+                    } else {
+                        pIlc = &ilc1_3;
+                        flip1 = 0;
+                        last1_3 = aSelector;
+                    }
+
+                    pIlc->ilc_func = __SEND1ADDR__;
+                    if (pIlc->ilc_poly) {
+                        __flushPolyCache(pIlc->ilc_poly);
+                        pIlc->ilc_poly = 0;
+                    }
                 }
-                last1 = aSelector;
+                RETURN ((*pIlc->ilc_func)(self, aSelector, nil, pIlc, argP[0]));
+            } else {
+                static struct inlineCache ilc1 = __DUMMYILCSELF1(@line+1);
+                RETURN (_SEND1(self, aSelector, nil, &ilc1, argP[0]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc1.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc1.ilc_func)(self, aSelector, nil, &ilc1, argP[0]));
 
         case 2: 
-            if ((InterruptPending != nil) || (aSelector != last2)) {
-                ilc2.ilc_func = __SEND2ADDR__;
-                if (ilc2.ilc_poly) {
-                    __flushPolyCache(ilc2.ilc_poly);
-                    ilc2.ilc_poly = 0;
+            if (InterruptPending == nil) {
+                static OBJ last2_0 = nil; static struct inlineCache ilc2_0 = __ILCPERF2(@line);
+                static OBJ last2_1 = nil; static struct inlineCache ilc2_1 = __ILCPERF2(@line);
+                static int flip2 = 0;
+                struct inlineCache *pIlc;
+
+                if (aSelector == last2_0) {
+                    pIlc = &ilc2_0;
+                } else if (aSelector == last2_1) {
+                    pIlc = &ilc2_1;
+                } else {
+                    if (flip2 == 0) {
+                        pIlc = &ilc2_0;
+                        flip2 = 1;
+                        last2_0 = aSelector;
+                    } else {
+                        pIlc = &ilc2_1;
+                        flip2 = 0;
+                        last2_1 = aSelector;
+                    }
+
+                    pIlc->ilc_func = __SEND2ADDR__;
+                    if (pIlc->ilc_poly) {
+                        __flushPolyCache(pIlc->ilc_poly);
+                        pIlc->ilc_poly = 0;
+                    }
                 }
-                last2 = aSelector;
+                RETURN ((*pIlc->ilc_func)(self, aSelector, nil, pIlc, argP[0], argP[1]));
+            } else {
+                static struct inlineCache ilc2 = __DUMMYILCSELF2(@line+1);
+                RETURN (_SEND2(self, aSelector, nil, &ilc2, argP[0], argP[1]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc2.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc2.ilc_func)(self, aSelector, nil, &ilc2, 
-                                            argP[0], argP[1]));
 
         case 3: 
-            if ((InterruptPending != nil) || (aSelector != last3)) {
-                ilc3.ilc_func = __SEND3ADDR__;
-                if (ilc3.ilc_poly) {
-                    __flushPolyCache(ilc3.ilc_poly);
-                    ilc3.ilc_poly = 0;
+            if (InterruptPending == nil) {
+                static OBJ last3_0 = nil; static struct inlineCache ilc3_0 = __ILCPERF3(@line);
+                static OBJ last3_1 = nil; static struct inlineCache ilc3_1 = __ILCPERF3(@line);
+                static int flip3 = 0;
+                struct inlineCache *pIlc;
+
+                if (aSelector == last3_0) {
+                    pIlc = &ilc3_0;
+                } else if (aSelector == last3_1) {
+                    pIlc = &ilc3_1;
+                } else {
+                    if (flip3 == 0) {
+                        pIlc = &ilc3_0;
+                        flip3 = 1;
+                        last3_0 = aSelector;
+                    } else {
+                        pIlc = &ilc3_1;
+                        flip3 = 0;
+                        last3_1 = aSelector;
+                    }
+
+                    pIlc->ilc_func = __SEND3ADDR__;
+                    if (pIlc->ilc_poly) {
+                        __flushPolyCache(pIlc->ilc_poly);
+                        pIlc->ilc_poly = 0;
+                    }
                 }
-                last3 = aSelector;
+                RETURN ((*pIlc->ilc_func)(self, aSelector, nil, pIlc, argP[0], argP[1], argP[2]));
+            } else {
+                static struct inlineCache ilc3 = __DUMMYILCSELF3(@line+1);
+                RETURN (_SEND3(self, aSelector, nil, &ilc3, argP[0], argP[1], argP[2]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc3.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc3.ilc_func)(self, aSelector, nil, &ilc3, 
-                                            argP[0], argP[1], argP[2]));
 
         case 4: 
-            if ((InterruptPending != nil) || (aSelector != last4)) {
-                ilc4.ilc_func = __SEND4ADDR__;
-                if (ilc4.ilc_poly) {
-                    __flushPolyCache(ilc4.ilc_poly);
-                    ilc4.ilc_poly = 0;
+            {
+                static OBJ last4 = nil; static struct inlineCache ilc4 = __ILCPERF4(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last4)) {
+                    ilc4.ilc_func = __SEND4ADDR__;
+                    if (ilc4.ilc_poly) {
+                        __flushPolyCache(ilc4.ilc_poly);
+                        ilc4.ilc_poly = 0;
+                    }
+                    last4 = aSelector;
                 }
-                last4 = aSelector;
+                RETURN ( (*ilc4.ilc_func)(self, aSelector, nil, &ilc4,
+                                                argP[0], argP[1], argP[2], argP[3]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc4.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc4.ilc_func)(self, aSelector, nil, &ilc4,
-                                            argP[0], argP[1], argP[2], argP[3]));
 
         case 5: 
-            if ((InterruptPending != nil) || (aSelector != last5)) {
-                ilc5.ilc_func = __SEND5ADDR__;
-                if (ilc5.ilc_poly) {
-                    __flushPolyCache(ilc5.ilc_poly);
-                    ilc5.ilc_poly = 0;
+            {
+                static OBJ last5 = nil; static struct inlineCache ilc5 = __ILCPERF5(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last5)) {
+                    ilc5.ilc_func = __SEND5ADDR__;
+                    if (ilc5.ilc_poly) {
+                        __flushPolyCache(ilc5.ilc_poly);
+                        ilc5.ilc_poly = 0;
+                    }
+                    last5 = aSelector;
                 }
-                last5 = aSelector;
+                RETURN ( (*ilc5.ilc_func)(self, aSelector, nil, &ilc5, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc5.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc5.ilc_func)(self, aSelector, nil, &ilc5, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4]));
 
         case 6: 
-            if ((InterruptPending != nil) || (aSelector != last6)) {
-                ilc6.ilc_func = __SEND6ADDR__;
-                if (ilc6.ilc_poly) {
-                    __flushPolyCache(ilc6.ilc_poly);
-                    ilc6.ilc_poly = 0;
+            {
+                static OBJ last6 = nil; static struct inlineCache ilc6 = __ILCPERF6(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last6)) {
+                    ilc6.ilc_func = __SEND6ADDR__;
+                    if (ilc6.ilc_poly) {
+                        __flushPolyCache(ilc6.ilc_poly);
+                        ilc6.ilc_poly = 0;
+                    }
+                    last6 = aSelector;
                 }
-                last6 = aSelector;
+                RETURN ( (*ilc6.ilc_func)(self, aSelector, nil, &ilc6, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc6.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc6.ilc_func)(self, aSelector, nil, &ilc6, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5]));
 
         case 7: 
-            if ((InterruptPending != nil) || (aSelector != last7)) {
-                ilc7.ilc_func = __SEND7ADDR__;
-                if (ilc7.ilc_poly) {
-                    __flushPolyCache(ilc7.ilc_poly);
-                    ilc7.ilc_poly = 0;
+            {
+                static OBJ last7 = nil; static struct inlineCache ilc7 = __ILCPERF7(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last7)) {
+                    ilc7.ilc_func = __SEND7ADDR__;
+                    if (ilc7.ilc_poly) {
+                        __flushPolyCache(ilc7.ilc_poly);
+                        ilc7.ilc_poly = 0;
+                    }
+                    last7 = aSelector;
                 }
-                last7 = aSelector;
+                RETURN ( (*ilc7.ilc_func)(self, aSelector, nil, &ilc7, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc7.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc7.ilc_func)(self, aSelector, nil, &ilc7, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6]));
 
         case 8:
-            if ((InterruptPending != nil) || (aSelector != last8)) {
-                ilc8.ilc_func = __SEND8ADDR__;
-                if (ilc8.ilc_poly) {
-                    __flushPolyCache(ilc8.ilc_poly);
-                    ilc8.ilc_poly = 0;
+            {
+                static OBJ last8 = nil; static struct inlineCache ilc8 = __ILCPERF8(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last8)) {
+                    ilc8.ilc_func = __SEND8ADDR__;
+                    if (ilc8.ilc_poly) {
+                        __flushPolyCache(ilc8.ilc_poly);
+                        ilc8.ilc_poly = 0;
+                    }
+                    last8 = aSelector;
                 }
-                last8 = aSelector;
+                RETURN ( (*ilc8.ilc_func)(self, aSelector, nil, &ilc8, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6], argP[7]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc8.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc8.ilc_func)(self, aSelector, nil, &ilc8, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6], argP[7]));
 
         case 9: 
-            if ((InterruptPending != nil) || (aSelector != last9)) {
-                ilc9.ilc_func = __SEND9ADDR__;
-                if (ilc9.ilc_poly) {
-                    __flushPolyCache(ilc9.ilc_poly);
-                    ilc9.ilc_poly = 0;
+            {
+                static OBJ last9 = nil; static struct inlineCache ilc9 = __ILCPERF9(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last9)) {
+                    ilc9.ilc_func = __SEND9ADDR__;
+                    if (ilc9.ilc_poly) {
+                        __flushPolyCache(ilc9.ilc_poly);
+                        ilc9.ilc_poly = 0;
+                    }
+                    last9 = aSelector;
                 }
-                last9 = aSelector;
+                RETURN ( (*ilc9.ilc_func)(self, aSelector, nil, &ilc9, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6], argP[7], argP[8]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc9.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc9.ilc_func)(self, aSelector, nil, &ilc9, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6], argP[7], argP[8]));
 
         case 10: 
-            if ((InterruptPending != nil) || (aSelector != last10)) {
-                ilc10.ilc_func = __SEND10ADDR__;
-                if (ilc10.ilc_poly) {
-                    __flushPolyCache(ilc10.ilc_poly);
-                    ilc10.ilc_poly = 0;
+            {
+                static OBJ last10 = nil; static struct inlineCache ilc10 = __ILCPERF10(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last10)) {
+                    ilc10.ilc_func = __SEND10ADDR__;
+                    if (ilc10.ilc_poly) {
+                        __flushPolyCache(ilc10.ilc_poly);
+                        ilc10.ilc_poly = 0;
+                    }
+                    last10 = aSelector;
                 }
-                last10 = aSelector;
+                RETURN ( (*ilc10.ilc_func)(self, aSelector, nil, &ilc10, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6], argP[7], argP[8], argP[9]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc10.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc10.ilc_func)(self, aSelector, nil, &ilc10, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6], argP[7], argP[8], argP[9]));
 
         case 11: 
-            if ((InterruptPending != nil) || (aSelector != last11)) {
-                ilc11.ilc_func = __SEND11ADDR__;
-                if (ilc11.ilc_poly) {
-                    __flushPolyCache(ilc11.ilc_poly);
-                    ilc11.ilc_poly = 0;
+            {
+                static OBJ last11 = nil; static struct inlineCache ilc11 = __ILCPERF11(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last11)) {
+                    ilc11.ilc_func = __SEND11ADDR__;
+                    if (ilc11.ilc_poly) {
+                        __flushPolyCache(ilc11.ilc_poly);
+                        ilc11.ilc_poly = 0;
+                    }
+                    last11 = aSelector;
                 }
-                last11 = aSelector;
+                RETURN ( (*ilc11.ilc_func)(self, aSelector, nil, &ilc11, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6], argP[7], argP[8], argP[9],
+                                                argP[10]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc11.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc11.ilc_func)(self, aSelector, nil, &ilc11, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6], argP[7], argP[8], argP[9],
-                                            argP[10]));
 
         case 12: 
-            if ((InterruptPending != nil) || (aSelector != last12)) {
-                ilc12.ilc_func = __SEND12ADDR__;
-                if (ilc12.ilc_poly) {
-                    __flushPolyCache(ilc12.ilc_poly);
-                    ilc12.ilc_poly = 0;
+            {
+                static OBJ last12 = nil; static struct inlineCache ilc12 = __ILCPERF12(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last12)) {
+                    ilc12.ilc_func = __SEND12ADDR__;
+                    if (ilc12.ilc_poly) {
+                        __flushPolyCache(ilc12.ilc_poly);
+                        ilc12.ilc_poly = 0;
+                    }
+                    last12 = aSelector;
                 }
-                last12 = aSelector;
+                RETURN ( (*ilc12.ilc_func)(self, aSelector, nil, &ilc12, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6], argP[7], argP[8], argP[9],
+                                                argP[10], argP[11]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc12.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc12.ilc_func)(self, aSelector, nil, &ilc12, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6], argP[7], argP[8], argP[9],
-                                            argP[10], argP[11]));
 
         case 13: 
-            if ((InterruptPending != nil) || (aSelector != last13)) {
-                ilc13.ilc_func = __SEND13ADDR__;
-                if (ilc13.ilc_poly) {
-                    __flushPolyCache(ilc13.ilc_poly);
-                    ilc13.ilc_poly = 0;
+            {
+                static OBJ last13 = nil; static struct inlineCache ilc13 = __ILCPERF13(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last13)) {
+                    ilc13.ilc_func = __SEND13ADDR__;
+                    if (ilc13.ilc_poly) {
+                        __flushPolyCache(ilc13.ilc_poly);
+                        ilc13.ilc_poly = 0;
+                    }
+                    last13 = aSelector;
                 }
-                last13 = aSelector;
+                RETURN ( (*ilc13.ilc_func)(self, aSelector, nil, &ilc13, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6], argP[7], argP[8], argP[9],
+                                                argP[10], argP[11], argP[12]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc13.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc13.ilc_func)(self, aSelector, nil, &ilc13, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6], argP[7], argP[8], argP[9],
-                                            argP[10], argP[11], argP[12]));
 
         case 14: 
-            if ((InterruptPending != nil) || (aSelector != last14)) {
-                ilc14.ilc_func = __SEND14ADDR__;
-                if (ilc14.ilc_poly) {
-                    __flushPolyCache(ilc14.ilc_poly);
-                    ilc14.ilc_poly = 0;
+            {
+                static OBJ last14 = nil; static struct inlineCache ilc14 = __ILCPERF14(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last14)) {
+                    ilc14.ilc_func = __SEND14ADDR__;
+                    if (ilc14.ilc_poly) {
+                        __flushPolyCache(ilc14.ilc_poly);
+                        ilc14.ilc_poly = 0;
+                    }
+                    last14 = aSelector;
                 }
-                last14 = aSelector;
+                RETURN ( (*ilc14.ilc_func)(self, aSelector, nil, &ilc14, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6], argP[7], argP[8], argP[9],
+                                                argP[10], argP[11], argP[12], argP[13]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc14.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc14.ilc_func)(self, aSelector, nil, &ilc14, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6], argP[7], argP[8], argP[9],
-                                            argP[10], argP[11], argP[12], argP[13]));
 
         case 15: 
-            if ((InterruptPending != nil) || (aSelector != last15)) {
-                ilc15.ilc_func = __SEND15ADDR__;
-                if (ilc15.ilc_poly) {
-                    __flushPolyCache(ilc15.ilc_poly);
-                    ilc15.ilc_poly = 0;
+            {
+                static OBJ last15 = nil; static struct inlineCache ilc15 = __ILCPERF15(@line);
+
+                if ((InterruptPending != nil) || (aSelector != last15)) {
+                    ilc15.ilc_func = __SEND15ADDR__;
+                    if (ilc15.ilc_poly) {
+                        __flushPolyCache(ilc15.ilc_poly);
+                        ilc15.ilc_poly = 0;
+                    }
+                    last15 = aSelector;
                 }
-                last15 = aSelector;
+                RETURN ( (*ilc15.ilc_func)(self, aSelector, nil, &ilc15, 
+                                                argP[0], argP[1], argP[2], argP[3], argP[4],
+                                                argP[5], argP[6], argP[7], argP[8], argP[9],
+                                                argP[10], argP[11], argP[12], argP[13],
+                                                argP[14]));
             }
-#ifdef xxTHIS_CONTEXT /* not because this has a context */
-            ilc15.ilc_lineNo = __pilc->ilc_lineNo;
-#endif
-            RETURN ( (*ilc15.ilc_func)(self, aSelector, nil, &ilc15, 
-                                            argP[0], argP[1], argP[2], argP[3], argP[4],
-                                            argP[5], argP[6], argP[7], argP[8], argP[9],
-                                            argP[10], argP[11], argP[12], argP[13],
-                                            argP[14]));
     }
 bad:;
 %}.
+
     "/ arrive here, if bad number of arguments (too many)
     "/ ST/X (currently) only allows up to 15 method arguments
 
@@ -8019,6 +8117,6 @@
 !Object class methodsFor:'documentation'!
 
 version
-    ^ '$Header: /cvs/stx/stx/libbasic/Object.st,v 1.335 2000-07-24 10:38:48 cg Exp $'
+    ^ '$Header: /cvs/stx/stx/libbasic/Object.st,v 1.336 2000-08-03 11:15:05 cg Exp $'
 ! !
 Object initialize!