mirror of
https://gitlab.com/camelot/kickc.git
synced 2025-04-07 06:37:31 +00:00
Implemented potential register elimination based on clobber analysis of individual statements.
This commit is contained in:
jespergravgaard
parent
0e5bd97e21
commit
439a70e52a
@ -1,8 +1,5 @@
|
||||
package dk.camelot64.kickc;
|
||||
|
||||
import dk.camelot64.kickc.asm.AsmFragment;
|
||||
import dk.camelot64.kickc.asm.AsmProgram;
|
||||
import dk.camelot64.kickc.asm.AsmSegment;
|
||||
import dk.camelot64.kickc.icl.*;
|
||||
import dk.camelot64.kickc.parser.KickCLexer;
|
||||
import dk.camelot64.kickc.parser.KickCParser;
|
||||
@ -66,6 +63,12 @@ public class Compiler {
|
||||
}
|
||||
|
||||
private void pass4RegisterAllocation(Program program) {
|
||||
|
||||
// Find potential registers for each live range equivalence class - based on clobbering of fragments
|
||||
new Pass3RegisterUpliftPotentialRegisterAnalysis(program).findPotentialRegisters();
|
||||
program.getLog().append("REGISTER UPLIFT POTENTIAL REGISTERS");
|
||||
program.getLog().append(program.getRegisterPotentials().toString());
|
||||
|
||||
// Find register uplift scopes
|
||||
new Pass3RegisterUpliftScopeAnalysis(program).findScopes();
|
||||
program.getLog().append("REGISTER UPLIFT SCOPES");
|
||||
@ -74,8 +77,6 @@ public class Compiler {
|
||||
// Attempt uplifting registers through a lot of combinations
|
||||
new Pass3RegisterUpliftCombinations(program).performUplift();
|
||||
|
||||
|
||||
|
||||
// Final register coalesce and code generation
|
||||
new Pass3ZeroPageCoalesce(program).allocate();
|
||||
new Pass3RegistersFinalize(program).allocate(true);
|
||||
|
||||
@ -419,7 +419,7 @@ public class AsmFragment {
|
||||
Asm6502Parser.ParamModeContext paramModeCtx = ctx.paramMode();
|
||||
AsmInstruction instruction;
|
||||
if (paramModeCtx == null) {
|
||||
AsmInstructionType type = AsmInstuctionSet.getInstructionType(ctx.MNEMONIC().getText(), AsmAddressingMode.NON, null);
|
||||
AsmInstructionType type = AsmInstructionSet.getInstructionType(ctx.MNEMONIC().getText(), AsmAddressingMode.NON, null);
|
||||
instruction = new AsmInstruction(type, null);
|
||||
} else {
|
||||
instruction = (AsmInstruction) this.visit(paramModeCtx);
|
||||
@ -471,7 +471,7 @@ public class AsmFragment {
|
||||
Asm6502Parser.InstructionContext instructionCtx = (Asm6502Parser.InstructionContext) ctx.getParent();
|
||||
String mnemonic = instructionCtx.MNEMONIC().getSymbol().getText();
|
||||
String parameter = (String) this.visit(exprCtx);
|
||||
AsmInstructionType type = AsmInstuctionSet.getInstructionType(mnemonic, addressingMode, parameter);
|
||||
AsmInstructionType type = AsmInstructionSet.getInstructionType(mnemonic, addressingMode, parameter);
|
||||
if (type == null) {
|
||||
throw new RuntimeException("Error in " + signature + ".asm line " + ctx.getStart().getLine() + " - Instruction type unknown " + mnemonic + " " + addressingMode + " " + parameter);
|
||||
}
|
||||
|
||||
@ -9,9 +9,9 @@ import java.util.List;
|
||||
/**
|
||||
* The set of all 6502 assembler instructions
|
||||
*/
|
||||
public class AsmInstuctionSet {
|
||||
public class AsmInstructionSet {
|
||||
|
||||
private static AsmInstuctionSet set = new AsmInstuctionSet();
|
||||
private static AsmInstructionSet set = new AsmInstructionSet();
|
||||
|
||||
public static AsmInstructionType getInstructionType(String mnemonic, AsmAddressingMode mode, String parameter) {
|
||||
AsmInstructionType type = null;
|
||||
@ -52,7 +52,7 @@ public class AsmInstuctionSet {
|
||||
instructions.add(new AsmInstructionType(opcode, mnemonic, addressingmMode, cycles));
|
||||
}
|
||||
|
||||
public AsmInstuctionSet() {
|
||||
public AsmInstructionSet() {
|
||||
this.instructions = new ArrayList<>();
|
||||
AsmAddressingMode non = AsmAddressingMode.NON;
|
||||
AsmAddressingMode zp = AsmAddressingMode.ZP;
|
||||
@ -60,7 +60,7 @@ public class AsmProgram {
|
||||
}
|
||||
|
||||
public void addInstruction(String mnemonic, AsmAddressingMode addressingMode, String parameter) {
|
||||
AsmInstructionType instructionType = AsmInstuctionSet.getInstructionType(mnemonic, addressingMode, parameter);
|
||||
AsmInstructionType instructionType = AsmInstructionSet.getInstructionType(mnemonic, addressingMode, parameter);
|
||||
addLine(new AsmInstruction(instructionType, parameter));
|
||||
}
|
||||
|
||||
|
||||
@ -33,6 +33,9 @@ public class Program {
|
||||
private LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet;
|
||||
/** The register weight of all variables describing how much the variable would theoretically gain from being in a register */
|
||||
private VariableRegisterWeights variableRegisterWeights;
|
||||
/** Registers potentially usable as allocation for each live range equivalence class. */
|
||||
private RegisterPotentials registerPotentials;
|
||||
/** Separation of live range equivalence classes into scopes - used for register uplift */
|
||||
private RegisterUpliftProgram registerUpliftProgram;
|
||||
|
||||
@JsonCreator
|
||||
@ -130,6 +133,14 @@ public class Program {
|
||||
return variableRegisterWeights;
|
||||
}
|
||||
|
||||
public void setRegisterPotentials(RegisterPotentials registerPotentials) {
|
||||
this.registerPotentials = registerPotentials;
|
||||
}
|
||||
|
||||
public RegisterPotentials getRegisterPotentials() {
|
||||
return registerPotentials;
|
||||
}
|
||||
|
||||
public void setRegisterUpliftProgram(RegisterUpliftProgram registerUpliftProgram) {
|
||||
this.registerUpliftProgram = registerUpliftProgram;
|
||||
}
|
||||
|
||||
@ -0,0 +1,55 @@
|
||||
package dk.camelot64.kickc.icl;
|
||||
|
||||
import java.util.LinkedHashMap;
|
||||
import java.util.Map;
|
||||
|
||||
/** A combination of register/ZP assignments for a set of equivalence classes */
|
||||
public class RegisterCombination {
|
||||
|
||||
/**
|
||||
* The registers allocated to each equivalence class.
|
||||
*/
|
||||
private Map<LiveRangeEquivalenceClass, RegisterAllocation.Register> allocation;
|
||||
|
||||
public RegisterCombination() {
|
||||
this.allocation = new LinkedHashMap<>();
|
||||
}
|
||||
|
||||
void setRegister(LiveRangeEquivalenceClass equivalenceClass, RegisterAllocation.Register register) {
|
||||
allocation.put(equivalenceClass, register);
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate the registers of the combination into the programs register allocation
|
||||
*/
|
||||
public void allocate(RegisterAllocation registerAllocation) {
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : allocation.keySet()) {
|
||||
RegisterAllocation.Register register = allocation.get(equivalenceClass);
|
||||
for (VariableRef variable : equivalenceClass.getVariables()) {
|
||||
registerAllocation.setRegister(variable, register);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Store the combination in the equivalence classes.
|
||||
*/
|
||||
public void store(LiveRangeEquivalenceClassSet equivalenceClassSet) {
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : allocation.keySet()) {
|
||||
VariableRef variable = equivalenceClass.getVariables().get(0);
|
||||
LiveRangeEquivalenceClass globalEquivalenceClass = equivalenceClassSet.getEquivalenceClass(variable);
|
||||
RegisterAllocation.Register register = allocation.get(equivalenceClass);
|
||||
globalEquivalenceClass.setRegister(register);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder out = new StringBuilder();
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : allocation.keySet()) {
|
||||
RegisterAllocation.Register register = allocation.get(equivalenceClass);
|
||||
out.append(register.toString()).append(" ").append(equivalenceClass.toString(false)).append(" ");
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
}
|
||||
@ -0,0 +1,59 @@
|
||||
package dk.camelot64.kickc.icl;
|
||||
|
||||
import java.util.Iterator;
|
||||
import java.util.List;
|
||||
|
||||
/** Iterator for running through all possible combinations of register allocations for a set of live range equivalence classes */
|
||||
public class RegisterCombinationIterator implements Iterator<RegisterCombination> {
|
||||
|
||||
/** The equivalence classes to create register combinations for. */
|
||||
private List<LiveRangeEquivalenceClass> equivalenceClasses;
|
||||
|
||||
/** The potential registers usable for the equivalence classes. */
|
||||
private RegisterPotentials registerPotentials;
|
||||
|
||||
/**
|
||||
* The ID of the next iteration. Combinations are created from the index by using modulo.
|
||||
*/
|
||||
private int nextIterationId;
|
||||
|
||||
public RegisterCombinationIterator(List<LiveRangeEquivalenceClass> equivalenceClasses, RegisterPotentials registerPotentials) {
|
||||
this.equivalenceClasses = equivalenceClasses;
|
||||
this.registerPotentials = registerPotentials;
|
||||
this.nextIterationId = 0;
|
||||
}
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return nextIterationId < getNumIterations();
|
||||
}
|
||||
|
||||
private int getNumIterations() {
|
||||
int numIterations = 1;
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : equivalenceClasses) {
|
||||
List<RegisterAllocation.Register> registers = registerPotentials.getPotentialRegisters(equivalenceClass);
|
||||
numIterations = numIterations * registers.size();
|
||||
}
|
||||
return numIterations;
|
||||
}
|
||||
|
||||
@Override
|
||||
public RegisterCombination next() {
|
||||
RegisterCombination combination = new RegisterCombination();
|
||||
int combinationIdRest = nextIterationId;
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : equivalenceClasses) {
|
||||
List<RegisterAllocation.Register> potentials = registerPotentials.getPotentialRegisters(equivalenceClass);
|
||||
int registerIdx = (combinationIdRest % potentials.size());
|
||||
RegisterAllocation.Register register = potentials.get(registerIdx);
|
||||
combination.setRegister(equivalenceClass, register);
|
||||
combinationIdRest = (int) Math.floor(combinationIdRest / potentials.size());
|
||||
}
|
||||
nextIterationId++;
|
||||
return combination;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
throw new RuntimeException("Not supported");
|
||||
}
|
||||
}
|
||||
51
src/main/java/dk/camelot64/kickc/icl/RegisterPotentials.java
Normal file
51
src/main/java/dk/camelot64/kickc/icl/RegisterPotentials.java
Normal file
@ -0,0 +1,51 @@
|
||||
package dk.camelot64.kickc.icl;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Holds potential registers for each live range equivalence class in the program.
|
||||
*/
|
||||
public class RegisterPotentials {
|
||||
|
||||
private Map<LiveRangeEquivalenceClass, List<RegisterAllocation.Register>> potentials;
|
||||
|
||||
public RegisterPotentials() {
|
||||
this.potentials = new LinkedHashMap<>();
|
||||
}
|
||||
|
||||
|
||||
public List<RegisterAllocation.Register> getPotentialRegisters(LiveRangeEquivalenceClass equivalenceClass) {
|
||||
return potentials.get(equivalenceClass);
|
||||
}
|
||||
|
||||
|
||||
public void setPotentialRegisters(LiveRangeEquivalenceClass equivalenceClass, List<RegisterAllocation.Register> registers) {
|
||||
potentials.put(equivalenceClass, new ArrayList<>(registers));
|
||||
}
|
||||
|
||||
public void removePotentialRegister(LiveRangeEquivalenceClass equivalenceClass, RegisterAllocation.Register register) {
|
||||
List<RegisterAllocation.Register> registers = potentials.get(equivalenceClass);
|
||||
registers.remove(register);
|
||||
}
|
||||
|
||||
public RegisterCombinationIterator getAllCombinations(Collection<LiveRangeEquivalenceClass> equivalenceClasses) {
|
||||
return new RegisterCombinationIterator(new ArrayList<>(equivalenceClasses), this);
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder out = new StringBuilder();
|
||||
for (LiveRangeEquivalenceClass liveRangeEquivalenceClass : potentials.keySet()) {
|
||||
out.append("Potential registers ");
|
||||
out.append(liveRangeEquivalenceClass.toString());
|
||||
out.append(" : ");
|
||||
List<RegisterAllocation.Register> registers = potentials.get(liveRangeEquivalenceClass);
|
||||
for (RegisterAllocation.Register register : registers) {
|
||||
out.append(register.toString());
|
||||
out.append(" , ");
|
||||
}
|
||||
out.append("\n");
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
}
|
||||
@ -4,14 +4,10 @@ import com.ibm.icu.text.NumberFormat;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/**
|
||||
* Register Uplift information for a single scope.
|
||||
*/
|
||||
/** Register Uplift information for a single scope. */
|
||||
public class RegisterUpliftScope {
|
||||
|
||||
/**
|
||||
* The scope.
|
||||
*/
|
||||
/** The scope. */
|
||||
private LabelRef scopeRef;
|
||||
|
||||
/**
|
||||
@ -55,157 +51,13 @@ public class RegisterUpliftScope {
|
||||
return toString(null);
|
||||
}
|
||||
|
||||
public Iterator<Combination> geCombinationIterator() {
|
||||
return new CombinationIterator(scopeRef, equivalenceClasses);
|
||||
}
|
||||
|
||||
/**
|
||||
* A combination of register/ZP assignments for the equivalence classes of the scope.
|
||||
* Get all register allocation combinations using the passed potential registers
|
||||
* @param registerPotentials The potential registers to use for each live range equivalence class
|
||||
* @return Iterator of all combinations
|
||||
*/
|
||||
public static class Combination {
|
||||
|
||||
/**
|
||||
* The scope.
|
||||
*/
|
||||
private LabelRef scopeRef;
|
||||
|
||||
|
||||
/**
|
||||
* The registers allocated to each equivalence class.
|
||||
*/
|
||||
private Map<LiveRangeEquivalenceClass, RegisterAllocation.Register> allocation;
|
||||
|
||||
public Combination(LabelRef scopeRef) {
|
||||
this.scopeRef = scopeRef;
|
||||
this.allocation = new LinkedHashMap<>();
|
||||
}
|
||||
|
||||
void setRegister(LiveRangeEquivalenceClass equivalenceClass, RegisterAllocation.Register register) {
|
||||
allocation.put(equivalenceClass, register);
|
||||
}
|
||||
|
||||
/**
|
||||
* Allocate the registers of the combination into the programs register allocation
|
||||
*/
|
||||
public void allocate(RegisterAllocation registerAllocation) {
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : allocation.keySet()) {
|
||||
RegisterAllocation.Register register = allocation.get(equivalenceClass);
|
||||
for (VariableRef variable : equivalenceClass.getVariables()) {
|
||||
registerAllocation.setRegister(variable, register);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Store the best combination in the equivalence classes.
|
||||
*/
|
||||
public void store(LiveRangeEquivalenceClassSet equivalenceClassSet) {
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : allocation.keySet()) {
|
||||
VariableRef variable = equivalenceClass.getVariables().get(0);
|
||||
LiveRangeEquivalenceClass globalEquivalenceClass = equivalenceClassSet.getEquivalenceClass(variable);
|
||||
RegisterAllocation.Register register = allocation.get(equivalenceClass);
|
||||
globalEquivalenceClass.setRegister(register);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public String toString() {
|
||||
StringBuilder out = new StringBuilder();
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : allocation.keySet()) {
|
||||
RegisterAllocation.Register register = allocation.get(equivalenceClass);
|
||||
out.append(register.toString()).append(" ").append(equivalenceClass.toString(false)).append(" ");
|
||||
}
|
||||
return out.toString();
|
||||
}
|
||||
public Iterator<RegisterCombination> geCombinationIterator(RegisterPotentials registerPotentials) {
|
||||
return new RegisterCombinationIterator(equivalenceClasses, registerPotentials);
|
||||
}
|
||||
|
||||
private static class CombinationIterator implements Iterator<Combination> {
|
||||
|
||||
/**
|
||||
* The scope we are creating combinations for.
|
||||
*/
|
||||
private LabelRef scopeRef;
|
||||
|
||||
|
||||
/**
|
||||
* The equivalence classes to create register combinations for.
|
||||
*/
|
||||
private List<LiveRangeEquivalenceClass> equivalenceClasses;
|
||||
|
||||
/**
|
||||
* The ID of the next iteration. Combinations are created from the index by using modulo.
|
||||
*/
|
||||
private int nextIterationId;
|
||||
|
||||
public CombinationIterator(LabelRef scopeRef, List<LiveRangeEquivalenceClass> equivalenceClasses) {
|
||||
this.scopeRef = scopeRef;
|
||||
this.equivalenceClasses = equivalenceClasses;
|
||||
this.nextIterationId = 0;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Examine the control flow graph to determine which registers could be usable for
|
||||
* optimizing the variables in a specific live range equivalence class.
|
||||
*
|
||||
* The optimizer will only test combinations with these registers
|
||||
*
|
||||
* @param equivalenceClass The equivalence class
|
||||
* @return The registers to try to optimize the variables of the equivalence class into
|
||||
*/
|
||||
public List<RegisterAllocation.Register> getPotentialRegisters(LiveRangeEquivalenceClass equivalenceClass) {
|
||||
// TODO!!
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
@Override
|
||||
public boolean hasNext() {
|
||||
return nextIterationId < getNumIterations();
|
||||
}
|
||||
|
||||
private int getNumIterations() {
|
||||
int numIterations = 1;
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : equivalenceClasses) {
|
||||
RegisterAllocation.Register defaultReegister = equivalenceClass.getRegister();
|
||||
if (defaultReegister.getType().equals(RegisterAllocation.RegisterType.ZP_BYTE)) {
|
||||
numIterations = numIterations *5;
|
||||
|
||||
}
|
||||
}
|
||||
return numIterations;
|
||||
}
|
||||
|
||||
@Override
|
||||
public Combination next() {
|
||||
Combination combination = new Combination(scopeRef);
|
||||
int combinationIdRest = nextIterationId;
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : equivalenceClasses) {
|
||||
RegisterAllocation.Register defaultReegister = equivalenceClass.getRegister();
|
||||
if (defaultReegister.getType().equals(RegisterAllocation.RegisterType.ZP_BYTE)) {
|
||||
int registerIdx = (combinationIdRest % 5);
|
||||
List<RegisterAllocation.Register> potentialRegisters =
|
||||
Arrays.asList(
|
||||
defaultReegister,
|
||||
RegisterAllocation.getRegisterA(),
|
||||
RegisterAllocation.getRegisterX(),
|
||||
RegisterAllocation.getRegisterY(),
|
||||
RegisterAllocation.getRegisterALU());
|
||||
RegisterAllocation.Register register = potentialRegisters.get(registerIdx);
|
||||
combination.setRegister(equivalenceClass, register);
|
||||
combinationIdRest = (int) Math.floor(combinationIdRest / 5);
|
||||
} else {
|
||||
combination.setRegister(equivalenceClass, defaultReegister);
|
||||
}
|
||||
}
|
||||
nextIterationId++;
|
||||
return combination;
|
||||
}
|
||||
|
||||
@Override
|
||||
public void remove() {
|
||||
throw new RuntimeException("Not supported");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@ -46,7 +46,7 @@ public class Pass3AssertNoCpuClobber extends Pass2Base {
|
||||
// Find alive variables
|
||||
List<VariableRef> aliveVars = new ArrayList<>(liveRangeVariables.getAlive(statement));
|
||||
// Find vars assignedVars to
|
||||
Collection<VariableRef> assignedVars = getAssignedVars(statement);
|
||||
Collection<VariableRef> assignedVars = Pass3RegisterUpliftPotentialRegisterAnalysis.getAssignedVars(statement);
|
||||
for (VariableRef aliveVar : aliveVars) {
|
||||
RegisterAllocation.Register aliveVarRegister = allocation.getRegister(aliveVar);
|
||||
if (aliveVarRegister.isZp()) {
|
||||
@ -71,36 +71,13 @@ public class Pass3AssertNoCpuClobber extends Pass2Base {
|
||||
return clobberProblem;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get the variables assigned to by a specific statement
|
||||
*
|
||||
* @param statement The statement
|
||||
* @return The variables assigned by the statement
|
||||
*/
|
||||
private Collection<VariableRef> getAssignedVars(Statement statement) {
|
||||
List<VariableRef> assignedVars = new ArrayList<>();
|
||||
if (statement instanceof StatementAssignment) {
|
||||
StatementAssignment assignment = (StatementAssignment) statement;
|
||||
if (assignment.getlValue() instanceof VariableRef) {
|
||||
assignedVars.add((VariableRef) assignment.getlValue());
|
||||
}
|
||||
} else if (statement instanceof StatementPhiBlock) {
|
||||
StatementPhiBlock phi = (StatementPhiBlock) statement;
|
||||
for (StatementPhiBlock.PhiVariable phiVariable : phi.getPhiVariables()) {
|
||||
assignedVars.add(phiVariable.getVariable());
|
||||
}
|
||||
}
|
||||
return assignedVars;
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all CPU registers clobbered by the ASM generated from a specific statement in the program
|
||||
*
|
||||
* @param asm The assembler to check
|
||||
* @return The clobbered CPU registers
|
||||
*/
|
||||
private Collection<RegisterAllocation.Register> getClobberRegisters(AsmClobber clobber) {
|
||||
public static Collection<RegisterAllocation.Register> getClobberRegisters(AsmClobber clobber) {
|
||||
List<RegisterAllocation.Register> clobberRegisters = new ArrayList<>();
|
||||
if (clobber.isClobberA()) {
|
||||
clobberRegisters.add(RegisterAllocation.getRegisterA());
|
||||
|
||||
@ -24,11 +24,11 @@ public class Pass3RegisterUpliftCombinations extends Pass2Base {
|
||||
List<RegisterUpliftScope> registerUpliftScopes = getProgram().getRegisterUpliftProgram().getRegisterUpliftScopes();
|
||||
for (RegisterUpliftScope upliftScope : registerUpliftScopes) {
|
||||
int bestScore = Integer.MAX_VALUE;
|
||||
RegisterUpliftScope.Combination bestCombination = null;
|
||||
RegisterCombination bestCombination = null;
|
||||
|
||||
Iterator<RegisterUpliftScope.Combination> combinationIterator = upliftScope.geCombinationIterator();
|
||||
Iterator<RegisterCombination> combinationIterator = upliftScope.geCombinationIterator(getProgram().getRegisterPotentials());
|
||||
while (combinationIterator.hasNext()) {
|
||||
RegisterUpliftScope.Combination combination = combinationIterator.next();
|
||||
RegisterCombination combination = combinationIterator.next();
|
||||
// Reset register allocation to original zero page allocation
|
||||
new Pass3RegistersFinalize(getProgram()).allocate(false);
|
||||
// Apply the uplift combination
|
||||
@ -41,12 +41,14 @@ public class Pass3RegisterUpliftCombinations extends Pass2Base {
|
||||
StringBuilder msg = new StringBuilder();
|
||||
msg.append("Uplift attempt [" + upliftScope.getScopeRef() + "] ");
|
||||
msg.append("missing fragment " + e.getFragmentSignature());
|
||||
msg.append(" allocation: ").append(combination.toString());
|
||||
getLog().append(msg.toString());
|
||||
continue;
|
||||
} catch (AsmFragment.AluNotApplicableException e) {
|
||||
StringBuilder msg = new StringBuilder();
|
||||
msg.append("Uplift attempt [" + upliftScope.getScopeRef() + "] ");
|
||||
msg.append("alu not applicable");
|
||||
msg.append(" allocation: ").append(combination.toString());
|
||||
getLog().append(msg.toString());
|
||||
continue;
|
||||
}
|
||||
|
||||
@ -0,0 +1,214 @@
|
||||
package dk.camelot64.kickc.passes;
|
||||
|
||||
import dk.camelot64.kickc.asm.AsmProgram;
|
||||
import dk.camelot64.kickc.asm.parser.AsmClobber;
|
||||
import dk.camelot64.kickc.icl.*;
|
||||
|
||||
import java.util.*;
|
||||
|
||||
/*** Find potential registers for each equivalence class - based on clobbering of all register combinations in each statement.
|
||||
* <p>
|
||||
* If all possible register combinations in a statement clobbers a register then that register cannot be used for any variable alive
|
||||
* in the statement - except the variable assigned by the statement.
|
||||
*
|
||||
* */
|
||||
public class Pass3RegisterUpliftPotentialRegisterAnalysis extends Pass2Base {
|
||||
|
||||
public Pass3RegisterUpliftPotentialRegisterAnalysis(Program program) {
|
||||
super(program);
|
||||
}
|
||||
|
||||
/*** For each statement - try out all potential register combinations and examine the clobber */
|
||||
public void findPotentialRegisters() {
|
||||
|
||||
LiveRangeEquivalenceClassSet liveRangeEquivalenceClassSet = getProgram().getLiveRangeEquivalenceClassSet();
|
||||
|
||||
RegisterPotentials registerPotentials = getProgram().getRegisterPotentials();
|
||||
|
||||
// Initialize potential registers for all live range equilavence classes
|
||||
if (registerPotentials == null) {
|
||||
registerPotentials = new RegisterPotentials();
|
||||
for (LiveRangeEquivalenceClass equivalenceClass : liveRangeEquivalenceClassSet.getEquivalenceClasses()) {
|
||||
RegisterAllocation.Register defaultRegister = equivalenceClass.getRegister();
|
||||
RegisterAllocation.RegisterType registerType = defaultRegister.getType();
|
||||
if (registerType.equals(RegisterAllocation.RegisterType.ZP_BYTE)) {
|
||||
List<RegisterAllocation.Register> potentials = Arrays.asList(
|
||||
defaultRegister,
|
||||
RegisterAllocation.getRegisterA(),
|
||||
RegisterAllocation.getRegisterX(),
|
||||
RegisterAllocation.getRegisterY());
|
||||
registerPotentials.setPotentialRegisters(equivalenceClass, potentials);
|
||||
} else {
|
||||
registerPotentials.setPotentialRegisters(equivalenceClass, Arrays.asList(defaultRegister));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
for (ControlFlowBlock block : getProgram().getGraph().getAllBlocks()) {
|
||||
for (Statement statement : block.getStatements()) {
|
||||
|
||||
// Find all variables referenced/assigned in the statement
|
||||
Set<VariableRef> referencedVars = getReferencedVars(statement);
|
||||
Set<VariableRef> assignedVars = getAssignedVars(statement);
|
||||
|
||||
// Find referenced/assigned live range equivalence classes
|
||||
Set<LiveRangeEquivalenceClass> assignedClasses = new LinkedHashSet<>();
|
||||
for (VariableRef var : assignedVars) {
|
||||
assignedClasses.add(liveRangeEquivalenceClassSet.getEquivalenceClass(var));
|
||||
}
|
||||
Set<LiveRangeEquivalenceClass> referencedClasses = new LinkedHashSet<>();
|
||||
for (VariableRef var : referencedVars) {
|
||||
referencedClasses.add(liveRangeEquivalenceClassSet.getEquivalenceClass(var));
|
||||
}
|
||||
|
||||
// Generate all combinations of potential register allocations for the referenced equivalence classes
|
||||
// one statement has so few references that all combinations wont explode
|
||||
RegisterCombinationIterator combinationIterator = registerPotentials.getAllCombinations(referencedClasses);
|
||||
|
||||
// For each combination generate the ASM and examine the clobber of all alive variables
|
||||
// Find the registers clobbered by all combinations!
|
||||
Set<RegisterAllocation.Register> alwaysClobbered = findAlwaysClobberedRegisters(block, statement, combinationIterator);
|
||||
if (alwaysClobbered.isEmpty()) {
|
||||
// No registers are always clobbered - move on to the next statement
|
||||
continue;
|
||||
} else {
|
||||
StringBuilder msg = new StringBuilder();
|
||||
msg.append("Statement ").append(statement.toString(getProgram()));
|
||||
msg.append(" always clobbers ");
|
||||
for (RegisterAllocation.Register register : alwaysClobbered) {
|
||||
msg.append(register).append(" ");
|
||||
}
|
||||
getLog().append(msg.toString());
|
||||
}
|
||||
|
||||
// For all non-assigned live variables: remove always clobbered registers from their potential allocation
|
||||
List<VariableRef> aliveVars = getProgram().getLiveRangeVariables().getAlive(statement);
|
||||
for (VariableRef aliveVar : aliveVars) {
|
||||
LiveRangeEquivalenceClass aliveClass = liveRangeEquivalenceClassSet.getEquivalenceClass(aliveVar);
|
||||
if (assignedClasses.contains(aliveClass)) {
|
||||
// Assigned registers are allowed to be be clobbered
|
||||
continue;
|
||||
}
|
||||
List<RegisterAllocation.Register> alivePotentialRegisters = registerPotentials.getPotentialRegisters(aliveClass);
|
||||
for (RegisterAllocation.Register clobberedRegister : alwaysClobbered) {
|
||||
if (alivePotentialRegisters.contains(clobberedRegister)) {
|
||||
registerPotentials.removePotentialRegister(aliveClass, clobberedRegister);
|
||||
StringBuilder msg = new StringBuilder();
|
||||
msg.append("Removing always clobbered register " + clobberedRegister + " as potential for " + aliveClass);
|
||||
getLog().append(msg.toString());
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
getProgram().setRegisterPotentials(registerPotentials);
|
||||
|
||||
}
|
||||
|
||||
/**
|
||||
* Find the registers clobbered by all regsiter allocation combinations.
|
||||
* For each combination generate the ASM and examine the clobber of all alive variables.
|
||||
*
|
||||
* @param block The block containins the statement
|
||||
* @param statement The statement to examine
|
||||
* @param combinations The regsiter combinations to test
|
||||
* @return A set with registers that are clobbered by all different register assignments in the combination
|
||||
*/
|
||||
private Set<RegisterAllocation.Register> findAlwaysClobberedRegisters(ControlFlowBlock block, Statement statement, RegisterCombinationIterator combinations) {
|
||||
Set<RegisterAllocation.Register> alwaysClobbered = new HashSet<>();
|
||||
alwaysClobbered.add(RegisterAllocation.getRegisterA());
|
||||
alwaysClobbered.add(RegisterAllocation.getRegisterX());
|
||||
alwaysClobbered.add(RegisterAllocation.getRegisterY());
|
||||
|
||||
while (combinations.hasNext()) {
|
||||
RegisterCombination combination = combinations.next();
|
||||
// Reset register allocation to original zero page allocation
|
||||
new Pass3RegistersFinalize(getProgram()).allocate(false);
|
||||
// Apply the combination
|
||||
combination.allocate(getProgram().getAllocation());
|
||||
// Generate ASM
|
||||
AsmProgram asm = new AsmProgram();
|
||||
asm.startSegment(statement.getIndex(), statement.toString(getProgram()));
|
||||
Pass3CodeGeneration.AsmCodegenAluState aluState = new Pass3CodeGeneration.AsmCodegenAluState();
|
||||
(new Pass3CodeGeneration(getProgram())).generateStatementAsm(asm, block, statement, aluState);
|
||||
AsmClobber clobber = asm.getClobber();
|
||||
Collection<RegisterAllocation.Register> clobberRegisters = Pass3AssertNoCpuClobber.getClobberRegisters(clobber);
|
||||
Iterator<RegisterAllocation.Register> alwaysClobberIt = alwaysClobbered.iterator();
|
||||
while (alwaysClobberIt.hasNext()) {
|
||||
RegisterAllocation.Register alwaysClobberRegister = alwaysClobberIt.next();
|
||||
if (!clobberRegisters.contains(alwaysClobberRegister)) {
|
||||
alwaysClobberIt.remove();
|
||||
}
|
||||
}
|
||||
if (alwaysClobbered.isEmpty()) {
|
||||
// No register is always clobbered - abort combination search
|
||||
break;
|
||||
}
|
||||
}
|
||||
return alwaysClobbered;
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Get all variables referenced (or assigned) in a statement.
|
||||
*
|
||||
* @param statement The statement
|
||||
* @return All variables referenced (or assigned) in the statement
|
||||
*/
|
||||
public static Set<VariableRef> getReferencedVars(Statement statement) {
|
||||
Set<VariableRef> referenced = new LinkedHashSet<>();
|
||||
if (statement instanceof StatementAssignment) {
|
||||
addReferenced(referenced, ((StatementAssignment) statement).getlValue());
|
||||
addReferenced(referenced, ((StatementAssignment) statement).getrValue1());
|
||||
addReferenced(referenced, ((StatementAssignment) statement).getrValue2());
|
||||
} else if (statement instanceof StatementPhiBlock) {
|
||||
for (StatementPhiBlock.PhiVariable phiVariable : ((StatementPhiBlock) statement).getPhiVariables()) {
|
||||
addReferenced(referenced, phiVariable.getVariable());
|
||||
for (StatementPhiBlock.PhiRValue phiRValue : phiVariable.getValues()) {
|
||||
addReferenced(referenced, phiRValue.getrValue());
|
||||
}
|
||||
}
|
||||
} else if (statement instanceof StatementConditionalJump) {
|
||||
addReferenced(referenced, ((StatementConditionalJump) statement).getrValue1());
|
||||
addReferenced(referenced, ((StatementConditionalJump) statement).getrValue2());
|
||||
}
|
||||
return referenced;
|
||||
}
|
||||
|
||||
private static void addReferenced(Set<VariableRef> referenced, RValue rValue) {
|
||||
if (rValue instanceof VariableRef) {
|
||||
referenced.add((VariableRef) rValue);
|
||||
} else if (rValue instanceof PointerDereferenceSimple) {
|
||||
addReferenced(referenced, ((PointerDereferenceSimple) rValue).getPointer());
|
||||
} else if (rValue instanceof PointerDereferenceIndexed) {
|
||||
addReferenced(referenced, ((PointerDereferenceIndexed) rValue).getPointer());
|
||||
addReferenced(referenced, ((PointerDereferenceIndexed) rValue).getIndex());
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Get all variables assigned a value in a statement
|
||||
*
|
||||
* @param statement The statement
|
||||
* @return The variables assigned a value in the statement
|
||||
*/
|
||||
public static Set<VariableRef> getAssignedVars(Statement statement) {
|
||||
LinkedHashSet<VariableRef> variableRefs = new LinkedHashSet<>();
|
||||
if (statement instanceof StatementPhiBlock) {
|
||||
List<StatementPhiBlock.PhiVariable> phiVariables = ((StatementPhiBlock) statement).getPhiVariables();
|
||||
for (StatementPhiBlock.PhiVariable phiVariable : phiVariables) {
|
||||
variableRefs.add(phiVariable.getVariable());
|
||||
}
|
||||
return variableRefs;
|
||||
} else if (statement instanceof StatementAssignment) {
|
||||
LValue lValue = ((StatementAssignment) statement).getlValue();
|
||||
if (lValue instanceof VariableRef) {
|
||||
variableRefs.add((VariableRef) lValue);
|
||||
}
|
||||
}
|
||||
return variableRefs;
|
||||
}
|
||||
|
||||
|
||||
}
|
||||
@ -64,6 +64,10 @@ public class TestCompilationOutput extends TestCase {
|
||||
compileAndCompare("ptrtest");
|
||||
}
|
||||
|
||||
public void testPtrTestMin() throws IOException, URISyntaxException {
|
||||
compileAndCompare("ptrtestmin");
|
||||
}
|
||||
|
||||
public void testUseGlobal() throws IOException, URISyntaxException {
|
||||
compileAndCompare("useglobal");
|
||||
}
|
||||
|
||||
18
src/main/java/dk/camelot64/kickc/test/ptrtestmin.kc
Normal file
18
src/main/java/dk/camelot64/kickc/test/ptrtestmin.kc
Normal file
@ -0,0 +1,18 @@
|
||||
// Test all types of pointers
|
||||
|
||||
main();
|
||||
|
||||
void main() {
|
||||
|
||||
// A constant pointer
|
||||
byte[1024] SCREEN = $0400;
|
||||
|
||||
byte b;
|
||||
|
||||
// RValue constant array variable index
|
||||
byte i=2;
|
||||
while(i<10) {
|
||||
b = SCREEN[i++];
|
||||
}
|
||||
|
||||
}
|
||||
@ -1171,134 +1171,33 @@ B3_from_B2:
|
||||
//SEG31 [6] phi (byte*) cursor#5 = (byte*) cursor#2 -- register_copy
|
||||
jmp B3
|
||||
|
||||
Statement [1] *((byte*) cursor#3) ← (byte) 81 [ cursor#3 x#2 e#3 y#2 ] always clobbers reg byte y reg byte a
|
||||
Removing always clobbered register reg byte y as potential for zp byte:4 [ x#2 x#1 ]
|
||||
Removing always clobbered register reg byte a as potential for zp byte:4 [ x#2 x#1 ]
|
||||
Removing always clobbered register reg byte y as potential for zp byte:5 [ e#3 e#5 e#1 e#2 ]
|
||||
Removing always clobbered register reg byte a as potential for zp byte:5 [ e#3 e#5 e#1 e#2 ]
|
||||
Removing always clobbered register reg byte y as potential for zp byte:6 [ y#2 y#4 y#1 ]
|
||||
Removing always clobbered register reg byte a as potential for zp byte:6 [ y#2 y#4 y#1 ]
|
||||
Statement [4] (byte) e#1 ← (byte) e#3 + (byte) 24 [ x#1 e#1 cursor#1 y#2 ] always clobbers reg byte a
|
||||
Statement [9] (byte*) cursor#2 ← (byte*) cursor#1 + (byte) 40 [ x#1 e#1 cursor#2 y#1 ] always clobbers reg byte a
|
||||
Statement [10] (byte) e#2 ← (byte) e#1 - (byte) 39 [ x#1 cursor#2 e#2 y#1 ] always clobbers reg byte a
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] : zp ptr byte:2 ,
|
||||
Potential registers zp byte:4 [ x#2 x#1 ] : zp byte:4 , reg byte x ,
|
||||
Potential registers zp byte:5 [ e#3 e#5 e#1 e#2 ] : zp byte:5 , reg byte x ,
|
||||
Potential registers zp byte:6 [ y#2 y#4 y#1 ] : zp byte:6 , reg byte x ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [] 55: zp byte:5 [ e#3 e#5 e#1 e#2 ] 46.75: zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] 29.33: zp byte:6 [ y#2 y#4 y#1 ] 14.67: zp byte:4 [ x#2 x#1 ]
|
||||
|
||||
Uplift attempt [] 1280 allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] 1180 allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 1220 allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte a [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 1190 allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte x [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte a [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte x [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:5 [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] reg byte y [ y#2 y#4 y#1 ] reg byte y [ x#2 x#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplifting [] best 1180 combination reg byte x [ e#3 e#5 e#1 e#2 ] zp ptr byte:2 [ cursor#3 cursor#5 cursor#1 cursor#2 ] zp byte:6 [ y#2 y#4 y#1 ] zp byte:4 [ x#2 x#1 ]
|
||||
Re-allocated ZP register from zp byte:6 to zp byte:5
|
||||
Removing instruction jmp B1
|
||||
|
||||
@ -8,8 +8,10 @@ B1_from_BBEGIN:
|
||||
B1_from_B1:
|
||||
B1:
|
||||
lda 4352,x
|
||||
sta 2
|
||||
lda 4353,x
|
||||
clc
|
||||
adc 4353,x
|
||||
adc 2
|
||||
sta 4354,x
|
||||
inx
|
||||
cpx #15
|
||||
|
||||
@ -487,6 +487,14 @@ B1:
|
||||
//SEG14 @END
|
||||
BEND:
|
||||
|
||||
Statement [0] *((word) 4352) ← (byte) 0 [ ] always clobbers reg byte a
|
||||
Statement [1] *((word) 4353) ← (byte) 1 [ ] always clobbers reg byte a
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ i#2 i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:3 [ $1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:4 [ $3 ] : zp byte:4 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:5 [ $4 ] : zp byte:5 , reg byte a , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [] 27.5: zp byte:2 [ i#2 i#1 ] 22: zp byte:4 [ $3 ] 22: zp byte:5 [ $4 ] 11: zp byte:3 [ $1 ]
|
||||
|
||||
@ -494,756 +502,260 @@ Uplift attempt [] 707 allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 527 allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 527 allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 647 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 487 allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 487 allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment zpby1=zpby2_plus_cowo1_staridx_zpby3
|
||||
Uplift attempt [] missing fragment zpby1=zpby2_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment zpby1=zpby2_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment zpby1=zpby2_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 647 allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 587 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 407 allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 407 allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 627 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 427 allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 627 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 427 allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment aby=zpby1_plus_cowo1_staridx_zpby2
|
||||
Uplift attempt [] missing fragment aby=zpby1_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment aby=zpby1_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment aby=zpby1_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 507 allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 627 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 447 allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 667 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 667 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment xby=zpby1_plus_cowo1_staridx_zpby2
|
||||
Uplift attempt [] missing fragment xby=zpby1_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment xby=zpby1_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment xby=zpby1_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 507 allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 627 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 447 allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 667 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 667 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment yby=zpby1_plus_cowo1_staridx_zpby2
|
||||
Uplift attempt [] missing fragment yby=zpby1_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment yby=zpby1_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment yby=zpby1_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=zpby2_plus_zpby3
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=zpby1_plus_zpby2
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=zpby1_plus_zpby2
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=zpby1_plus_zpby2
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=zpby2_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=zpby1_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=zpby1_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=zpby1_plus_aby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=zpby2_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=zpby1_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=zpby1_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=zpby1_plus_xby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=zpby2_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=zpby1_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=zpby1_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=zpby1_plus_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment zpby1=aby_plus_cowo1_staridx_zpby2
|
||||
Uplift attempt [] missing fragment zpby1=aby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment zpby1=aby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment zpby1=aby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] 407 allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] 407 allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment aby=aby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment aby=aby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] 347 allocation: reg byte x [ i#2 i#1 ] reg byte alu [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] missing fragment aby=aby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] 447 allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment xby=aby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment xby=aby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment xby=aby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment xby=aby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] 447 allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment yby=aby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment yby=aby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment yby=aby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment yby=aby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=aby_plus_zpby2
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=aby_plus_zpby1
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=aby_plus_zpby1
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=aby_plus_zpby1
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=aby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=aby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=aby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=aby_plus_aby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=aby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=aby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=aby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=aby_plus_xby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=aby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=aby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=aby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=aby_plus_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] 487 allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 707 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment zpby1=xby_plus_cowo1_staridx_zpby2
|
||||
Uplift attempt [] missing fragment zpby1=xby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment zpby1=xby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment zpby1=xby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] 427 allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] 407 allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 647 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment aby=xby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment aby=xby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment aby=xby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment aby=xby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] 447 allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment xby=xby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment xby=xby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment xby=xby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment xby=xby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment yby=xby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment yby=xby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment yby=xby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment yby=xby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=xby_plus_zpby2
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=xby_plus_zpby1
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=xby_plus_zpby1
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=xby_plus_zpby1
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=xby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=xby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=xby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=xby_plus_aby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=xby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=xby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=xby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=xby_plus_xby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=xby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=xby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=xby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=xby_plus_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] 487 allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 667 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 707 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] zp byte:5 [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment zpby1=yby_plus_cowo1_staridx_zpby2
|
||||
Uplift attempt [] missing fragment zpby1=yby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment zpby1=yby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment zpby1=yby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 627 allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] 427 allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 607 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] 407 allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 647 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte a [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment aby=yby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment aby=yby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment aby=yby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment aby=yby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 667 allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 647 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte x [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment xby=yby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment xby=yby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment xby=yby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment xby=yby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 667 allocation: zp byte:2 [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] 467 allocation: reg byte x [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] zp byte:4 [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 647 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] 447 allocation: reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte a [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 687 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte x [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $3 ] reg byte y [ $4 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment yby=yby_plus_cowo1_staridx_zpby1
|
||||
Uplift attempt [] missing fragment yby=yby_plus_cowo1_staridx_aby
|
||||
Uplift attempt [] missing fragment yby=yby_plus_cowo1_staridx_xby
|
||||
Uplift attempt [] missing fragment yby=yby_plus_cowo1_staridx_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=yby_plus_zpby2
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=yby_plus_zpby1
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=yby_plus_zpby1
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=yby_plus_zpby1
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=yby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=yby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=yby_plus_aby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=yby_plus_aby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=yby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=yby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=yby_plus_xby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=yby_plus_xby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=yby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=yby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=yby_plus_yby
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=yby_plus_yby
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplifting [] best 347 combination reg byte x [ i#2 i#1 ] reg byte alu [ $3 ] reg byte a [ $4 ] reg byte a [ $1 ]
|
||||
MISSING FRAGMENTS
|
||||
zpby1=zpby2_plus_cowo1_staridx_zpby3
|
||||
zpby1=zpby2_plus_cowo1_staridx_aby
|
||||
zpby1=zpby2_plus_cowo1_staridx_xby
|
||||
zpby1=zpby2_plus_cowo1_staridx_yby
|
||||
aby=zpby1_plus_cowo1_staridx_zpby2
|
||||
aby=zpby1_plus_cowo1_staridx_aby
|
||||
aby=zpby1_plus_cowo1_staridx_xby
|
||||
aby=zpby1_plus_cowo1_staridx_yby
|
||||
xby=zpby1_plus_cowo1_staridx_zpby2
|
||||
xby=zpby1_plus_cowo1_staridx_aby
|
||||
xby=zpby1_plus_cowo1_staridx_xby
|
||||
xby=zpby1_plus_cowo1_staridx_yby
|
||||
yby=zpby1_plus_cowo1_staridx_zpby2
|
||||
yby=zpby1_plus_cowo1_staridx_aby
|
||||
yby=zpby1_plus_cowo1_staridx_xby
|
||||
yby=zpby1_plus_cowo1_staridx_yby
|
||||
cowo1_staridx_zpby1=zpby2_plus_zpby3
|
||||
cowo1_staridx_aby=zpby1_plus_zpby2
|
||||
cowo1_staridx_xby=zpby1_plus_zpby2
|
||||
cowo1_staridx_yby=zpby1_plus_zpby2
|
||||
cowo1_staridx_zpby1=zpby2_plus_aby
|
||||
cowo1_staridx_aby=zpby1_plus_aby
|
||||
cowo1_staridx_xby=zpby1_plus_aby
|
||||
cowo1_staridx_yby=zpby1_plus_aby
|
||||
cowo1_staridx_zpby1=zpby2_plus_xby
|
||||
cowo1_staridx_aby=zpby1_plus_xby
|
||||
cowo1_staridx_xby=zpby1_plus_xby
|
||||
cowo1_staridx_yby=zpby1_plus_xby
|
||||
cowo1_staridx_zpby1=zpby2_plus_yby
|
||||
cowo1_staridx_aby=zpby1_plus_yby
|
||||
cowo1_staridx_xby=zpby1_plus_yby
|
||||
cowo1_staridx_yby=zpby1_plus_yby
|
||||
zpby1=aby_plus_cowo1_staridx_zpby2
|
||||
zpby1=aby_plus_cowo1_staridx_aby
|
||||
zpby1=aby_plus_cowo1_staridx_xby
|
||||
zpby1=aby_plus_cowo1_staridx_yby
|
||||
aby=aby_plus_cowo1_staridx_zpby1
|
||||
aby=aby_plus_cowo1_staridx_aby
|
||||
aby=aby_plus_cowo1_staridx_yby
|
||||
xby=aby_plus_cowo1_staridx_zpby1
|
||||
xby=aby_plus_cowo1_staridx_aby
|
||||
xby=aby_plus_cowo1_staridx_xby
|
||||
xby=aby_plus_cowo1_staridx_yby
|
||||
yby=aby_plus_cowo1_staridx_zpby1
|
||||
yby=aby_plus_cowo1_staridx_aby
|
||||
yby=aby_plus_cowo1_staridx_xby
|
||||
yby=aby_plus_cowo1_staridx_yby
|
||||
cowo1_staridx_zpby1=aby_plus_zpby2
|
||||
cowo1_staridx_aby=aby_plus_zpby1
|
||||
cowo1_staridx_xby=aby_plus_zpby1
|
||||
cowo1_staridx_yby=aby_plus_zpby1
|
||||
cowo1_staridx_zpby1=aby_plus_aby
|
||||
cowo1_staridx_aby=aby_plus_aby
|
||||
cowo1_staridx_xby=aby_plus_aby
|
||||
cowo1_staridx_yby=aby_plus_aby
|
||||
cowo1_staridx_zpby1=aby_plus_xby
|
||||
cowo1_staridx_aby=aby_plus_xby
|
||||
cowo1_staridx_xby=aby_plus_xby
|
||||
cowo1_staridx_yby=aby_plus_xby
|
||||
cowo1_staridx_zpby1=aby_plus_yby
|
||||
cowo1_staridx_aby=aby_plus_yby
|
||||
cowo1_staridx_xby=aby_plus_yby
|
||||
cowo1_staridx_yby=aby_plus_yby
|
||||
zpby1=xby_plus_cowo1_staridx_zpby2
|
||||
zpby1=xby_plus_cowo1_staridx_aby
|
||||
zpby1=xby_plus_cowo1_staridx_xby
|
||||
zpby1=xby_plus_cowo1_staridx_yby
|
||||
aby=xby_plus_cowo1_staridx_zpby1
|
||||
aby=xby_plus_cowo1_staridx_aby
|
||||
aby=xby_plus_cowo1_staridx_xby
|
||||
aby=xby_plus_cowo1_staridx_yby
|
||||
xby=xby_plus_cowo1_staridx_zpby1
|
||||
xby=xby_plus_cowo1_staridx_aby
|
||||
xby=xby_plus_cowo1_staridx_xby
|
||||
xby=xby_plus_cowo1_staridx_yby
|
||||
yby=xby_plus_cowo1_staridx_zpby1
|
||||
yby=xby_plus_cowo1_staridx_aby
|
||||
yby=xby_plus_cowo1_staridx_xby
|
||||
yby=xby_plus_cowo1_staridx_yby
|
||||
cowo1_staridx_zpby1=xby_plus_zpby2
|
||||
cowo1_staridx_aby=xby_plus_zpby1
|
||||
cowo1_staridx_xby=xby_plus_zpby1
|
||||
cowo1_staridx_yby=xby_plus_zpby1
|
||||
cowo1_staridx_zpby1=xby_plus_aby
|
||||
cowo1_staridx_aby=xby_plus_aby
|
||||
cowo1_staridx_xby=xby_plus_aby
|
||||
cowo1_staridx_yby=xby_plus_aby
|
||||
cowo1_staridx_zpby1=xby_plus_xby
|
||||
cowo1_staridx_aby=xby_plus_xby
|
||||
cowo1_staridx_xby=xby_plus_xby
|
||||
cowo1_staridx_yby=xby_plus_xby
|
||||
cowo1_staridx_zpby1=xby_plus_yby
|
||||
cowo1_staridx_aby=xby_plus_yby
|
||||
cowo1_staridx_xby=xby_plus_yby
|
||||
cowo1_staridx_yby=xby_plus_yby
|
||||
zpby1=yby_plus_cowo1_staridx_zpby2
|
||||
zpby1=yby_plus_cowo1_staridx_aby
|
||||
zpby1=yby_plus_cowo1_staridx_xby
|
||||
zpby1=yby_plus_cowo1_staridx_yby
|
||||
aby=yby_plus_cowo1_staridx_zpby1
|
||||
aby=yby_plus_cowo1_staridx_aby
|
||||
aby=yby_plus_cowo1_staridx_xby
|
||||
aby=yby_plus_cowo1_staridx_yby
|
||||
xby=yby_plus_cowo1_staridx_zpby1
|
||||
xby=yby_plus_cowo1_staridx_aby
|
||||
xby=yby_plus_cowo1_staridx_xby
|
||||
xby=yby_plus_cowo1_staridx_yby
|
||||
yby=yby_plus_cowo1_staridx_zpby1
|
||||
yby=yby_plus_cowo1_staridx_aby
|
||||
yby=yby_plus_cowo1_staridx_xby
|
||||
yby=yby_plus_cowo1_staridx_yby
|
||||
cowo1_staridx_zpby1=yby_plus_zpby2
|
||||
cowo1_staridx_aby=yby_plus_zpby1
|
||||
cowo1_staridx_xby=yby_plus_zpby1
|
||||
cowo1_staridx_yby=yby_plus_zpby1
|
||||
cowo1_staridx_zpby1=yby_plus_aby
|
||||
cowo1_staridx_aby=yby_plus_aby
|
||||
cowo1_staridx_xby=yby_plus_aby
|
||||
cowo1_staridx_yby=yby_plus_aby
|
||||
cowo1_staridx_zpby1=yby_plus_xby
|
||||
cowo1_staridx_aby=yby_plus_xby
|
||||
cowo1_staridx_xby=yby_plus_xby
|
||||
cowo1_staridx_yby=yby_plus_xby
|
||||
cowo1_staridx_zpby1=yby_plus_yby
|
||||
cowo1_staridx_aby=yby_plus_yby
|
||||
cowo1_staridx_xby=yby_plus_yby
|
||||
cowo1_staridx_yby=yby_plus_yby
|
||||
Uplifting [] best 407 combination reg byte x [ i#2 i#1 ] reg byte a [ $3 ] reg byte a [ $4 ] zp byte:3 [ $1 ]
|
||||
Re-allocated ZP register from zp byte:3 to zp byte:2
|
||||
Removing instruction jmp B1
|
||||
Removing instruction jmp BEND
|
||||
Succesful ASM optimization Pass5NextJumpElimination
|
||||
@ -1266,13 +778,14 @@ B1_from_B1:
|
||||
//SEG6 [2] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
//SEG7 @1
|
||||
B1:
|
||||
//SEG8 [3] (byte~) $1 ← (word) 4352 *idx (byte) i#2 [ i#2 $1 ] -- aby=cowo1_staridx_xby
|
||||
//SEG8 [3] (byte~) $1 ← (word) 4352 *idx (byte) i#2 [ i#2 $1 ] -- zpby1=cowo1_staridx_xby
|
||||
lda 4352,x
|
||||
//SEG9 [4] (byte~) $3 ← (word) 4353 *idx (byte) i#2 [ i#2 $1 $3 ]
|
||||
// [4] $3 ← 4353 *idx i#2 // ALU
|
||||
//SEG10 [5] (byte~) $4 ← (byte~) $1 + (byte~) $3 [ i#2 $4 ] -- aby=aby_plus_cowo1_staridx_xby
|
||||
sta 2
|
||||
//SEG9 [4] (byte~) $3 ← (word) 4353 *idx (byte) i#2 [ i#2 $1 $3 ] -- aby=cowo1_staridx_xby
|
||||
lda 4353,x
|
||||
//SEG10 [5] (byte~) $4 ← (byte~) $1 + (byte~) $3 [ i#2 $4 ] -- aby=zpby1_plus_aby
|
||||
clc
|
||||
adc 4353,x
|
||||
adc 2
|
||||
//SEG11 [6] *((word) 4354 + (byte) i#2) ← (byte~) $4 [ i#2 ] -- cowo1_staridx_xby=aby
|
||||
sta 4354,x
|
||||
//SEG12 [7] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1
|
||||
@ -1303,13 +816,14 @@ B1_from_B1:
|
||||
//SEG6 [2] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
//SEG7 @1
|
||||
B1:
|
||||
//SEG8 [3] (byte~) $1 ← (word) 4352 *idx (byte) i#2 [ i#2 $1 ] -- aby=cowo1_staridx_xby
|
||||
//SEG8 [3] (byte~) $1 ← (word) 4352 *idx (byte) i#2 [ i#2 $1 ] -- zpby1=cowo1_staridx_xby
|
||||
lda 4352,x
|
||||
//SEG9 [4] (byte~) $3 ← (word) 4353 *idx (byte) i#2 [ i#2 $1 $3 ]
|
||||
// [4] $3 ← 4353 *idx i#2 // ALU
|
||||
//SEG10 [5] (byte~) $4 ← (byte~) $1 + (byte~) $3 [ i#2 $4 ] -- aby=aby_plus_cowo1_staridx_xby
|
||||
sta 2
|
||||
//SEG9 [4] (byte~) $3 ← (word) 4353 *idx (byte) i#2 [ i#2 $1 $3 ] -- aby=cowo1_staridx_xby
|
||||
lda 4353,x
|
||||
//SEG10 [5] (byte~) $4 ← (byte~) $1 + (byte~) $3 [ i#2 $4 ] -- aby=zpby1_plus_aby
|
||||
clc
|
||||
adc 4353,x
|
||||
adc 2
|
||||
//SEG11 [6] *((word) 4354 + (byte) i#2) ← (byte~) $4 [ i#2 ] -- cowo1_staridx_xby=aby
|
||||
sta 4354,x
|
||||
//SEG12 [7] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1
|
||||
@ -1321,8 +835,8 @@ B1:
|
||||
BEND:
|
||||
|
||||
FINAL SYMBOL TABLE
|
||||
(byte~) $1 reg byte a 11.0
|
||||
(byte~) $3 reg byte alu 22.0
|
||||
(byte~) $1 zp byte:2 11.0
|
||||
(byte~) $3 reg byte a 22.0
|
||||
(byte~) $4 reg byte a 22.0
|
||||
(label) @1
|
||||
(label) @BEGIN
|
||||
@ -1333,8 +847,8 @@ FINAL SYMBOL TABLE
|
||||
(byte) i#2 reg byte x 11.0
|
||||
|
||||
reg byte x [ i#2 i#1 ]
|
||||
reg byte a [ $1 ]
|
||||
reg byte alu [ $3 ]
|
||||
zp byte:2 [ $1 ]
|
||||
reg byte a [ $3 ]
|
||||
reg byte a [ $4 ]
|
||||
|
||||
FINAL CODE
|
||||
@ -1355,13 +869,14 @@ B1_from_B1:
|
||||
//SEG6 [2] phi (byte) i#2 = (byte) i#1 -- register_copy
|
||||
//SEG7 @1
|
||||
B1:
|
||||
//SEG8 [3] (byte~) $1 ← (word) 4352 *idx (byte) i#2 [ i#2 $1 ] -- aby=cowo1_staridx_xby
|
||||
//SEG8 [3] (byte~) $1 ← (word) 4352 *idx (byte) i#2 [ i#2 $1 ] -- zpby1=cowo1_staridx_xby
|
||||
lda 4352,x
|
||||
//SEG9 [4] (byte~) $3 ← (word) 4353 *idx (byte) i#2 [ i#2 $1 $3 ]
|
||||
// [4] $3 ← 4353 *idx i#2 // ALU
|
||||
//SEG10 [5] (byte~) $4 ← (byte~) $1 + (byte~) $3 [ i#2 $4 ] -- aby=aby_plus_cowo1_staridx_xby
|
||||
sta 2
|
||||
//SEG9 [4] (byte~) $3 ← (word) 4353 *idx (byte) i#2 [ i#2 $1 $3 ] -- aby=cowo1_staridx_xby
|
||||
lda 4353,x
|
||||
//SEG10 [5] (byte~) $4 ← (byte~) $1 + (byte~) $3 [ i#2 $4 ] -- aby=zpby1_plus_aby
|
||||
clc
|
||||
adc 4353,x
|
||||
adc 2
|
||||
//SEG11 [6] *((word) 4354 + (byte) i#2) ← (byte~) $4 [ i#2 ] -- cowo1_staridx_xby=aby
|
||||
sta 4354,x
|
||||
//SEG12 [7] (byte) i#1 ← (byte) i#2 + (byte) 1 [ i#1 ] -- xby=xby_plus_1
|
||||
|
||||
@ -1,5 +1,5 @@
|
||||
(byte~) $1 reg byte a 11.0
|
||||
(byte~) $3 reg byte alu 22.0
|
||||
(byte~) $1 zp byte:2 11.0
|
||||
(byte~) $3 reg byte a 22.0
|
||||
(byte~) $4 reg byte a 22.0
|
||||
(label) @1
|
||||
(label) @BEGIN
|
||||
@ -10,6 +10,6 @@
|
||||
(byte) i#2 reg byte x 11.0
|
||||
|
||||
reg byte x [ i#2 i#1 ]
|
||||
reg byte a [ $1 ]
|
||||
reg byte alu [ $3 ]
|
||||
zp byte:2 [ $1 ]
|
||||
reg byte a [ $3 ]
|
||||
reg byte a [ $4 ]
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@ -429,6 +429,10 @@ B3_from_B2:
|
||||
//SEG18 [2] phi (byte) s#4 = (byte) s#1 -- register_copy
|
||||
jmp B3
|
||||
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ i#2 i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:3 [ s#2 s#4 s#1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [] 49.5: zp byte:3 [ s#2 s#4 s#1 ] 27.5: zp byte:2 [ i#2 i#1 ]
|
||||
|
||||
@ -436,27 +440,18 @@ Uplift attempt [] 565 allocation: zp byte:3 [ s#2 s#4 s#1 ] zp byte:2 [ i#2 i#1
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s#2 s#4 s#1 ] zp byte:2 [ i#2 i#1 ]
|
||||
Uplift attempt [] 515 allocation: reg byte x [ s#2 s#4 s#1 ] zp byte:2 [ i#2 i#1 ]
|
||||
Uplift attempt [] 515 allocation: reg byte y [ s#2 s#4 s#1 ] zp byte:2 [ i#2 i#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:3 [ s#2 s#4 s#1 ] reg byte a [ i#2 i#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s#2 s#4 s#1 ] reg byte a [ i#2 i#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s#2 s#4 s#1 ] reg byte a [ i#2 i#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s#2 s#4 s#1 ] reg byte a [ i#2 i#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 455 allocation: zp byte:3 [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ]
|
||||
Uplift attempt [] 405 allocation: reg byte a [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ]
|
||||
Uplift attempt [] 445 allocation: reg byte y [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 455 allocation: zp byte:3 [ s#2 s#4 s#1 ] reg byte y [ i#2 i#1 ]
|
||||
Uplift attempt [] 405 allocation: reg byte a [ s#2 s#4 s#1 ] reg byte y [ i#2 i#1 ]
|
||||
Uplift attempt [] 445 allocation: reg byte x [ s#2 s#4 s#1 ] reg byte y [ i#2 i#1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s#2 s#4 s#1 ] reg byte y [ i#2 i#1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplifting [] best 405 combination reg byte a [ s#2 s#4 s#1 ] reg byte x [ i#2 i#1 ]
|
||||
Removing instruction jmp B1
|
||||
Removing instruction jmp B3
|
||||
|
||||
@ -793,6 +793,10 @@ nest__Breturn:
|
||||
//SEG25 [10] return [ main::i#2 ]
|
||||
rts
|
||||
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:3 [ nest::j#2 nest::j#1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [nest] 303: zp byte:3 [ nest::j#2 nest::j#1 ]
|
||||
Uplift Scope [main] 19.64: zp byte:2 [ main::i#2 main::i#1 ]
|
||||
@ -802,13 +806,11 @@ Uplift attempt [nest] 3506 allocation: zp byte:3 [ nest::j#2 nest::j#1 ]
|
||||
Uplift attempt [nest] 2706 allocation: reg byte a [ nest::j#2 nest::j#1 ]
|
||||
Uplift attempt [nest] 2506 allocation: reg byte x [ nest::j#2 nest::j#1 ]
|
||||
Uplift attempt [nest] 2506 allocation: reg byte y [ nest::j#2 nest::j#1 ]
|
||||
Uplift attempt [nest] alu not applicable
|
||||
Uplifting [nest] best 2506 combination reg byte x [ nest::j#2 nest::j#1 ]
|
||||
Uplift attempt [main] 2506 allocation: zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 2456 allocation: reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 2436 allocation: reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplifting [main] best 2436 combination reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [] 2436 allocation:
|
||||
Uplifting [] best 2436 combination
|
||||
|
||||
@ -1989,6 +1989,14 @@ nest2__Breturn:
|
||||
//SEG61 [24] return [ main::j#2 main::i#2 nest1::j#2 nest1::i#2 ]
|
||||
rts
|
||||
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:3 [ main::j#2 main::j#1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:4 [ nest1::i#2 nest1::i#1 ] : zp byte:4 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:5 [ nest1::j#2 nest1::j#1 ] : zp byte:5 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:6 [ nest2::i#2 nest2::i#1 ] : zp byte:6 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:7 [ nest2::j#2 nest2::j#1 ] : zp byte:7 , reg byte a , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [nest2] 3,000,003: zp byte:7 [ nest2::j#2 nest2::j#1 ] 190,001.9: zp byte:6 [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift Scope [nest1] 17,001.7: zp byte:5 [ nest1::j#2 nest1::j#1 ] 1,655.5: zp byte:4 [ nest1::i#2 nest1::i#1 ]
|
||||
@ -1999,79 +2007,52 @@ Uplift attempt [nest2] 34313122 allocation: zp byte:7 [ nest2::j#2 nest2::j#1 ]
|
||||
Uplift attempt [nest2] 26313122 allocation: reg byte a [ nest2::j#2 nest2::j#1 ] zp byte:6 [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] 24313122 allocation: reg byte x [ nest2::j#2 nest2::j#1 ] zp byte:6 [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] 24313122 allocation: reg byte y [ nest2::j#2 nest2::j#1 ] zp byte:6 [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplift attempt [nest2] clobber allocation: zp byte:7 [ nest2::j#2 nest2::j#1 ] reg byte a [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] clobber allocation: reg byte a [ nest2::j#2 nest2::j#1 ] reg byte a [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] 23813122 allocation: reg byte x [ nest2::j#2 nest2::j#1 ] reg byte a [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] 23813122 allocation: reg byte y [ nest2::j#2 nest2::j#1 ] reg byte a [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplift attempt [nest2] 33613122 allocation: zp byte:7 [ nest2::j#2 nest2::j#1 ] reg byte x [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] 25613122 allocation: reg byte a [ nest2::j#2 nest2::j#1 ] reg byte x [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] clobber allocation: reg byte x [ nest2::j#2 nest2::j#1 ] reg byte x [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] 23613122 allocation: reg byte y [ nest2::j#2 nest2::j#1 ] reg byte x [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplift attempt [nest2] 33613122 allocation: zp byte:7 [ nest2::j#2 nest2::j#1 ] reg byte y [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] 25613122 allocation: reg byte a [ nest2::j#2 nest2::j#1 ] reg byte y [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] 23613122 allocation: reg byte x [ nest2::j#2 nest2::j#1 ] reg byte y [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] clobber allocation: reg byte y [ nest2::j#2 nest2::j#1 ] reg byte y [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplift attempt [nest2] alu not applicable
|
||||
Uplifting [nest2] best 23613122 combination reg byte y [ nest2::j#2 nest2::j#1 ] reg byte x [ nest2::i#2 nest2::i#1 ]
|
||||
Uplift attempt [nest1] 23613122 allocation: zp byte:5 [ nest1::j#2 nest1::j#1 ] zp byte:4 [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] 23563122 allocation: reg byte a [ nest1::j#2 nest1::j#1 ] zp byte:4 [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte x [ nest1::j#2 nest1::j#1 ] zp byte:4 [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte y [ nest1::j#2 nest1::j#1 ] zp byte:4 [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplift attempt [nest1] clobber allocation: zp byte:5 [ nest1::j#2 nest1::j#1 ] reg byte a [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte a [ nest1::j#2 nest1::j#1 ] reg byte a [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte x [ nest1::j#2 nest1::j#1 ] reg byte a [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte y [ nest1::j#2 nest1::j#1 ] reg byte a [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplift attempt [nest1] clobber allocation: zp byte:5 [ nest1::j#2 nest1::j#1 ] reg byte x [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte a [ nest1::j#2 nest1::j#1 ] reg byte x [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte x [ nest1::j#2 nest1::j#1 ] reg byte x [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte y [ nest1::j#2 nest1::j#1 ] reg byte x [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplift attempt [nest1] clobber allocation: zp byte:5 [ nest1::j#2 nest1::j#1 ] reg byte y [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte a [ nest1::j#2 nest1::j#1 ] reg byte y [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte x [ nest1::j#2 nest1::j#1 ] reg byte y [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] clobber allocation: reg byte y [ nest1::j#2 nest1::j#1 ] reg byte y [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplift attempt [nest1] alu not applicable
|
||||
Uplifting [nest1] best 23563122 combination reg byte a [ nest1::j#2 nest1::j#1 ] zp byte:4 [ nest1::i#2 nest1::i#1 ]
|
||||
Uplift attempt [main] 23563122 allocation: zp byte:3 [ main::j#2 main::j#1 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte a [ main::j#2 main::j#1 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte x [ main::j#2 main::j#1 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte y [ main::j#2 main::j#1 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] clobber allocation: zp byte:3 [ main::j#2 main::j#1 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte a [ main::j#2 main::j#1 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte x [ main::j#2 main::j#1 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte y [ main::j#2 main::j#1 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] clobber allocation: zp byte:3 [ main::j#2 main::j#1 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte a [ main::j#2 main::j#1 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte x [ main::j#2 main::j#1 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte y [ main::j#2 main::j#1 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] clobber allocation: zp byte:3 [ main::j#2 main::j#1 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte a [ main::j#2 main::j#1 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte x [ main::j#2 main::j#1 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte y [ main::j#2 main::j#1 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplifting [main] best 23563122 combination zp byte:3 [ main::j#2 main::j#1 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [] 23563122 allocation:
|
||||
Uplifting [] best 23563122 combination
|
||||
|
||||
@ -591,6 +591,10 @@ main__B1_from_B4:
|
||||
//SEG23 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp main__B1
|
||||
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:3 [ main::s#3 main::s#1 main::s#2 ] : zp byte:3 , reg byte a , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [main] 55: zp byte:3 [ main::s#3 main::s#1 main::s#2 ] 44: zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift Scope []
|
||||
@ -599,27 +603,18 @@ Uplift attempt [main] 570 allocation: zp byte:3 [ main::s#3 main::s#1 main::s#2
|
||||
Uplift attempt [main] clobber allocation: reg byte a [ main::s#3 main::s#1 main::s#2 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 480 allocation: reg byte x [ main::s#3 main::s#1 main::s#2 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 480 allocation: reg byte y [ main::s#3 main::s#1 main::s#2 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] 490 allocation: zp byte:3 [ main::s#3 main::s#1 main::s#2 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte a [ main::s#3 main::s#1 main::s#2 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 400 allocation: reg byte x [ main::s#3 main::s#1 main::s#2 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 400 allocation: reg byte y [ main::s#3 main::s#1 main::s#2 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] 470 allocation: zp byte:3 [ main::s#3 main::s#1 main::s#2 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 420 allocation: reg byte a [ main::s#3 main::s#1 main::s#2 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte x [ main::s#3 main::s#1 main::s#2 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 380 allocation: reg byte y [ main::s#3 main::s#1 main::s#2 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] 470 allocation: zp byte:3 [ main::s#3 main::s#1 main::s#2 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 420 allocation: reg byte a [ main::s#3 main::s#1 main::s#2 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 380 allocation: reg byte x [ main::s#3 main::s#1 main::s#2 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte y [ main::s#3 main::s#1 main::s#2 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplift attempt [main] alu not applicable
|
||||
Uplifting [main] best 380 combination reg byte y [ main::s#3 main::s#1 main::s#2 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [] 380 allocation:
|
||||
Uplifting [] best 380 combination
|
||||
|
||||
@ -340,40 +340,28 @@ B1:
|
||||
//SEG10 @END
|
||||
BEND:
|
||||
|
||||
Statement [1] (byte~) $1 ← (byte) i#2 + (byte) 4 [ i#2 $1 ] always clobbers reg byte a
|
||||
Removing always clobbered register reg byte a as potential for zp byte:2 [ i#2 i#1 ]
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ i#2 i#1 ] : zp byte:2 , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:3 [ $1 ] : zp byte:3 , reg byte a , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [] 31.17: zp byte:2 [ i#2 i#1 ] 22: zp byte:3 [ $1 ]
|
||||
|
||||
Uplift attempt [] 475 allocation: zp byte:2 [ i#2 i#1 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 345 allocation: reg byte x [ i#2 i#1 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] 345 allocation: reg byte y [ i#2 i#1 ] zp byte:3 [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 415 allocation: zp byte:2 [ i#2 i#1 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] 285 allocation: reg byte x [ i#2 i#1 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] 285 allocation: reg byte y [ i#2 i#1 ] reg byte a [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 455 allocation: zp byte:2 [ i#2 i#1 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ i#2 i#1 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] 325 allocation: reg byte y [ i#2 i#1 ] reg byte x [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 455 allocation: zp byte:2 [ i#2 i#1 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ i#2 i#1 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] 325 allocation: reg byte x [ i#2 i#1 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ i#2 i#1 ] reg byte y [ $1 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] missing fragment cowo1_staridx_zpby1=zpby1_plus_coby2
|
||||
Uplift attempt [] missing fragment cowo1_staridx_aby=aby_plus_coby2
|
||||
Uplift attempt [] missing fragment cowo1_staridx_xby=xby_plus_coby2
|
||||
Uplift attempt [] missing fragment cowo1_staridx_yby=yby_plus_coby2
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplifting [] best 285 combination reg byte x [ i#2 i#1 ] reg byte a [ $1 ]
|
||||
MISSING FRAGMENTS
|
||||
cowo1_staridx_zpby1=zpby1_plus_coby2
|
||||
cowo1_staridx_aby=aby_plus_coby2
|
||||
cowo1_staridx_xby=xby_plus_coby2
|
||||
cowo1_staridx_yby=yby_plus_coby2
|
||||
Removing instruction jmp B1
|
||||
Removing instruction jmp BEND
|
||||
Succesful ASM optimization Pass5NextJumpElimination
|
||||
|
||||
@ -58,6 +58,7 @@ rvaluevar__B1_from_B2:
|
||||
jmp rvaluevar__B1
|
||||
rvalue:
|
||||
lda 1024
|
||||
lda 1025
|
||||
rvalue__B1_from_rvalue:
|
||||
ldx #2
|
||||
rvalue__B1:
|
||||
|
||||
@ -2066,6 +2066,28 @@ lvalue__B1_from_B2:
|
||||
//SEG70 [27] phi (byte) lvalue::i#2 = (byte) lvalue::i#1 -- register_copy
|
||||
jmp lvalue__B1
|
||||
|
||||
Statement [9] *((byte*) lvaluevar::screen#2) ← (byte) 4 [ lvaluevar::i#2 lvaluevar::screen#2 ] always clobbers reg byte y reg byte a
|
||||
Removing always clobbered register reg byte y as potential for zp byte:2 [ lvaluevar::i#2 lvaluevar::i#1 ]
|
||||
Removing always clobbered register reg byte a as potential for zp byte:2 [ lvaluevar::i#2 lvaluevar::i#1 ]
|
||||
Statement [15] (byte) rvaluevar::b#0 ← * (byte*) rvaluevar::screen#2 [ rvaluevar::i#2 rvaluevar::screen#2 ] always clobbers reg byte a reg byte y
|
||||
Removing always clobbered register reg byte a as potential for zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ]
|
||||
Removing always clobbered register reg byte y as potential for zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ]
|
||||
Statement [25] *((word) 1024) ← (byte) 1 [ ] always clobbers reg byte a
|
||||
Statement [26] *((word) 1025) ← (byte) 2 [ ] always clobbers reg byte a
|
||||
Statement [30] *((word) 1024 + (byte) lvalue::i#2) ← (byte) 3 [ lvalue::i#2 ] always clobbers reg byte a
|
||||
Removing always clobbered register reg byte a as potential for zp byte:9 [ lvalue::i#2 lvalue::i#1 ]
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ lvaluevar::i#2 lvaluevar::i#1 ] : zp byte:2 , reg byte x ,
|
||||
Potential registers zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ] : zp ptr byte:3 ,
|
||||
Potential registers zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] : zp byte:5 , reg byte x ,
|
||||
Potential registers zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ] : zp ptr byte:6 ,
|
||||
Potential registers zp byte:8 [ rvalue::i#2 rvalue::i#1 ] : zp byte:8 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:9 [ lvalue::i#2 lvalue::i#1 ] : zp byte:9 , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:10 [ rvaluevar::b#0 ] : zp byte:10 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:11 [ rvalue::b#0 ] : zp byte:11 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:12 [ rvalue::b#1 ] : zp byte:12 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:13 [ rvalue::b#2 ] : zp byte:13 , reg byte a , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [rvalue] ∞: zp byte:11 [ rvalue::b#0 ] ∞: zp byte:12 [ rvalue::b#1 ] ∞: zp byte:13 [ rvalue::b#2 ] 36.67: zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift Scope [rvaluevar] ∞: zp byte:10 [ rvaluevar::b#0 ] 30.25: zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] 22: zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
@ -2078,670 +2100,279 @@ Uplift attempt [rvalue] 2061 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [
|
||||
Uplift attempt [rvalue] 2058 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2058 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2058 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2058 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2058 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2058 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2055 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2054 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2051 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2051 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2051 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2031 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2028 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2028 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2028 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2028 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2028 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2028 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2025 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2024 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2021 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2021 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2021 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2051 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2048 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2048 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2048 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2048 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2048 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2048 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2044 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2041 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2041 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2041 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2051 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2048 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2048 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2048 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2048 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2048 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2048 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2045 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 2044 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2041 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2041 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 2041 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] zp byte:8 [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte a [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1941 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1938 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1938 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1938 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1938 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1938 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1938 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1934 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1931 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1931 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1931 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1911 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1904 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1911 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1904 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1941 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1938 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1938 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1938 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1938 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1938 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1938 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1935 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1934 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1931 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1931 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1931 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] zp byte:13 [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1911 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1904 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1911 allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1908 allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1908 allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1905 allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] 1904 allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] 1901 allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte x [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] zp byte:12 [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte x [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte y [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] clobber allocation: zp byte:11 [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte x [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] clobber allocation: reg byte y [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte y [ rvalue::b#2 ] reg byte y [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplift attempt [rvalue] alu not applicable
|
||||
Uplifting [rvalue] best 1901 combination reg byte a [ rvalue::b#0 ] reg byte alu [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvaluevar] 1901 allocation: zp byte:10 [ rvaluevar::b#0 ] zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1871 allocation: reg byte a [ rvaluevar::b#0 ] zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1891 allocation: reg byte x [ rvaluevar::b#0 ] zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1891 allocation: reg byte y [ rvaluevar::b#0 ] zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplift attempt [rvaluevar] clobber allocation: zp byte:10 [ rvaluevar::b#0 ] reg byte a [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] clobber allocation: reg byte a [ rvaluevar::b#0 ] reg byte a [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] clobber allocation: reg byte x [ rvaluevar::b#0 ] reg byte a [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] clobber allocation: reg byte y [ rvaluevar::b#0 ] reg byte a [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplift attempt [rvaluevar] 1811 allocation: zp byte:10 [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1781 allocation: reg byte a [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplifting [rvalue] best 1905 combination reg byte a [ rvalue::b#0 ] reg byte a [ rvalue::b#1 ] reg byte a [ rvalue::b#2 ] reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
Uplift attempt [rvaluevar] 1905 allocation: zp byte:10 [ rvaluevar::b#0 ] zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1875 allocation: reg byte a [ rvaluevar::b#0 ] zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1895 allocation: reg byte x [ rvaluevar::b#0 ] zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1895 allocation: reg byte y [ rvaluevar::b#0 ] zp byte:5 [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1815 allocation: zp byte:10 [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1785 allocation: reg byte a [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] clobber allocation: reg byte x [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] 1801 allocation: reg byte y [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplift attempt [rvaluevar] clobber allocation: zp byte:10 [ rvaluevar::b#0 ] reg byte y [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] clobber allocation: reg byte a [ rvaluevar::b#0 ] reg byte y [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] clobber allocation: reg byte x [ rvaluevar::b#0 ] reg byte y [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] clobber allocation: reg byte y [ rvaluevar::b#0 ] reg byte y [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplift attempt [rvaluevar] alu not applicable
|
||||
Uplifting [rvaluevar] best 1781 combination reg byte a [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [lvaluevar] 1781 allocation: zp byte:2 [ lvaluevar::i#2 lvaluevar::i#1 ] zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ]
|
||||
Uplift attempt [lvaluevar] clobber allocation: reg byte a [ lvaluevar::i#2 lvaluevar::i#1 ] zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ]
|
||||
Uplift attempt [lvaluevar] 1691 allocation: reg byte x [ lvaluevar::i#2 lvaluevar::i#1 ] zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ]
|
||||
Uplift attempt [lvaluevar] clobber allocation: reg byte y [ lvaluevar::i#2 lvaluevar::i#1 ] zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ]
|
||||
Uplift attempt [lvaluevar] alu not applicable
|
||||
Uplifting [lvaluevar] best 1691 combination reg byte x [ lvaluevar::i#2 lvaluevar::i#1 ] zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ]
|
||||
Uplift attempt [lvalue] 1691 allocation: zp byte:9 [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplift attempt [lvalue] clobber allocation: reg byte a [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplift attempt [lvalue] 1571 allocation: reg byte x [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplift attempt [lvalue] 1571 allocation: reg byte y [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplift attempt [lvalue] alu not applicable
|
||||
Uplifting [lvalue] best 1571 combination reg byte x [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplift attempt [main] 1571 allocation:
|
||||
Uplifting [main] best 1571 combination
|
||||
Uplift attempt [] 1571 allocation:
|
||||
Uplifting [] best 1571 combination
|
||||
Uplift attempt [rvaluevar] 1805 allocation: reg byte y [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplifting [rvaluevar] best 1785 combination reg byte a [ rvaluevar::b#0 ] reg byte x [ rvaluevar::i#2 rvaluevar::i#1 ] zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ]
|
||||
Uplift attempt [lvaluevar] 1785 allocation: zp byte:2 [ lvaluevar::i#2 lvaluevar::i#1 ] zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ]
|
||||
Uplift attempt [lvaluevar] 1695 allocation: reg byte x [ lvaluevar::i#2 lvaluevar::i#1 ] zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ]
|
||||
Uplifting [lvaluevar] best 1695 combination reg byte x [ lvaluevar::i#2 lvaluevar::i#1 ] zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ]
|
||||
Uplift attempt [lvalue] 1695 allocation: zp byte:9 [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplift attempt [lvalue] 1575 allocation: reg byte x [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplift attempt [lvalue] 1575 allocation: reg byte y [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplifting [lvalue] best 1575 combination reg byte x [ lvalue::i#2 lvalue::i#1 ]
|
||||
Uplift attempt [main] 1575 allocation:
|
||||
Uplifting [main] best 1575 combination
|
||||
Uplift attempt [] 1575 allocation:
|
||||
Uplifting [] best 1575 combination
|
||||
Coalescing zero page register [ zp ptr byte:3 [ lvaluevar::screen#2 lvaluevar::screen#1 ] ] with [ zp ptr byte:6 [ rvaluevar::screen#2 rvaluevar::screen#1 ] ]
|
||||
Re-allocated ZP register from zp ptr byte:3 to zp ptr byte:2
|
||||
Removing instruction jmp BEND
|
||||
@ -2864,8 +2495,8 @@ rvaluevar__B1_from_B2:
|
||||
rvalue:
|
||||
//SEG44 [18] (byte) rvalue::b#0 ← * (word) 1024 [ ] -- aby=_star_cowo1
|
||||
lda 1024
|
||||
//SEG45 [19] (byte) rvalue::b#1 ← * (word) 1025 [ ]
|
||||
// [19] rvalue::b#1 ← * 1025 // ALU
|
||||
//SEG45 [19] (byte) rvalue::b#1 ← * (word) 1025 [ ] -- aby=_star_cowo1
|
||||
lda 1025
|
||||
//SEG46 [20] phi from rvalue to rvalue::@1
|
||||
rvalue__B1_from_rvalue:
|
||||
//SEG47 [20] phi (byte) rvalue::i#2 = (byte) 2 -- xby=coby1
|
||||
@ -2956,7 +2587,7 @@ FINAL SYMBOL TABLE
|
||||
(byte[1024]) rvalue::SCREEN
|
||||
(byte) rvalue::b
|
||||
(byte) rvalue::b#0 reg byte a Infinity
|
||||
(byte) rvalue::b#1 reg byte alu Infinity
|
||||
(byte) rvalue::b#1 reg byte a Infinity
|
||||
(byte) rvalue::b#2 reg byte a Infinity
|
||||
(byte) rvalue::i
|
||||
(byte) rvalue::i#1 reg byte x 22.0
|
||||
@ -2981,7 +2612,7 @@ reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
reg byte x [ lvalue::i#2 lvalue::i#1 ]
|
||||
reg byte a [ rvaluevar::b#0 ]
|
||||
reg byte a [ rvalue::b#0 ]
|
||||
reg byte alu [ rvalue::b#1 ]
|
||||
reg byte a [ rvalue::b#1 ]
|
||||
reg byte a [ rvalue::b#2 ]
|
||||
|
||||
FINAL CODE
|
||||
@ -3090,8 +2721,8 @@ rvaluevar__B1_from_B2:
|
||||
rvalue:
|
||||
//SEG44 [18] (byte) rvalue::b#0 ← * (word) 1024 [ ] -- aby=_star_cowo1
|
||||
lda 1024
|
||||
//SEG45 [19] (byte) rvalue::b#1 ← * (word) 1025 [ ]
|
||||
// [19] rvalue::b#1 ← * 1025 // ALU
|
||||
//SEG45 [19] (byte) rvalue::b#1 ← * (word) 1025 [ ] -- aby=_star_cowo1
|
||||
lda 1025
|
||||
//SEG46 [20] phi from rvalue to rvalue::@1
|
||||
rvalue__B1_from_rvalue:
|
||||
//SEG47 [20] phi (byte) rvalue::i#2 = (byte) 2 -- xby=coby1
|
||||
|
||||
@ -31,7 +31,7 @@
|
||||
(byte[1024]) rvalue::SCREEN
|
||||
(byte) rvalue::b
|
||||
(byte) rvalue::b#0 reg byte a Infinity
|
||||
(byte) rvalue::b#1 reg byte alu Infinity
|
||||
(byte) rvalue::b#1 reg byte a Infinity
|
||||
(byte) rvalue::b#2 reg byte a Infinity
|
||||
(byte) rvalue::i
|
||||
(byte) rvalue::i#1 reg byte x 22.0
|
||||
@ -56,5 +56,5 @@ reg byte x [ rvalue::i#2 rvalue::i#1 ]
|
||||
reg byte x [ lvalue::i#2 lvalue::i#1 ]
|
||||
reg byte a [ rvaluevar::b#0 ]
|
||||
reg byte a [ rvalue::b#0 ]
|
||||
reg byte alu [ rvalue::b#1 ]
|
||||
reg byte a [ rvalue::b#1 ]
|
||||
reg byte a [ rvalue::b#2 ]
|
||||
|
||||
16
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.asm
Normal file
16
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.asm
Normal file
@ -0,0 +1,16 @@
|
||||
BBEGIN:
|
||||
jsr main
|
||||
BEND:
|
||||
main:
|
||||
main__B1_from_main:
|
||||
ldx #2
|
||||
main__B1:
|
||||
cpx #10
|
||||
bcc main__B2
|
||||
main__Breturn:
|
||||
rts
|
||||
main__B2:
|
||||
lda 1024,x
|
||||
inx
|
||||
main__B1_from_B2:
|
||||
jmp main__B1
|
||||
17
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.cfg
Normal file
17
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.cfg
Normal file
@ -0,0 +1,17 @@
|
||||
@BEGIN: from
|
||||
[0] call main param-assignment [ ]
|
||||
to:@END
|
||||
@END: from @BEGIN
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte) main::i#1 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ]
|
||||
to:main::@return
|
||||
main::@return: from main::@1
|
||||
[3] return [ ]
|
||||
to:@RETURN
|
||||
main::@2: from main::@1
|
||||
[4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ]
|
||||
[5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
to:main::@1
|
||||
604
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.log
Normal file
604
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.log
Normal file
@ -0,0 +1,604 @@
|
||||
// Test all types of pointers
|
||||
|
||||
main();
|
||||
|
||||
void main() {
|
||||
|
||||
// A constant pointer
|
||||
byte[1024] SCREEN = $0400;
|
||||
|
||||
byte b;
|
||||
|
||||
// RValue constant array variable index
|
||||
byte i=2;
|
||||
while(i<10) {
|
||||
b = SCREEN[i++];
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Adding pre/post-modifier (byte) main::i ← ++ (byte) main::i
|
||||
PROGRAM
|
||||
(void~) $0 ← call main
|
||||
proc (void()) main()
|
||||
(byte[1024]) main::SCREEN ← (word) 1024
|
||||
(byte) main::i ← (byte) 2
|
||||
main::@1:
|
||||
(boolean~) main::$0 ← (byte) main::i < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
goto main::@3
|
||||
main::@2:
|
||||
(byte~) main::$1 ← (byte[1024]) main::SCREEN *idx (byte) main::i
|
||||
(byte) main::b ← (byte~) main::$1
|
||||
(byte) main::i ← ++ (byte) main::i
|
||||
goto main::@1
|
||||
main::@3:
|
||||
main::@return:
|
||||
return
|
||||
endproc // main()
|
||||
|
||||
SYMBOLS
|
||||
(void~) $0
|
||||
(void()) main()
|
||||
(boolean~) main::$0
|
||||
(byte~) main::$1
|
||||
(label) main::@1
|
||||
(label) main::@2
|
||||
(label) main::@3
|
||||
(label) main::@return
|
||||
(byte[1024]) main::SCREEN
|
||||
(byte) main::b
|
||||
(byte) main::i
|
||||
|
||||
INITIAL CONTROL FLOW GRAPH
|
||||
@BEGIN: from
|
||||
(void~) $0 ← call main
|
||||
to:@1
|
||||
main: from
|
||||
(byte[1024]) main::SCREEN ← (word) 1024
|
||||
(byte) main::i ← (byte) 2
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(boolean~) main::$0 ← (byte) main::i < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@4
|
||||
main::@2: from main::@1 main::@5
|
||||
(byte~) main::$1 ← (byte[1024]) main::SCREEN *idx (byte) main::i
|
||||
(byte) main::b ← (byte~) main::$1
|
||||
(byte) main::i ← ++ (byte) main::i
|
||||
to:main::@1
|
||||
main::@4: from main::@1
|
||||
to:main::@3
|
||||
main::@3: from main::@4 main::@6
|
||||
to:main::@return
|
||||
main::@5: from
|
||||
to:main::@2
|
||||
main::@6: from
|
||||
to:main::@3
|
||||
main::@return: from main::@3
|
||||
return
|
||||
to:@RETURN
|
||||
@1: from @BEGIN
|
||||
to:@END
|
||||
@END: from @1
|
||||
|
||||
Removing empty block main::@4
|
||||
Removing empty block main::@3
|
||||
Removing empty block main::@5
|
||||
Removing empty block main::@6
|
||||
Removing empty block @1
|
||||
CONTROL FLOW GRAPH
|
||||
@BEGIN: from
|
||||
(void~) $0 ← call main
|
||||
to:@END
|
||||
main: from
|
||||
(byte[1024]) main::SCREEN ← (word) 1024
|
||||
(byte) main::i ← (byte) 2
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(boolean~) main::$0 ← (byte) main::i < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte~) main::$1 ← (byte[1024]) main::SCREEN *idx (byte) main::i
|
||||
(byte) main::b ← (byte~) main::$1
|
||||
(byte) main::i ← ++ (byte) main::i
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @BEGIN
|
||||
|
||||
CONTROL FLOW GRAPH WITH ASSIGNMENT CALL
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@2
|
||||
@2: from @BEGIN
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
(byte[1024]) main::SCREEN ← (word) 1024
|
||||
(byte) main::i ← (byte) 2
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(boolean~) main::$0 ← (byte) main::i < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte~) main::$1 ← (byte[1024]) main::SCREEN *idx (byte) main::i
|
||||
(byte) main::b ← (byte~) main::$1
|
||||
(byte) main::i ← ++ (byte) main::i
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @2
|
||||
|
||||
Completing Phi functions...
|
||||
Completing Phi functions...
|
||||
CONTROL FLOW GRAPH SSA
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@2
|
||||
@2: from @BEGIN
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
(byte[1024]) main::SCREEN#0 ← (word) 1024
|
||||
(byte) main::i#0 ← (byte) 2
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte[1024]) main::SCREEN#2 ← phi( main/(byte[1024]) main::SCREEN#0 main::@2/(byte[1024]) main::SCREEN#1 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
|
||||
(byte[1024]) main::SCREEN#1 ← phi( main::@1/(byte[1024]) main::SCREEN#2 )
|
||||
(byte~) main::$1 ← (byte[1024]) main::SCREEN#1 *idx (byte) main::i#3
|
||||
(byte) main::b#0 ← (byte~) main::$1
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @2
|
||||
|
||||
CONTROL FLOW GRAPH WITH ASSIGNMENT CALL & RETURN
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@2
|
||||
@2: from @BEGIN
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
(byte[1024]) main::SCREEN#0 ← (word) 1024
|
||||
(byte) main::i#0 ← (byte) 2
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte[1024]) main::SCREEN#2 ← phi( main/(byte[1024]) main::SCREEN#0 main::@2/(byte[1024]) main::SCREEN#1 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
|
||||
(byte[1024]) main::SCREEN#1 ← phi( main::@1/(byte[1024]) main::SCREEN#2 )
|
||||
(byte~) main::$1 ← (byte[1024]) main::SCREEN#1 *idx (byte) main::i#3
|
||||
(byte) main::b#0 ← (byte~) main::$1
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @2
|
||||
|
||||
Culled Empty Block (label) @2
|
||||
Succesful SSA optimization Pass2CullEmptyBlocks
|
||||
CONTROL FLOW GRAPH
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
(byte[1024]) main::SCREEN#0 ← (word) 1024
|
||||
(byte) main::i#0 ← (byte) 2
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte[1024]) main::SCREEN#2 ← phi( main/(byte[1024]) main::SCREEN#0 main::@2/(byte[1024]) main::SCREEN#1 )
|
||||
(byte) main::i#2 ← phi( main/(byte) main::i#0 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
|
||||
(byte[1024]) main::SCREEN#1 ← phi( main::@1/(byte[1024]) main::SCREEN#2 )
|
||||
(byte~) main::$1 ← (byte[1024]) main::SCREEN#1 *idx (byte) main::i#3
|
||||
(byte) main::b#0 ← (byte~) main::$1
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @BEGIN
|
||||
|
||||
Constant (byte[1024]) main::SCREEN#0 (word) 1024
|
||||
Constant (byte) main::i#0 (byte) 2
|
||||
Succesful SSA optimization Pass2ConstantPropagation
|
||||
CONTROL FLOW GRAPH
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte[1024]) main::SCREEN#2 ← phi( main/(word) 1024 main::@2/(byte[1024]) main::SCREEN#1 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte) main::i#3 ← phi( main::@1/(byte) main::i#2 )
|
||||
(byte[1024]) main::SCREEN#1 ← phi( main::@1/(byte[1024]) main::SCREEN#2 )
|
||||
(byte~) main::$1 ← (byte[1024]) main::SCREEN#1 *idx (byte) main::i#3
|
||||
(byte) main::b#0 ← (byte~) main::$1
|
||||
(byte) main::i#1 ← ++ (byte) main::i#3
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @BEGIN
|
||||
|
||||
Alias (byte[1024]) main::SCREEN#1 = (byte[1024]) main::SCREEN#2
|
||||
Alias (byte) main::i#2 = (byte) main::i#3
|
||||
Alias (byte) main::b#0 = (byte~) main::$1
|
||||
Succesful SSA optimization Pass2AliasElimination
|
||||
CONTROL FLOW GRAPH
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte[1024]) main::SCREEN#1 ← phi( main/(word) 1024 main::@2/(byte[1024]) main::SCREEN#1 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte) main::b#0 ← (byte[1024]) main::SCREEN#1 *idx (byte) main::i#2
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @BEGIN
|
||||
|
||||
Self Phi Eliminated (byte[1024]) main::SCREEN#1
|
||||
Succesful SSA optimization Pass2SelfPhiElimination
|
||||
CONTROL FLOW GRAPH
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte[1024]) main::SCREEN#1 ← phi( main/(word) 1024 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte) main::i#1 )
|
||||
(boolean~) main::$0 ← (byte) main::i#2 < (byte) 10
|
||||
if((boolean~) main::$0) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte) main::b#0 ← (byte[1024]) main::SCREEN#1 *idx (byte) main::i#2
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @BEGIN
|
||||
|
||||
Simple Condition (boolean~) main::$0 if((byte) main::i#2<(byte) 10) goto main::@2
|
||||
Succesful SSA optimization Pass2ConditionalJumpSimplification
|
||||
CONTROL FLOW GRAPH
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte[1024]) main::SCREEN#1 ← phi( main/(word) 1024 )
|
||||
(byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte) main::i#1 )
|
||||
if((byte) main::i#2<(byte) 10) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte) main::b#0 ← (byte[1024]) main::SCREEN#1 *idx (byte) main::i#2
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @BEGIN
|
||||
|
||||
Constant (byte[1024]) main::SCREEN#1 (word) 1024
|
||||
Succesful SSA optimization Pass2ConstantPropagation
|
||||
CONTROL FLOW GRAPH
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@END
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte) main::i#1 )
|
||||
if((byte) main::i#2<(byte) 10) goto main::@2
|
||||
to:main::@return
|
||||
main::@2: from main::@1
|
||||
(byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
to:main::@1
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
@END: from @BEGIN
|
||||
|
||||
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
|
||||
Multiple usages for variable. Not optimizing sub-constant (byte) main::i#2
|
||||
Block Sequence Planned @BEGIN @END main main::@1 main::@return main::@2
|
||||
Block Sequence Planned @BEGIN @END main main::@1 main::@return main::@2
|
||||
CONTROL FLOW GRAPH - PHI LIFTED
|
||||
@BEGIN: from
|
||||
call main param-assignment
|
||||
to:@END
|
||||
@END: from @BEGIN
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
(byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte~) main::i#4 )
|
||||
if((byte) main::i#2<(byte) 10) goto main::@2
|
||||
to:main::@return
|
||||
main::@return: from main::@1
|
||||
return
|
||||
to:@RETURN
|
||||
main::@2: from main::@1
|
||||
(byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2
|
||||
(byte) main::i#1 ← ++ (byte) main::i#2
|
||||
(byte~) main::i#4 ← (byte) main::i#1
|
||||
to:main::@1
|
||||
|
||||
Adding empty live range for unused variable main::b#0
|
||||
Propagating live ranges...
|
||||
CONTROL FLOW GRAPH - LIVE RANGES
|
||||
@BEGIN: from
|
||||
[0] call main param-assignment [ ]
|
||||
to:@END
|
||||
@END: from @BEGIN
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte~) main::i#4 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ]
|
||||
to:main::@return
|
||||
main::@return: from main::@1
|
||||
[3] return [ ]
|
||||
to:@RETURN
|
||||
main::@2: from main::@1
|
||||
[4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ]
|
||||
[5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
[6] (byte~) main::i#4 ← (byte) main::i#1 [ main::i#4 ]
|
||||
to:main::@1
|
||||
|
||||
Created 1 initial phi equivalence classes
|
||||
Coalesced [6] main::i#4 ← main::i#1
|
||||
Coalesced down to 1 phi equivalence classes
|
||||
Block Sequence Planned @BEGIN @END main main::@1 main::@return main::@2
|
||||
Adding empty live range for unused variable main::b#0
|
||||
Propagating live ranges...
|
||||
CONTROL FLOW GRAPH - PHI MEM COALESCED
|
||||
@BEGIN: from
|
||||
[0] call main param-assignment [ ]
|
||||
to:@END
|
||||
@END: from @BEGIN
|
||||
main: from @BEGIN
|
||||
to:main::@1
|
||||
main::@1: from main main::@2
|
||||
[1] (byte) main::i#2 ← phi( main/(byte) 2 main::@2/(byte) main::i#1 ) [ main::i#2 ]
|
||||
[2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ]
|
||||
to:main::@return
|
||||
main::@return: from main::@1
|
||||
[3] return [ ]
|
||||
to:@RETURN
|
||||
main::@2: from main::@1
|
||||
[4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ]
|
||||
[5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ]
|
||||
to:main::@1
|
||||
|
||||
CALL GRAPH
|
||||
Calls in [] to 0:main
|
||||
|
||||
DOMINATORS
|
||||
@BEGIN dominated by @BEGIN
|
||||
@END dominated by @BEGIN @END
|
||||
main dominated by @BEGIN main
|
||||
main::@1 dominated by @BEGIN main::@1 main
|
||||
main::@return dominated by @BEGIN main::@return main::@1 main
|
||||
main::@2 dominated by @BEGIN main::@2 main::@1 main
|
||||
|
||||
Found back edge: Loop head: main::@1 tails: main::@2 blocks: null
|
||||
Populated: Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1
|
||||
NATURAL LOOPS
|
||||
Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1
|
||||
|
||||
Found 0 loops in scope []
|
||||
Found 1 loops in scope [main]
|
||||
Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1
|
||||
NATURAL LOOPS WITH DEPTH
|
||||
Loop head: main::@1 tails: main::@2 blocks: main::@2 main::@1 depth: 1
|
||||
|
||||
|
||||
VARIABLE REGISTER WEIGHTS
|
||||
(void()) main()
|
||||
(byte[1024]) main::SCREEN
|
||||
(byte) main::b
|
||||
(byte) main::b#0 Infinity
|
||||
(byte) main::i
|
||||
(byte) main::i#1 22.0
|
||||
(byte) main::i#2 14.666666666666666
|
||||
|
||||
Initial phi equivalence classes
|
||||
[ main::i#2 main::i#1 ]
|
||||
Added variable main::b#0 to zero page equivalence class [ main::b#0 ]
|
||||
Complete equivalence classes
|
||||
[ main::i#2 main::i#1 ]
|
||||
[ main::b#0 ]
|
||||
Allocated zp byte:2 to zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Allocated zp byte:3 to zp byte:3 [ main::b#0 ]
|
||||
INITIAL ASM
|
||||
//SEG0 @BEGIN
|
||||
BBEGIN:
|
||||
//SEG1 [0] call main param-assignment [ ]
|
||||
jsr main
|
||||
jmp BEND
|
||||
//SEG2 @END
|
||||
BEND:
|
||||
//SEG3 main
|
||||
main:
|
||||
//SEG4 [1] phi from main to main::@1
|
||||
main__B1_from_main:
|
||||
//SEG5 [1] phi (byte) main::i#2 = (byte) 2 -- zpby1=coby1
|
||||
lda #2
|
||||
sta 2
|
||||
jmp main__B1
|
||||
//SEG6 main::@1
|
||||
main__B1:
|
||||
//SEG7 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- zpby1_lt_coby1_then_la1
|
||||
lda 2
|
||||
cmp #10
|
||||
bcc main__B2
|
||||
jmp main__Breturn
|
||||
//SEG8 main::@return
|
||||
main__Breturn:
|
||||
//SEG9 [3] return [ ]
|
||||
rts
|
||||
//SEG10 main::@2
|
||||
main__B2:
|
||||
//SEG11 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- zpby1=cowo1_staridx_zpby2
|
||||
ldx 2
|
||||
lda 1024,x
|
||||
sta 3
|
||||
//SEG12 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- zpby1=_inc_zpby1
|
||||
inc 2
|
||||
//SEG13 [1] phi from main::@2 to main::@1
|
||||
main__B1_from_B2:
|
||||
//SEG14 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp main__B1
|
||||
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ main::i#2 main::i#1 ] : zp byte:2 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:3 [ main::b#0 ] : zp byte:3 , reg byte a , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [main] ∞: zp byte:3 [ main::b#0 ] 36.67: zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift Scope []
|
||||
|
||||
Uplift attempt [main] 385 allocation: zp byte:3 [ main::b#0 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 355 allocation: reg byte a [ main::b#0 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 375 allocation: reg byte x [ main::b#0 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 375 allocation: reg byte y [ main::b#0 ] zp byte:2 [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: zp byte:3 [ main::b#0 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte a [ main::b#0 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte x [ main::b#0 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte y [ main::b#0 ] reg byte a [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 265 allocation: zp byte:3 [ main::b#0 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 235 allocation: reg byte a [ main::b#0 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte x [ main::b#0 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 235 allocation: reg byte y [ main::b#0 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 265 allocation: zp byte:3 [ main::b#0 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 235 allocation: reg byte a [ main::b#0 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] 235 allocation: reg byte x [ main::b#0 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [main] clobber allocation: reg byte y [ main::b#0 ] reg byte y [ main::i#2 main::i#1 ]
|
||||
Uplifting [main] best 235 combination reg byte a [ main::b#0 ] reg byte x [ main::i#2 main::i#1 ]
|
||||
Uplift attempt [] 235 allocation:
|
||||
Uplifting [] best 235 combination
|
||||
Removing instruction jmp BEND
|
||||
Removing instruction jmp main__B1
|
||||
Removing instruction jmp main__Breturn
|
||||
Succesful ASM optimization Pass5NextJumpElimination
|
||||
ASSEMBLER
|
||||
//SEG0 @BEGIN
|
||||
BBEGIN:
|
||||
//SEG1 [0] call main param-assignment [ ]
|
||||
jsr main
|
||||
//SEG2 @END
|
||||
BEND:
|
||||
//SEG3 main
|
||||
main:
|
||||
//SEG4 [1] phi from main to main::@1
|
||||
main__B1_from_main:
|
||||
//SEG5 [1] phi (byte) main::i#2 = (byte) 2 -- xby=coby1
|
||||
ldx #2
|
||||
//SEG6 main::@1
|
||||
main__B1:
|
||||
//SEG7 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1
|
||||
cpx #10
|
||||
bcc main__B2
|
||||
//SEG8 main::@return
|
||||
main__Breturn:
|
||||
//SEG9 [3] return [ ]
|
||||
rts
|
||||
//SEG10 main::@2
|
||||
main__B2:
|
||||
//SEG11 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- aby=cowo1_staridx_xby
|
||||
lda 1024,x
|
||||
//SEG12 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
inx
|
||||
//SEG13 [1] phi from main::@2 to main::@1
|
||||
main__B1_from_B2:
|
||||
//SEG14 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp main__B1
|
||||
|
||||
FINAL SYMBOL TABLE
|
||||
(label) @BEGIN
|
||||
(label) @END
|
||||
(void()) main()
|
||||
(label) main::@1
|
||||
(label) main::@2
|
||||
(label) main::@return
|
||||
(byte[1024]) main::SCREEN
|
||||
(byte) main::b
|
||||
(byte) main::b#0 reg byte a Infinity
|
||||
(byte) main::i
|
||||
(byte) main::i#1 reg byte x 22.0
|
||||
(byte) main::i#2 reg byte x 14.666666666666666
|
||||
|
||||
reg byte x [ main::i#2 main::i#1 ]
|
||||
reg byte a [ main::b#0 ]
|
||||
|
||||
FINAL CODE
|
||||
//SEG0 @BEGIN
|
||||
BBEGIN:
|
||||
//SEG1 [0] call main param-assignment [ ]
|
||||
jsr main
|
||||
//SEG2 @END
|
||||
BEND:
|
||||
//SEG3 main
|
||||
main:
|
||||
//SEG4 [1] phi from main to main::@1
|
||||
main__B1_from_main:
|
||||
//SEG5 [1] phi (byte) main::i#2 = (byte) 2 -- xby=coby1
|
||||
ldx #2
|
||||
//SEG6 main::@1
|
||||
main__B1:
|
||||
//SEG7 [2] if((byte) main::i#2<(byte) 10) goto main::@2 [ main::i#2 ] -- xby_lt_coby1_then_la1
|
||||
cpx #10
|
||||
bcc main__B2
|
||||
//SEG8 main::@return
|
||||
main__Breturn:
|
||||
//SEG9 [3] return [ ]
|
||||
rts
|
||||
//SEG10 main::@2
|
||||
main__B2:
|
||||
//SEG11 [4] (byte) main::b#0 ← (word) 1024 *idx (byte) main::i#2 [ main::i#2 ] -- aby=cowo1_staridx_xby
|
||||
lda 1024,x
|
||||
//SEG12 [5] (byte) main::i#1 ← ++ (byte) main::i#2 [ main::i#1 ] -- xby=_inc_xby
|
||||
inx
|
||||
//SEG13 [1] phi from main::@2 to main::@1
|
||||
main__B1_from_B2:
|
||||
//SEG14 [1] phi (byte) main::i#2 = (byte) main::i#1 -- register_copy
|
||||
jmp main__B1
|
||||
|
||||
15
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.sym
Normal file
15
src/main/java/dk/camelot64/kickc/test/ref/ptrtestmin.sym
Normal file
@ -0,0 +1,15 @@
|
||||
(label) @BEGIN
|
||||
(label) @END
|
||||
(void()) main()
|
||||
(label) main::@1
|
||||
(label) main::@2
|
||||
(label) main::@return
|
||||
(byte[1024]) main::SCREEN
|
||||
(byte) main::b
|
||||
(byte) main::b#0 reg byte a Infinity
|
||||
(byte) main::i
|
||||
(byte) main::i#1 reg byte x 22.0
|
||||
(byte) main::i#2 reg byte x 14.666666666666666
|
||||
|
||||
reg byte x [ main::i#2 main::i#1 ]
|
||||
reg byte a [ main::b#0 ]
|
||||
@ -4,16 +4,18 @@ sum_from_BBEGIN:
|
||||
lda #1
|
||||
jsr sum
|
||||
B2:
|
||||
ldx 2
|
||||
stx 2
|
||||
sum_from_B2:
|
||||
lda #13
|
||||
lda #9
|
||||
jsr sum
|
||||
B3:
|
||||
lda 2
|
||||
txa
|
||||
clc
|
||||
adc 2
|
||||
BEND:
|
||||
sum:
|
||||
asl
|
||||
sta 2
|
||||
tax
|
||||
sum__Breturn:
|
||||
rts
|
||||
|
||||
@ -442,6 +442,18 @@ sum__Breturn:
|
||||
//SEG18 [7] return [ sum::return#0 s1#0 ]
|
||||
rts
|
||||
|
||||
Statement [0] call sum param-assignment [ sum::return#0 s1#0 ] always clobbers reg byte a
|
||||
Removing always clobbered register reg byte a as potential for zp byte:7 [ sum::return#0 ]
|
||||
Removing always clobbered register reg byte a as potential for zp byte:4 [ s1#0 ]
|
||||
Statement [2] call sum param-assignment [ sum::return#0 s1#0 ] always clobbers reg byte a
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
Potential registers zp byte:2 [ sum::a#2 ] : zp byte:2 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:3 [ sum::b#2 ] : zp byte:3 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:4 [ s1#0 ] : zp byte:4 , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:5 [ s2#0 ] : zp byte:5 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:6 [ s3#0 ] : zp byte:6 , reg byte a , reg byte x , reg byte y ,
|
||||
Potential registers zp byte:7 [ sum::return#0 ] : zp byte:7 , reg byte x , reg byte y ,
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [] ∞: zp byte:6 [ s3#0 ] 4: zp byte:5 [ s2#0 ] 0.57: zp byte:4 [ s1#0 ]
|
||||
Uplift Scope [sum] 2: zp byte:2 [ sum::a#2 ] 2: zp byte:3 [ sum::b#2 ] 1.2: zp byte:7 [ sum::return#0 ]
|
||||
@ -450,258 +462,101 @@ Uplift attempt [] 84 allocation: zp byte:6 [ s3#0 ] zp byte:5 [ s2#0 ] zp byte:4
|
||||
Uplift attempt [] 81 allocation: reg byte a [ s3#0 ] zp byte:5 [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 83 allocation: reg byte x [ s3#0 ] zp byte:5 [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 83 allocation: reg byte y [ s3#0 ] zp byte:5 [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 73 allocation: reg byte alu [ s3#0 ] zp byte:5 [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 78 allocation: zp byte:6 [ s3#0 ] reg byte a [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 75 allocation: reg byte a [ s3#0 ] reg byte a [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte x [ s3#0 ] reg byte a [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte y [ s3#0 ] reg byte a [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 70 allocation: reg byte alu [ s3#0 ] reg byte a [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 80 allocation: zp byte:6 [ s3#0 ] reg byte x [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte a [ s3#0 ] reg byte x [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte x [ s3#0 ] reg byte x [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte y [ s3#0 ] reg byte x [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 70 allocation: reg byte alu [ s3#0 ] reg byte x [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 80 allocation: zp byte:6 [ s3#0 ] reg byte y [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte a [ s3#0 ] reg byte y [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte x [ s3#0 ] reg byte y [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte y [ s3#0 ] reg byte y [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 70 allocation: reg byte alu [ s3#0 ] reg byte y [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 78 allocation: zp byte:6 [ s3#0 ] reg byte alu [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 75 allocation: reg byte a [ s3#0 ] reg byte alu [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte x [ s3#0 ] reg byte alu [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte y [ s3#0 ] reg byte alu [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] clobber allocation: zp byte:6 [ s3#0 ] zp byte:5 [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s3#0 ] zp byte:5 [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s3#0 ] zp byte:5 [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s3#0 ] zp byte:5 [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte alu [ s3#0 ] zp byte:5 [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: zp byte:6 [ s3#0 ] reg byte a [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s3#0 ] reg byte a [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s3#0 ] reg byte a [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s3#0 ] reg byte a [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte alu [ s3#0 ] reg byte a [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: zp byte:6 [ s3#0 ] reg byte x [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s3#0 ] reg byte x [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s3#0 ] reg byte x [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s3#0 ] reg byte x [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte alu [ s3#0 ] reg byte x [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: zp byte:6 [ s3#0 ] reg byte y [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s3#0 ] reg byte y [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s3#0 ] reg byte y [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s3#0 ] reg byte y [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte alu [ s3#0 ] reg byte y [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: zp byte:6 [ s3#0 ] reg byte alu [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s3#0 ] reg byte alu [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s3#0 ] reg byte alu [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s3#0 ] reg byte alu [ s2#0 ] reg byte a [ s1#0 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 80 allocation: zp byte:6 [ s3#0 ] zp byte:5 [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte a [ s3#0 ] zp byte:5 [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte x [ s3#0 ] zp byte:5 [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte y [ s3#0 ] zp byte:5 [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 70 allocation: reg byte alu [ s3#0 ] zp byte:5 [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 78 allocation: zp byte:6 [ s3#0 ] reg byte a [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 75 allocation: reg byte a [ s3#0 ] reg byte a [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte x [ s3#0 ] reg byte a [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte y [ s3#0 ] reg byte a [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 67 allocation: reg byte alu [ s3#0 ] reg byte a [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: zp byte:6 [ s3#0 ] reg byte x [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s3#0 ] reg byte x [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s3#0 ] reg byte x [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s3#0 ] reg byte x [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte alu [ s3#0 ] reg byte x [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 80 allocation: zp byte:6 [ s3#0 ] reg byte y [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte a [ s3#0 ] reg byte y [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte x [ s3#0 ] reg byte y [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte y [ s3#0 ] reg byte y [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 67 allocation: reg byte alu [ s3#0 ] reg byte y [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 74 allocation: zp byte:6 [ s3#0 ] reg byte alu [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 71 allocation: reg byte a [ s3#0 ] reg byte alu [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 73 allocation: reg byte x [ s3#0 ] reg byte alu [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] 73 allocation: reg byte y [ s3#0 ] reg byte alu [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] 80 allocation: zp byte:6 [ s3#0 ] zp byte:5 [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte a [ s3#0 ] zp byte:5 [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte x [ s3#0 ] zp byte:5 [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte y [ s3#0 ] zp byte:5 [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 70 allocation: reg byte alu [ s3#0 ] zp byte:5 [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 78 allocation: zp byte:6 [ s3#0 ] reg byte a [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 75 allocation: reg byte a [ s3#0 ] reg byte a [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte x [ s3#0 ] reg byte a [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte y [ s3#0 ] reg byte a [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 67 allocation: reg byte alu [ s3#0 ] reg byte a [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 80 allocation: zp byte:6 [ s3#0 ] reg byte x [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 77 allocation: reg byte a [ s3#0 ] reg byte x [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte x [ s3#0 ] reg byte x [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 79 allocation: reg byte y [ s3#0 ] reg byte x [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 67 allocation: reg byte alu [ s3#0 ] reg byte x [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: zp byte:6 [ s3#0 ] reg byte y [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte a [ s3#0 ] reg byte y [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte x [ s3#0 ] reg byte y [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte y [ s3#0 ] reg byte y [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] clobber allocation: reg byte alu [ s3#0 ] reg byte y [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 74 allocation: zp byte:6 [ s3#0 ] reg byte alu [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 71 allocation: reg byte a [ s3#0 ] reg byte alu [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 73 allocation: reg byte x [ s3#0 ] reg byte alu [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] 73 allocation: reg byte y [ s3#0 ] reg byte alu [ s2#0 ] reg byte y [ s1#0 ]
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplift attempt [] alu not applicable
|
||||
Uplifting [] best 67 combination reg byte alu [ s3#0 ] reg byte a [ s2#0 ] reg byte x [ s1#0 ]
|
||||
Uplift attempt [sum] 67 allocation: zp byte:2 [ sum::a#2 ] zp byte:3 [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte a [ sum::a#2 ] zp byte:3 [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte x [ sum::a#2 ] zp byte:3 [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 60 allocation: reg byte y [ sum::a#2 ] zp byte:3 [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] 58 allocation: zp byte:2 [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 49 allocation: reg byte a [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte x [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 55 allocation: reg byte y [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] clobber allocation: zp byte:2 [ sum::a#2 ] reg byte x [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte a [ sum::a#2 ] reg byte x [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte x [ sum::a#2 ] reg byte x [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte y [ sum::a#2 ] reg byte x [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] 60 allocation: zp byte:2 [ sum::a#2 ] reg byte y [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 55 allocation: reg byte a [ sum::a#2 ] reg byte y [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte x [ sum::a#2 ] reg byte y [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 51 allocation: reg byte y [ sum::a#2 ] reg byte y [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] missing fragment xby=aby
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] clobber allocation: zp byte:2 [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte a [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte x [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte y [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] clobber allocation: zp byte:2 [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte a [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte x [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte y [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] clobber allocation: zp byte:2 [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte a [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte x [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte y [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] clobber allocation: zp byte:2 [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte a [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte x [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] clobber allocation: reg byte y [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] missing fragment xby=yby
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplift attempt [sum] alu not applicable
|
||||
Uplifting [sum] best 49 combination reg byte a [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
MISSING FRAGMENTS
|
||||
xby=aby
|
||||
xby=yby
|
||||
Re-allocated ZP register from zp byte:7 to zp byte:2
|
||||
Uplifting [] best 75 combination reg byte a [ s3#0 ] reg byte a [ s2#0 ] zp byte:4 [ s1#0 ]
|
||||
Uplift attempt [sum] 75 allocation: zp byte:2 [ sum::a#2 ] zp byte:3 [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 66 allocation: reg byte a [ sum::a#2 ] zp byte:3 [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 68 allocation: reg byte x [ sum::a#2 ] zp byte:3 [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 68 allocation: reg byte y [ sum::a#2 ] zp byte:3 [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 66 allocation: zp byte:2 [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 57 allocation: reg byte a [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: reg byte x [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: reg byte y [ sum::a#2 ] reg byte a [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 68 allocation: zp byte:2 [ sum::a#2 ] reg byte x [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: reg byte a [ sum::a#2 ] reg byte x [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 59 allocation: reg byte x [ sum::a#2 ] reg byte x [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 65 allocation: reg byte y [ sum::a#2 ] reg byte x [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 68 allocation: zp byte:2 [ sum::a#2 ] reg byte y [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: reg byte a [ sum::a#2 ] reg byte y [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 65 allocation: reg byte x [ sum::a#2 ] reg byte y [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 59 allocation: reg byte y [ sum::a#2 ] reg byte y [ sum::b#2 ] zp byte:7 [ sum::return#0 ]
|
||||
Uplift attempt [sum] 70 allocation: zp byte:2 [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 61 allocation: reg byte a [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: reg byte x [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: reg byte y [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 61 allocation: zp byte:2 [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 52 allocation: reg byte a [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte x [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte y [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: zp byte:2 [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte a [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 54 allocation: reg byte x [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 60 allocation: reg byte y [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: zp byte:2 [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte a [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 60 allocation: reg byte x [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 54 allocation: reg byte y [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Uplift attempt [sum] 70 allocation: zp byte:2 [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 61 allocation: reg byte a [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: reg byte x [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: reg byte y [ sum::a#2 ] zp byte:3 [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 61 allocation: zp byte:2 [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 52 allocation: reg byte a [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte x [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte y [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: zp byte:2 [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte a [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 54 allocation: reg byte x [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 60 allocation: reg byte y [ sum::a#2 ] reg byte x [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 63 allocation: zp byte:2 [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 58 allocation: reg byte a [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 60 allocation: reg byte x [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplift attempt [sum] 54 allocation: reg byte y [ sum::a#2 ] reg byte y [ sum::b#2 ] reg byte y [ sum::return#0 ]
|
||||
Uplifting [sum] best 52 combination reg byte a [ sum::a#2 ] reg byte a [ sum::b#2 ] reg byte x [ sum::return#0 ]
|
||||
Re-allocated ZP register from zp byte:4 to zp byte:2
|
||||
Removing instruction jmp B2
|
||||
Removing instruction jmp B3
|
||||
Removing instruction jmp BEND
|
||||
@ -720,8 +575,8 @@ sum_from_BBEGIN:
|
||||
jsr sum
|
||||
//SEG5 @2
|
||||
B2:
|
||||
//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ sum::return#0 s1#0 ] -- xby=zpby1
|
||||
ldx 2
|
||||
//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ sum::return#0 s1#0 ] -- zpby1=xby
|
||||
stx 2
|
||||
//SEG7 [2] call sum param-assignment [ sum::return#0 s1#0 ]
|
||||
//SEG8 [5] phi from @2 to sum
|
||||
sum_from_B2:
|
||||
@ -732,17 +587,18 @@ sum_from_B2:
|
||||
jsr sum
|
||||
//SEG11 @3
|
||||
B3:
|
||||
//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- aby=zpby1
|
||||
lda 2
|
||||
//SEG13 [4] (byte) s3#0 ← (byte) s1#0 + (byte) s2#0 [ ]
|
||||
// [4] s3#0 ← s1#0 + s2#0 // ALU
|
||||
//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- aby=xby
|
||||
txa
|
||||
//SEG13 [4] (byte) s3#0 ← (byte) s1#0 + (byte) s2#0 [ ] -- aby=zpby1_plus_aby
|
||||
clc
|
||||
adc 2
|
||||
//SEG14 @END
|
||||
BEND:
|
||||
//SEG15 sum
|
||||
sum:
|
||||
//SEG16 [6] (byte) sum::return#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ sum::return#0 s1#0 ] -- zpby1=aby_plus_aby
|
||||
//SEG16 [6] (byte) sum::return#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ sum::return#0 s1#0 ] -- xby=aby_plus_aby
|
||||
asl
|
||||
sta 2
|
||||
tax
|
||||
//SEG17 sum::@return
|
||||
sum__Breturn:
|
||||
//SEG18 [7] return [ sum::return#0 s1#0 ]
|
||||
@ -754,11 +610,11 @@ FINAL SYMBOL TABLE
|
||||
(label) @BEGIN
|
||||
(label) @END
|
||||
(byte) s1
|
||||
(byte) s1#0 reg byte x 0.5714285714285714
|
||||
(byte) s1#0 zp byte:2 0.5714285714285714
|
||||
(byte) s2
|
||||
(byte) s2#0 reg byte a 4.0
|
||||
(byte) s3
|
||||
(byte) s3#0 reg byte alu Infinity
|
||||
(byte) s3#0 reg byte a Infinity
|
||||
(byte()) sum((byte) sum::a , (byte) sum::b)
|
||||
(label) sum::@return
|
||||
(byte) sum::a
|
||||
@ -766,14 +622,14 @@ FINAL SYMBOL TABLE
|
||||
(byte) sum::b
|
||||
(byte) sum::b#2 reg byte a 2.0
|
||||
(byte) sum::return
|
||||
(byte) sum::return#0 zp byte:2 1.2000000000000002
|
||||
(byte) sum::return#0 reg byte x 1.2000000000000002
|
||||
|
||||
reg byte a [ sum::a#2 ]
|
||||
reg byte a [ sum::b#2 ]
|
||||
reg byte x [ s1#0 ]
|
||||
zp byte:2 [ s1#0 ]
|
||||
reg byte a [ s2#0 ]
|
||||
reg byte alu [ s3#0 ]
|
||||
zp byte:2 [ sum::return#0 ]
|
||||
reg byte a [ s3#0 ]
|
||||
reg byte x [ sum::return#0 ]
|
||||
|
||||
FINAL CODE
|
||||
//SEG0 @BEGIN
|
||||
@ -788,8 +644,8 @@ sum_from_BBEGIN:
|
||||
jsr sum
|
||||
//SEG5 @2
|
||||
B2:
|
||||
//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ sum::return#0 s1#0 ] -- xby=zpby1
|
||||
ldx 2
|
||||
//SEG6 [1] (byte) s1#0 ← (byte) sum::return#0 [ sum::return#0 s1#0 ] -- zpby1=xby
|
||||
stx 2
|
||||
//SEG7 [2] call sum param-assignment [ sum::return#0 s1#0 ]
|
||||
//SEG8 [5] phi from @2 to sum
|
||||
sum_from_B2:
|
||||
@ -800,17 +656,18 @@ sum_from_B2:
|
||||
jsr sum
|
||||
//SEG11 @3
|
||||
B3:
|
||||
//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- aby=zpby1
|
||||
lda 2
|
||||
//SEG13 [4] (byte) s3#0 ← (byte) s1#0 + (byte) s2#0 [ ]
|
||||
// [4] s3#0 ← s1#0 + s2#0 // ALU
|
||||
//SEG12 [3] (byte) s2#0 ← (byte) sum::return#0 [ s1#0 s2#0 ] -- aby=xby
|
||||
txa
|
||||
//SEG13 [4] (byte) s3#0 ← (byte) s1#0 + (byte) s2#0 [ ] -- aby=zpby1_plus_aby
|
||||
clc
|
||||
adc 2
|
||||
//SEG14 @END
|
||||
BEND:
|
||||
//SEG15 sum
|
||||
sum:
|
||||
//SEG16 [6] (byte) sum::return#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ sum::return#0 s1#0 ] -- zpby1=aby_plus_aby
|
||||
//SEG16 [6] (byte) sum::return#0 ← (byte) sum::a#2 + (byte) sum::b#2 [ sum::return#0 s1#0 ] -- xby=aby_plus_aby
|
||||
asl
|
||||
sta 2
|
||||
tax
|
||||
//SEG17 sum::@return
|
||||
sum__Breturn:
|
||||
//SEG18 [7] return [ sum::return#0 s1#0 ]
|
||||
|
||||
@ -3,11 +3,11 @@
|
||||
(label) @BEGIN
|
||||
(label) @END
|
||||
(byte) s1
|
||||
(byte) s1#0 reg byte x 0.5714285714285714
|
||||
(byte) s1#0 zp byte:2 0.5714285714285714
|
||||
(byte) s2
|
||||
(byte) s2#0 reg byte a 4.0
|
||||
(byte) s3
|
||||
(byte) s3#0 reg byte alu Infinity
|
||||
(byte) s3#0 reg byte a Infinity
|
||||
(byte()) sum((byte) sum::a , (byte) sum::b)
|
||||
(label) sum::@return
|
||||
(byte) sum::a
|
||||
@ -15,11 +15,11 @@
|
||||
(byte) sum::b
|
||||
(byte) sum::b#2 reg byte a 2.0
|
||||
(byte) sum::return
|
||||
(byte) sum::return#0 zp byte:2 1.2000000000000002
|
||||
(byte) sum::return#0 reg byte x 1.2000000000000002
|
||||
|
||||
reg byte a [ sum::a#2 ]
|
||||
reg byte a [ sum::b#2 ]
|
||||
reg byte x [ s1#0 ]
|
||||
zp byte:2 [ s1#0 ]
|
||||
reg byte a [ s2#0 ]
|
||||
reg byte alu [ s3#0 ]
|
||||
zp byte:2 [ sum::return#0 ]
|
||||
reg byte a [ s3#0 ]
|
||||
reg byte x [ sum::return#0 ]
|
||||
|
||||
@ -225,6 +225,9 @@ main__Breturn:
|
||||
//SEG6 [2] return [ ]
|
||||
rts
|
||||
|
||||
Statement [1] *((word) 1024) ← (byte) 1 [ ] always clobbers reg byte a
|
||||
REGISTER UPLIFT POTENTIAL REGISTERS
|
||||
|
||||
REGISTER UPLIFT SCOPES
|
||||
Uplift Scope [main]
|
||||
Uplift Scope []
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user