mirror of https://github.com/cc65/cc65.git
943 lines
26 KiB
C
943 lines
26 KiB
C
/*****************************************************************************/
|
|
/* */
|
|
/* 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 with branches */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
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 &&
|
|
(GetRegInfo (S, I + 2, PSTATE_Z) & PSTATE_Z) == 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;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptBoolUnary (CodeSeg* S)
|
|
/* Try to remove the call to a bcastax/bnegax 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;
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* Remove calls to the boolean cast/negation subroutines */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
unsigned OptBoolUnary1 (CodeSeg* S)
|
|
/* Search for and remove cmp #0/bcastax/boolne following a bcastax/bnegax.
|
|
** Or search for and remove cmp #1/bnegax/booleq following a bcastax/bnegax
|
|
** and invert the bcastax/bnegax.
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
int Neg = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[2];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence.
|
|
** We allow the first entry to have labels.
|
|
*/
|
|
if (L[0]->OPC == OP65_JSR &&
|
|
(L[1] = CS_GetNextEntry (S, I)) != 0 &&
|
|
!CE_HasLabel (L[1])) {
|
|
if (strcmp (L[0]->Arg, "bnegax") == 0) {
|
|
Neg = 1;
|
|
} else if (strcmp (L[0]->Arg, "bcastax") == 0) {
|
|
Neg = 0;
|
|
} else {
|
|
/* Next entry */
|
|
++I;
|
|
continue;
|
|
}
|
|
if ((L[1]->OPC == OP65_CMP && CE_IsKnownImm (L[1], 0x0)) ||
|
|
CE_IsCallTo (L[1], "boolne") ||
|
|
CE_IsCallTo (L[1], "bcastax")) {
|
|
/* Delete the entry no longer needed. */
|
|
CS_DelEntry (S, I + 1);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
/* We are still at this index */
|
|
continue;
|
|
|
|
} else if ((L[1]->OPC == OP65_CMP && CE_IsKnownImm (L[1], 0x1)) ||
|
|
CE_IsCallTo (L[1], "booleq") ||
|
|
CE_IsCallTo (L[1], "bnegax")) {
|
|
/* Invert the previous bool conversion */
|
|
CE_SetArg (L[0], Neg ? "bcastax" : "bnegax");
|
|
|
|
/* Delete the entry no longer needed */
|
|
CS_DelEntry (S, I + 1);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
/* We are still at this index */
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptBoolUnary2 (CodeSeg* S)
|
|
/* Search for and remove cmp #0/bcastax/boolne following a boolean transformer.
|
|
** Or search for and remove cmp #1/bnegax/booleq following a boolean transformer
|
|
** and invert the boolean transformer.
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
cmp_t Cond;
|
|
char Buf[16];
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[2];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence.
|
|
** We allow the first entry to have labels.
|
|
*/
|
|
if (L[0]->OPC == OP65_JSR &&
|
|
(L[1] = CS_GetNextEntry (S, I)) != 0 &&
|
|
!CE_HasLabel (L[1]) &&
|
|
(Cond = FindBoolCmpCond (L[0]->Arg)) != CMP_INV) {
|
|
if ((L[1]->OPC == OP65_CMP && CE_IsKnownImm (L[1], 0x0)) ||
|
|
CE_IsCallTo (L[1], "boolne") ||
|
|
CE_IsCallTo (L[1], "bcastax")) {
|
|
/* Delete the entry no longer needed */
|
|
CS_DelEntry (S, I + 1);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
/* We are still at this index */
|
|
continue;
|
|
|
|
} else if ((L[1]->OPC == OP65_CMP && CE_IsKnownImm (L[1], 0x1)) ||
|
|
CE_IsCallTo (L[1], "booleq") ||
|
|
CE_IsCallTo (L[1], "bnegax")) {
|
|
/* Invert the bool conversion */
|
|
if (GetBoolCmpSuffix (Buf, GetNegatedCond (Cond)) == 0) {
|
|
Internal ("No inverted boolean transformer for: %s", L[0]->Arg);
|
|
}
|
|
CE_SetArg (L[0], Buf);
|
|
|
|
/* Delete the entry no longer needed */
|
|
CS_DelEntry (S, I + 1);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
/* We are still at this index */
|
|
continue;
|
|
}
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptBoolUnary3 (CodeSeg* S)
|
|
/* If A == 0, replace bcastax/bnegax with
|
|
**
|
|
** cpx #0
|
|
** jsr boolne/booleq
|
|
**
|
|
** Or if X == 0, replace bcastax/bnegax with
|
|
**
|
|
** cmp #0
|
|
** jsr boolne/booleq
|
|
**
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
opc_t Op = OP65_COUNT;
|
|
const char* Sub = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* E;
|
|
CodeEntry* X;
|
|
|
|
/* Get next entry */
|
|
E = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (!CE_HasLabel (E)) {
|
|
/* Choose the right subroutine */
|
|
if (CE_IsCallTo (E, "bnegax")) {
|
|
Sub = "booleq";
|
|
} else if (CE_IsCallTo (E, "bcastax")) {
|
|
Sub = "boolne";
|
|
}
|
|
/* Choose the right opcode */
|
|
if (RegValIsKnown (E->RI->In.RegA) && E->RI->In.RegA == 0) {
|
|
Op = OP65_CPX;
|
|
} else if (RegValIsKnown (E->RI->In.RegX) && E->RI->In.RegX == 0) {
|
|
Op = OP65_CMP;
|
|
}
|
|
/* Replace the sequence if all requirements are met*/
|
|
if (Op != OP65_COUNT && Sub != 0) {
|
|
/* Replace bcastax/bnegax with boolne/booleq */
|
|
CE_SetArg (E, Sub);
|
|
|
|
/* Insert the compare */
|
|
X = NewCodeEntry (Op, AM65_IMM, "$00", 0, E->LI);
|
|
CS_InsertEntry (S, X, I);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
/* Correct the index */
|
|
++I;
|
|
}
|
|
|
|
/* Reset the choices */
|
|
Op = OP65_COUNT;
|
|
Sub = 0;
|
|
}
|
|
|
|
/* 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]) &&
|
|
(GetRegInfo (S, I + 3, PSTATE_Z) & PSTATE_Z) == 0) {
|
|
|
|
/* 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 &&
|
|
(GetRegInfo (S, I + 4, PSTATE_Z) & PSTATE_Z) == 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]) &&
|
|
(GetRegInfo (S, I + 4, PSTATE_Z) & PSTATE_Z) == 0) {
|
|
|
|
/* 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]) &&
|
|
(GetRegInfo (S, I + 3, PSTATE_Z) & PSTATE_Z) == 0) {
|
|
|
|
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;
|
|
}
|