X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=src%2Fcc65%2Fcodeopt.c;h=c596068be0f280b9200f1378ed2d7a2142e82100;hb=8cd7b15c8b3546af94ba8dabe3bdd5d5c65246a2;hp=f3b31edb98b6dbc2c4087c50fcbd01685a9be921;hpb=68c0d38dfae987627f6f338ccc86e4bf4721b946;p=cc65 diff --git a/src/cc65/codeopt.c b/src/cc65/codeopt.c index f3b31edb9..c596068be 100644 --- a/src/cc65/codeopt.c +++ b/src/cc65/codeopt.c @@ -91,22 +91,22 @@ static const char CmpSignedTab [] = { /*****************************************************************************/ -/* Helper functions */ +/* Helper functions */ /*****************************************************************************/ -static cmp_t FindCmpCond (const char* Suffix) -/* Map a condition suffix to a code. Return the code or CMP_INV on failure */ +static cmp_t FindCmpCond (const char* Code, unsigned CodeLen) +/* Search for a compare condition by the given code using the given length */ { - int I; + unsigned I; /* Linear search */ for (I = 0; I < sizeof (CmpSuffixTab) / sizeof (CmpSuffixTab [0]); ++I) { - if (strcmp (Suffix, CmpSuffixTab [I]) == 0) { + if (strncmp (Code, CmpSuffixTab [I], CodeLen) == 0) { /* Found */ - return I; - } + return I; + } } /* Not found */ @@ -115,8 +115,233 @@ static cmp_t FindCmpCond (const char* Suffix) +static cmp_t FindBoolCmpCond (const char* Name) +/* Map a condition suffix to a code. Return the code or CMP_INV on failure */ +{ + /* Check for the correct subroutine name */ + if (strncmp (Name, "bool", 4) == 0) { + /* Name is ok, search for the code in the table */ + return FindCmpCond (Name+4, strlen(Name)-4); + } else { + /* Not found */ + return CMP_INV; + } +} + + + +static cmp_t FindTosCmpCond (const char* Name) +/* Check if this is a call to one of the TOS compare functions (tosgtax). + * Return the condition code or CMP_INV on failure. + */ +{ + unsigned Len = strlen (Name); + + /* Check for the correct subroutine name */ + if (strncmp (Name, "tos", 3) == 0 && strcmp (Name+Len-2, "ax") == 0) { + /* Name is ok, search for the code in the table */ + return FindCmpCond (Name+3, Len-3-2); + } else { + /* Not found */ + return CMP_INV; + } +} + + + +static void ReplaceCmp (CodeSeg* S, unsigned I, cmp_t Cond) +/* Helper function for the replacement of routines that return a boolean + * followed by a conditional jump. Instead of the boolean value, the condition + * codes are evaluated directly. + * I is the index of the conditional branch, the sequence is already checked + * to be correct. + */ +{ + CodeEntry* N; + CodeLabel* L; + + /* Get the entry */ + CodeEntry* E = CS_GetEntry (S, I); + + /* Replace the conditional branch */ + switch (Cond) { + + case CMP_EQ: + CE_ReplaceOPC (E, OP65_JEQ); + break; + + case CMP_NE: + CE_ReplaceOPC (E, OP65_JNE); + break; + + case CMP_GT: + /* Replace by + * beq @L + * jpl Target + * @L: ... + */ + if ((N = CS_GetNextEntry (S, I)) == 0) { + /* No such entry */ + Internal ("Invalid program flow"); + } + L = CS_GenLabel (S, N); + N = NewCodeEntry (OP65_BEQ, AM65_BRA, L->Name, L, E->LI); + CS_InsertEntry (S, N, I); + CE_ReplaceOPC (E, OP65_JPL); + break; + + case CMP_GE: + CE_ReplaceOPC (E, OP65_JPL); + break; + + case CMP_LT: + CE_ReplaceOPC (E, OP65_JMI); + break; + + case CMP_LE: + /* Replace by + * jmi Target + * jeq Target + */ + CE_ReplaceOPC (E, OP65_JMI); + L = E->JumpTo; + N = NewCodeEntry (OP65_JEQ, AM65_BRA, L->Name, L, E->LI); + CS_InsertEntry (S, N, I+1); + break; + + case CMP_UGT: + /* Replace by + * beq @L + * jcs Target + * @L: ... + */ + if ((N = CS_GetNextEntry (S, I)) == 0) { + /* No such entry */ + Internal ("Invalid program flow"); + } + L = CS_GenLabel (S, N); + N = NewCodeEntry (OP65_BEQ, AM65_BRA, L->Name, L, E->LI); + CS_InsertEntry (S, N, I); + CE_ReplaceOPC (E, OP65_JCS); + break; + + case CMP_UGE: + CE_ReplaceOPC (E, OP65_JCS); + break; + + case CMP_ULT: + CE_ReplaceOPC (E, OP65_JCC); + break; + + case CMP_ULE: + /* Replace by + * jcc Target + * jeq Target + */ + CE_ReplaceOPC (E, OP65_JCC); + L = E->JumpTo; + N = NewCodeEntry (OP65_JEQ, AM65_BRA, L->Name, L, E->LI); + CS_InsertEntry (S, N, I+1); + break; + + default: + Internal ("Unknown jump condition: %d", Cond); + + } + +} + + + +static int IsBitOp (const CodeEntry* E) +/* Check if E is one of the bit operations (and, or, eor) */ +{ + return (E->OPC == OP65_AND || E->OPC == OP65_ORA || E->OPC == OP65_EOR); +} + + + +static int IsCmpToZero (const CodeEntry* E) +/* Check if the given instrcuction is a compare to zero instruction */ +{ + return (E->OPC == OP65_CMP && + E->AM == AM65_IMM && + (E->Flags & CEF_NUMARG) != 0 && + E->Num == 0); +} + + + +static int IsSpLoad (const CodeEntry* E) +/* Return true if this is the load of A from the stack */ +{ + return E->OPC == OP65_LDA && E->AM == AM65_ZP_INDY && strcmp (E->Arg, "sp") == 0; +} + + + +static int IsLocalLoad16 (CodeSeg* S, unsigned Index, + CodeEntry** L, unsigned Count) +/* Check if a 16 bit load of a local variable follows: + * + * ldy #$xx + * lda (sp),y + * tax + * dey + * lda (sp),y + * + * If so, read Count entries following the first ldy into L and return true + * if this is possible. Otherwise return false. + */ +{ + /* Be sure we read enough entries for the check */ + CHECK (Count >= 5); + + /* Read the first entry */ + L[0] = CS_GetEntry (S, Index); + + /* Check for the sequence */ + return (L[0]->OPC == OP65_LDY && + L[0]->AM == AM65_IMM && + (L[0]->Flags & CEF_NUMARG) != 0 && + CS_GetEntries (S, L+1, Index+1, Count-1) && + IsSpLoad (L[1]) && + !CE_HasLabel (L[1]) && + L[2]->OPC == OP65_TAX && + !CE_HasLabel (L[2]) && + L[3]->OPC == OP65_DEY && + !CE_HasLabel (L[3]) && + IsSpLoad (L[4]) && + !CE_HasLabel (L[4])); +} + + + +static int IsImmCmp16 (CodeSeg* S, CodeEntry** L) +/* Check if the instructions at L are an immidiate compare of a/x: + * + * + */ +{ + return (L[0]->OPC == OP65_CPX && + L[0]->AM == AM65_IMM && + (L[0]->Flags & CEF_NUMARG) != 0 && + !CE_HasLabel (L[0]) && + (L[1]->OPC == OP65_JNE || L[1]->OPC == OP65_BNE) && + L[1]->JumpTo != 0 && + !CE_HasLabel (L[1]) && + L[2]->OPC == OP65_CMP && + L[2]->AM == AM65_IMM && + (L[2]->Flags & CEF_NUMARG) != 0 && + (L[3]->Info & OF_ZBRA) != 0 && + L[3]->JumpTo != 0 && + (L[1]->JumpTo->Owner == L[3] || L[1]->JumpTo == L[3]->JumpTo)); +} + + + /*****************************************************************************/ -/* Remove calls to the bool transformer subroutines */ +/* Remove calls to the bool transformer subroutines */ /*****************************************************************************/ @@ -130,23 +355,19 @@ static unsigned OptBoolTransforms (CodeSeg* S) /* Walk over the entries */ unsigned I = 0; - while (I < GetCodeEntryCount (S)) { + while (I < CS_GetEntryCount (S)) { CodeEntry* N; cmp_t Cond; /* Get next entry */ - CodeEntry* E = GetCodeEntry (S, I); + CodeEntry* E = CS_GetEntry (S, I); /* Check for a boolean transformer */ - if (E->OPC == OPC_JSR && - strncmp (E->Arg, "bool", 4) == 0 && - (N = GetNextCodeEntry (S, I)) != 0 && - (N->Info & OF_ZBRA) != 0 && - (Cond = FindCmpCond (E->Arg+4)) != CMP_INV) { - - CodeEntry* X; - CodeLabel* L; + if (E->OPC == OP65_JSR && + (Cond = FindBoolCmpCond (E->Arg)) != CMP_INV && + (N = CS_GetNextEntry (S, I)) != 0 && + (N->Info & OF_ZBRA) != 0) { /* Make the boolean transformer unnecessary by changing the * the conditional jump to evaluate the condition flags that @@ -160,100 +381,535 @@ static unsigned OptBoolTransforms (CodeSeg* S) } /* Check if we can replace the code by something better */ - switch (Cond) { - - case CMP_EQ: - ReplaceOPC (N, OPC_JEQ); - break; - - case CMP_NE: - ReplaceOPC (N, OPC_JNE); - break; - - case CMP_GT: - /* Replace by - * beq @L - * jpl Target - * @L: ... - */ - if ((X = GetNextCodeEntry (S, I+1)) == 0) { - /* No such entry */ - goto NextEntry; - } - L = GenCodeLabel (S, X); - X = NewCodeEntry (OPC_BEQ, AM_BRA, L->Name, L); - InsertCodeEntry (S, X, I+1); - ReplaceOPC (N, OPC_JPL); - break; - - case CMP_GE: - ReplaceOPC (N, OPC_JPL); - break; - - case CMP_LT: - ReplaceOPC (N, OPC_JMI); - break; - - case CMP_LE: - /* Replace by - * jmi Target - * jeq Target - */ - ReplaceOPC (N, OPC_JMI); - L = N->JumpTo; - X = NewCodeEntry (OPC_JEQ, AM_BRA, L->Name, L); - InsertCodeEntry (S, X, I+2); - break; - - case CMP_UGT: - /* Replace by - * beq @L - * jcs Target - * @L: ... - */ - if ((X = GetNextCodeEntry (S, I+1)) == 0) { - /* No such entry */ - goto NextEntry; - } - L = GenCodeLabel (S, X); - X = NewCodeEntry (OPC_BEQ, AM_BRA, L->Name, L); - InsertCodeEntry (S, X, I+1); - ReplaceOPC (N, OPC_JCS); - break; - - case CMP_UGE: - ReplaceOPC (N, OPC_JCS); - break; - - case CMP_ULT: - ReplaceOPC (N, OPC_JCC); - break; - - case CMP_ULE: - /* Replace by - * jcc Target - * jeq Target - */ - ReplaceOPC (N, OPC_JCC); - L = N->JumpTo; - X = NewCodeEntry (OPC_JEQ, AM_BRA, L->Name, L); - InsertCodeEntry (S, X, I+2); - break; - - default: - Internal ("Unknown jump condition: %d", Cond); + ReplaceCmp (S, I+1, Cond); + + /* Remove the call to the bool transformer */ + CS_DelEntry (S, I); + /* Remember, we had changes */ + ++Changes; + + } + + /* Next entry */ + ++I; + + } + + /* Return the number of changes made */ + return Changes; +} + + + +/*****************************************************************************/ +/* Optimize subtractions */ +/*****************************************************************************/ + + + +static unsigned OptSub1 (CodeSeg* S) +/* Search for the sequence + * + * sbc ... + * bcs L + * dex + * L: + * + * and remove the handling of the high byte if X is not used later. + */ +{ + unsigned Changes = 0; + + /* Walk over the entries */ + unsigned I = 0; + while (I < CS_GetEntryCount (S)) { + + CodeEntry* L[3]; + + /* Get next entry */ + CodeEntry* E = CS_GetEntry (S, I); + + /* Check for the sequence */ + if (E->OPC == OP65_SBC && + CS_GetEntries (S, L, I+1, 3) && + (L[0]->OPC == OP65_BCS || L[0]->OPC == OP65_JCS) && + L[0]->JumpTo != 0 && + !CE_HasLabel (L[0]) && + L[1]->OPC == OP65_DEX && + !CE_HasLabel (L[1]) && + L[0]->JumpTo->Owner == L[2] && + !RegXUsed (S, I+3)) { + + /* Remove the bcs/dex */ + CS_DelEntries (S, I+1, 2); + + /* Remember, we had changes */ + ++Changes; + + } + + /* Next entry */ + ++I; + + } + + /* Return the number of changes made */ + return Changes; +} + + + +static unsigned OptSub2 (CodeSeg* S) +/* Search for the sequence + * + * lda xx + * sec + * sta tmp1 + * lda yy + * sbc tmp1 + * sta yy + * + * and replace it by + * + * sec + * lda yy + * sbc xx + * sta yy + */ +{ + unsigned Changes = 0; + + /* Walk over the entries */ + unsigned I = 0; + while (I < CS_GetEntryCount (S)) { + + CodeEntry* L[5]; + + /* Get next entry */ + CodeEntry* E = CS_GetEntry (S, I); + + /* Check for the sequence */ + if (E->OPC == OP65_LDA && + CS_GetEntries (S, L, I+1, 5) && + L[0]->OPC == OP65_SEC && + !CE_HasLabel (L[0]) && + L[1]->OPC == OP65_STA && + strcmp (L[1]->Arg, "tmp1") == 0 && + !CE_HasLabel (L[1]) && + L[2]->OPC == OP65_LDA && + !CE_HasLabel (L[2]) && + L[3]->OPC == OP65_SBC && + strcmp (L[3]->Arg, "tmp1") == 0 && + !CE_HasLabel (L[3]) && + L[4]->OPC == OP65_STA && + strcmp (L[4]->Arg, L[2]->Arg) == 0 && + !CE_HasLabel (L[4])) { + + /* Remove the store to tmp1 */ + CS_DelEntry (S, I+2); + + /* Remove the subtraction */ + CS_DelEntry (S, I+3); + + /* Move the lda to the position of the subtraction and change the + * op to SBC. + */ + CS_MoveEntry (S, I, I+3); + CE_ReplaceOPC (E, OP65_SBC); + + /* If the sequence head had a label, move this label back to the + * head. + */ + if (CE_HasLabel (E)) { + CS_MoveLabels (S, E, L[0]); } - /* Remove the call to the bool transformer */ - DelCodeEntry (S, I); + /* Remember, we had changes */ + ++Changes; + + } + + /* Next entry */ + ++I; + + } + + /* Return the number of changes made */ + return Changes; +} + + + +/*****************************************************************************/ +/* Optimize additions */ +/*****************************************************************************/ + + + +static unsigned OptAdd1 (CodeSeg* S) +/* Search for the sequence + * + * adc ... + * bcc L + * inx + * L: + * + * and remove the handling of the high byte if X is not used later. + */ +{ + unsigned Changes = 0; + + /* Walk over the entries */ + unsigned I = 0; + while (I < CS_GetEntryCount (S)) { + + CodeEntry* L[3]; + + /* Get next entry */ + CodeEntry* E = CS_GetEntry (S, I); + + /* Check for the sequence */ + if (E->OPC == OP65_ADC && + CS_GetEntries (S, L, I+1, 3) && + (L[0]->OPC == OP65_BCC || L[0]->OPC == OP65_JCC) && + L[0]->JumpTo != 0 && + !CE_HasLabel (L[0]) && + L[1]->OPC == OP65_INX && + !CE_HasLabel (L[1]) && + L[0]->JumpTo->Owner == L[2] && + !RegXUsed (S, I+3)) { + + /* Remove the bcs/dex */ + CS_DelEntries (S, I+1, 2); + + /* Remember, we had changes */ + ++Changes; + + } + + /* Next entry */ + ++I; + + } + + /* Return the number of changes made */ + return Changes; +} + + + +/*****************************************************************************/ +/* Optimizations for compares */ +/*****************************************************************************/ + + + +static unsigned OptCmp1 (CodeSeg* S) +/* Search for the sequence + * + * stx xx + * stx tmp1 + * ora tmp1 + * + * and replace it by + * + * stx xx + * ora xx + */ +{ + unsigned Changes = 0; + + /* Walk over the entries */ + unsigned I = 0; + while (I < CS_GetEntryCount (S)) { + + CodeEntry* L[2]; + + /* Get next entry */ + CodeEntry* E = CS_GetEntry (S, I); + + /* Check for the sequence */ + if (E->OPC == OP65_STX && + CS_GetEntries (S, L, I+1, 2) && + L[0]->OPC == OP65_STX && + strcmp (L[0]->Arg, "tmp1") == 0 && + !CE_HasLabel (L[0]) && + L[1]->OPC == OP65_ORA && + strcmp (L[1]->Arg, "tmp1") == 0 && + !CE_HasLabel (L[1])) { + + /* Remove the remaining instructions */ + CS_DelEntries (S, I+1, 2); + + /* Insert the ora instead */ + CS_InsertEntry (S, NewCodeEntry (OP65_ORA, E->AM, E->Arg, 0, E->LI), I+1); + + /* Remember, we had changes */ + ++Changes; + + } + + /* Next entry */ + ++I; + + } + + /* Return the number of changes made */ + return Changes; +} + + + +static unsigned OptCmp2 (CodeSeg* S) +/* Search for + * + * lda/and/ora/eor ... + * cmp #$00 + * jeq/jne + * + * and remove the cmp. + */ +{ + unsigned Changes = 0; + + /* Walk over the entries */ + unsigned I = 0; + while (I < CS_GetEntryCount (S)) { + + CodeEntry* L[2]; + + /* Get next entry */ + CodeEntry* E = CS_GetEntry (S, I); + + /* Check for the sequence */ + if ((E->OPC == OP65_LDA || IsBitOp (E)) && + CS_GetEntries (S, L, I+1, 2) && + IsCmpToZero (L[0]) && + !CE_HasLabel (L[0]) && + (L[1]->Info & OF_FBRA) != 0 && + !CE_HasLabel (L[1])) { + + /* Remove the compare */ + CS_DelEntry (S, I+1); + + /* Remember, we had changes */ + ++Changes; + + } + + /* Next entry */ + ++I; + + } + + /* Return the number of changes made */ + return Changes; +} + + + +static unsigned OptCmp3 (CodeSeg* S) +/* Search for + * + * lda x + * ldx y + * cpx #a + * bne L1 + * cmp #b + * jne/jeq L2 + * + * If a is zero, we may remove the compare. If a and b are both zero, we may + * replace it by the sequence + * + * lda x + * ora x+1 + * jne/jeq ... + * + * L1 may be either the label at the branch instruction, or the target label + * of this instruction. + */ +{ + unsigned Changes = 0; + + /* Walk over the entries */ + unsigned I = 0; + while (I < CS_GetEntryCount (S)) { + + CodeEntry* L[5]; + + /* Get next entry */ + CodeEntry* E = CS_GetEntry (S, I); + + /* Check for the sequence */ + if (E->OPC == OP65_LDA && + CS_GetEntries (S, L, I+1, 5) && + L[0]->OPC == OP65_LDX && + !CE_HasLabel (L[0]) && + IsImmCmp16 (S, L+1)) { + + if (L[1]->Num == 0 && L[3]->Num == 0) { + /* The value is zero, we may use the simple code version. */ + CE_ReplaceOPC (L[0], OP65_ORA); + CS_DelEntries (S, I+2, 3); + } else { + /* Move the lda instruction after the first branch. This will + * improve speed, since the load is delayed after the first + * test. + */ + CS_MoveEntry (S, I, I+4); + + /* We will replace the ldx/cpx by lda/cmp */ + CE_ReplaceOPC (L[0], OP65_LDA); + CE_ReplaceOPC (L[1], OP65_CMP); + + /* Beware: If the first LDA instruction had a label, we have + * to move this label to the top of the sequence again. + */ + if (CE_HasLabel (E)) { + CS_MoveLabels (S, E, L[0]); + } + + } + + ++Changes; + } + + /* Next entry */ + ++I; + + } + + /* Return the number of changes made */ + return Changes; +} + + + +static unsigned OptCmp4 (CodeSeg* S) +/* Optimize compares of local variables: + * + * ldy #o + * lda (sp),y + * tax + * dey + * lda (sp),y + * cpx #a + * bne L1 + * cmp #b + * jne/jeq L2 + */ +{ + unsigned Changes = 0; + + /* Walk over the entries */ + unsigned I = 0; + while (I < CS_GetEntryCount (S)) { + + CodeEntry* L[9]; + + /* Check for the sequence */ + if (IsLocalLoad16 (S, I, L, 9) && IsImmCmp16 (S, L+5)) { + + if (L[5]->Num == 0 && L[7]->Num == 0) { + + /* The value is zero, we may use the simple code version: + * ldy #o + * lda (sp),y + * dey + * ora (sp),y + * jne/jeq ... + */ + CE_ReplaceOPC (L[4], OP65_ORA); + CS_DelEntries (S, I+5, 3); /* cpx/bne/cmp */ + CS_DelEntry (S, I+2); /* tax */ + + } else { + + /* Change the code to just use the A register. Move the load + * of the low byte after the first branch if possible: + * + * ldy #o + * lda (sp),y + * cmp #a + * bne L1 + * dey + * lda (sp),y + * cmp #b + * jne/jeq ... + */ + CS_DelEntry (S, I+2); /* tax */ + CE_ReplaceOPC (L[5], OP65_CMP); /* cpx -> cmp */ + CS_MoveEntry (S, I+4, I+2); /* cmp */ + CS_MoveEntry (S, I+5, I+3); /* bne */ + + } + + ++Changes; + } + + /* Next entry */ + ++I; + + } + + /* Return the number of changes made */ + return Changes; +} + + + +static unsigned OptCmp5 (CodeSeg* S) +/* Search for calls to compare subroutines followed by a conditional branch + * and replace them by cheaper versions, since the branch means that the + * boolean value returned by these routines is not needed (we may also check + * that explicitly, but for the current code generator it is always true). + */ +{ + unsigned Changes = 0; + + /* Walk over the entries */ + unsigned I = 0; + while (I < CS_GetEntryCount (S)) { + + CodeEntry* N; + cmp_t Cond; + + /* Get next entry */ + CodeEntry* E = CS_GetEntry (S, I); + + /* Check for the sequence */ + if (E->OPC == OP65_JSR && + (Cond = FindTosCmpCond (E->Arg)) != CMP_INV && + (N = CS_GetNextEntry (S, I)) != 0 && + (N->Info & OF_ZBRA) != 0 && + !CE_HasLabel (N)) { + + /* The tos... functions will return a boolean value in a/x and + * the Z flag says if this value is zero or not. We will call + * a cheaper subroutine instead, one that does not return a + * boolean value but only valid flags. Note: jeq jumps if + * the condition is not met, jne jumps if the condition is met. + * Invert the code if we jump on condition not met. + */ + if (GetBranchCond (N->OPC) == BC_EQ) { + /* Jumps if condition false, invert condition */ + Cond = CmpInvertTab [Cond]; + } + + /* Replace the subroutine call. */ + E = NewCodeEntry (OP65_JSR, AM65_ABS, "tosicmp", 0, E->LI); + CS_InsertEntry (S, E, I+1); + CS_DelEntry (S, I); + + /* Replace the conditional branch */ + ReplaceCmp (S, I+1, Cond); /* Remember, we had changes */ ++Changes; } -NextEntry: /* Next entry */ ++I; @@ -266,7 +922,7 @@ NextEntry: /*****************************************************************************/ -/* nega optimizations */ +/* nega optimizations */ /*****************************************************************************/ @@ -285,26 +941,26 @@ static unsigned OptNegA1 (CodeSeg* S) /* Walk over the entries */ unsigned I = 0; - while (I < GetCodeEntryCount (S)) { + while (I < CS_GetEntryCount (S)) { CodeEntry* L[2]; /* Get next entry */ - CodeEntry* E = GetCodeEntry (S, I); + CodeEntry* E = CS_GetEntry (S, I); /* Check for a ldx */ - if (E->OPC == OPC_LDX && - E->AM == AM_IMM && + if (E->OPC == OP65_LDX && + E->AM == AM65_IMM && (E->Flags & CEF_NUMARG) != 0 && E->Num == 0 && - GetCodeEntries (S, L, I+1, 2) && - L[0]->OPC == OPC_LDA && + CS_GetEntries (S, L, I+1, 2) && + L[0]->OPC == OP65_LDA && (L[0]->Use & REG_X) == 0 && - L[1]->OPC == OPC_JSR && + L[1]->OPC == OP65_JSR && strcmp (L[1]->Arg, "bnega") == 0) { /* Remove the ldx instruction */ - DelCodeEntry (S, I); + CS_DelEntry (S, I); /* Remember, we had changes */ ++Changes; @@ -336,26 +992,26 @@ static unsigned OptNegA2 (CodeSeg* S) /* Walk over the entries */ unsigned I = 0; - while (I < GetCodeEntryCount (S)) { + while (I < CS_GetEntryCount (S)) { CodeEntry* L[2]; /* Get next entry */ - CodeEntry* E = GetCodeEntry (S, I); + CodeEntry* E = CS_GetEntry (S, I); /* Check for the sequence */ - if (E->OPC == OPC_LDA && - GetCodeEntries (S, L, I+1, 2) && - L[0]->OPC == OPC_JSR && + if (E->OPC == OP65_LDA && + CS_GetEntries (S, L, I+1, 2) && + L[0]->OPC == OP65_JSR && strcmp (L[0]->Arg, "bnega") == 0 && - !CodeEntryHasLabel (L[0]) && + !CE_HasLabel (L[0]) && (L[1]->Info & OF_ZBRA) != 0) { /* Invert the branch */ - ReplaceOPC (L[1], GetInverseBranch (L[1]->OPC)); + CE_ReplaceOPC (L[1], GetInverseBranch (L[1]->OPC)); /* Delete the subroutine call */ - DelCodeEntry (S, I+1); + CS_DelEntry (S, I+1); /* Remember, we had changes */ ++Changes; @@ -401,39 +1057,39 @@ static unsigned OptNegAX1 (CodeSeg* S) /* Walk over the entries */ unsigned I = 0; - while (I < GetCodeEntryCount (S)) { + while (I < CS_GetEntryCount (S)) { CodeEntry* L[5]; /* Get next entry */ - CodeEntry* E = GetCodeEntry (S, I); + CodeEntry* E = CS_GetEntry (S, I); /* Check for the sequence */ - if (E->OPC == OPC_LDA && - E->AM == AM_ZP_INDY && - GetCodeEntries (S, L, I+1, 5) && - L[0]->OPC == OPC_TAX && - L[1]->OPC == OPC_DEY && - L[2]->OPC == OPC_LDA && - L[2]->AM == AM_ZP_INDY && + if (E->OPC == OP65_LDA && + E->AM == AM65_ZP_INDY && + CS_GetEntries (S, L, I+1, 5) && + L[0]->OPC == OP65_TAX && + L[1]->OPC == OP65_DEY && + L[2]->OPC == OP65_LDA && + L[2]->AM == AM65_ZP_INDY && strcmp (L[2]->Arg, E->Arg) == 0 && - !CodeEntryHasLabel (L[2]) && - L[3]->OPC == OPC_JSR && + !CE_HasLabel (L[2]) && + L[3]->OPC == OP65_JSR && strcmp (L[3]->Arg, "bnegax") == 0 && - !CodeEntryHasLabel (L[3]) && + !CE_HasLabel (L[3]) && (L[4]->Info & OF_ZBRA) != 0) { /* lda --> ora */ - ReplaceOPC (L[2], OPC_ORA); + CE_ReplaceOPC (L[2], OP65_ORA); /* Invert the branch */ - ReplaceOPC (L[4], GetInverseBranch (L[4]->OPC)); + CE_ReplaceOPC (L[4], GetInverseBranch (L[4]->OPC)); /* Delete the entries no longer needed. Beware: Deleting entries * will change the indices. */ - DelCodeEntry (S, I+4); /* jsr bnegax */ - DelCodeEntry (S, I+1); /* tax */ + CS_DelEntry (S, I+4); /* jsr bnegax */ + CS_DelEntry (S, I+1); /* tax */ /* Remember, we had changes */ ++Changes; @@ -470,31 +1126,31 @@ static unsigned OptNegAX2 (CodeSeg* S) /* Walk over the entries */ unsigned I = 0; - while (I < GetCodeEntryCount (S)) { + while (I < CS_GetEntryCount (S)) { CodeEntry* L[3]; /* Get next entry */ - CodeEntry* E = GetCodeEntry (S, I); + CodeEntry* E = CS_GetEntry (S, I); /* Check for the sequence */ - if (E->OPC == OPC_LDA && - GetCodeEntries (S, L, I+1, 3) && - L[0]->OPC == OPC_LDX && - !CodeEntryHasLabel (L[0]) && - L[1]->OPC == OPC_JSR && + if (E->OPC == OP65_LDA && + CS_GetEntries (S, L, I+1, 3) && + L[0]->OPC == OP65_LDX && + !CE_HasLabel (L[0]) && + L[1]->OPC == OP65_JSR && strcmp (L[1]->Arg, "bnegax") == 0 && - !CodeEntryHasLabel (L[1]) && + !CE_HasLabel (L[1]) && (L[2]->Info & OF_ZBRA) != 0) { /* ldx --> ora */ - ReplaceOPC (L[0], OPC_ORA); + CE_ReplaceOPC (L[0], OP65_ORA); /* Invert the branch */ - ReplaceOPC (L[2], GetInverseBranch (L[2]->OPC)); + CE_ReplaceOPC (L[2], GetInverseBranch (L[2]->OPC)); /* Delete the subroutine call */ - DelCodeEntry (S, I+2); + CS_DelEntry (S, I+2); /* Remember, we had changes */ ++Changes; @@ -530,40 +1186,45 @@ static unsigned OptNegAX3 (CodeSeg* S) /* Walk over the entries */ unsigned I = 0; - while (I < GetCodeEntryCount (S)) { + while (I < CS_GetEntryCount (S)) { CodeEntry* L[2]; /* Get next entry */ - CodeEntry* E = GetCodeEntry (S, I); + CodeEntry* E = CS_GetEntry (S, I); /* Check for the sequence */ - if (E->OPC == OPC_JSR && - E->Arg[0] == '_' && - GetCodeEntries (S, L, I+1, 2) && - L[0]->OPC == OPC_JSR && - strncmp (L[0]->Arg,"bnega",5) == 0 && - !CodeEntryHasLabel (L[0]) && + if (E->OPC == OP65_JSR && + E->Arg[0] == '_' && + CS_GetEntries (S, L, I+1, 2) && + L[0]->OPC == OP65_JSR && + strncmp (L[0]->Arg,"bnega",5) == 0 && + !CE_HasLabel (L[0]) && (L[1]->Info & OF_ZBRA) != 0) { + CodeEntry* X; + /* Check if we're calling bnega or bnegax */ int ByteSized = (strcmp (L[0]->Arg, "bnega") == 0); - /* Delete the subroutine call */ - DelCodeEntry (S, I+1); - /* Insert apropriate test code */ if (ByteSized) { /* Test bytes */ - InsertCodeEntry (S, NewCodeEntry (OPC_TAX, AM_IMP, 0, 0), I+1); + X = NewCodeEntry (OP65_TAX, AM65_IMP, 0, 0, L[0]->LI); + CS_InsertEntry (S, X, I+2); } else { /* Test words */ - InsertCodeEntry (S, NewCodeEntry (OPC_STX, AM_ZP, "tmp1", 0), I+1); - InsertCodeEntry (S, NewCodeEntry (OPC_ORA, AM_ZP, "tmp1", 0), I+2); + X = NewCodeEntry (OP65_STX, AM65_ZP, "tmp1", 0, L[0]->LI); + CS_InsertEntry (S, X, I+2); + X = NewCodeEntry (OP65_ORA, AM65_ZP, "tmp1", 0, L[0]->LI); + CS_InsertEntry (S, X, I+3); } + /* Delete the subroutine call */ + CS_DelEntry (S, I+1); + /* Invert the branch */ - ReplaceOPC (L[1], GetInverseBranch (L[1]->OPC)); + CE_ReplaceOPC (L[1], GetInverseBranch (L[1]->OPC)); /* Remember, we had changes */ ++Changes; @@ -599,6 +1260,11 @@ struct OptFunc { /* Table with optimizer steps - are called in this order */ static OptFunc OptFuncs [] = { + /* Optimize subtractions */ + { OptSub1, "OptSub1", 0 }, + { OptSub2, "OptSub2", 0 }, + /* Optimize additions */ + { OptAdd1, "OptAdd1", 0 }, /* Optimize jump cascades */ { OptJumpCascades, "OptJumpCascades", 0 }, /* Remove dead jumps */ @@ -617,16 +1283,21 @@ static OptFunc OptFuncs [] = { { OptBoolTransforms, "OptBoolTransforms", 0 }, /* Optimize calls to nega */ { OptNegA1, "OptNegA1", 0 }, - /* Optimize calls to nega */ { OptNegA2, "OptNegA2", 0 }, /* Optimize calls to negax */ { OptNegAX1, "OptNegAX1", 0 }, - /* Optimize calls to negax */ { OptNegAX2, "OptNegAX2", 0 }, - /* Optimize calls to negax */ { OptNegAX3, "OptNegAX3", 0 }, + /* Optimize compares */ + { OptCmp1, "OptCmp1", 0 }, + { OptCmp2, "OptCmp2", 0 }, + { OptCmp3, "OptCmp3", 0 }, + { OptCmp4, "OptCmp4", 0 }, + { OptCmp5, "OptCmp5", 0 }, /* Remove unused loads */ { OptUnusedLoads, "OptUnusedLoads", 0 }, + { OptDuplicateLoads, "OptDuplicateLoads", 0 }, + { OptStoreLoad, "OptStoreLoad", 0 }, /* Optimize branch distance */ { OptBranchDist, "OptBranchDist", 0 }, }; @@ -658,8 +1329,15 @@ static OptFunc* FindOptStep (const char* Name) void DisableOpt (const char* Name) /* Disable the optimization with the given name */ { - OptFunc* F = FindOptStep (Name); - F->Disabled = 1; + if (strcmp (Name, "any") == 0) { + unsigned I; + for (I = 0; I < sizeof(OptFuncs)/sizeof(OptFuncs[0]); ++I) { + OptFuncs[I].Disabled = 1; + } + } else { + OptFunc* F = FindOptStep (Name); + F->Disabled = 1; + } } @@ -667,8 +1345,15 @@ void DisableOpt (const char* Name) void EnableOpt (const char* Name) /* Enable the optimization with the given name */ { - OptFunc* F = FindOptStep (Name); - F->Disabled = 0; + if (strcmp (Name, "any") == 0) { + unsigned I; + for (I = 0; I < sizeof(OptFuncs)/sizeof(OptFuncs[0]); ++I) { + OptFuncs[I].Disabled = 0; + } + } else { + OptFunc* F = FindOptStep (Name); + F->Disabled = 0; + } }