-static unsigned OptAdd2 (CodeSeg* S)
-/* Search for the sequence
- *
- * ldy #xx
- * lda (sp),y
- * tax
- * dey
- * lda (sp),y
- * ldy #$yy
- * jsr addeqysp
- *
- * and replace it by:
- *
- * ldy #xx-1
- * lda (sp),y
- * ldy #yy
- * clc
- * adc (sp),y
- * sta (sp),y
- * ldy #xx
- * lda (sp),y
- * ldy #yy+1
- * adc (sp),y
- * sta (sp),y
- *
- * provided that a/x is not used later.
- */
-{
- unsigned Changes = 0;
-
- /* Walk over the entries */
- unsigned I = 0;
- while (I < CS_GetEntryCount (S)) {
-
- CodeEntry* L[7];
-
- /* Get next entry */
- L[0] = CS_GetEntry (S, I);
-
- /* Check for the sequence */
- if (L[0]->OPC == OP65_LDY &&
- CE_KnownImm (L[0]) &&
- CS_GetEntries (S, L+1, I+1, 6) &&
- L[1]->OPC == OP65_LDA &&
- L[1]->AM == AM65_ZP_INDY &&
- !CE_HasLabel (L[1]) &&
- L[2]->OPC == OP65_TAX &&
- !CE_HasLabel (L[2]) &&
- L[3]->OPC == OP65_DEY &&
- !CE_HasLabel (L[3]) &&
- L[4]->OPC == OP65_LDA &&
- L[4]->AM == AM65_ZP_INDY &&
- !CE_HasLabel (L[4]) &&
- L[5]->OPC == OP65_LDY &&
- CE_KnownImm (L[5]) &&
- !CE_HasLabel (L[5]) &&
- L[6]->OPC == OP65_JSR &&
- strcmp (L[6]->Arg, "addeqysp") == 0 &&
- !CE_HasLabel (L[6]) &&
- (GetRegInfo (S, I+7, REG_AX) & REG_AX) == 0) {
-
- char Buf [20];
- CodeEntry* X;
- int Offs;
-
-
- /* Create a replacement for the first LDY */
- Offs = (int) (L[0]->Num - 1);
- xsprintf (Buf, sizeof (Buf), "$%02X", Offs);
- X = NewCodeEntry (OP65_LDY, AM65_IMM, Buf, 0, L[0]->LI);
- CS_InsertEntry (S, X, I+1);
- CS_DelEntry (S, I);
-
- /* Load Y with the low offset of the target variable */
- X = NewCodeEntry (OP65_LDY, AM65_IMM, L[5]->Arg, 0, L[1]->LI);
- CS_InsertEntry (S, X, I+2);
-
- /* Add the CLC */
- X = NewCodeEntry (OP65_CLC, AM65_IMP, 0, 0, L[1]->LI);
- CS_InsertEntry (S, X, I+3);
-
- /* Remove the TAX/DEY sequence */
- CS_DelEntry (S, I+5); /* dey */
- CS_DelEntry (S, I+4); /* tax */
-
- /* Addition of the low byte */
- X = NewCodeEntry (OP65_ADC, AM65_ZP_INDY, "sp", 0, L[4]->LI);
- CS_InsertEntry (S, X, I+4);
- X = NewCodeEntry (OP65_STA, AM65_ZP_INDY, "sp", 0, L[4]->LI);
- CS_InsertEntry (S, X, I+5);
-
- /* LDY */
- xsprintf (Buf, sizeof (Buf), "$%02X", (Offs+1));
- X = NewCodeEntry (OP65_LDY, AM65_IMM, Buf, 0, L[4]->LI);
- CS_InsertEntry (S, X, I+6);
-
- /* Addition of the high byte */
- xsprintf (Buf, sizeof (Buf), "$%02X", (int)(L[5]->Num+1));
- X = NewCodeEntry (OP65_LDY, AM65_IMM, Buf, 0, L[5]->LI);
- CS_InsertEntry (S, X, I+8);
- X = NewCodeEntry (OP65_ADC, AM65_ZP_INDY, "sp", 0, L[6]->LI);
- CS_InsertEntry (S, X, I+9);
- X = NewCodeEntry (OP65_STA, AM65_ZP_INDY, "sp", 0, L[6]->LI);
- CS_InsertEntry (S, X, I+10);
-
- /* Delete the remaining stuff */
- CS_DelEntry (S, I+12);
- CS_DelEntry (S, I+11);
-
- /* Remember, we had changes */
- ++Changes;
-
- }
-
- /* Next entry */
- ++I;
-
- }
-
- /* Return the number of changes made */
- return Changes;
-}
-
-
-
-static unsigned OptAdd3 (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;
-}
-
-
-
-/*****************************************************************************/
-/* Optimize shifts */
-/*****************************************************************************/
-
-
-
-static unsigned OptShift1 (CodeSeg* S)
-/* A call to the shlaxN routine may get replaced by one or more asl insns
- * if the value of X is not used later.
- */
-{
- unsigned Changes = 0;
-
- /* Walk over the entries */
- unsigned I = 0;
- while (I < CS_GetEntryCount (S)) {
-
- /* Get next entry */
- CodeEntry* E = CS_GetEntry (S, I);
-
- /* Check for the sequence */
- if (E->OPC == OP65_JSR &&
- (strncmp (E->Arg, "shlax", 5) == 0 ||
- strncmp (E->Arg, "aslax", 5) == 0) &&
- strlen (E->Arg) == 6 &&
- IsDigit (E->Arg[5]) &&
- !RegXUsed (S, I+1)) {
-
- /* Insert shift insns */
- unsigned Count = E->Arg[5] - '0';
- while (Count--) {
- CodeEntry* X = NewCodeEntry (OP65_ASL, AM65_ACC, "a", 0, E->LI);
- CS_InsertEntry (S, X, I+1);
- }
-
- /* Delete the call to shlax */
- CS_DelEntry (S, I);
-
- /* 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
- * or
- * lda/and/ora/eor ...
- * cmp #$00
- * jsr boolxx
- *
- * 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_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) &&
- IsCmpToZero (L[0]) &&
- !CE_HasLabel (L[0]) &&
- ((L[1]->Info & OF_FBRA) != 0 ||
- (L[1]->OPC == OP65_JSR &&
- FindBoolCmpCond (L[1]->Arg) != CMP_INV)) &&
- !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;
-
- }
-
- /* Next entry */
- ++I;
-
- }
-
- /* Return the number of changes made */
- return Changes;
-}
-
-
-
-static unsigned OptCmp6 (CodeSeg* S)
-/* Search for a sequence ldx/txa/branch and remove the txa if A is not
- * used later.
- */
-{
- 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_LDX) &&
- CS_GetEntries (S, L, I+1, 2) &&
- L[0]->OPC == OP65_TXA &&
- !CE_HasLabel (L[0]) &&
- (L[1]->Info & OF_FBRA) != 0 &&
- !CE_HasLabel (L[1]) &&
- !RegAUsed (S, I+3)) {
-
- /* Remove the txa */
- CS_DelEntry (S, I+1);
-
- /* Remember, we had changes */
- ++Changes;
-
- }
-
- /* Next entry */
- ++I;
-
- }
-
- /* Return the number of changes made */
- return Changes;
-}
-
-
-
-static unsigned OptCmp7 (CodeSeg* S)
-/* Check for register compares where the contents of the register and therefore
- * the result of the compare is known.
- */
-{
- unsigned Changes = 0;
- unsigned I;
-
- /* Generate register info for this step */
- CS_GenRegInfo (S);
-
- /* Walk over the entries */
- I = 0;
- while (I < CS_GetEntryCount (S)) {
-
- int RegVal;
-
- /* Get next entry */
- CodeEntry* E = CS_GetEntry (S, I);
-
- /* Check for a compare against an immediate value */
- if ((E->Info & OF_CMP) != 0 &&
- (RegVal = GetCmpRegVal (E)) >= 0 &&
- CE_KnownImm (E)) {
-
- /* We are able to evaluate the compare at compile time. Check if
- * one or more branches are ahead.
- */
- unsigned JumpsChanged = 0;
- CodeEntry* N;
- while ((N = CS_GetNextEntry (S, I)) != 0 && /* Followed by something.. */
- (N->Info & OF_CBRA) != 0 && /* ..that is a cond branch.. */
- !CE_HasLabel (N)) { /* ..and has no label */
-
- /* Evaluate the branch condition */
- int Cond;
- switch (GetBranchCond (N->OPC)) {
- case BC_CC:
- Cond = ((unsigned char)RegVal) < ((unsigned char)E->Num);
- break;
-
- case BC_CS:
- Cond = ((unsigned char)RegVal) >= ((unsigned char)E->Num);
- break;
-
- case BC_EQ:
- Cond = ((unsigned char)RegVal) == ((unsigned char)E->Num);
- break;
-
- case BC_MI:
- Cond = ((signed char)RegVal) < ((signed char)E->Num);
- break;
-
- case BC_NE:
- Cond = ((unsigned char)RegVal) != ((unsigned char)E->Num);
- break;
-
- case BC_PL:
- Cond = ((signed char)RegVal) >= ((signed char)E->Num);
- break;
-
- case BC_VC:
- case BC_VS:
- }
-
- /* If the condition is false, we may remove the jump. Otherwise
- * the branch will always be taken, so we may replace it by a
- * jump (and bail out).
- */
- if (!Cond) {
- CS_DelEntry (S, I+1);
- } else {
- CodeLabel* L = N->JumpTo;
- CodeEntry* X = NewCodeEntry (OP65_JMP, AM65_BRA, L->Name, L, N->LI);
- CS_InsertEntry (S, X, I+2);
- CS_DelEntry (S, I+1);
- }
-
- /* Remember, we had changes */
- ++JumpsChanged;
- ++Changes;
- }
-
- /* If we have made changes above, we may also remove the compare */
- if (JumpsChanged) {
- CS_DelEntry (S, I);
- }
-
- }
-
- /* Next entry */
- ++I;
-
- }
-
- /* Free register info */
- CS_FreeRegInfo (S);
-
- /* Return the number of changes made */
- return Changes;
-}
-
-
-
-/*****************************************************************************/
-/* Optimize tests */
-/*****************************************************************************/
-
-
-
-static unsigned OptTest1 (CodeSeg* S)
-/* On a sequence
- *
- * stx xxx
- * ora xxx
- * beq/bne ...
- *
- * if X is zero, the sequence may be changed to
- *
- * cmp #$00
- * beq/bne ...
- *
- * which may be optimized further by another step.
- *
- * If A is zero, the sequence may be changed to
- *
- * txa
- * beq/bne ...
- *
- */
-{
- unsigned Changes = 0;
- unsigned I;
-
- /* Generate register info for this step */
- CS_GenRegInfo (S);
-
- /* Walk over the entries */
- I = 0;
- while (I < CS_GetEntryCount (S)) {
-
- CodeEntry* L[3];
-
- /* Get next entry */
- L[0] = CS_GetEntry (S, I);
-
- /* Check if it's the sequence we're searching for */
- if (L[0]->OPC == OP65_STX &&
- CS_GetEntries (S, L+1, I+1, 2) &&
- !CE_HasLabel (L[1]) &&
- L[1]->OPC == OP65_ORA &&
- strcmp (L[0]->Arg, L[1]->Arg) == 0 &&
- !CE_HasLabel (L[2]) &&
- (L[2]->Info & OF_ZBRA) != 0) {
-
- /* Check if X is zero */
- if (L[0]->RI->In.RegX == 0) {
-
- /* Insert the compare */
- CodeEntry* N = NewCodeEntry (OP65_CMP, AM65_IMM, "$00", 0, L[0]->LI);
- CS_InsertEntry (S, N, I+2);
-
- /* Remove the two other insns */
- CS_DelEntry (S, I+1);
- CS_DelEntry (S, I);
-
- /* We had changes */
- ++Changes;
-
- /* Check if A is zero */
- } else if (L[1]->RI->In.RegA == 0) {
-
- /* Insert the txa */
- CodeEntry* N = NewCodeEntry (OP65_TXA, AM65_IMP, 0, 0, L[1]->LI);
- CS_InsertEntry (S, N, I+2);
-
- /* Remove the two other insns */
- CS_DelEntry (S, I+1);
- CS_DelEntry (S, I);
-
- /* We had changes */
- ++Changes;
- }
- }
-
- /* Next entry */
- ++I;
-
- }
-
- /* Free register info */
- CS_FreeRegInfo (S);
-
- /* Return the number of changes made */
- return Changes;
-}
-
-
-
-/*****************************************************************************/
-/* nega optimizations */
-/*****************************************************************************/
-
-
-
-static unsigned OptNegA1 (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 &&
- (E->Flags & CEF_NUMARG) != 0 &&
- 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]) &&
- L[1]->OPC == OP65_JSR &&
- strcmp (L[1]->Arg, "bnega") == 0 &&
- !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;
-}
-
-
-
-static unsigned OptNegA2 (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) &&
- L[0]->OPC == OP65_JSR &&
- strcmp (L[0]->Arg, "bnega") == 0 &&
- !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;
-}
-
-
-
-/*****************************************************************************/
-/* negax optimizations */
-/*****************************************************************************/
-
-
-
-static unsigned OptNegAX1 (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;
-
- /* Generate register info for this step */
- CS_GenRegInfo (S);
-
- /* 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->OPC == OP65_JSR &&
- E->RI->In.RegX == 0 &&
- strcmp (E->Arg, "bnegax") == 0) {
-
- /* We're cheating somewhat here ... */
- E->Arg[5] = '\0';
- E->Use &= ~REG_X;
-
- /* We had changes */
- ++Changes;
- }
-
- /* Next entry */
- ++I;
-
- }
-
- /* Free register info */
- CS_FreeRegInfo (S);
-
- /* Return the number of changes made */
- return Changes;
-}
-
-
-
-static unsigned OptNegAX2 (CodeSeg* S)
-/* Search for the sequence:
- *
- * lda (xx),y
- * tax
- * dey
- * lda (xx),y
- * jsr bnegax
- * jne/jeq ...
- *
- * and replace it by
- *
- * lda (xx),y
- * dey
- * ora (xx),y
- * jeq/jne ...