/*****************************************************************************/
-/* 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 */
+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 */
/*****************************************************************************/
/* 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
}
/* 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;
/*****************************************************************************/
-/* nega optimizations */
+/* nega optimizations */
/*****************************************************************************/
/* 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;
/* 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;
/* 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;
/* 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;
/* 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;
/* 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 */
{ 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 },
};
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;
+ }
}
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;
+ }
}
projects / cc65 / blobdiff