Separated boolean optimizers from bitwise unary operator optimizers.
Renamed OptCmp6 to OptBoolCmp.
This commit is contained in:
acqn
660
src/cc65/coptbool.c
Normal file
660
src/cc65/coptbool.c
Normal file
@@ -0,0 +1,660 @@
|
||||
/*****************************************************************************/
|
||||
/* */
|
||||
/* coptbool.c */
|
||||
/* */
|
||||
/* Optimize boolean sequences */
|
||||
/* */
|
||||
/* */
|
||||
/* */
|
||||
/* (C) 2001-2012, Ullrich von Bassewitz */
|
||||
/* Roemerstrasse 52 */
|
||||
/* D-70794 Filderstadt */
|
||||
/* EMail: uz@cc65.org */
|
||||
/* */
|
||||
/* */
|
||||
/* This software is provided 'as-is', without any expressed or implied */
|
||||
/* warranty. In no event will the authors be held liable for any damages */
|
||||
/* arising from the use of this software. */
|
||||
/* */
|
||||
/* Permission is granted to anyone to use this software for any purpose, */
|
||||
/* including commercial applications, and to alter it and redistribute it */
|
||||
/* freely, subject to the following restrictions: */
|
||||
/* */
|
||||
/* 1. The origin of this software must not be misrepresented; you must not */
|
||||
/* claim that you wrote the original software. If you use this software */
|
||||
/* in a product, an acknowledgment in the product documentation would be */
|
||||
/* appreciated but is not required. */
|
||||
/* 2. Altered source versions must be plainly marked as such, and must not */
|
||||
/* be misrepresented as being the original software. */
|
||||
/* 3. This notice may not be removed or altered from any source */
|
||||
/* distribution. */
|
||||
/* */
|
||||
/*****************************************************************************/
|
||||
|
||||
|
||||
|
||||
/* cc65 */
|
||||
#include "codeent.h"
|
||||
#include "codeinfo.h"
|
||||
#include "error.h"
|
||||
#include "coptbool.h"
|
||||
|
||||
|
||||
|
||||
/*****************************************************************************/
|
||||
/* Data */
|
||||
/*****************************************************************************/
|
||||
|
||||
|
||||
|
||||
/* Table used to invert a condition, indexed by condition */
|
||||
static const unsigned char CmpInvertTab[] = {
|
||||
CMP_NE, CMP_EQ,
|
||||
CMP_LE, CMP_LT, CMP_GE, CMP_GT,
|
||||
CMP_ULE, CMP_ULT, CMP_UGE, CMP_UGT
|
||||
};
|
||||
|
||||
|
||||
|
||||
/*****************************************************************************/
|
||||
/* Helper functions */
|
||||
/*****************************************************************************/
|
||||
|
||||
|
||||
|
||||
static void ReplaceBranchCond (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);
|
||||
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*****************************************************************************/
|
||||
/* Optimize bool comparison and transformer subroutines */
|
||||
/*****************************************************************************/
|
||||
|
||||
|
||||
|
||||
unsigned OptBoolCmp (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 */
|
||||
ReplaceBranchCond (S, I+1, Cond);
|
||||
|
||||
/* Remember, we had changes */
|
||||
++Changes;
|
||||
|
||||
}
|
||||
|
||||
/* Next entry */
|
||||
++I;
|
||||
|
||||
}
|
||||
|
||||
/* Return the number of changes made */
|
||||
return Changes;
|
||||
}
|
||||
|
||||
|
||||
|
||||
unsigned OptBoolTrans (CodeSeg* S)
|
||||
/* Try to remove the call to boolean transformer routines where the call is
|
||||
** not really needed and change following branch condition accordingly.
|
||||
*/
|
||||
{
|
||||
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 a boolean transformer */
|
||||
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
|
||||
** are set after the compare directly. 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];
|
||||
}
|
||||
|
||||
/* Check if we can replace the code by something better */
|
||||
ReplaceBranchCond (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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*****************************************************************************/
|
||||
/* bnega optimizations */
|
||||
/*****************************************************************************/
|
||||
|
||||
|
||||
|
||||
unsigned OptBNegA1 (CodeSeg* S)
|
||||
/* Check for
|
||||
**
|
||||
** ldx #$00
|
||||
** lda ..
|
||||
** jsr bnega
|
||||
**
|
||||
** Remove the ldx if the lda does not use it.
|
||||
*/
|
||||
{
|
||||
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 a ldx */
|
||||
if (E->OPC == OP65_LDX &&
|
||||
E->AM == AM65_IMM &&
|
||||
CE_HasNumArg (E) &&
|
||||
E->Num == 0 &&
|
||||
CS_GetEntries (S, L, I+1, 2) &&
|
||||
L[0]->OPC == OP65_LDA &&
|
||||
(L[0]->Use & REG_X) == 0 &&
|
||||
!CE_HasLabel (L[0]) &&
|
||||
CE_IsCallTo (L[1], "bnega") &&
|
||||
!CE_HasLabel (L[1])) {
|
||||
|
||||
/* Remove the ldx instruction */
|
||||
CS_DelEntry (S, I);
|
||||
|
||||
/* Remember, we had changes */
|
||||
++Changes;
|
||||
|
||||
}
|
||||
|
||||
/* Next entry */
|
||||
++I;
|
||||
|
||||
}
|
||||
|
||||
/* Return the number of changes made */
|
||||
return Changes;
|
||||
}
|
||||
|
||||
|
||||
|
||||
unsigned OptBNegA2 (CodeSeg* S)
|
||||
/* Check for
|
||||
**
|
||||
** lda ..
|
||||
** jsr bnega
|
||||
** jeq/jne ..
|
||||
**
|
||||
** Adjust the conditional branch and remove the call to the subroutine.
|
||||
*/
|
||||
{
|
||||
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_ADC ||
|
||||
E->OPC == OP65_AND ||
|
||||
E->OPC == OP65_DEA ||
|
||||
E->OPC == OP65_EOR ||
|
||||
E->OPC == OP65_INA ||
|
||||
E->OPC == OP65_LDA ||
|
||||
E->OPC == OP65_ORA ||
|
||||
E->OPC == OP65_PLA ||
|
||||
E->OPC == OP65_SBC ||
|
||||
E->OPC == OP65_TXA ||
|
||||
E->OPC == OP65_TYA) &&
|
||||
CS_GetEntries (S, L, I+1, 2) &&
|
||||
CE_IsCallTo (L[0], "bnega") &&
|
||||
!CE_HasLabel (L[0]) &&
|
||||
(L[1]->Info & OF_ZBRA) != 0 &&
|
||||
!CE_HasLabel (L[1])) {
|
||||
|
||||
/* Invert the branch */
|
||||
CE_ReplaceOPC (L[1], GetInverseBranch (L[1]->OPC));
|
||||
|
||||
/* Delete the subroutine call */
|
||||
CS_DelEntry (S, I+1);
|
||||
|
||||
/* Remember, we had changes */
|
||||
++Changes;
|
||||
|
||||
}
|
||||
|
||||
/* Next entry */
|
||||
++I;
|
||||
|
||||
}
|
||||
|
||||
/* Return the number of changes made */
|
||||
return Changes;
|
||||
}
|
||||
|
||||
|
||||
|
||||
/*****************************************************************************/
|
||||
/* bnegax optimizations */
|
||||
/*****************************************************************************/
|
||||
|
||||
|
||||
|
||||
unsigned OptBNegAX1 (CodeSeg* S)
|
||||
/* On a call to bnegax, if X is zero, the result depends only on the value in
|
||||
** A, so change the call to a call to bnega. This will get further optimized
|
||||
** later if possible.
|
||||
*/
|
||||
{
|
||||
unsigned Changes = 0;
|
||||
unsigned I;
|
||||
|
||||
/* Walk over the entries */
|
||||
I = 0;
|
||||
while (I < CS_GetEntryCount (S)) {
|
||||
|
||||
/* Get next entry */
|
||||
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_IsCallTo (E, "bnegax")) {
|
||||
|
||||
CodeEntry* X = NewCodeEntry (OP65_JSR, AM65_ABS, "bnega", 0, E->LI);
|
||||
CS_InsertEntry (S, X, I+1);
|
||||
CS_DelEntry (S, I);
|
||||
|
||||
/* We had changes */
|
||||
++Changes;
|
||||
}
|
||||
|
||||
/* Next entry */
|
||||
++I;
|
||||
|
||||
}
|
||||
|
||||
/* Return the number of changes made */
|
||||
return Changes;
|
||||
}
|
||||
|
||||
|
||||
|
||||
unsigned OptBNegAX2 (CodeSeg* S)
|
||||
/* Search for the sequence:
|
||||
**
|
||||
** ldy #xx
|
||||
** jsr ldaxysp
|
||||
** jsr bnegax
|
||||
** jne/jeq ...
|
||||
**
|
||||
** and replace it by
|
||||
**
|
||||
** ldy #xx
|
||||
** lda (sp),y
|
||||
** dey
|
||||
** ora (sp),y
|
||||
** jeq/jne ...
|
||||
*/
|
||||
{
|
||||
unsigned Changes = 0;
|
||||
|
||||
/* Walk over the entries */
|
||||
unsigned I = 0;
|
||||
while (I < CS_GetEntryCount (S)) {
|
||||
|
||||
CodeEntry* L[4];
|
||||
|
||||
/* Get next entry */
|
||||
L[0] = CS_GetEntry (S, I);
|
||||
|
||||
/* Check for the sequence */
|
||||
if (L[0]->OPC == OP65_LDY &&
|
||||
CE_IsConstImm (L[0]) &&
|
||||
!CS_RangeHasLabel (S, I+1, 3) &&
|
||||
CS_GetEntries (S, L+1, I+1, 3) &&
|
||||
CE_IsCallTo (L[1], "ldaxysp") &&
|
||||
CE_IsCallTo (L[2], "bnegax") &&
|
||||
(L[3]->Info & OF_ZBRA) != 0) {
|
||||
|
||||
CodeEntry* X;
|
||||
|
||||
/* lda (sp),y */
|
||||
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "sp", 0, L[1]->LI);
|
||||
CS_InsertEntry (S, X, I+1);
|
||||
|
||||
/* dey */
|
||||
X = NewCodeEntry (OP65_DEY, AM65_IMP, 0, 0, L[1]->LI);
|
||||
CS_InsertEntry (S, X, I+2);
|
||||
|
||||
/* ora (sp),y */
|
||||
X = NewCodeEntry (OP65_ORA, AM65_ZP_INDY, "sp", 0, L[1]->LI);
|
||||
CS_InsertEntry (S, X, I+3);
|
||||
|
||||
/* Invert the branch */
|
||||
CE_ReplaceOPC (L[3], GetInverseBranch (L[3]->OPC));
|
||||
|
||||
/* Delete the entries no longer needed. */
|
||||
CS_DelEntries (S, I+4, 2);
|
||||
|
||||
/* Remember, we had changes */
|
||||
++Changes;
|
||||
|
||||
}
|
||||
|
||||
/* Next entry */
|
||||
++I;
|
||||
|
||||
}
|
||||
|
||||
/* Return the number of changes made */
|
||||
return Changes;
|
||||
}
|
||||
|
||||
|
||||
|
||||
unsigned OptBNegAX3 (CodeSeg* S)
|
||||
/* Search for the sequence:
|
||||
**
|
||||
** lda xx
|
||||
** ldx yy
|
||||
** jsr bnegax
|
||||
** jne/jeq ...
|
||||
**
|
||||
** and replace it by
|
||||
**
|
||||
** lda xx
|
||||
** ora xx+1
|
||||
** jeq/jne ...
|
||||
*/
|
||||
{
|
||||
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_LDA &&
|
||||
CS_GetEntries (S, L, I+1, 3) &&
|
||||
L[0]->OPC == OP65_LDX &&
|
||||
!CE_HasLabel (L[0]) &&
|
||||
CE_IsCallTo (L[1], "bnegax") &&
|
||||
!CE_HasLabel (L[1]) &&
|
||||
(L[2]->Info & OF_ZBRA) != 0 &&
|
||||
!CE_HasLabel (L[2])) {
|
||||
|
||||
/* ldx --> ora */
|
||||
CE_ReplaceOPC (L[0], OP65_ORA);
|
||||
|
||||
/* Invert the branch */
|
||||
CE_ReplaceOPC (L[2], GetInverseBranch (L[2]->OPC));
|
||||
|
||||
/* Delete the subroutine call */
|
||||
CS_DelEntry (S, I+2);
|
||||
|
||||
/* Remember, we had changes */
|
||||
++Changes;
|
||||
|
||||
}
|
||||
|
||||
/* Next entry */
|
||||
++I;
|
||||
|
||||
}
|
||||
|
||||
/* Return the number of changes made */
|
||||
return Changes;
|
||||
}
|
||||
|
||||
|
||||
|
||||
unsigned OptBNegAX4 (CodeSeg* S)
|
||||
/* Search for the sequence:
|
||||
**
|
||||
** jsr xxx
|
||||
** jsr bnega(x)
|
||||
** jeq/jne ...
|
||||
**
|
||||
** and replace it by:
|
||||
**
|
||||
** jsr xxx
|
||||
** <boolean test>
|
||||
** jne/jeq ...
|
||||
*/
|
||||
{
|
||||
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_JSR &&
|
||||
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 &&
|
||||
!CE_HasLabel (L[1])) {
|
||||
|
||||
CodeEntry* X;
|
||||
|
||||
/* Check if we're calling bnega or bnegax */
|
||||
int ByteSized = (strcmp (L[0]->Arg, "bnega") == 0);
|
||||
|
||||
/* Insert apropriate test code */
|
||||
if (ByteSized) {
|
||||
/* Test bytes */
|
||||
X = NewCodeEntry (OP65_TAX, AM65_IMP, 0, 0, L[0]->LI);
|
||||
CS_InsertEntry (S, X, I+2);
|
||||
} else {
|
||||
/* Test words */
|
||||
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 */
|
||||
CE_ReplaceOPC (L[1], GetInverseBranch (L[1]->OPC));
|
||||
|
||||
/* Remember, we had changes */
|
||||
++Changes;
|
||||
|
||||
}
|
||||
|
||||
/* Next entry */
|
||||
++I;
|
||||
|
||||
}
|
||||
|
||||
/* Return the number of changes made */
|
||||
return Changes;
|
||||
}
|
||||
Reference in New Issue
Block a user