mirror of https://github.com/cc65/cc65.git
1674 lines
50 KiB
C
1674 lines
50 KiB
C
/*****************************************************************************/
|
|
/* */
|
|
/* coptptrload.c */
|
|
/* */
|
|
/* Optimize loads through pointers */
|
|
/* */
|
|
/* */
|
|
/* */
|
|
/* (C) 2001-2009 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. */
|
|
/* */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
#include <string.h>
|
|
|
|
/* common */
|
|
#include "xmalloc.h"
|
|
|
|
/* cc65 */
|
|
#include "codeent.h"
|
|
#include "codeinfo.h"
|
|
#include "coptptrload.h"
|
|
|
|
|
|
|
|
/*****************************************************************************/
|
|
/* Code */
|
|
/*****************************************************************************/
|
|
|
|
|
|
|
|
unsigned OptPtrLoad1 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** clc
|
|
** adc xxx
|
|
** tay
|
|
** txa
|
|
** adc yyy
|
|
** tax
|
|
** tya
|
|
** ldy #$00
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** sta ptr1
|
|
** txa
|
|
** clc
|
|
** adc yyy
|
|
** sta ptr1+1
|
|
** ldy xxx
|
|
** ldx #$00
|
|
** lda (ptr1),y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[9];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_CLC &&
|
|
CS_GetEntries (S, L+1, I+1, 8) &&
|
|
L[1]->OPC == OP65_ADC &&
|
|
(L[1]->AM == AM65_ABS ||
|
|
L[1]->AM == AM65_ZP ||
|
|
L[1]->AM == AM65_IMM) &&
|
|
L[2]->OPC == OP65_TAY &&
|
|
L[3]->OPC == OP65_TXA &&
|
|
L[4]->OPC == OP65_ADC &&
|
|
L[5]->OPC == OP65_TAX &&
|
|
L[6]->OPC == OP65_TYA &&
|
|
L[7]->OPC == OP65_LDY &&
|
|
CE_IsKnownImm (L[7], 0) &&
|
|
CE_IsCallTo (L[8], "ldauidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 8)) {
|
|
|
|
CodeEntry* X;
|
|
CodeEntry* P;
|
|
|
|
/* Track the insertion point */
|
|
unsigned IP = I+9;
|
|
|
|
/* sta ptr1 */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1", 0, L[2]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* If the instruction before the clc is a ldx, replace the
|
|
** txa by an lda with the same location of the ldx. Otherwise
|
|
** transfer the value in X to A.
|
|
*/
|
|
if ((P = CS_GetPrevEntry (S, I)) != 0 &&
|
|
P->OPC == OP65_LDX &&
|
|
!CE_HasLabel (P)) {
|
|
X = NewCodeEntry (OP65_LDA, P->AM, P->Arg, 0, P->LI);
|
|
} else {
|
|
X = NewCodeEntry (OP65_TXA, AM65_IMP, 0, 0, L[3]->LI);
|
|
}
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* clc */
|
|
X = NewCodeEntry (OP65_CLC, AM65_IMP, 0, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* adc yyy */
|
|
X = NewCodeEntry (OP65_ADC, L[4]->AM, L[4]->Arg, 0, L[4]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* sta ptr1+1 */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1+1", 0, L[5]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* ldy xxx */
|
|
X = NewCodeEntry (OP65_LDY, L[1]->AM, L[1]->Arg, 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* ldx #$00 */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[8]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* lda (ptr1),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[8]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* Remove the old instructions */
|
|
CS_DelEntries (S, I, 9);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad2 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** adc xxx
|
|
** pha
|
|
** txa
|
|
** iny
|
|
** adc yyy
|
|
** tax
|
|
** pla
|
|
** ldy
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** adc xxx
|
|
** sta ptr1
|
|
** txa
|
|
** iny
|
|
** adc yyy
|
|
** sta ptr1+1
|
|
** ldy
|
|
** ldx #$00
|
|
** lda (ptr1),y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[9];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_ADC &&
|
|
CS_GetEntries (S, L+1, I+1, 8) &&
|
|
L[1]->OPC == OP65_PHA &&
|
|
L[2]->OPC == OP65_TXA &&
|
|
L[3]->OPC == OP65_INY &&
|
|
L[4]->OPC == OP65_ADC &&
|
|
L[5]->OPC == OP65_TAX &&
|
|
L[6]->OPC == OP65_PLA &&
|
|
L[7]->OPC == OP65_LDY &&
|
|
CE_IsCallTo (L[8], "ldauidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 8)) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* Store the low byte and remove the PHA instead */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+1);
|
|
|
|
/* Store the high byte */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1+1", 0, L[4]->LI);
|
|
CS_InsertEntry (S, X, I+6);
|
|
|
|
/* Load high and low byte */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[6]->LI);
|
|
CS_InsertEntry (S, X, I+10);
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[6]->LI);
|
|
CS_InsertEntry (S, X, I+11);
|
|
|
|
/* Delete the old code */
|
|
CS_DelEntry (S, I+12); /* jsr ldauidx */
|
|
CS_DelEntry (S, I+8); /* pla */
|
|
CS_DelEntry (S, I+7); /* tax */
|
|
CS_DelEntry (S, I+2); /* pha */
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad3 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** lda #<(label+0)
|
|
** ldx #>(label+0)
|
|
** clc
|
|
** adc xxx
|
|
** bcc L
|
|
** inx
|
|
** L: ldy #$00
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** ldy xxx
|
|
** ldx #$00
|
|
** lda label,y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[8];
|
|
unsigned Len;
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_LDA &&
|
|
L[0]->AM == AM65_IMM &&
|
|
CS_GetEntries (S, L+1, I+1, 7) &&
|
|
L[1]->OPC == OP65_LDX &&
|
|
L[1]->AM == AM65_IMM &&
|
|
L[2]->OPC == OP65_CLC &&
|
|
L[3]->OPC == OP65_ADC &&
|
|
(L[3]->AM == AM65_ABS || L[3]->AM == AM65_ZP) &&
|
|
(L[4]->OPC == OP65_BCC || L[4]->OPC == OP65_JCC) &&
|
|
L[4]->JumpTo != 0 &&
|
|
L[4]->JumpTo->Owner == L[6] &&
|
|
L[5]->OPC == OP65_INX &&
|
|
L[6]->OPC == OP65_LDY &&
|
|
CE_IsKnownImm (L[6], 0) &&
|
|
CE_IsCallTo (L[7], "ldauidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 5) &&
|
|
!CE_HasLabel (L[7]) &&
|
|
/* Check the label last because this is quite costly */
|
|
(Len = strlen (L[0]->Arg)) > 3 &&
|
|
L[0]->Arg[0] == '<' &&
|
|
L[0]->Arg[1] == '(' &&
|
|
strlen (L[1]->Arg) == Len &&
|
|
L[1]->Arg[0] == '>' &&
|
|
memcmp (L[0]->Arg+1, L[1]->Arg+1, Len-1) == 0) {
|
|
|
|
CodeEntry* X;
|
|
char* Label;
|
|
|
|
/* We will create all the new stuff behind the current one so
|
|
** we keep the line references.
|
|
*/
|
|
X = NewCodeEntry (OP65_LDY, L[3]->AM, L[3]->Arg, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+8);
|
|
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+9);
|
|
|
|
Label = memcpy (xmalloc (Len-2), L[0]->Arg+2, Len-3);
|
|
Label[Len-3] = '\0';
|
|
X = NewCodeEntry (OP65_LDA, AM65_ABSY, Label, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+10);
|
|
xfree (Label);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntries (S, I, 8);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad4 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** lda #<(label+0)
|
|
** ldx #>(label+0)
|
|
** ldy #$xx
|
|
** clc
|
|
** adc (sp),y
|
|
** bcc L
|
|
** inx
|
|
** L: ldy #$00
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** ldy #$xx
|
|
** lda (sp),y
|
|
** tay
|
|
** ldx #$00
|
|
** lda label,y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[9];
|
|
unsigned Len;
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_LDA &&
|
|
L[0]->AM == AM65_IMM &&
|
|
CS_GetEntries (S, L+1, I+1, 8) &&
|
|
L[1]->OPC == OP65_LDX &&
|
|
L[1]->AM == AM65_IMM &&
|
|
!CE_HasLabel (L[1]) &&
|
|
L[2]->OPC == OP65_LDY &&
|
|
CE_IsConstImm (L[2]) &&
|
|
!CE_HasLabel (L[2]) &&
|
|
L[3]->OPC == OP65_CLC &&
|
|
!CE_HasLabel (L[3]) &&
|
|
L[4]->OPC == OP65_ADC &&
|
|
L[4]->AM == AM65_ZP_INDY &&
|
|
!CE_HasLabel (L[4]) &&
|
|
(L[5]->OPC == OP65_BCC || L[5]->OPC == OP65_JCC) &&
|
|
L[5]->JumpTo != 0 &&
|
|
L[5]->JumpTo->Owner == L[7] &&
|
|
!CE_HasLabel (L[5]) &&
|
|
L[6]->OPC == OP65_INX &&
|
|
!CE_HasLabel (L[6]) &&
|
|
L[7]->OPC == OP65_LDY &&
|
|
CE_IsKnownImm (L[7], 0) &&
|
|
CE_IsCallTo (L[8], "ldauidx") &&
|
|
!CE_HasLabel (L[8]) &&
|
|
/* Check the label last because this is quite costly */
|
|
(Len = strlen (L[0]->Arg)) > 3 &&
|
|
L[0]->Arg[0] == '<' &&
|
|
L[0]->Arg[1] == '(' &&
|
|
strlen (L[1]->Arg) == Len &&
|
|
L[1]->Arg[0] == '>' &&
|
|
memcmp (L[0]->Arg+1, L[1]->Arg+1, Len-1) == 0) {
|
|
|
|
CodeEntry* X;
|
|
char* Label;
|
|
|
|
/* Add the lda */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, L[4]->Arg, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+3);
|
|
|
|
/* Add the tay */
|
|
X = NewCodeEntry (OP65_TAY, AM65_IMP, 0, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+4);
|
|
|
|
/* Add the ldx */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+5);
|
|
|
|
/* Add the lda */
|
|
Label = memcpy (xmalloc (Len-2), L[0]->Arg+2, Len-3);
|
|
Label[Len-3] = '\0';
|
|
X = NewCodeEntry (OP65_LDA, AM65_ABSY, Label, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+6);
|
|
xfree (Label);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntries (S, I, 2);
|
|
CS_DelEntries (S, I+5, 6);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad5 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** jsr pushax
|
|
** ldx #$00
|
|
** lda yyy
|
|
** jsr tosaddax
|
|
** ldy #$00
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** sta ptr1
|
|
** stx ptr1+1
|
|
** ldy yyy
|
|
** ldx #$00
|
|
** lda (ptr1),y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[6];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (CE_IsCallTo (L[0], "pushax") &&
|
|
CS_GetEntries (S, L+1, I+1, 5) &&
|
|
L[1]->OPC == OP65_LDX &&
|
|
CE_IsKnownImm (L[1], 0) &&
|
|
L[2]->OPC == OP65_LDA &&
|
|
(L[2]->AM == AM65_ABS ||
|
|
L[2]->AM == AM65_ZP ||
|
|
L[2]->AM == AM65_IMM) &&
|
|
CE_IsCallTo (L[3], "tosaddax") &&
|
|
L[4]->OPC == OP65_LDY &&
|
|
CE_IsKnownImm (L[4], 0) &&
|
|
CE_IsCallTo (L[5], "ldauidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 5)) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* sta ptr1 */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+6);
|
|
|
|
/* stx ptr1+1 */
|
|
X = NewCodeEntry (OP65_STX, AM65_ZP, "ptr1+1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+7);
|
|
|
|
/* ldy yyy */
|
|
X = NewCodeEntry (OP65_LDY, L[2]->AM, L[2]->Arg, 0, L[2]->LI);
|
|
CS_InsertEntry (S, X, I+8);
|
|
|
|
/* ldx #$00 */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[5]->LI);
|
|
CS_InsertEntry (S, X, I+9);
|
|
|
|
/* lda (ptr1),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[5]->LI);
|
|
CS_InsertEntry (S, X, I+10);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntries (S, I, 6);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad6 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** jsr pushax
|
|
** ldy #xxx
|
|
** ldx #$00
|
|
** lda (sp),y
|
|
** jsr tosaddax
|
|
** ldy #$00
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** sta ptr1
|
|
** stx ptr1+1
|
|
** ldy #xxx-2
|
|
** lda (sp),y
|
|
** tay
|
|
** ldx #$00
|
|
** lda (ptr1),y
|
|
*/
|
|
{
|
|
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 (CE_IsCallTo (L[0], "pushax") &&
|
|
CS_GetEntries (S, L+1, I+1, 6) &&
|
|
L[1]->OPC == OP65_LDY &&
|
|
CE_IsConstImm (L[1]) &&
|
|
L[1]->Num >= 2 &&
|
|
L[2]->OPC == OP65_LDX &&
|
|
CE_IsKnownImm (L[2], 0) &&
|
|
L[3]->OPC == OP65_LDA &&
|
|
L[3]->AM == AM65_ZP_INDY &&
|
|
CE_IsCallTo (L[4], "tosaddax") &&
|
|
L[5]->OPC == OP65_LDY &&
|
|
CE_IsKnownImm (L[5], 0) &&
|
|
CE_IsCallTo (L[6], "ldauidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 6) &&
|
|
!RegYUsed (S, I+7)) {
|
|
|
|
CodeEntry* X;
|
|
const char* Arg;
|
|
|
|
/* sta ptr1 */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+7);
|
|
|
|
/* stx ptr1+1 */
|
|
X = NewCodeEntry (OP65_STX, AM65_ZP, "ptr1+1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+8);
|
|
|
|
/* ldy #xxx-2 */
|
|
Arg = MakeHexArg (L[1]->Num - 2);
|
|
X = NewCodeEntry (OP65_LDY, AM65_IMM, Arg, 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+9);
|
|
|
|
/* lda (sp),y */
|
|
X = NewCodeEntry (OP65_LDA, L[3]->AM, L[3]->Arg, 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+10);
|
|
|
|
/* tay */
|
|
X = NewCodeEntry (OP65_TAY, AM65_IMP, 0, 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+11);
|
|
|
|
/* ldx #$00 */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[5]->LI);
|
|
CS_InsertEntry (S, X, I+12);
|
|
|
|
/* lda (ptr1),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[6]->LI);
|
|
CS_InsertEntry (S, X, I+13);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntries (S, I, 7);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad7 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** jsr aslax1/shlax1
|
|
** clc
|
|
** adc xxx
|
|
** tay
|
|
** txa
|
|
** adc yyy
|
|
** tax
|
|
** tya
|
|
** ldy zzz
|
|
** jsr ldaxidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** stx tmp1
|
|
** asl a
|
|
** rol tmp1
|
|
** clc
|
|
** adc xxx
|
|
** sta ptr1
|
|
** lda tmp1
|
|
** adc yyy
|
|
** sta ptr1+1
|
|
** ldy zzz
|
|
** lda (ptr1),y
|
|
** tax
|
|
** dey
|
|
** lda (ptr1),y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
unsigned I;
|
|
|
|
/* Walk over the entries */
|
|
I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[10];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_JSR &&
|
|
(strcmp (L[0]->Arg, "aslax1") == 0 ||
|
|
strcmp (L[0]->Arg, "shlax1") == 0) &&
|
|
CS_GetEntries (S, L+1, I+1, 9) &&
|
|
L[1]->OPC == OP65_CLC &&
|
|
L[2]->OPC == OP65_ADC &&
|
|
L[3]->OPC == OP65_TAY &&
|
|
L[4]->OPC == OP65_TXA &&
|
|
L[5]->OPC == OP65_ADC &&
|
|
L[6]->OPC == OP65_TAX &&
|
|
L[7]->OPC == OP65_TYA &&
|
|
L[8]->OPC == OP65_LDY &&
|
|
CE_IsCallTo (L[9], "ldaxidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 9)) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* Track the insertion point */
|
|
unsigned IP = I + 10;
|
|
|
|
|
|
/* If X is zero on entry to aslax1, we can generate:
|
|
**
|
|
** asl a
|
|
** bcc L1
|
|
** inx
|
|
** L1: clc
|
|
**
|
|
** instead of the code above. "lda tmp1" needs to be changed
|
|
** to "txa" in this case.
|
|
*/
|
|
int ShortCode = (L[0]->RI->In.RegX == 0);
|
|
|
|
if (ShortCode) {
|
|
|
|
CodeLabel* Lab;
|
|
|
|
/* asl a */
|
|
X = NewCodeEntry (OP65_ASL, AM65_ACC, "a", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* Generate clc first, since we need the label */
|
|
X = NewCodeEntry (OP65_CLC, AM65_IMP, 0, 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, IP);
|
|
|
|
/* Get the label */
|
|
Lab = CS_GenLabel (S, X);
|
|
|
|
/* bcc Lab */
|
|
X = NewCodeEntry (OP65_BCC, AM65_BRA, Lab->Name, Lab, L[0]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* inx */
|
|
X = NewCodeEntry (OP65_INX, AM65_IMP, 0, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* Skip the clc insn */
|
|
++IP;
|
|
|
|
} else {
|
|
|
|
/* stx tmp1 */
|
|
X = NewCodeEntry (OP65_STX, AM65_ZP, "tmp1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* asl a */
|
|
X = NewCodeEntry (OP65_ASL, AM65_ACC, "a", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* rol tmp1 */
|
|
X = NewCodeEntry (OP65_ROL, AM65_ZP, "tmp1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* clc */
|
|
X = NewCodeEntry (OP65_CLC, AM65_IMP, 0, 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
}
|
|
|
|
/* adc xxx */
|
|
X = NewCodeEntry (L[2]->OPC, L[2]->AM, L[2]->Arg, 0, L[2]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* sta ptr1 */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1", 0, L[9]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
if (ShortCode) {
|
|
/* txa */
|
|
X = NewCodeEntry (OP65_TXA, AM65_IMP, 0, 0, L[4]->LI);
|
|
} else {
|
|
/* lda tmp1 */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP, "tmp1", 0, L[4]->LI);
|
|
}
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* adc xxx */
|
|
X = NewCodeEntry (L[5]->OPC, L[5]->AM, L[5]->Arg, 0, L[5]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* sta ptr1+1 */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1+1", 0, L[9]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* ldy zzz */
|
|
X = NewCodeEntry (L[8]->OPC, L[8]->AM, L[8]->Arg, 0, L[8]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* lda (ptr1),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[9]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* tax */
|
|
X = NewCodeEntry (OP65_TAX, AM65_IMP, 0, 0, L[9]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* dey */
|
|
X = NewCodeEntry (OP65_DEY, AM65_IMP, 0, 0, L[9]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* lda (ptr1),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[9]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntries (S, I, 10);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad11 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** clc
|
|
** adc xxx
|
|
** bcc L
|
|
** inx
|
|
** L: ldy #$00
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** ldy xxx
|
|
** sta ptr1
|
|
** stx ptr1+1
|
|
** ldx #$00
|
|
** lda (ptr1),y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[6];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_CLC &&
|
|
CS_GetEntries (S, L+1, I+1, 5) &&
|
|
L[1]->OPC == OP65_ADC &&
|
|
(L[1]->AM == AM65_ABS || L[1]->AM == AM65_ZP || L[1]->AM == AM65_IMM) &&
|
|
(L[2]->OPC == OP65_BCC || L[2]->OPC == OP65_JCC) &&
|
|
L[2]->JumpTo != 0 &&
|
|
L[2]->JumpTo->Owner == L[4] &&
|
|
L[3]->OPC == OP65_INX &&
|
|
L[4]->OPC == OP65_LDY &&
|
|
CE_IsKnownImm (L[4], 0) &&
|
|
CE_IsCallTo (L[5], "ldauidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 3) &&
|
|
!CE_HasLabel (L[5])) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* We will create all the new stuff behind the current one so
|
|
** we keep the line references.
|
|
*/
|
|
X = NewCodeEntry (OP65_LDY, L[1]->AM, L[1]->Arg, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+6);
|
|
|
|
/* sta ptr1 */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+7);
|
|
|
|
/* stx ptr1+1 */
|
|
X = NewCodeEntry (OP65_STX, AM65_ZP, "ptr1+1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+8);
|
|
|
|
/* ldx #$00 */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+9);
|
|
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+10);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntries (S, I, 6);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad12 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** lda regbank+n
|
|
** ldx regbank+n+1
|
|
** sta regsave
|
|
** stx regsave+1
|
|
** clc
|
|
** adc #$01
|
|
** bcc L0005
|
|
** inx
|
|
** L: sta regbank+n
|
|
** stx regbank+n+1
|
|
** lda regsave
|
|
** ldx regsave+1
|
|
** ldy #$00
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** ldy #$00
|
|
** ldx #$00
|
|
** lda (regbank+n),y
|
|
** inc regbank+n
|
|
** bne L1
|
|
** inc regbank+n+1
|
|
** L1: tay <- only if flags are used
|
|
**
|
|
** This function must execute before OptPtrLoad7!
|
|
**
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[15];
|
|
unsigned Len;
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_LDA &&
|
|
L[0]->AM == AM65_ZP &&
|
|
strncmp (L[0]->Arg, "regbank+", 8) == 0 &&
|
|
(Len = strlen (L[0]->Arg)) > 0 &&
|
|
CS_GetEntries (S, L+1, I+1, 14) &&
|
|
!CS_RangeHasLabel (S, I+1, 7) &&
|
|
!CS_RangeHasLabel (S, I+9, 5) &&
|
|
L[1]->OPC == OP65_LDX &&
|
|
L[1]->AM == AM65_ZP &&
|
|
strncmp (L[1]->Arg, L[0]->Arg, Len) == 0 &&
|
|
strcmp (L[1]->Arg+Len, "+1") == 0 &&
|
|
L[2]->OPC == OP65_STA &&
|
|
L[2]->AM == AM65_ZP &&
|
|
strcmp (L[2]->Arg, "regsave") == 0 &&
|
|
L[3]->OPC == OP65_STX &&
|
|
L[3]->AM == AM65_ZP &&
|
|
strcmp (L[3]->Arg, "regsave+1") == 0 &&
|
|
L[4]->OPC == OP65_CLC &&
|
|
L[5]->OPC == OP65_ADC &&
|
|
CE_IsKnownImm (L[5], 1) &&
|
|
(L[6]->OPC == OP65_BCC || L[6]->OPC == OP65_JCC) &&
|
|
L[6]->JumpTo != 0 &&
|
|
L[6]->JumpTo->Owner == L[8] &&
|
|
L[7]->OPC == OP65_INX &&
|
|
L[8]->OPC == OP65_STA &&
|
|
L[8]->AM == AM65_ZP &&
|
|
strcmp (L[8]->Arg, L[0]->Arg) == 0 &&
|
|
L[9]->OPC == OP65_STX &&
|
|
L[9]->AM == AM65_ZP &&
|
|
strcmp (L[9]->Arg, L[1]->Arg) == 0 &&
|
|
L[10]->OPC == OP65_LDA &&
|
|
L[10]->AM == AM65_ZP &&
|
|
strcmp (L[10]->Arg, "regsave") == 0 &&
|
|
L[11]->OPC == OP65_LDX &&
|
|
L[11]->AM == AM65_ZP &&
|
|
strcmp (L[11]->Arg, "regsave+1") == 0 &&
|
|
L[12]->OPC == OP65_LDY &&
|
|
CE_IsConstImm (L[12]) &&
|
|
CE_IsCallTo (L[13], "ldauidx")) {
|
|
|
|
CodeEntry* X;
|
|
CodeLabel* Label;
|
|
|
|
/* Check if the instruction following the sequence uses the flags
|
|
** set by the load. If so, insert a test of the value in the
|
|
** accumulator.
|
|
*/
|
|
if (CE_UseLoadFlags (L[14])) {
|
|
X = NewCodeEntry (OP65_TAY, AM65_IMP, 0, 0, L[13]->LI);
|
|
CS_InsertEntry (S, X, I+14);
|
|
}
|
|
|
|
/* Attach a label to L[14]. This may be either the just inserted
|
|
** instruction, or the one following the sequence.
|
|
*/
|
|
Label = CS_GenLabel (S, L[14]);
|
|
|
|
/* ldy #$xx */
|
|
X = NewCodeEntry (OP65_LDY, AM65_IMM, L[12]->Arg, 0, L[12]->LI);
|
|
CS_InsertEntry (S, X, I+14);
|
|
|
|
/* ldx #$xx */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[13]->LI);
|
|
CS_InsertEntry (S, X, I+15);
|
|
|
|
/* lda (regbank+n),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, L[0]->Arg, 0, L[13]->LI);
|
|
CS_InsertEntry (S, X, I+16);
|
|
|
|
/* inc regbank+n */
|
|
X = NewCodeEntry (OP65_INC, AM65_ZP, L[0]->Arg, 0, L[5]->LI);
|
|
CS_InsertEntry (S, X, I+17);
|
|
|
|
/* bne ... */
|
|
X = NewCodeEntry (OP65_BNE, AM65_BRA, Label->Name, Label, L[6]->LI);
|
|
CS_InsertEntry (S, X, I+18);
|
|
|
|
/* inc regbank+n+1 */
|
|
X = NewCodeEntry (OP65_INC, AM65_ZP, L[1]->Arg, 0, L[7]->LI);
|
|
CS_InsertEntry (S, X, I+19);
|
|
|
|
/* Delete the old code */
|
|
CS_DelEntries (S, I, 14);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad13 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** lda zp
|
|
** ldx zp+1
|
|
** ldy xx
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** ldy xx
|
|
** ldx #$00
|
|
** lda (zp),y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[4];
|
|
unsigned Len;
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_LDA && L[0]->AM == AM65_ZP &&
|
|
CS_GetEntries (S, L+1, I+1, 3) &&
|
|
!CS_RangeHasLabel (S, I+1, 3) &&
|
|
L[1]->OPC == OP65_LDX && L[1]->AM == AM65_ZP &&
|
|
(Len = strlen (L[0]->Arg)) > 0 &&
|
|
strncmp (L[0]->Arg, L[1]->Arg, Len) == 0 &&
|
|
strcmp (L[1]->Arg + Len, "+1") == 0 &&
|
|
L[2]->OPC == OP65_LDY &&
|
|
CE_IsCallTo (L[3], "ldauidx")) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* ldx #$00 */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+3);
|
|
|
|
/* lda (zp),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, L[0]->Arg, 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+4);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntry (S, I+5);
|
|
CS_DelEntries (S, I, 2);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad14 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** lda zp
|
|
** ldx zp+1
|
|
** (anything that doesn't change a/x)
|
|
** ldy xx
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** lda zp
|
|
** ldx zp+1
|
|
** (anything that doesn't change a/x)
|
|
** ldy xx
|
|
** ldx #$00
|
|
** lda (zp),y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
unsigned I;
|
|
|
|
/* Walk over the entries */
|
|
I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[5];
|
|
unsigned Len;
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_LDA && L[0]->AM == AM65_ZP &&
|
|
CS_GetEntries (S, L+1, I+1, 4) &&
|
|
!CS_RangeHasLabel (S, I+1, 4) &&
|
|
L[1]->OPC == OP65_LDX && L[1]->AM == AM65_ZP &&
|
|
(Len = strlen (L[0]->Arg)) > 0 &&
|
|
strncmp (L[0]->Arg, L[1]->Arg, Len) == 0 &&
|
|
strcmp (L[1]->Arg + Len, "+1") == 0 &&
|
|
(L[2]->Chg & REG_AX) == 0 &&
|
|
L[3]->OPC == OP65_LDY &&
|
|
CE_IsCallTo (L[4], "ldauidx")) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* ldx #$00 */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+5);
|
|
|
|
/* lda (zp),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, L[0]->Arg, 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+6);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntry (S, I+4);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad15 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** lda zp
|
|
** ldx zp+1
|
|
** jsr pushax <- optional
|
|
** ldy xx
|
|
** jsr ldaxidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** lda zp <- only if
|
|
** ldx zp+1 <- call to
|
|
** jsr pushax <- pushax present
|
|
** ldy xx
|
|
** lda (zp),y
|
|
** tax
|
|
** dey
|
|
** lda (zp),y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[5];
|
|
unsigned Len;
|
|
|
|
/* Check for the start of the sequence */
|
|
if (CS_GetEntries (S, L, I, 3) &&
|
|
L[0]->OPC == OP65_LDA && L[0]->AM == AM65_ZP &&
|
|
L[1]->OPC == OP65_LDX && L[1]->AM == AM65_ZP &&
|
|
!CS_RangeHasLabel (S, I+1, 2) &&
|
|
(Len = strlen (L[0]->Arg)) > 0 &&
|
|
strncmp (L[0]->Arg, L[1]->Arg, Len) == 0 &&
|
|
strcmp (L[1]->Arg + Len, "+1") == 0) {
|
|
|
|
unsigned PushAX = CE_IsCallTo (L[2], "pushax");
|
|
|
|
/* Check for the remainder of the sequence */
|
|
if (CS_GetEntries (S, L+3, I+3, 1 + PushAX) &&
|
|
!CS_RangeHasLabel (S, I+3, 1 + PushAX) &&
|
|
L[2+PushAX]->OPC == OP65_LDY &&
|
|
CE_IsCallTo (L[3+PushAX], "ldaxidx")) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* lda (zp),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, L[0]->Arg, 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+PushAX+4);
|
|
|
|
/* tax */
|
|
X = NewCodeEntry (OP65_TAX, AM65_IMP, 0, 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+PushAX+5);
|
|
|
|
/* dey */
|
|
X = NewCodeEntry (OP65_DEY, AM65_IMP, 0, 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+PushAX+6);
|
|
|
|
/* lda (zp),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, L[0]->Arg, 0, L[3]->LI);
|
|
CS_InsertEntry (S, X, I+PushAX+7);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntry (S, I+PushAX+3);
|
|
if (!PushAX) {
|
|
CS_DelEntries (S, I, 2);
|
|
}
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad16 (CodeSeg* S)
|
|
/* Search for the sequence
|
|
**
|
|
** ldy ...
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** stx ptr1+1
|
|
** sta ptr1
|
|
** ldy ...
|
|
** ldx #$00
|
|
** lda (ptr1),y
|
|
**
|
|
** This step must be executed *after* OptPtrLoad1!
|
|
*/
|
|
{
|
|
unsigned Changes = 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 */
|
|
if (L[0]->OPC == OP65_LDY &&
|
|
CS_GetEntries (S, L+1, I+1, 1) &&
|
|
CE_IsCallTo (L[1], "ldauidx") &&
|
|
!CE_HasLabel (L[1])) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* stx ptr1+1 */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1", 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+2);
|
|
|
|
/* sta ptr1 */
|
|
X = NewCodeEntry (OP65_STX, AM65_ZP, "ptr1+1", 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+3);
|
|
|
|
/* ldy ... */
|
|
X = NewCodeEntry (L[0]->OPC, L[0]->AM, L[0]->Arg, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+4);
|
|
|
|
/* ldx #$00 */
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+5);
|
|
|
|
/* lda (ptr1),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+6);
|
|
|
|
/* Delete the old code */
|
|
CS_DelEntries (S, I, 2);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad17 (CodeSeg* S)
|
|
/* Search for the sequence
|
|
**
|
|
** ldy ...
|
|
** jsr ldaxidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** sta ptr1
|
|
** stx ptr1+1
|
|
** ldy ...
|
|
** lda (ptr1),y
|
|
** tax
|
|
** dey
|
|
** lda (ptr1),y
|
|
**
|
|
** This step must be executed *after* OptPtrLoad9! While code size increases
|
|
** by more than 200%, inlining will greatly improve visibility for the
|
|
** optimizer, so often part of the code gets improved later. So we will mark
|
|
** the step with less than 200% so it gets executed when -Oi is in effect.
|
|
*/
|
|
{
|
|
unsigned Changes = 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 */
|
|
if (L[0]->OPC == OP65_LDY &&
|
|
CS_GetEntries (S, L+1, I+1, 1) &&
|
|
CE_IsCallTo (L[1], "ldaxidx") &&
|
|
!CE_HasLabel (L[1])) {
|
|
|
|
CodeEntry* X;
|
|
|
|
/* Store the high byte */
|
|
X = NewCodeEntry (OP65_STA, AM65_ZP, "ptr1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+2);
|
|
|
|
/* Store the low byte */
|
|
X = NewCodeEntry (OP65_STX, AM65_ZP, "ptr1+1", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+3);
|
|
|
|
/* ldy ... */
|
|
X = NewCodeEntry (L[0]->OPC, L[0]->AM, L[0]->Arg, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+4);
|
|
|
|
/* lda (ptr1),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+5);
|
|
|
|
/* tax */
|
|
X = NewCodeEntry (OP65_TAX, AM65_IMP, 0, 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+6);
|
|
|
|
/* dey */
|
|
X = NewCodeEntry (OP65_DEY, AM65_IMP, 0, 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+7);
|
|
|
|
/* lda (ptr1),y */
|
|
X = NewCodeEntry (OP65_LDA, AM65_ZP_INDY, "ptr1", 0, L[1]->LI);
|
|
CS_InsertEntry (S, X, I+8);
|
|
|
|
/* Delete original sequence */
|
|
CS_DelEntries (S, I, 2);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad18 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** ldx #$xx
|
|
** lda #$yy
|
|
** clc
|
|
** adc xxx
|
|
** bcc L
|
|
** inx
|
|
** L: ldy #$00
|
|
** jsr ldauidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** ldy xxx
|
|
** ldx #$00
|
|
** lda $xxyy,y
|
|
**
|
|
** This is similar to OptPtrLoad3 but works on a constant address
|
|
** instead of a label. Also, the initial X and A loads are reversed.
|
|
** Must be run before OptPtrLoad7().
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
|
|
/* Walk over the entries */
|
|
unsigned I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[8];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_LDX &&
|
|
L[0]->AM == AM65_IMM &&
|
|
CS_GetEntries (S, L+1, I+1, 7) &&
|
|
L[1]->OPC == OP65_LDA &&
|
|
L[1]->AM == AM65_IMM &&
|
|
L[2]->OPC == OP65_CLC &&
|
|
L[3]->OPC == OP65_ADC &&
|
|
(L[3]->AM == AM65_ABS || L[3]->AM == AM65_ZP) &&
|
|
(L[4]->OPC == OP65_BCC || L[4]->OPC == OP65_JCC) &&
|
|
L[4]->JumpTo != 0 &&
|
|
L[4]->JumpTo->Owner == L[6] &&
|
|
L[5]->OPC == OP65_INX &&
|
|
L[6]->OPC == OP65_LDY &&
|
|
CE_IsKnownImm (L[6], 0) &&
|
|
CE_IsCallTo (L[7], "ldauidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 5) &&
|
|
!CE_HasLabel (L[7]) &&
|
|
L[0]->Arg[0] == '$' &&
|
|
L[1]->Arg[0] == '$' &&
|
|
strlen (L[0]->Arg) == 3 &&
|
|
strlen (L[1]->Arg) == 3 ) {
|
|
|
|
CodeEntry* X;
|
|
char* Label;
|
|
|
|
/* We will create all the new stuff behind the current one so
|
|
** we keep the line references.
|
|
*/
|
|
X = NewCodeEntry (OP65_LDY, L[3]->AM, L[3]->Arg, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+8);
|
|
|
|
X = NewCodeEntry (OP65_LDX, AM65_IMM, "$00", 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+9);
|
|
|
|
Label = xmalloc(6);
|
|
sprintf(Label, "$%s%s", L[0]->Arg+1, L[1]->Arg+1);
|
|
X = NewCodeEntry (OP65_LDA, AM65_ABSY, Label, 0, L[0]->LI);
|
|
CS_InsertEntry (S, X, I+10);
|
|
xfree (Label);
|
|
|
|
/* Remove the old code */
|
|
CS_DelEntries (S, I, 8);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|
|
|
|
|
|
|
|
unsigned OptPtrLoad19 (CodeSeg* S)
|
|
/* Search for the sequence:
|
|
**
|
|
** ldx #0
|
|
** and #mask (any value < 0x80)
|
|
** jsr aslax1/shlax1
|
|
** clc
|
|
** adc #<(label+0)
|
|
** tay
|
|
** txa
|
|
** adc #>(label+0)
|
|
** tax
|
|
** tya
|
|
** ldy #$01
|
|
** jsr ldaxidx
|
|
**
|
|
** and replace it by:
|
|
**
|
|
** and #mask (remove if == 0x7F)
|
|
** asl
|
|
** tay
|
|
** lda label,y
|
|
** ldx label+1,y
|
|
*/
|
|
{
|
|
unsigned Changes = 0;
|
|
unsigned I;
|
|
|
|
/* Walk over the entries */
|
|
I = 0;
|
|
while (I < CS_GetEntryCount (S)) {
|
|
|
|
CodeEntry* L[12];
|
|
|
|
/* Get next entry */
|
|
L[0] = CS_GetEntry (S, I);
|
|
|
|
/* Check for the sequence */
|
|
if (L[0]->OPC == OP65_LDX &&
|
|
CE_IsKnownImm(L[0], 0) &&
|
|
CS_GetEntries (S, L+1, I+1, 11) &&
|
|
L[1]->OPC == OP65_AND &&
|
|
L[1]->AM == AM65_IMM &&
|
|
CE_HasNumArg (L[1]) && L[1]->Num <= 0x7F &&
|
|
L[2]->OPC == OP65_JSR &&
|
|
L[3]->OPC == OP65_CLC &&
|
|
L[4]->OPC == OP65_ADC &&
|
|
L[5]->OPC == OP65_TAY &&
|
|
L[6]->OPC == OP65_TXA &&
|
|
L[7]->OPC == OP65_ADC &&
|
|
L[8]->OPC == OP65_TAX &&
|
|
L[9]->OPC == OP65_TYA &&
|
|
L[10]->OPC == OP65_LDY &&
|
|
CE_IsKnownImm(L[10], 1) &&
|
|
L[4]->Arg[0] == '<' &&
|
|
L[7]->Arg[0] == '>' &&
|
|
strlen(L[4]->Arg) > 3 &&
|
|
strlen(L[7]->Arg) > 3 &&
|
|
strcmp(L[4]->Arg+1, L[7]->Arg+1) == 0 &&
|
|
(strcmp (L[2]->Arg, "aslax1") == 0 ||
|
|
strcmp (L[2]->Arg, "shlax1") == 0) &&
|
|
CE_IsCallTo (L[11], "ldaxidx") &&
|
|
!CS_RangeHasLabel (S, I+1, 11)) {
|
|
|
|
CodeEntry* X;
|
|
char* Label;
|
|
int Len = strlen(L[4]->Arg);
|
|
|
|
/* Track the insertion point */
|
|
unsigned IP = I + 12;
|
|
|
|
/* asl a */
|
|
X = NewCodeEntry (OP65_ASL, AM65_ACC, "a", 0, L[2]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* tay */
|
|
X = NewCodeEntry (OP65_TAY, AM65_IMP, 0, 0, L[2]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* lda label,y */
|
|
/* allocate Label memory */
|
|
Label = memcpy (xmalloc (Len), L[4]->Arg+2, Len-3);
|
|
Label[Len-3] = '\0';
|
|
X = NewCodeEntry (OP65_LDA, AM65_ABSY, Label, 0, L[10]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
|
|
/* ldx label+1,y */
|
|
strcpy(&Label[Len-3], "+1");
|
|
X = NewCodeEntry (OP65_LDX, AM65_ABSY, Label, 0, L[10]->LI);
|
|
CS_InsertEntry (S, X, IP++);
|
|
/* free Label memory */
|
|
xfree (Label);
|
|
|
|
/* Remove the old code */
|
|
/* Remove the AND only if it's == 0x7F, since ASL erases high bit */
|
|
if (L[1]->Num == 0x7F) {
|
|
CS_DelEntries (S, I+1, 11);
|
|
} else {
|
|
CS_DelEntries (S, I+2, 10);
|
|
}
|
|
|
|
/* Remove the ldx #0 */
|
|
CS_DelEntry(S, I);
|
|
|
|
/* Remember, we had changes */
|
|
++Changes;
|
|
|
|
}
|
|
|
|
/* Next entry */
|
|
++I;
|
|
|
|
}
|
|
|
|
/* Return the number of changes made */
|
|
return Changes;
|
|
}
|