New optimizer pass OptShift3.

Renamed CE_IsCall to CE_IsCallTo.

git-svn-id: svn://svn.cc65.org/cc65/trunk@1451 b7a2c559-68d2-44c3-8de9-860c34a00d81

diff --git a/src/cc65/codeent.h b/src/cc65/codeent.h
index a78d77e8107f949fad7250add5835feddceeccf4..60fc28bf85d0b7e706cf70f3e88dd65480bf3f07 100644 (file)
--- a/src/cc65/codeent.h
+++ b/src/cc65/codeent.h
@@ -187,13 +187,13 @@ int CE_KnownImm (const CodeEntry* E);
 /* Return true if the argument of E is a known immediate value */
 
 #if defined(HAVE_INLINE)
-INLINE int CE_IsCall (const CodeEntry* E, const char* Name)
+INLINE int CE_IsCallTo (const CodeEntry* E, const char* Name)
 /* Check if this is a call to the given function */
 {
     return (E->OPC == OP65_JSR && strcmp (E->Arg, Name) == 0);
 }
 #else
-#  define CE_IsCall(E, Name) ((E)->OPC == OP65_JSR && strcmp ((E)->Arg, (Name)) == 0)
+#  define CE_IsCallTo(E, Name) ((E)->OPC == OP65_JSR && strcmp ((E)->Arg, (Name)) == 0)
 #endif
 
 int CE_UseLoadFlags (const CodeEntry* E);

diff --git a/src/cc65/codeopt.c b/src/cc65/codeopt.c
index 4e5b4890a6ca552a7a979a5bfa43ff8dc0bf1941..50b014212faee11a04de5b4886931636e6e19808 100644 (file)
--- a/src/cc65/codeopt.c
+++ b/src/cc65/codeopt.c
@@ -63,6 +63,23 @@
 
 
 
+/*****************************************************************************/
+/*                                     Data                                  */
+/*****************************************************************************/
+
+
+
+/* Shift types */
+enum {
+    SHIFT_NONE,
+    SHIFT_ASR_1,
+    SHIFT_ASL_1,
+    SHIFT_LSR_1,
+    SHIFT_LSL_1
+};
+
+
+
 /*****************************************************************************/
 /*                             Optimize shifts                              */
 /*****************************************************************************/
@@ -164,6 +181,148 @@ static unsigned OptShift2 (CodeSeg* S)
 
 
 
+static unsigned GetShiftType (const char* Sub)
+/* Helper function for OptShift3 */
+{
+    if (*Sub == 'a') {
+        if (strcmp (Sub+1, "slax1") == 0) {
+            return SHIFT_ASL_1;
+        } else if (strcmp (Sub+1, "srax1") == 0) {
+            return SHIFT_ASR_1;
+        }
+    } else if (*Sub == 's') {
+        if (strcmp (Sub+1, "hlax1") == 0) {
+            return SHIFT_LSL_1;
+        } else if (strcmp (Sub+1, "hrax1") == 0) {
+            return SHIFT_LSR_1;
+        }
+    }
+    return SHIFT_NONE;
+}
+
+
+
+static unsigned OptShift3 (CodeSeg* S)
+/* Search for the sequence
+ *
+ *      lda     xxx
+ *      ldx     yyy
+ *      jsr     aslax1/asrax1/shlax1/shrax1
+ *      sta     aaa
+ *      stx     bbb
+ *
+ * and replace it by
+ *
+ *      lda     xxx
+ *      asl     a
+ *      sta     aaa
+ *      lda     yyy
+ *      rol     a
+ *      sta     bbb
+ *
+ * or similar, provided that a/x is not used later
+ */
+{
+    unsigned Changes = 0;
+
+    /* Walk over the entries */
+    unsigned I = 0;
+    while (I < CS_GetEntryCount (S)) {
+
+        unsigned ShiftType;
+       CodeEntry* L[5];
+
+       /* Get next entry */
+               L[0] = CS_GetEntry (S, I);
+
+       /* Check for the sequence */
+               if (L[0]->OPC == OP65_LDA                               &&
+            (L[0]->AM == AM65_ABS || L[0]->AM == AM65_ZP)       &&
+                   CS_GetEntries (S, L+1, I+1, 4)                      &&
+            !CS_RangeHasLabel (S, I+1, 4)                       &&
+            L[1]->OPC == OP65_LDX                               &&
+            (L[1]->AM == AM65_ABS || L[1]->AM == AM65_ZP)       &&
+            L[2]->OPC == OP65_JSR                               &&
+            (ShiftType = GetShiftType (L[2]->Arg)) != SHIFT_NONE&&
+                   L[3]->OPC == OP65_STA                               &&
+            (L[3]->AM == AM65_ABS || L[3]->AM == AM65_ZP)       &&
+            L[4]->OPC == OP65_STX                               &&
+            (L[4]->AM == AM65_ABS || L[4]->AM == AM65_ZP)       &&
+            !RegAXUsed (S, I+5)) {
+
+            CodeEntry* X;
+
+            /* Handle the four shift types differently */
+            switch (ShiftType) {
+
+                case SHIFT_ASR_1:
+                    X = NewCodeEntry (OP65_LDA, L[1]->AM, L[1]->Arg, 0, L[1]->LI);
+                    CS_InsertEntry (S, X, I+5);
+                    X = NewCodeEntry (OP65_CMP, AM65_IMM, "$80", 0, L[2]->LI);
+                    CS_InsertEntry (S, X, I+6);
+                    X = NewCodeEntry (OP65_ROR, AM65_ACC, "a", 0, L[2]->LI);
+                    CS_InsertEntry (S, X, I+7);
+                    X = NewCodeEntry (OP65_STA, L[4]->AM, L[4]->Arg, 0, L[4]->LI);
+                    CS_InsertEntry (S, X, I+8);
+                    X = NewCodeEntry (OP65_LDA, L[0]->AM, L[0]->Arg, 0, L[0]->LI);
+                    CS_InsertEntry (S, X, I+9);
+                    X = NewCodeEntry (OP65_ROR, AM65_ACC, "a", 0, L[2]->LI);
+                    CS_InsertEntry (S, X, I+10);
+                    X = NewCodeEntry (OP65_STA, L[3]->AM, L[3]->Arg, 0, L[3]->LI);
+                    CS_InsertEntry (S, X, I+11);
+                    CS_DelEntries (S, I, 5);
+                    break;
+
+                case SHIFT_LSR_1:
+                    X = NewCodeEntry (OP65_LDA, L[1]->AM, L[1]->Arg, 0, L[1]->LI);
+                    CS_InsertEntry (S, X, I+5);
+                    X = NewCodeEntry (OP65_LSR, AM65_ACC, "a", 0, L[2]->LI);
+                    CS_InsertEntry (S, X, I+6);
+                    X = NewCodeEntry (OP65_STA, L[4]->AM, L[4]->Arg, 0, L[4]->LI);
+                    CS_InsertEntry (S, X, I+7);
+                    X = NewCodeEntry (OP65_LDA, L[0]->AM, L[0]->Arg, 0, L[0]->LI);
+                    CS_InsertEntry (S, X, I+8);
+                    X = NewCodeEntry (OP65_ROR, AM65_ACC, "a", 0, L[2]->LI);
+                    CS_InsertEntry (S, X, I+9);
+                    X = NewCodeEntry (OP65_STA, L[3]->AM, L[3]->Arg, 0, L[3]->LI);
+                    CS_InsertEntry (S, X, I+10);
+                    CS_DelEntries (S, I, 5);
+                    break;
+
+                case SHIFT_LSL_1:
+                case SHIFT_ASL_1:
+                    /* These two are identical */
+                    X = NewCodeEntry (OP65_ASL, AM65_ACC, "a", 0, L[2]->LI);
+                    CS_InsertEntry (S, X, I+1);
+                    X = NewCodeEntry (OP65_STA, L[3]->AM, L[3]->Arg, 0, L[3]->LI);
+                    CS_InsertEntry (S, X, I+2);
+                    X = NewCodeEntry (OP65_LDA, L[1]->AM, L[1]->Arg, 0, L[1]->LI);
+                    CS_InsertEntry (S, X, I+3);
+                    X = NewCodeEntry (OP65_ROL, AM65_ACC, "a", 0, L[2]->LI);
+                    CS_InsertEntry (S, X, I+4);
+                    X = NewCodeEntry (OP65_STA, L[4]->AM, L[4]->Arg, 0, L[4]->LI);
+                    CS_InsertEntry (S, X, I+5);
+                    CS_DelEntries (S, I+6, 4);
+                    break;
+
+            }
+
+           /* Remember, we had changes */
+            ++Changes;
+
+       }
+
+       /* Next entry */
+       ++I;
+
+    }
+
+    /* Return the number of changes made */
+    return Changes;
+}
+
+
+
 /*****************************************************************************/
 /*                    Optimize stores through pointers                      */
 /*****************************************************************************/
@@ -243,19 +402,19 @@ static unsigned OptPtrStore1 (CodeSeg* S)
                L[0] = CS_GetEntry (S, I);
 
        /* Check for the sequence */
-               if (CE_IsCall (L[0], "pushax")              &&
+               if (CE_IsCallTo (L[0], "pushax")            &&
                    CS_GetEntries (S, L+1, I+1, 3)          &&
                    L[1]->OPC == OP65_LDY                   &&
            CE_KnownImm (L[1])                      &&
            !CE_HasLabel (L[1])                     &&
-                   CE_IsCall (L[2], "ldauidx")             &&
+                   CE_IsCallTo (L[2], "ldauidx")           &&
            !CE_HasLabel (L[2])                     &&
                    (K = OptPtrStore1Sub (S, I+3, L+3)) > 0 &&
            CS_GetEntries (S, L+3+K, I+3+K, 2)      &&
                    L[3+K]->OPC == OP65_LDY                 &&
            CE_KnownImm (L[3+K])                    &&
            !CE_HasLabel (L[3+K])                   &&
-           CE_IsCall (L[4+K], "staspidx")          &&
+           CE_IsCallTo (L[4+K], "staspidx")        &&
            !CE_HasLabel (L[4+K])) {
 
            CodeEntry* X;
@@ -331,13 +490,13 @@ static unsigned OptPtrStore2 (CodeSeg* S)
                L[0] = CS_GetEntry (S, I);
 
        /* Check for the sequence */
-               if (CE_IsCall (L[0], "pushax")          &&
+               if (CE_IsCallTo (L[0], "pushax")        &&
                    CS_GetEntries (S, L+1, I+1, 3)      &&
                    L[1]->OPC == OP65_LDA               &&
            !CE_HasLabel (L[1])                 &&
            L[2]->OPC == OP65_LDY               &&
            !CE_HasLabel (L[2])                 &&
-           CE_IsCall (L[3], "staspidx")        &&
+           CE_IsCallTo (L[3], "staspidx")      &&
            !CE_HasLabel (L[3])) {
 
            CodeEntry* X;
@@ -421,7 +580,7 @@ static unsigned OptPtrLoad1 (CodeSeg* S)
            !CE_HasLabel (L[2])                 &&
            L[3]->OPC == OP65_LDY               &&
            !CE_HasLabel (L[3])                 &&
-           CE_IsCall (L[4], "ldauidx")         &&
+           CE_IsCallTo (L[4], "ldauidx")       &&
            !CE_HasLabel (L[4])) {
 
            CodeEntry* X;
@@ -514,7 +673,7 @@ static unsigned OptPtrLoad2 (CodeSeg* S)
            !CE_HasLabel (L[6])                 &&
            L[7]->OPC == OP65_LDY               &&
            !CE_HasLabel (L[7])                 &&
-                   CE_IsCall (L[8], "ldauidx")         &&
+                   CE_IsCallTo (L[8], "ldauidx")       &&
            !CE_HasLabel (L[8])) {
 
            CodeEntry* X;
@@ -624,7 +783,7 @@ static unsigned OptPtrLoad3 (CodeSeg* S)
            !CE_HasLabel (L[6])                 &&
            L[7]->OPC == OP65_LDY               &&
            !CE_HasLabel (L[7])                 &&
-                   CE_IsCall (L[8], "ldauidx")         &&
+                   CE_IsCallTo (L[8], "ldauidx")       &&
            !CE_HasLabel (L[8])) {
 
            CodeEntry* X;
@@ -719,7 +878,7 @@ static unsigned OptPtrLoad4 (CodeSeg* S)
            L[6]->OPC == OP65_LDY                            &&
            CE_KnownImm (L[6])                               &&
            L[6]->Num == 0                                   &&
-                   CE_IsCall (L[7], "ldauidx")                      &&
+                   CE_IsCallTo (L[7], "ldauidx")                    &&
            !CE_HasLabel (L[7])                              &&
            /* Check the label last because this is quite costly */
            (Len = strlen (L[0]->Arg)) > 3                   &&
@@ -824,7 +983,7 @@ static unsigned OptPtrLoad5 (CodeSeg* S)
            L[7]->OPC == OP65_LDY                            &&
            CE_KnownImm (L[7])                               &&
            L[7]->Num == 0                                   &&
-                   CE_IsCall (L[8], "ldauidx")                      &&
+                   CE_IsCallTo (L[8], "ldauidx")                    &&
            !CE_HasLabel (L[8])                              &&
            /* Check the label last because this is quite costly */
            (Len = strlen (L[0]->Arg)) > 3                   &&
@@ -907,7 +1066,7 @@ static unsigned OptPtrLoad6 (CodeSeg* S)
        /* Check for the sequence */
                if (L[0]->OPC == OP65_LDY               &&
                    CS_GetEntries (S, L+1, I+1, 1)      &&
-                   CE_IsCall (L[1], "ldauidx")         &&
+                   CE_IsCallTo (L[1], "ldauidx")       &&
            !CE_HasLabel (L[1])) {
 
            CodeEntry* X;
@@ -1150,49 +1309,36 @@ static unsigned OptSize1 (CodeSeg* S)
  * removal pass.
  */
 {
-    static const char* Func = {
-       "stax0sp",           /* staxysp, y = 0 */
-       "addeq0sp",
-       "ldax0sp",           /* ldaxysp, y = 1 */
-               "ldeax0sp",          /* ldeaxysp, y = 3 */
-       "push0",             /* pushax, a = 0, x = 0 */
-       "pusha0",            /* pushax, x = 0 */
-       "pushaFF",           /* pushax, x = ff */
-       "pusha0sp",          /* pushaysp, y = 0 */
-       "tosadda0",          /* tosaddax, x = 0 */
-       "tosanda0",          /* tosandax, x = 0 */
-       "tosdiva0",          /* tosdivax, x = 0 */
-       "toseqa0",           /* toseqax, x = 0 */
-       "tosgea0",           /* tosgeax, x = 0 */
-               "tosgta0",           /* tosgtax, x = 0 */
-       "tosadd0ax",         /* tosaddeax, sreg = 0 */
-       "laddeqa",           /* laddeq, sreg = 0, x = 0 */
-       "laddeq1",           /* laddeq, sreg = 0, x = 0, a = 1 */
-       "laddeq0sp",         /* laddeqysp, y = 0 */
-               "tosand0ax",         /* tosandeax, sreg = 0 */
-        "ldaxi",             /* ldaxidx, y = 1 */
-       "ldeaxi",            /* ldeaxidx, y = 3 */
-       "ldeax0sp",          /* ldeaxysp, y = 3 */
-       "tosdiv0ax",         /* tosdiveax, sreg = 0 */
-       "toslea0",           /* tosleax, x = 0 */
-       "tosmod0ax",         /* tosmodeax, sreg = 0 */
-       "tosmul0ax",         /* tosmuleax, sreg = 0 */
-               "tosumul0ax",        /* tosumuleax, sreg = 0 */
-       "tosor0ax",          /* tosoreax, sreg = 0 */
-       "push0ax",           /* pusheax, sreg = 0 */
-       "tosrsub0ax",        /* tosrsubeax, sreg = 0 */
-       "tosshl0ax",         /* tosshleax, sreg = 0 */
-       "tosasl0ax",         /* tosasleax, sreg = 0 */
-       "tosshr0ax",         /* tosshreax, sreg = 0 */
-       "tosasr0ax",         /* tosasreax, sreg = 0 */
-       "tossub0ax",         /* tossubeax, sreg = 0 */
-       "lsubeqa",           /* lsubeq, sreg = 0, x = 0 */
-       "lsubeq1",           /* lsubeq, sreg = 0, x = 0, a = 1 */
-       "lsubeq0sp",         /* lsubeqysp, y = 0 */
+    typedef struct CallDesc CallDesc;
+    struct CallDesc {
+        const char*     LongFunc;       /* Long function name */
+        short           A, X, Y;        /* Register contents */
+        const char*     ShortFunc;      /* Short function name */
+    };
+
+    static const CallDesc CallTable [] = {
+               { "staxysp",    -1,   -1,    0, "stax0sp"       },
+               { "addeqysp",   -1,   -1,    0, "addeq0sp"      },
+               { "ldaxysp",    -1,   -1,    1, "ldax0sp"       },
+               { "ldeaxysp",   -1,   -1,    3, "ldeax0sp"      },
+               { "pushax",      0,    0,   -1, "push0"         },
+               { "pushax",     -1,    0,   -1, "pusha0"        },
+               { "pushax",     -1, 0xFF,   -1, "pushaFF"       },
+               { "pushaysp",   -1,   -1,    0, "pusha0sp"      },
+               { "tosaddax",   -1,    0,   -1, "tosadda0"      },
+               { "tosandax",   -1,    0,   -1, "tosanda0"      },
+               { "tosdivax",   -1,    0,   -1, "tosdiva0"      },
+               { "toseqax",    -1,    0,   -1, "toseqa0"       },
+               { "tosgeax",    -1,    0,   -1, "tosgea0"       },
+               { "tosgtax",    -1,    0,   -1, "tosgta0"       },
+               { "laddeqysp",  -1,   -1,    0, "laddeq0sp"     },
+        { "ldaxidx",    -1,   -1,    1, "ldaxi"         },
+               { "ldeaxidx",   -1,   -1,    3, "ldeaxi"        },
+        { "ldeaxysp",   -1,   -1,    3, "ldeax0sp"      },
+               { "tosleax",    -1,    0,   -1, "toslea0"       },
+        { "lsubeqysp",  -1,   -1,    0, "lsubeq0sp"     },
+
        "toslta0",           /* tosltax, x = 0 */
-       "tosudiv0ax",        /* tosudiveax, sreg = 0 */
-       "tosumod0ax",        /* tosumodeax, sreg = 0 */
-       "tosxor0ax",         /* tosxoreax, sreg = 0 */
        "tosmoda0",          /* tosmodax, x = 0 */
        "tosmula0",          /* tosmulax, x = 0 */
        "tosumula0",         /* tosumulax, x = 0 */
@@ -1223,6 +1369,29 @@ static unsigned OptSize1 (CodeSeg* S)
                "tosulta0",          /* tosultax, x = 0 */
                "tosumoda0",         /* tosumodax, x = 0 */
                "tosxora0",          /* tosxorax, x = 0 */
+
+               "tosadd0ax",         /* tosaddeax, sreg = 0 */
+       "laddeqa",           /* laddeq, sreg = 0, x = 0 */
+       "laddeq1",           /* laddeq, sreg = 0, x = 0, a = 1 */
+               "tosand0ax",         /* tosandeax, sreg = 0 */
+       "tosdiv0ax",         /* tosdiveax, sreg = 0 */
+       "tosmod0ax",         /* tosmodeax, sreg = 0 */
+       "tosmul0ax",         /* tosmuleax, sreg = 0 */
+               "tosumul0ax",        /* tosumuleax, sreg = 0 */
+       "tosor0ax",          /* tosoreax, sreg = 0 */
+       "push0ax",           /* pusheax, sreg = 0 */
+       "tosrsub0ax",        /* tosrsubeax, sreg = 0 */
+       "tosshl0ax",         /* tosshleax, sreg = 0 */
+       "tosasl0ax",         /* tosasleax, sreg = 0 */
+       "tosshr0ax",         /* tosshreax, sreg = 0 */
+       "tosasr0ax",         /* tosasreax, sreg = 0 */
+       "tossub0ax",         /* tossubeax, sreg = 0 */
+       "lsubeqa",           /* lsubeq, sreg = 0, x = 0 */
+       "lsubeq1",           /* lsubeq, sreg = 0, x = 0, a = 1 */
+       "tosudiv0ax",        /* tosudiveax, sreg = 0 */
+       "tosumod0ax",        /* tosumodeax, sreg = 0 */
+       "tosxor0ax",         /* tosxoreax, sreg = 0 */
+
     };
 
     unsigned Changes = 0;
@@ -1428,6 +1597,7 @@ static OptFunc DOptPush1          = { OptPush1,        "OptPush1",         65, 0,
 static OptFunc DOptPushPop      = { OptPushPop,      "OptPushPop",        0, 0, 0, 0, 0, 0 };
 static OptFunc DOptShift1              = { OptShift1,       "OptShift1",       100, 0, 0, 0, 0, 0 };
 static OptFunc DOptShift2              = { OptShift2,       "OptShift2",       100, 0, 0, 0, 0, 0 };
+static OptFunc DOptShift3              = { OptShift3,       "OptShift3",       110, 0, 0, 0, 0, 0 };
 /*static OptFunc DOptSize1        = { OptSize1,        "OptSize1",        100, 0, 0, 0, 0, 0 };*/
 static OptFunc DOptSize2        = { OptSize2,        "OptSize2",        100, 0, 0, 0, 0, 0 };
 static OptFunc DOptStackOps            = { OptStackOps,     "OptStackOps",     100, 0, 0, 0, 0, 0 };
@@ -1485,6 +1655,7 @@ static OptFunc* OptFuncs[] = {
     &DOptRTSJumps2,
     &DOptShift1,
     &DOptShift2,
+    &DOptShift3,
     /*&DOptSize1,*/
     &DOptSize2,
     &DOptStackOps,
@@ -1743,6 +1914,7 @@ static unsigned RunOptGroup1 (CodeSeg* S)
     Changes += RunOptFunc (S, &DOptAdd2, 1);
     Changes += RunOptFunc (S, &DOptShift1, 1);
     Changes += RunOptFunc (S, &DOptShift2, 1);
+    Changes += RunOptFunc (S, &DOptShift3, 1);
 
     /* Return the number of changes */
     return Changes;

diff --git a/src/cc65/coptadd.c b/src/cc65/coptadd.c
index 558dd85ab79bd67eea3bebaa368e9ce7d2186873..3fa886fed7b3acaa743cd49ee903249991efdcc3 100644 (file)
--- a/src/cc65/coptadd.c
+++ b/src/cc65/coptadd.c
@@ -57,7 +57,7 @@ unsigned OptAdd1 (CodeSeg* S)
  *      jsr     tosaddax
  *
  * and replace it by:
- *      
+ *
  *      ldy     #xx-1
  *      lda     (sp),y
  *      clc
@@ -88,12 +88,12 @@ unsigned OptAdd1 (CodeSeg* S)
            CE_KnownImm (L[0])               &&
            !CS_RangeHasLabel (S, I+1, 5)    &&
                    CS_GetEntries (S, L+1, I+1, 5)   &&
-                   CE_IsCall (L[1], "ldaxysp")      &&
-                   CE_IsCall (L[2], "pushax")       &&
+                   CE_IsCallTo (L[1], "ldaxysp")    &&
+                   CE_IsCallTo (L[2], "pushax")     &&
                    L[3]->OPC == OP65_LDY            &&
            CE_KnownImm (L[3])               &&
-                   CE_IsCall (L[4], "ldaxysp")      &&
-                   CE_IsCall (L[5], "tosaddax")) {
+                   CE_IsCallTo (L[4], "ldaxysp")    &&
+                   CE_IsCallTo (L[5], "tosaddax")) {
 
            CodeEntry* X;
             const char* Arg;
@@ -208,10 +208,10 @@ unsigned OptAdd2 (CodeSeg* S)
            CE_KnownImm (L[0])                  &&
            !CS_RangeHasLabel (S, I+1, 3)       &&
                    CS_GetEntries (S, L+1, I+1, 3)      &&
-           CE_IsCall (L[1], "ldaxysp")         &&
+           CE_IsCallTo (L[1], "ldaxysp")       &&
                    L[2]->OPC == OP65_LDY               &&
            CE_KnownImm (L[2])                  &&
-                   CE_IsCall (L[3], "addeqysp")        &&
+                   CE_IsCallTo (L[3], "addeqysp")      &&
                    (GetRegInfo (S, I+4, REG_AX) & REG_AX) == 0) {
 
            /* Insert new code behind the addeqysp */

diff --git a/src/cc65/coptcmp.c b/src/cc65/coptcmp.c
index 049b3ef7970c492bad7364549cfae7531db9dc75..012291e9acc4da9be9906c60778b883446d90c9e 100644 (file)
--- a/src/cc65/coptcmp.c
+++ b/src/cc65/coptcmp.c
@@ -6,7 +6,7 @@
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 2001      Ullrich von Bassewitz                                       */
+/* (C) 2001-2002 Ullrich von Bassewitz                                       */
 /*               Wacholderweg 14                                             */
 /*               D-70597 Stuttgart                                           */
 /* EMail:        uz@cc65.org                                                 */
@@ -558,7 +558,7 @@ unsigned OptCmp4 (CodeSeg* S)
            CE_KnownImm (L[0])              &&
            CS_GetEntries (S, L+1, I+1, 5)  &&
            !CE_HasLabel (L[1])             &&
-           CE_IsCall (L[1], "ldaxysp")     &&
+           CE_IsCallTo (L[1], "ldaxysp")   &&
            IsImmCmp16 (L+2)) {
 
                    if ((L[5]->Info & OF_FBRA) != 0 && L[2]->Num == 0 && L[4]->Num == 0) {

diff --git a/src/cc65/coptneg.c b/src/cc65/coptneg.c
index 7ca08249ea7cc9dd905f1faa167e7460c77d058b..86394d9a18f30565f8698e7fbed5cb0a82af9db7 100644 (file)
--- a/src/cc65/coptneg.c
+++ b/src/cc65/coptneg.c
@@ -6,7 +6,7 @@
 /*                                                                           */
 /*                                                                           */
 /*                                                                           */
-/* (C) 2001      Ullrich von Bassewitz                                       */
+/* (C) 2001-2002 Ullrich von Bassewitz                                       */
 /*               Wacholderweg 14                                             */
 /*               D-70597 Stuttgart                                           */
 /* EMail:        uz@cc65.org                                                 */
@@ -76,7 +76,7 @@ unsigned OptNegA1 (CodeSeg* S)
            L[0]->OPC == OP65_LDA               &&
            (L[0]->Use & REG_X) == 0            &&
            !CE_HasLabel (L[0])                 &&
-           CE_IsCall (L[1], "bnega")           &&
+           CE_IsCallTo (L[1], "bnega")         &&
            !CE_HasLabel (L[1])) {
 
            /* Remove the ldx instruction */
@@ -132,7 +132,7 @@ unsigned OptNegA2 (CodeSeg* S)
             E->OPC == OP65_TXA ||
             E->OPC == OP65_TYA)                &&
            CS_GetEntries (S, L, I+1, 2)        &&
-                   CE_IsCall (L[0], "bnega")           &&
+                   CE_IsCallTo (L[0], "bnega")         &&
            !CE_HasLabel (L[0])                 &&
            (L[1]->Info & OF_ZBRA) != 0         &&
            !CE_HasLabel (L[1])) {
@@ -185,7 +185,7 @@ unsigned OptNegAX1 (CodeSeg* S)
                CodeEntry* E = CS_GetEntry (S, I);
 
        /* Check if this is a call to bnegax, and if X is known and zero */
-       if (E->RI->In.RegX == 0 && CE_IsCall (E, "bnegax")) {
+       if (E->RI->In.RegX == 0 && CE_IsCallTo (E, "bnegax")) {
 
            CodeEntry* X = NewCodeEntry (OP65_JSR, AM65_ABS, "bnega", 0, E->LI);
            CS_InsertEntry (S, X, I+1);
@@ -242,8 +242,8 @@ unsigned OptNegAX2 (CodeSeg* S)
            CE_KnownImm (L[0])                  &&
            !CS_RangeHasLabel (S, I+1, 3)       &&
                    CS_GetEntries (S, L+1, I+1, 3)      &&
-           CE_IsCall (L[1], "ldaxysp")         &&
-                   CE_IsCall (L[2], "bnegax")          &&
+           CE_IsCallTo (L[1], "ldaxysp")       &&
+                   CE_IsCallTo (L[2], "bnegax")        &&
                    (L[3]->Info & OF_ZBRA) != 0) {
 
            CodeEntry* X;
@@ -313,7 +313,7 @@ unsigned OptNegAX3 (CodeSeg* S)
                    CS_GetEntries (S, L, I+1, 3)        &&
            L[0]->OPC == OP65_LDX               &&
            !CE_HasLabel (L[0])                 &&
-                   CE_IsCall (L[1], "bnegax")          &&
+                   CE_IsCallTo (L[1], "bnegax")        &&
            !CE_HasLabel (L[1])                 &&
                    (L[2]->Info & OF_ZBRA) != 0         &&
            !CE_HasLabel (L[2])) {

diff --git a/src/cc65/coptpush.c b/src/cc65/coptpush.c
index 1be755f9ef1a4697629421948e0d1b0277d23e7d..bede323077fa2afa42264a0bd2d1dc04961e0515 100644 (file)
--- a/src/cc65/coptpush.c
+++ b/src/cc65/coptpush.c
@@ -78,8 +78,8 @@ unsigned OptPush1 (CodeSeg* S)
            L[0]->Num < 0xFE                    &&
            !CS_RangeHasLabel (S, I+1, 2)       &&
                    CS_GetEntries (S, L+1, I+1, 2)      &&
-           CE_IsCall (L[1], "ldaxysp")         &&
-                   CE_IsCall (L[2], "pushax")          &&
+           CE_IsCallTo (L[1], "ldaxysp")       &&
+                   CE_IsCallTo (L[2], "pushax")        &&
                    (GetRegInfo (S, I+3, REG_AX) & REG_AX) == 0) {
 
            /* Insert new code behind the pushax */

diff --git a/src/cc65/coptstop.c b/src/cc65/coptstop.c
index 625ddfe709e70f39022af2be7e687ca04734e1ff..360e64729adc31280eebd346cf6668401ee658da 100644 (file)
--- a/src/cc65/coptstop.c
+++ b/src/cc65/coptstop.c
@@ -104,7 +104,7 @@ static unsigned AdjustStackOffset (CodeSeg* S, unsigned Start, unsigned Stop,
             /* We need to correct this one */
             NeedCorrection = 1;
 
-        } else if (CE_IsCall (E, "ldaxysp")) {
+        } else if (CE_IsCallTo (E, "ldaxysp")) {
 
             /* We need to correct this one */
             NeedCorrection = 1;
@@ -663,8 +663,7 @@ unsigned OptStackOps (CodeSeg* S)
        /* Handling depends if we're inside a sequence or not */
        if (InSeq) {
 
-           if ((E->Info & OF_BRA) != 0                              ||
-               ((E->Use & REG_SP) != 0                         &&
+                   if (((E->Use & REG_SP) != 0                         &&
                 (E->AM != AM65_ZP_INDY || E->RI->In.RegY < 0))) {
 
                /* All this stuff is not allowed in a sequence */
@@ -753,7 +752,7 @@ unsigned OptStackOps (CodeSeg* S)
 
            }
 
-       } else if (CE_IsCall (E, "pushax")) {
+       } else if (CE_IsCallTo (E, "pushax")) {
 
            /* This starts a sequence */
            Push     = I;